ccamel/playground-binding.scala

View on GitHub

Showing 20 of 24 total issues

Function renderControl has 108 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  @dom def renderControl = {
    <div class="row">
      <div class="col s12">
        <label>Selected demo</label>
        <select local-id="itDemo" onchange={_: Event => selectDemo(Some(demos(itDemo.value.toInt)))}>
Severity: Major
Found in src/main/scala/com/ccm/me/playground/bindingscala/ledmatrix/ui.scala - About 4 hrs to fix

    File ui.scala has 292 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*
    The MIT License (MIT)
    
    Copyright (c) 2017 Chris Camel
    
    
    Severity: Minor
    Found in src/main/scala/com/ccm/me/playground/bindingscala/ledmatrix/ui.scala - About 3 hrs to fix

      Function renderContent has 72 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        @dom def renderContent = {
          def handleChange[T: ClassTag](i: HTMLInputElement, to: Var[T]) = {
            try{
              to match {
                case aDouble: Var[Double @unchecked] if classTag[T] == classTag[Double] ⇒ aDouble.value = i.value.toDouble

        File demo.scala has 258 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        /*
        The MIT License (MIT)
        
        Copyright (c) 2017 Chris Camel
        
        

          Function renderForm has 45 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            @dom override def renderForm(): Binding[Element] = {
              <div>
                <div class="col s12">
                  <div class="col s12">
                    <label for="lissajous-a">Parameter a for the lissajous curve (

            Function onMouseMove has 39 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              private def onMouseMove(e: MouseEvent) = {
                model.drag.value match {
                  case Some(drag@Edition(Position(lastx, lasty), action)) ⇒
                    val (x, y) = (e.clientX.toInt, e.clientY.toInt)
                    val (dx, dy) = (x - lastx, y - lasty)
            Severity: Minor
            Found in src/main/scala/com/ccm/me/playground/bindingscala/dragme/ui.scala - About 1 hr to fix

              Function apply has 36 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                def apply(t: Token): CalcModel = {
                  state match {
                    case 'accum => t match {
                      case NoOp() => doNothing()
                      case Clear() => doClear()
              Severity: Minor
              Found in src/main/scala/com/ccm/me/playground/bindingscala/calc/model.scala - About 1 hr to fix

                Function bodyHeader has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  @dom def bodyHeader: Binding[BindingSeq[Node]] = {
                    <header>
                      <a href="https://github.com/ccamel/playground-binding.scala">
                        <img style="position: absolute; top: 0; right: 0; border: 0;"
                             src="https://camo.githubusercontent.com/38ef81f8aca64bb9a64448d0d70f1308ef5341ab/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f6461726b626c75655f3132313632312e706e67"
                Severity: Minor
                Found in src/main/scala/com/ccm/me/playground/bindingscala/App.scala - About 1 hr to fix

                  Function header has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    @dom def header = {
                      <meta charset="UTF-8"/>
                      <title>{showCase.bind.name}</title>
                  
                      <link href="http://fonts.googleapis.com/icon?family=Material+Icons|VT323|Cutive+Mono" rel="stylesheet"/>
                  Severity: Minor
                  Found in src/main/scala/com/ccm/me/playground/bindingscala/App.scala - About 1 hr to fix

                    Function render has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      @dom override def render: Binding[Node] = {
                          <div class="container list">
                            <p>Virtual list displaying <em>1,000,000</em> elements. You can explore the data with the following means:</p>
                            <ul class="browser-default">
                              <li>Move the scrollbar by dragging the mouse</li>

                      Function render has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        @dom def render: Binding[Node] = {
                          val btns = List(List("7", "8", "9", "+", "C"),
                            List("4", "5", "6", "-", "MS"),
                            List("1", "2", "3", "x", "MR"),
                            List(".", "0", "=", "/", "MC"))
                      Severity: Minor
                      Found in src/main/scala/com/ccm/me/playground/bindingscala/calc/ui.scala - About 1 hr to fix

                        Function render has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                          @dom override def render: Binding[Node] = {
                            import View._
                            implicit def toSvgTags(a: dom.Runtime.TagsAndTags2.type) = scalatags.JsDom.svgTags
                        
                            <div class="container" style="height:100%">

                          Function apply has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                          Open

                            def apply(t: Token): CalcModel = {
                              state match {
                                case 'accum => t match {
                                  case NoOp() => doNothing()
                                  case Clear() => doClear()
                          Severity: Minor
                          Found in src/main/scala/com/ccm/me/playground/bindingscala/calc/model.scala - About 55 mins to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Constructor has 6 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                                                    x: Var[Int],
                                                    y: Var[Int],
                                                    w: Var[Int],
                                                    h: Var[Int],
                                                    selected: Var[Boolean],
                          Severity: Minor
                          Found in src/main/scala/com/ccm/me/playground/bindingscala/dragme/model.scala - About 45 mins to fix

                            Constructor has 5 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                            case class MonthlyPayment(monthNb: Int,
                                                      payment: Double,
                                                      principal: Double,
                                                      interrestPayment: Double,
                                                      loan: Double)

                              Constructor has 5 arguments (exceeds 4 allowed). Consider refactoring.
                              Open

                              case class RectShape(x: Var[Int],
                                                   y: Var[Int],
                                                   w: Var[Int],
                                                   h: Var[Int],
                                                   label: Var[String]) extends Shape
                              Severity: Minor
                              Found in src/main/scala/com/ccm/me/playground/bindingscala/svg-editor/model.scala - About 35 mins to fix

                                Constructor has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                Open

                                case class CalcModel(outputs: Seq[Double],
                                                     operators: Seq[Op],
                                                     state: Symbol,
                                                     accumulator: String,
                                                     memory: Option[Double]) extends Immutable with PartialFunction[Token, CalcModel] {
                                Severity: Minor
                                Found in src/main/scala/com/ccm/me/playground/bindingscala/calc/model.scala - About 35 mins to fix

                                  Constructor has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                  Open

                                                           size: Var[Int],
                                                         // content
                                                           data: Vars[A],
                                                         // total amount of data
                                                           total: Var[Long],

                                    Function apply has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                    Open

                                      override def apply(screen: Screen): Unit = {
                                        if (firstFrame) {
                                          screen.clear(0x000000)
                                          firstFrame = false
                                        } else {
                                    Severity: Minor
                                    Found in src/main/scala/com/ccm/me/playground/bindingscala/ledmatrix/demo.scala - About 35 mins to fix

                                    Cognitive Complexity

                                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                    A method's cognitive complexity is based on a few simple rules:

                                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                    • Code is considered more complex for each "break in the linear flow of the code"
                                    • Code is considered more complex when "flow breaking structures are nested"

                                    Further reading

                                    Function apply has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                    Open

                                      override def apply(screen: Screen): Unit = {
                                        if (firstFrame) {
                                          screen.clear(0x000000)
                                    
                                          buffer = screen.buffer()
                                    Severity: Minor
                                    Found in src/main/scala/com/ccm/me/playground/bindingscala/ledmatrix/demo.scala - About 25 mins to fix

                                    Cognitive Complexity

                                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                    A method's cognitive complexity is based on a few simple rules:

                                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                    • Code is considered more complex for each "break in the linear flow of the code"
                                    • Code is considered more complex when "flow breaking structures are nested"

                                    Further reading

                                    Severity
                                    Category
                                    Status
                                    Source
                                    Language