rails-route-checker 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad69825f00790c2dbac821ca39fc909f3e651e78
-  data.tar.gz: b24150ef71ea4f975f1e85e19d18a58c9985a0b2
+  metadata.gz: b24a961c0772ee84e1c259c0a0ec3ae58e604a00
+  data.tar.gz: 0cc8d360ec7a9b00ba983438777c84b3e380e506
 SHA512:
-  metadata.gz: 7e96ff4b2f655d30c21f5aacb947bcc85eb499e983986b35605154cf48664e62d8a2cc0e1745a775624661907c61aab957d967a82aa712fe605a25a951f01e43
-  data.tar.gz: 55cf806407c1855d25171ce9c912ec7d2c0db6ea46cf5d4270ad1befbe6f35e241e6ae2ad5c5a8a2cf8f2ec3fbaeba28ace1f999757335ded1273ef1cb95955c
+  metadata.gz: 94985375668b8d095725af978851124f9212b05a84cca9ef754ac8b1a9b3b62a33ce9f61a898f252392d5220b3f9ea4a313a83cba0bf129ef49431ba38b54768
+  data.tar.gz: 802d00447e68e0ea6f7a302f2228de146e4612d57c251c067cf5857d9e5895a2abfd33bbe8cc392a14dab85cb7cf8a1df60dc9ebd84ce3a9d4183029bc566482

data/lib/rails-route-checker.rb

@@ -1,7 +1,8 @@
-require 'rails-route-checker/app_interface'
-require 'rails-route-checker/config_file'
-require 'rails-route-checker/loaded_app'
-require 'rails-route-checker/runner'
-require 'rails-route-checker/version'
+require_relative 'rails-route-checker/app_interface'
+require_relative 'rails-route-checker/config_file'
+require_relative 'rails-route-checker/loaded_app'
+require_relative 'rails-route-checker/runner'
+require_relative 'rails-route-checker/parsers/loader'
+require_relative 'rails-route-checker/version'
 
 module RailsRouteChecker; end

data/lib/rails-route-checker/app_interface.rb

@@ -1,7 +1,7 @@
 module RailsRouteChecker
   class AppInterface
     def initialize(**opts)
-      @options = opts
+      @options = { ignored_controllers: [], ignored_paths: [], ignored_path_whitelist: {} }.merge(opts)
     end
 
     def routes_without_actions
@@ -38,77 +38,89 @@ module RailsRouteChecker
     end
 
     def generate_undef_view_path_calls
-      files = `find app -type f -iregex '.*\\.haml' -or -iregex '.*\\.erb' -or -iregex '.*\\.html'`.split("\n")
+      generate_undef_view_path_calls_erb + generate_undef_view_path_calls_haml
+    end
+
+    def generate_undef_view_path_calls_erb
+      files = `find app -type f -iregex '.*\\.erb'`.split("\n")
+      return [] if files.none?
+
+      RailsRouteChecker::Parsers::Loader.load_parser(:erb)
+
       files.map do |filename|
         controller = controller_from_view_file(filename)
 
