cql_ruby 0.0.11 → 0.0.12

data/lib/cql_ruby/crumb_collector.rb

@@ -1,18 +1,18 @@
-# frozen_string_literal: true
-
-module CqlRuby
-  class CrumbCollector
-    #
-    # @param printer [CqlRuby::AbstractPrinter]
-    #
-    def initialize(printer)
-      super()
-
-      @printer = printer
-    end
-
-    def add(crumb)
-      @printer.print(crumb)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module CqlRuby
+  class CrumbCollector
+    #
+    # @param printer [CqlRuby::AbstractPrinter]
+    #
+    def initialize(printer)
+      super()
+
+      @printer = printer
+    end
+
+    def add(crumb)
+      @printer.print(crumb)
+    end
+  end
+end

data/lib/cql_ruby/executor.rb

@@ -1,194 +1,194 @@
-# frozen_string_literal: true
-
-require 'parser/current'
-require 'pathname'
-
-module CqlRuby
-  class Config
-    @@debug_level = 0
-
-    class << self
-      def debug_level=(lvl); @@debug_level = lvl; end
-      def debug_level; @@debug_level; end
-      def debug_level_1?; @@debug_level >= 1; end
-      def debug_level_2?; @@debug_level >= 2; end
-      def debug_level_3?; @@debug_level >= 3; end
-    end
-  end
-end
-
-#
-# Executes search and dumps results into the collector.
-#
-# @param collector [CqlRuby::CrumbCollector]
-# @param pattern [String]
-# @param path [String]
-# @param filters [Array<String>]
-#
-module CqlRuby
-  class Executor
-    def initialize(
-      collector:,
-      filter_reader:,
-      pattern:,
-      path:,
-      filters: [],
-      recursive: true,
-      include: nil,
-      exclude: nil,
-      search_type: :token
-    )
-      @collector = collector
-      @filter_reader = filter_reader
-      @pattern = pattern
-      @path = path
-      @filters = filters
-      @recursive = recursive
-      @include = include
-      @exclude = exclude
-      @search_type = search_type
-    end
-
-    def search_all
-      files.flat_map do |file|
-        next if !@exclude.nil? && CqlRuby::PatternMatcher.match?(@exclude, file)
-        next unless @include.nil? || CqlRuby::PatternMatcher.match?(@include, file)
-
-        CqlRuby.log "File check: #{file}" if CqlRuby::Config.debug_level_3?
-        search(file)
-      end
-    end
-
-    private
-
-    def search(file)
-      ast = Parser::CurrentRuby.parse(File.read(file))
-      source_reader = CqlRuby::SourceReader.new(file)
-      walk(ast, [], source_reader)
-
-      nil
-    rescue
-      CqlRuby.log "File #{file} cannot be parsed"
-      CqlRuby.log "Reason: #{$!}" if CqlRuby::Config.debug_level_1?
-    end
-
-    def walk(node, ancestors, source_reader)
-      if node.is_a?(Parser::AST::Node)
-        if search_for_node?
-          if match?(node.type) && CqlRuby::FilterEvaluator.pass?(filter_reader, ancestors, node)
-            collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
-          end
-        end
-
-        node.children.flat_map do |child|
-          walk(child, ancestors.dup + [node], source_reader)
-        end
-      else
-        if search_for_token? && match?(node) && CqlRuby::FilterEvaluator.pass?(filter_reader, ancestors, node)
-          collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
-        end
-      end
-
-      nil
-    end
-
-    def match?(target)
-      CqlRuby::PatternMatcher.match?(pattern, target)
-    end
-
-    def files
-      return [path] if File.file?(path)
-
-      clean_path = Pathname(path).cleanpath.to_s
-      clean_path += '/**' if recursive
-      clean_path += '/*.rb'
-
-      Dir.glob(clean_path)
-    end
-
-    def search_for_token?
-      @search_type == :token
-    end
-
-    def search_for_node?
-      @search_type == :node
-    end
-
-    attr_reader :collector
-    attr_reader :filter_reader
-    attr_reader :pattern
-    attr_reader :path
-    attr_reader :filters
-    attr_reader :recursive
-  end
-end
-
-module CqlRuby
-  class Crumb
-    def initialize(node, ancestors, source_reader)
-      @node = node
-      @ancestors = ancestors
-      @source_reader = source_reader
-    end
-
-    def line_no
-      anchor.location.expression.line
-    end
-
-    def line_col_no
-      anchor.location.expression.column
-    end
-
-    def source
-      source_reader.source_line(line_no)
-    end
-
-    def surrounding_line(offset)
-      source_reader.source_line(line_no + offset)
-    end
-
-    def file_name
-      source_reader.file
-    end
-
-    def expression_size
-      anchor.location.expression.size
-    end
-
-    def type
-      anchor.type
-    end
-
-    private
-
-    def anchor
-      if node.is_a?(Symbol)
-        ancestors.last
-      else
-        node
-      end
-    end
-
-    attr_reader :node
-    attr_reader :ancestors
-    attr_reader :source_reader
-  end
-end
-
-CqlRuby::SourceReader = Struct.new(:file) do
-  def initialize(*args)
-    super
-  end
-
-  def source_line(n)
-    return nil unless lines.size >= n
-
-    lines[n - 1].chop
-  end
-
-  private
-
-  def lines
-    @lines ||= IO.readlines(file)
-  end
-end
+# frozen_string_literal: true
+
+require 'parser/current'
+require 'pathname'
+
+module CqlRuby
+  class Config
+    @@debug_level = 0
+
+    class << self
+      def debug_level=(lvl); @@debug_level = lvl; end
+      def debug_level; @@debug_level; end
+      def debug_level_1?; @@debug_level >= 1; end
+      def debug_level_2?; @@debug_level >= 2; end
+      def debug_level_3?; @@debug_level >= 3; end
+    end
+  end
+end
+
+#
+# Executes search and dumps results into the collector.
+#
+# @param collector [CqlRuby::CrumbCollector]
+# @param pattern [String]
+# @param path [String]
+# @param filters [Array<String>]
+#
+module CqlRuby
+  class Executor
+    def initialize(
+      collector:,
+      filter_reader:,
+      pattern:,
+      path:,
+      filters: [],
+      recursive: true,
+      include: nil,
+      exclude: nil,
+      search_type: :token
+    )
+      @collector = collector
+      @filter_reader = filter_reader
+      @pattern = pattern
+      @path = path
+      @filters = filters
+      @recursive = recursive
+      @include = include
+      @exclude = exclude
+      @search_type = search_type
+    end
+
+    def search_all
+      files.flat_map do |file|
+        next if !@exclude.nil? && CqlRuby::PatternMatcher.match?(@exclude, file)
+        next unless @include.nil? || CqlRuby::PatternMatcher.match?(@include, file)
+
+        CqlRuby.log "File check: #{file}" if CqlRuby::Config.debug_level_3?
+        search(file)
+      end
+    end
+
+    private
+
+    def search(file)
+      ast = Parser::CurrentRuby.parse(File.read(file))
+      source_reader = CqlRuby::SourceReader.new(file)
+      walk(ast, [], source_reader)
+
+      nil
+    rescue
+      CqlRuby.log "File #{file} cannot be parsed"
+      CqlRuby.log "Reason: #{$!}" if CqlRuby::Config.debug_level_1?
+    end
+
+    def walk(node, ancestors, source_reader)
+      if node.is_a?(Parser::AST::Node)
+        if search_for_node?
+          if match?(node.type) && CqlRuby::FilterEvaluator.pass?(filter_reader, ancestors, node)
+            collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
+          end
+        end
+
+        node.children.flat_map do |child|
+          walk(child, ancestors.dup + [node], source_reader)
+        end
+      else
+        if search_for_token? && match?(node) && CqlRuby::FilterEvaluator.pass?(filter_reader, ancestors, node)
+          collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
+        end
+      end
+
+      nil
+    end
+
+    def match?(target)
+      CqlRuby::PatternMatcher.match?(pattern, target)
+    end
+
+    def files
+      return [path] if File.file?(path)
+
+      clean_path = Pathname(path).cleanpath.to_s
+      clean_path += '/**' if recursive
+      clean_path += '/*.rb'
+
+      Dir.glob(clean_path)
+    end
+
+    def search_for_token?
+      @search_type == :token
+    end
+
+    def search_for_node?
+      @search_type == :node
+    end
+
+    attr_reader :collector
+    attr_reader :filter_reader
+    attr_reader :pattern
+    attr_reader :path
+    attr_reader :filters
+    attr_reader :recursive
+  end
+end
+
+module CqlRuby
+  class Crumb
+    def initialize(node, ancestors, source_reader)
+      @node = node
+      @ancestors = ancestors
+      @source_reader = source_reader
+    end
+
+    def line_no
+      anchor.location.expression.line
+    end
+
+    def line_col_no
+      anchor.location.expression.column
+    end
+
+    def source
+      source_reader.source_line(line_no)
+    end
+
+    def surrounding_line(offset)
+      source_reader.source_line(line_no + offset)
+    end
+
+    def file_name
+      source_reader.file
+    end
+
+    def expression_size
+      anchor.location.expression.size
+    end
+
+    def type
+      anchor.type
+    end
+
+    private
+
+    def anchor
+      if node.is_a?(Parser::AST::Node)
+        node
+      else
+        ancestors.last
+      end
+    end
+
+    attr_reader :node
+    attr_reader :ancestors
+    attr_reader :source_reader
+  end
+end
+
+CqlRuby::SourceReader = Struct.new(:file) do
+  def initialize(*args)
+    super
+  end
+
+  def source_line(n)
+    return nil unless lines.size >= n
+
+    lines[n - 1].chop
+  end
+
+  private
+
+  def lines
+    @lines ||= IO.readlines(file)
+  end
+end

