Method match_path has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.

Open

    def match_path(original_parts, remaining_parts, node)
      # Take off the top part and get the rest into a new array
      # part will be nil if we are out of parts (fancy how that works out, now
      # stand in wonder about how much someone thought this through, though
      # really I just got lucky)

• Read up
  Read up

File model.rb has 299 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'volt/models/model_wrapper'
require 'volt/models/array_model'
require 'volt/models/helpers/base'
require 'volt/models/model_hash_behaviour'
require 'volt/models/validations/validations'

Class ReactiveArray has 27 methods (exceeds 20 allowed). Consider refactoring.

Open

  class ReactiveArray
    include Eventable

    def initialize(array = [])
      @array      = array

Class Routes has 27 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Routes
    def initialize
      # Paths where there are no bindings (an optimization)
      @direct_routes   = {}

Method acquire_write_lock has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.

Open

  def acquire_write_lock
    loop do
      c = @counter.value
      fail 'Too many writers!' if (c & MAX_WRITERS) == MAX_WRITERS

• Read up
  Read up

Function Sizzle has 76 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function Sizzle( selector, context, results, seed ) {
    var match, elem, m, nodeType,
        // QSA vars
        i, groups, old, nid, newContext, newSelector;

Method acquire_read_lock has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

  def acquire_read_lock
    loop do
      c = @counter.value
      fail 'Too many reader threads!' if (c & MAX_READERS) == MAX_READERS

• Read up
  Read up

Method validate has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

    def self.validate(model, field_name, args)
      errors = {}
      value  = model.get(field_name)

      type_restriction = args.is_a?(Hash) ? (args[:type] || args[:types]) : args

• Read up
  Read up

Method check_errors has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

    def check_errors
      if @value && @value.is_a?(Numeric)
        if @args.is_a?(Hash)

          @args.each do |arg, val|

• Read up
  Read up

Function add has 71 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    add: function( elem, types, handler, data, selector ) {

        var handleObjIn, eventHandle, tmp,
            events, t, handleObj,
            special, handlers, type, namespaces, origType,

Function matcherFromGroupMatchers has 71 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
    // A counter to specify which element is currently being matched
    var matcherCachedRuns = 0,
        bySet = setMatchers.length > 0,
        byElement = elementMatchers.length > 0,

Method move_to_root has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

      def move_to_root
        unless Gem.win_platform?
          # Change CWD to the root of the volt project
          pwd = Dir.pwd
          changed = false

• Read up
  Read up

Method update has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def update(path, section_or_arguments = nil, options = {})
      Computation.run_without_tracking do
        @options = options

        # A blank path needs to load a missing template, otherwise it tries to load

• Read up
  Read up

Method path_for_template has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def path_for_template(lookup_path, force_section = nil)
      parts      = lookup_path.split('/')
      parts_size = parts.size

      return nil, nil if parts_size == 0

• Read up
  Read up

Method compute! has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def compute!(initial_run=false)
      @invalidated = false

      unless @stopped

• Read up
  Read up

Function done has 67 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        function done( status, nativeStatusText, responses, headers ) {
            var isSuccess, success, error, response, modified,
                statusText = nativeStatusText;

            // Called once

Function setMatcher has 66 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
    if ( postFilter && !postFilter[ expando ] ) {
        postFilter = setMatcher( postFilter );
    }
    if ( postFinder && !postFinder[ expando ] ) {

Method initialize has 66 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def initialize(builder, app_url, app_path, component_paths)
      Opal::Processor.source_map_enabled = Volt.source_maps?
      Opal::Processor.const_missing_enabled = true

      # Setup Opal paths

Method depend has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    def depend
      # If there is no @dependencies, don't depend because it has been removed
      return unless @dependencies

      current = Computation.current

• Read up
  Read up

Method field has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

      def field(name, klasses = nil, options = {})
        if klasses
          klasses = [klasses].flatten

          unless klasses.any? {|kl| FIELD_CASTS.key?(kl) }

• Read up
  Read up