-        defined_variables = []
-
-        File.read(filename).each_line.each_with_index.map do |line, line_num|
-          next if line =~ /^\s*-\s*#/
-          skip_first = false
-          if line =~ /^\s*-/
-            line_match = line.match(/^\s*-\s*([a-zA-Z0-9_]+_(?:path|url))\s*=/)
-            defined_variables << line_match[1] if line_match
-            skip_first = true
-          end
-
-          matches = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))[^a-z0-9_]/)
-          matches.shift if skip_first
-          ignores = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))(?: =|[!:])/).map(&:first)
-          ignores += line.scan(/[.@:_'"]([a-zA-Z][a-zA-Z0-9_]+_(?:path|url))[^a-z0-9_]/).map(&:first)
-
-          matches.reject! { |match| ignores.include?(match[0]) }
-
-          matches.map do |match|
-            next if match_in_whitelist?(filename, match)
-            next if match_defined_in_view?(controller, defined_variables, match)
-            { file: filename, line: line_num + 1, method: match[0] }
-          end
+        filter = lambda do |path_or_url|
+          return false if match_in_whitelist?(filename, path_or_url)
+          return false if match_defined_in_view?(controller, path_or_url)
+          true
         end
+
+        RailsRouteChecker::Parsers::ErbParser.run(filename, filter: filter)
       end.flatten.compact
     end
 
-    def generate_undef_controller_path_calls
-      `find app/controllers -type f -iregex '.*\\.rb'`.split("\n").map do |filename|
-        controller = controller_from_ruby_file(filename)
+    def generate_undef_view_path_calls_haml
+      files = `find app -type f -iregex '.*\\.haml'`.split("\n")
+      return [] if files.none?
+
+      unless RailsRouteChecker::Parsers::Loader.haml_available?
+        puts 'WARNING: There are Haml files in your codebase, ' \
+           "but the Haml parser for rails-route-checker couldn't load!"
+        return []
+      end
+
+      RailsRouteChecker::Parsers::Loader.load_parser(:haml)
+
+      files.map do |filename|
+        controller = controller_from_view_file(filename)
 
-        File.read(filename).each_line.each_with_index.map do |line, line_num|
-          next if line =~ /^\s*#/
-          next if line =~ /^\s*def\s/
+        filter = lambda do |path_or_url|
+          return false if match_in_whitelist?(filename, path_or_url)
+          return false if match_defined_in_view?(controller, path_or_url)
+          true
+        end
 
-          matches = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))[^a-z0-9_]/)
-          ignores = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))(?: =|[!:])/).map(&:first)
-          ignores += line.scan(/[.@:_'"]([a-zA-Z][a-zA-Z0-9_]+_(?:path|url))[^a-z0-9_]/).map(&:first)
+        RailsRouteChecker::Parsers::HamlParser.run(filename, filter: filter)
+      end.flatten.compact
+    end
 
-          matches.reject! { |match| ignores.include?(match[0]) }
+    def generate_undef_controller_path_calls
+      files = `find app/controllers -type f -iregex '.*\\.rb'`.split("\n")
+      return [] if files.none?
 
-          matches.map do |match|
-            next if match_in_whitelist?(filename, match)
-            next if match_defined_in_ruby?(controller, match)
-            { file: filename, line: line_num + 1, method: match[0] }
-          end
+      RailsRouteChecker::Parsers::Loader.load_parser(:ruby)
+
+      files.map do |filename|
+        controller = controller_from_ruby_file(filename)
+        next unless controller # controller will be nil if it's an ignored controller
+
+        filter = lambda do |path_or_url|
+          return false if match_in_whitelist?(filename, path_or_url)
+          return false if match_defined_in_ruby?(controller, path_or_url)
+          return true
         end
+
+        RailsRouteChecker::Parsers::RubyParser.run(filename, filter: filter)
       end.flatten.compact
     end
 
-    def match_in_whitelist?(filename, match)
-      full_match, possible_route_name = match
+    def match_in_whitelist?(filename, path_or_url)
+      possible_route_name = path_or_url.sub(/_(?:url|path)$/, '')
       return true if options[:ignored_paths].include?(possible_route_name)
-      (options[:ignored_path_whitelist][filename] || []).include?(full_match)
+      (options[:ignored_path_whitelist][filename] || []).include?(path_or_url)
     end
 
-    def match_defined_in_view?(controller, defined_variables, match)
-      full_match, possible_route_name = match
+    def match_defined_in_view?(controller, path_or_url)
+      possible_route_name = path_or_url.sub(/_(?:url|path)$/, '')
       return true if loaded_app.all_route_names.include?(possible_route_name)
-      return true if defined_variables.include?(full_match)
-      controller && controller[:helpers].include?(full_match)
+      controller && controller[:helpers].include?(path_or_url)
     end
 
-    def match_defined_in_ruby?(controller, match)
-      full_match, possible_route_name = match
+    def match_defined_in_ruby?(controller, path_or_url)
+      possible_route_name = path_or_url.sub(/_(?:url|path)$/, '')
       return true if loaded_app.all_route_names.include?(possible_route_name)
-      controller && controller[:instance_methods].include?(full_match)
+      controller && controller[:instance_methods].include?(path_or_url)
     end
 
     def controller_from_view_file(filename)

data/lib/rails-route-checker/parsers/erb_parser.rb

@@ -0,0 +1,52 @@
+module RailsRouteChecker
+  module Parsers
+    module ErbParser
+      class << self
+        def run(filename, **opts)
+          file_source = opts[:source] || File.read(filename)
+
+          next_ruby_source_line_num = 1
+          ruby_source = ''
+          source_map = {}
+
+          file_source.split("\n").each_with_index do |line, line_num|
+            ruby_lines = process_line(line)
+            next unless ruby_lines.any?
+
+            ruby_source += ruby_lines.join("\n") + "\n"
+            ruby_lines.length.times do |i|
+              source_map[next_ruby_source_line_num + i] = line_num + 1
+            end
+            next_ruby_source_line_num += ruby_lines.length
+          end
+
+          opts[:source] = ruby_source
+          opts[:source_map] = source_map
+
+          RailsRouteChecker::Parsers::RubyParser.run(filename, **opts)
+        end
+
+        private
+
+        def process_line(line)
+          lookup_index = 0
+          ruby_lines = []
+
+          while lookup_index < line.length
+            opening = line.index('<%=', lookup_index)
+            is_write_opening = opening
+            opening ||= line.index('<%', lookup_index)
+            break unless opening
+
+            closing = line.index('%>', opening + 2)
+            break unless closing
+
+            ruby_lines << line[(opening + (is_write_opening ? 3 : 2))..(closing - 1)]
+            lookup_index = closing + 2
+          end
+          ruby_lines
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser.rb

@@ -0,0 +1,28 @@
+require_relative 'haml_parser/document'
+require_relative 'haml_parser/tree/node'
+require_relative 'haml_parser/tree/filter_node'
+require_relative 'haml_parser/tree/root_node'
+require_relative 'haml_parser/tree/script_node'
+require_relative 'haml_parser/tree/silent_script_node'
+require_relative 'haml_parser/tree/tag_node'
+require_relative 'haml_parser/ruby_extractor'
+
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      class << self
+        def run(filename, **opts)
+          file_source = opts[:source] || File.read(filename)
+
+          document = RailsRouteChecker::Parsers::HamlParser::Document.new(file_source)
+          extracted_ruby = RailsRouteChecker::Parsers::HamlParser::RubyExtractor.extract(document)
+
+          opts[:source] = extracted_ruby.source
+          opts[:source_map] = extracted_ruby.source_map
+
+          RailsRouteChecker::Parsers::RubyParser.run(filename, **opts)
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/document.rb

@@ -0,0 +1,47 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      class Document
+        attr_reader :tree, :source, :source_lines
+
+        def initialize(source)
+          @source = source.force_encoding(Encoding::UTF_8)
+          @source_lines = @source.split(/\r\n|\r|\n/)
+
+          version = Gem::Version.new(Haml::VERSION).approximate_recommendation
+          original_tree = case version
+                          when '~> 4.0', '~> 4.1' then Haml::Parser.new(@source, Haml::Options.new).parse
+                          when '~> 5.0' then Haml::Parser.new(options).call(@source)
+                          else raise "Cannot handle Haml version: #{version}"
+                          end
+
+          @tree = process_tree(original_tree)
+        end
+
+        private
+
+        def process_tree(original_tree)
+          if Gem::Requirement.new('~> 4.0.0').satisfied_by?(Gem.loaded_specs['haml'].version)
+            original_tree.children.pop
+          end
+
+          convert_tree(original_tree)
+        end
+
+        def convert_tree(haml_node, parent = nil)
+          node_class_name = "#{haml_node.type.to_s.split(/[-_ ]/).collect(&:capitalize).join}Node"
+          node_class_name = 'Node' unless RailsRouteChecker::Parsers::HamlParser::Tree.const_defined?(node_class_name)
+
+          new_node = RailsRouteChecker::Parsers::HamlParser::Tree.const_get(node_class_name).new(self, haml_node)
+          new_node.parent = parent
+
+          new_node.children = haml_node.children.map do |child|
+            convert_tree(child, new_node)
+          end
+
+          new_node
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/ruby_extractor.rb

@@ -0,0 +1,151 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      class RubyExtractor
+        RubySource = Struct.new(:source, :source_map)
+
+        def self.extract(document)
+          new(document).extract
+        end
+
+        def initialize(document)
+          @document = document
+        end
+
+        def extract
+          @source_lines = []
+          @source_map = {}
+          @line_count = 0
+          @indent_level = 0
+          @output_count = 0
+
+          visit_children(document.tree)
+
+          RubySource.new(@source_lines.join("\n"), @source_map)
+        end
+
+        def visit_tag(node)
+          additional_attributes = node.dynamic_attributes_sources
+
+          additional_attributes.each do |attributes_code|
+            attributes_code = attributes_code.gsub(/\s*\n\s*/, ' ').strip
+            add_line("{}.merge(#{attributes_code.strip})", node)
+          end
+
+          if node.hash_attributes? && node.dynamic_attributes_sources.empty?
+            normalized_attr_source = node.dynamic_attributes_source[:hash].gsub(/\s*\n\s*/, ' ')
+
+            add_line(normalized_attr_source, node)
+          end
+
+          code = node.script.strip
+          add_line(code, node) unless code.empty?
+        end
+
+        def visit_script(node)
+          code = node.text
+          add_line(code.strip, node)
+
+          start_block = anonymous_block?(code) || start_block_keyword?(code)
+
+          @indent_level += 1 if start_block
+
+          yield
+
+          return unless start_block
+          @indent_level -= 1
+          add_line('end', node)
+        end
+
+        def visit_filter(node)
+          return unless node.filter_type == 'ruby'
+
+          node.text.split("\n").each_with_index do |line, index|
+            add_line(line, node.line + index + 1, false)
+          end
+        end
+
+        def visit(node)
+          block_called = false
+
+          block = lambda do |descend = :children|
+            block_called = true
+            visit_children(node) if descend == :children
+          end
+
+          case node.type
+          when :tag
+            visit_tag(node)
+          when :script, :silent_script
+            visit_script(node, &block)
+          when :filter
+            visit_filter(node)
+          end
+
+          visit_children(node) unless block_called
+        end
+
+        def visit_children(parent)
+          parent.children.each { |node| visit(node) }
+        end
+
+        private
+
+        attr_reader :document
+
+        def add_line(code, node_or_line, discard_blanks = true)
+          return if code.empty? && discard_blanks
+
+          indent_level = @indent_level
+
+          if node_or_line.respond_to?(:line)
+            indent_level -= 1 if mid_block_keyword?(code)
+          end
+
+          indent = (' ' * 2 * indent_level)
+
+          @source_lines << indent_code(code, indent)
+
+          original_line =
+            node_or_line.respond_to?(:line) ? node_or_line.line : node_or_line
+
+          (code.count("\n") + 1).times do
+            @line_count += 1
+            @source_map[@line_count] = original_line
+          end
+        end
+
+        def indent_code(code, indent)
+          codes = code.split("\n")
+          codes.map { |c| indent + c }.join("\n")
+        end
+
+        def anonymous_block?(text)
+          text =~ /\bdo\s*(\|\s*[^\|]*\s*\|)?(\s*#.*)?\z/
+        end
+
+        START_BLOCK_KEYWORDS = %w[if unless case begin for until while].freeze
+        def start_block_keyword?(text)
+          START_BLOCK_KEYWORDS.include?(block_keyword(text))
+        end
+
+        MID_BLOCK_KEYWORDS = %w[else elsif when rescue ensure].freeze
+        def mid_block_keyword?(text)
+          MID_BLOCK_KEYWORDS.include?(block_keyword(text))
+        end
+
+        LOOP_KEYWORDS = %w[for until while].freeze
+        def block_keyword(text)
+          # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
+          keyword = text[/\A\s*([^\s]+)\s+/, 1]
+          return keyword if keyword && LOOP_KEYWORDS.include?(keyword)
+
+          keyword = text.scan(Haml::Parser::BLOCK_KEYWORD_REGEX)[0]
+          return unless keyword
+
+          keyword[0] || keyword[1]
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/tree/filter_node.rb

@@ -0,0 +1,13 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      module Tree
+        class FilterNode < Node
+          def filter_type
+            @value[:name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/tree/node.rb

@@ -0,0 +1,126 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      module Tree
+        class Node
+          include Enumerable
+
+          attr_accessor :children, :parent
+          attr_reader :line, :type
+
+          def initialize(document, parse_node)
+            @line = parse_node.line
+            @document = document
+            @value = parse_node.value
+            @type = parse_node.type
+          end
+
+          def each
+            return to_enum(__callee__) unless block_given?
+
+            node = self
+            loop do
+              yield node
+              break unless (node = node.next_node)
+            end
+          end
+
+          def directives
+            directives = []
+            directives << predecessor.directives if predecessor
+            directives.flatten
+          end
+
+          def source_code
+            next_node_line =
+              if next_node
+                next_node.line - 1
+              else
+                @document.source_lines.count + 1
+              end
+
+            @document.source_lines[@line - 1...next_node_line]
+                     .join("\n")
+                     .gsub(/^\s*\z/m, '')
+          end
+
+          def inspect
+            "#<#{self.class.name}>"
+          end
+
+          def lines
+            return [] unless @value && text
+
+            text.split(/\r\n|\r|\n/)
+          end
+
+          def line_numbers
+            return (line..line) unless @value && text
+
+            (line..line + lines.count)
+          end
+
+          def predecessor
+            siblings.previous(self) || parent
+          end
+
+          def successor
+            next_sibling = siblings.next(self)
+            return next_sibling if next_sibling
+
+            parent.successor if parent
+          end
+
+          def next_node
+            children.first || successor
+          end
+
+          def subsequents
+            siblings.subsequents(self)
+          end
+
+          def text
+            @value[:text].to_s
+          end
+
+          private
+
+          def siblings
+            @siblings ||= Siblings.new(parent ? parent.children : [self])
+          end
+
+          class Siblings < SimpleDelegator
+            def next(node)
+              subsequents(node).first
+            end
+
+            def previous(node)
+              priors(node).last
+            end
+
+            def priors(node)
+              position = position(node)
+              if position.zero?
+                []
+              else
+                siblings[0..(position - 1)]
+              end
+            end
+
+            def subsequents(node)
+              siblings[(position(node) + 1)..-1]
+            end
+
+            private
+
+            alias siblings __getobj__
+
+            def position(node)
+              siblings.index(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/tree/root_node.rb

@@ -0,0 +1,13 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      module Tree
+        class RootNode < Node
+          def file
+            @document.file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/tree/script_node.rb

@@ -0,0 +1,13 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      module Tree
+        class ScriptNode < Node
+          def script
+            @value[:text]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/tree/silent_script_node.rb

@@ -0,0 +1,13 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      module Tree
+        class SilentScriptNode < Node
+          def script
+            @value[:text]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/haml_parser/tree/tag_node.rb

@@ -0,0 +1,56 @@
+module RailsRouteChecker
+  module Parsers
+    module HamlParser
+      module Tree
+        class TagNode < Node
+          def dynamic_attributes_sources
+            @dynamic_attributes_sources ||=
+              if Gem::Version.new(Haml::VERSION) < Gem::Version.new('5')
+                @value[:attributes_hashes]
+              else
+                Array(@value[:dynamic_attributes].to_literal).reject(&:empty?)
+              end
+          end
+
+          def dynamic_attributes_source
+            @dynamic_attributes_source ||=
+              attributes_source.reject { |key| key == :static }
+          end
+
+          def attributes_source
+            @attr_source ||=
+              begin
+                _explicit_tag, static_attrs, rest =
+                  source_code.scan(/\A\s*(%[-:\w]+)?([-:\w\.\#]*)(.*)/m)[0]
+
+                attr_types = {
+                  '{' => [:hash, %w[{ }]],
+                  '(' => [:html, %w[( )]],
+                  '[' => [:object_ref, %w[[ ]]]
+                }
+
+                attr_source = { static: static_attrs }
+                while rest
+                  type, chars = attr_types[rest[0]]
+                  break unless type
+                  break if attr_source[type]
+
+                  attr_source[type], rest = Haml::Util.balance(rest, *chars)
+                end
+
+                attr_source
+              end
+          end
+
+          def hash_attributes?
+            !dynamic_attributes_source[:hash].nil?
+          end
+
+          def script
+            (@value[:value] if @value[:parse]) || ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/loader.rb

@@ -0,0 +1,55 @@
+module RailsRouteChecker
+  module Parsers
+    module Loader
+      class << self
+        def load_parser(type)
+          case type
+          when :ruby
+            load_basic_parser(:ruby)
+          when :erb
+            load_basic_parser(:ruby)
+            load_basic_parser(:erb)
+          when :haml
+            if haml_available?
+              load_basic_parser(:ruby)
+              load_haml_parser
+            end
+          else
+            raise "Unrecognised parser attempting to be loaded: #{type}"
+          end
+        end
+
+        def haml_available?
+          return @haml_available if defined?(@haml_available)
+          @haml_available = gem_installed?('haml')
+        end
+
+        private
+
+        def gem_installed?(name, version_requirement = nil)
+          Gem::Dependency.new(name, version_requirement).matching_specs.any?
+        end
+
+        def load_basic_parser(parser_name)
+          if_unloaded(parser_name) do
+            require_relative "#{parser_name}_parser"
+          end
+        end
+
+        def load_haml_parser
+          if_unloaded(:haml) do
+            require 'haml'
+            require_relative 'haml_parser'
+          end
+        end
+
+        def if_unloaded(parser)
+          @loaded_parsers ||= {}
+          return false if @loaded_parsers[parser]
+          yield
+          @loaded_parsers[parser] = true
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/parsers/ruby_parser.rb

@@ -0,0 +1,57 @@
+require 'ripper'
+
+module RailsRouteChecker
+  module Parsers
+    module RubyParser
+      class << self
+        def run(filename, **opts)
+          file_source = opts[:source] || File.read(filename)
+
+          items = []
+
+          deep_iterator(Ripper.sexp(file_source)) do |item, extra_data|
+            scope = extra_data[:scope]
+            next unless %i[vcall fcall].include?(scope[-2])
+            next unless scope[-1] == :@ident
+            next unless item.end_with?('_path', '_url')
+
+            next if opts[:filter].respond_to?(:call) && !opts[:filter].call(item)
+
+            line = extra_data[:position][0]
+            line = opts[:source_map][line] || 'unknown' if opts[:source_map]
+
+            items << { file: filename, line: line, method: item }
+          end
+
+          items
+        end
+
+        private
+
+        def deep_iterator(list, current_scope = [], current_line_num = [], &block)
+          if list.is_a?(Array)
+            if list[0].is_a?(Symbol)
+              current_scope << list[0]
+
+              if list[-1].is_a?(Array) && list[-1].length == 2 && list[-1].all? { |item| item.is_a?(Integer) }
+                current_line_num = list[-1]
+                list = list[0..-2]
+              end
+
+              list[1..-1].each do |item|
+                deep_iterator(item, current_scope, current_line_num, &block)
+              end
+              current_scope.pop
+            else
+              list.each do |item|
+                deep_iterator(item, current_scope, current_line_num, &block)
+              end
+            end
+          elsif !list.nil?
+            yield(list, { scope: current_scope, position: current_line_num })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-route-checker/version.rb

@@ -1,3 +1,3 @@
 module RailsRouteChecker
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-route-checker
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Dave Allie
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-28 00:00:00.000000000 Z
+date: 2017-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,6 +68,18 @@ files:
 - lib/rails-route-checker/app_interface.rb
 - lib/rails-route-checker/config_file.rb
 - lib/rails-route-checker/loaded_app.rb
+- lib/rails-route-checker/parsers/erb_parser.rb
+- lib/rails-route-checker/parsers/haml_parser.rb
+- lib/rails-route-checker/parsers/haml_parser/document.rb
+- lib/rails-route-checker/parsers/haml_parser/ruby_extractor.rb
+- lib/rails-route-checker/parsers/haml_parser/tree/filter_node.rb
+- lib/rails-route-checker/parsers/haml_parser/tree/node.rb
+- lib/rails-route-checker/parsers/haml_parser/tree/root_node.rb
+- lib/rails-route-checker/parsers/haml_parser/tree/script_node.rb
+- lib/rails-route-checker/parsers/haml_parser/tree/silent_script_node.rb
+- lib/rails-route-checker/parsers/haml_parser/tree/tag_node.rb
+- lib/rails-route-checker/parsers/loader.rb
+- lib/rails-route-checker/parsers/ruby_parser.rb
 - lib/rails-route-checker/runner.rb
 - lib/rails-route-checker/version.rb
 - rails-route-checker.gemspec