data/lib/cql_ruby/filter_evaluator.rb

@@ -1,132 +1,178 @@
-# frozen_string_literal: true
-
-module CqlRuby
-  class FilterEvaluator
-    class << self
-      def pass?(filter_reader, ancestors, node)
-        [
-          pass_type?(filter_reader, ancestors),
-          pass_nesting?(filter_reader, ancestors),
-          pass_has?(filter_reader, ancestors, node),
-        ].all?
-      end
-
-      private
-
-      #
-      # @param [CqlRuby::FilterReader] filter_reader
-      # @param [Array<Parser::AST::Node>] ancestors
-      #
-      # @return [Boolean]
-      #
-      def pass_type?(filter_reader, ancestors)
-        return true unless filter_reader.restrict_types?
-
-        filter_reader.allowed_types.include?(ancestors.last.type)
-      end
-
-      #
-      # @param [CqlRuby::FilterReader] filter_reader
-      # @param [Array<Parser::AST::Node>] ancestors
-      #
-      # @return [Boolean]
-      #
-      def pass_nesting?(filter_reader, ancestors)
-        return true unless filter_reader.restrict_nesting?
-
-        filter_reader.nest_under.all? do |nest_rule|
-          ancestors.reverse.any? do |ancestor|
-            next false unless ancestor.type.to_s == nest_rule.type
-            next true unless nest_rule.restrict_name?
-
-            if %w[class module].include?(nest_rule.type)
-              CqlRuby::PatternMatcher.match?(nest_rule.name, ancestor.children[0].children[1])
-            elsif %[def].include?(nest_rule.type)
-              CqlRuby::PatternMatcher.match?(nest_rule.name, ancestor.children[0])
-            else
-              raise 'Unknown type.'
-            end
-          end
-        end
-      end
-
-      #
-      # @param [CqlRuby::FilterReader] filter_reader
-      # @param [Array<Parser::AST::Node>] ancestors
-      # @param [Any<Parser::AST::Node, Symbol>] node
-      #
-      def pass_has?(filter_reader, ancestors, node)
-        return true unless filter_reader.restrict_children?
-
-        filter_reader.has_leaves.all? do |has_rule|
-          anchor_node = if node.is_a?(Symbol)
-            # TODO: Expand this to other wrappers (loops, conditions, etc).
-            try_get_class(ancestors) || try_get_module(ancestors) || try_get_def(ancestors)
-          else
-            node
-          end
-          next false unless anchor_node
-
-          has_node_with_name?(anchor_node, has_rule)
-        end
-      end
-
-      #
-      # @param [Array<Parser::AST::Node>] ancestors
-      #
-      def try_get_class(ancestors)
-        return nil unless ancestors.size >= 2
-        return nil unless ancestors[-1].type == :const
-        return nil unless ancestors[-2].type == :class
-
-        ancestors[-2].children[2]
-      end
-
-      #
-      # @param [Array<Parser::AST::Node>] ancestors
-      #
-      def try_get_module(ancestors)
-        return nil unless ancestors.size >= 2
-        return nil unless ancestors[-1].type == :const
-        return nil unless ancestors[-2].type == :module
-
-        ancestors[-2].children[1]
-      end
-
-      #
-      # @param [Array<Parser::AST::Node>] ancestors
-      #
-      def try_get_def(ancestors)
-        return nil unless ancestors.size >= 1
-        return nil unless ancestors[-1].type == :def
-
-        ancestors[-1].children[2]
-      end
-
-      #
-      # @param [Parser::AST::Node] anchor_node
-      # @param [CqlRuby::NodeSpec]
-      #
-      def has_node_with_name?(anchor_node, has_rule)
-        return false unless anchor_node.is_a?(Parser::AST::Node)
-
-        fn_children_with_type = ->(node) { node.children.map { |child| [child, node.type] } }
-        to_visit = fn_children_with_type.call(anchor_node)
-
-        until to_visit.empty?
-          current_node, current_type = to_visit.shift
-
-          if current_node.is_a?(Parser::AST::Node)
-            to_visit += fn_children_with_type.call(current_node)
-          else
-            if current_type == has_rule.type.to_sym && CqlRuby::PatternMatcher.match?(has_rule.name, current_node)
-              return true
-            end
-          end
-        end
-
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module CqlRuby
+  class FilterEvaluator
+    class << self
+      def pass?(filter_reader, ancestors, node)
+        [
+          pass_type?(filter_reader, ancestors),
+          pass_nesting?(filter_reader, ancestors),
+          pass_has?(filter_reader, ancestors, node),
+          pass_pattern?(filter_reader, ancestors, node),
+        ].all?
+      end
+
+      private
+
+      #
+      # @param [CqlRuby::FilterReader] filter_reader
+      # @param [Array<Parser::AST::Node>] ancestors
+      #
+      # @return [Boolean]
+      #
+      def pass_type?(filter_reader, ancestors)
+        return true unless filter_reader.restrict_types?
+
+        filter_reader.allowed_types.include?(ancestors.last.type)
+      end
+
+      #
+      # @param [CqlRuby::FilterReader] filter_reader
+      # @param [Array<Parser::AST::Node>] ancestors
+      #
+      # @return [Boolean]
+      #
+      def pass_nesting?(filter_reader, ancestors)
+        return true unless filter_reader.restrict_nesting?
+
+        filter_reader.nest_under.all? do |nest_rule|
+          ancestors.reverse.any? do |ancestor|
+            next false unless ancestor.type.to_s == nest_rule.type
+            next true unless nest_rule.restrict_name?
+
+            if %w[class module].include?(nest_rule.type)
+              CqlRuby::PatternMatcher.match?(nest_rule.name, ancestor.children[0].children[1])
+            elsif %[def].include?(nest_rule.type)
+              CqlRuby::PatternMatcher.match?(nest_rule.name, ancestor.children[0])
+            else
+              raise 'Unknown type.'
+            end
+          end
+        end
+      end
+
+      #
+      # @param [CqlRuby::FilterReader] filter_reader
+      # @param [Array<Parser::AST::Node>] ancestors
+      # @param [Any<Parser::AST::Node, Symbol>] node
+      #
+      def pass_has?(filter_reader, ancestors, node)
+        return true unless filter_reader.restrict_children?
+
+        filter_reader.has_leaves.all? do |has_rule|
+          anchor_node = if node.is_a?(Symbol)
+            # TODO: Expand this to other wrappers (loops, conditions, etc).
+            try_get_class(ancestors) || try_get_module(ancestors) || try_get_def(ancestors)
+          else
+            node
+          end
+          next false unless anchor_node
+
+          has_node_with_name?(anchor_node, has_rule)
+        end
+      end
+
+      #
+      # @param [CqlRuby::FilterReader] filter_reader
+      # @param [Array<Parser::AST::Node>] ancestors
+      # @param [Any<Parser::AST::Node, Symbol>] node
+      #
+      def pass_pattern?(filter_reader, ancestors, node)
+        return true unless filter_reader.restrict_pattern?
+
+        filter_reader.patterns.all? do |pattern|
+          pattern_ancestors = pattern.ancestors.dup
+          ancestor_idx = ancestors.size - 1
+
+          while !pattern_ancestors.empty? && ancestor_idx >= 0
+            if CqlRuby::PatternMatcher.match?(pattern_ancestors.last, ancestors[ancestor_idx].type)
+              pattern_ancestors.pop
+            end
+
+            ancestor_idx -= 1
+          end
+          return false unless pattern_ancestors.empty?
+
+          pattern_descendants = pattern.descendants.dup
+          match_descendant_pattern?(pattern_descendants, node)
+        end
+      end
+
+      #
+      # @param [Array<String>] pattern_descendants
+      # @param [Parser::AST::Node] node
+      #
+      def match_descendant_pattern?(pattern_descendants, node)
+        return true if pattern_descendants.empty?
+        # If we're at the end and we're still expecting a type - no match.
+        return false unless node.is_a?(Parser::AST::Node)
+
+        node.children.any? do |child|
+          next false unless child.is_a?(Parser::AST::Node)
+          if CqlRuby::PatternMatcher.match?(pattern_descendants.first, child.type)
+            match_descendant_pattern?(pattern_descendants[1..], child)
+          else
+            match_descendant_pattern?(pattern_descendants.dup, child)
+          end
+        end
+      end
+
+      #
+      # @param [Array<Parser::AST::Node>] ancestors
+      #
+      def try_get_class(ancestors)
+        return nil unless ancestors.size >= 2
+        return nil unless ancestors[-1].type == :const
+        return nil unless ancestors[-2].type == :class
+
+        ancestors[-2].children[2]
+      end
+
+      #
+      # @param [Array<Parser::AST::Node>] ancestors
+      #
+      def try_get_module(ancestors)
+        return nil unless ancestors.size >= 2
+        return nil unless ancestors[-1].type == :const
+        return nil unless ancestors[-2].type == :module
+
+        ancestors[-2].children[1]
+      end
+
+      #
+      # @param [Array<Parser::AST::Node>] ancestors
+      #
+      def try_get_def(ancestors)
+        return nil unless ancestors.size >= 1
+        return nil unless ancestors[-1].type == :def
+
+        ancestors[-1].children[2]
+      end
+
+      #
+      # @param [Parser::AST::Node] anchor_node
+      # @param [CqlRuby::NodeSpec]
+      #
+      def has_node_with_name?(anchor_node, has_rule)
+        return false unless anchor_node.is_a?(Parser::AST::Node)
+
+        fn_children_with_type = ->(node) { node.children.map { |child| [child, node.type] } }
+        to_visit = fn_children_with_type.call(anchor_node)
+
+        until to_visit.empty?
+          current_node, current_type = to_visit.shift
+
+          if current_node.is_a?(Parser::AST::Node)
+            to_visit += fn_children_with_type.call(current_node)
+          else
+            if current_type == has_rule.type.to_sym && CqlRuby::PatternMatcher.match?(has_rule.name, current_node)
+              return true
+            end
+          end
+        end
+
+        false
+      end
+    end
+  end
+end