cql_ruby 0.0.10 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e75a456d8dff7bb1b1affde452bfc7df1e01508a2514ca1729cf996e28c3bff6
-  data.tar.gz: 57d5bdbfe2991ba0ed0c529373405885cc4382c8cf2f6cec3c86117b65fc31bf
+  metadata.gz: f10c73e5413cfa12307f6343a47469c7b4836e682d31847f5786539a2edff359
+  data.tar.gz: 4c54670fbfea11478aefd78b266448f9776988ce2089df53ceae001ae35b57eb
 SHA512:
-  metadata.gz: b56ead4780a2823d1e327c7ab24e5d73923d21096a5b95832cdfbe7bc499a335bdc2ea5d252efaff96e2ba4fd6471b4ca6e12c9c18f90249116bff509217b66d
-  data.tar.gz: 1b30aedc86c325e1cc6fdd8813abe2d46f5d76d34f542e0d9f0446b0a7fa42721c4f76dfec376c477287eff46d71311f2b86b20c1dea6c9658cfe8b04207b775
+  metadata.gz: f7b22f9f736297227407e8abfaddc33329d3564174dce7072330149d84d15a160df6ce18b34bf3237977af5cf467370d983536bd7c453d3d8d398950644562f0
+  data.tar.gz: a3e8fcf9c81fff91cf9f807ba5ce8185b97e354842e1f95e694528badd93cdde19dbbccd22d2ede34d8309df268b1fbebd162cf14df03e35f4b950d72e24a05e

data/bin/cql_ruby

@@ -2,12 +2,14 @@
 
 require 'parser'
 require 'cql_ruby'
+require 'pry-byebug'
 
 def show_help
   puts <<~HELP
         
     \tSYNOPSIS
-    \t\tcql_ruby options pattern path filters ...
+    \t\tcql_ruby [--token] pattern path options filters ...
+    \t\tcql_ruby --node    type    path options filters ...
 
     \tDESCRIPTION
     \t\tCQL (Code Query Language) is a semantic search tool for your Ruby source code.
@@ -16,6 +18,8 @@ def show_help
     \t\tParent node type: type:T(,T)* Example: type:def,send,arg
     \t\tNesting under: nest:T(=NAME) Example: nest:def=save_user nest:class=UserManager
     \t\tHas child: has:T(=NAME) Example: has:const has:def=valid?
+    \t\tPattern: pattern:(T-)*X(-T)* Example: pattern:class-def-X-block
+    \t\tAssignment left side: assigned Example: assigned
 
     \tOPTIONS
     \t\t--include=PATTERN Parses only files whose name matches the pattern.
@@ -49,6 +53,7 @@ def extract_options
     surrounding_lines: 0,
     include_pattern: nil,
     exclude_pattern: nil,
+    search_type: :token,
   }
 
   ARGV.delete_if do |arg|
@@ -72,6 +77,10 @@ def extract_options
         options[:include_pattern] = arg.split('=')[1]
       elsif arg.start_with?('--exclude=')
         options[:exclude_pattern] = arg.split('=')[1]
+      elsif arg == '--node'
+        options[:search_type] = :node
+      elsif arg == '--token'
+        options[:search_type] = :token
       else
         raise "Unknown arg #{arg}"
       end
@@ -124,6 +133,7 @@ begin
     recursive: options[:recursive_search],
     include: options[:include_pattern],
     exclude: options[:exclude_pattern],
+    search_type: options[:search_type],
   ).search_all
 rescue
   puts "Error: #{$!}"

data/lib/cql_ruby.rb

@@ -6,10 +6,12 @@ module CqlRuby;
   end
 end
 
+require 'cql_ruby/defs'
 require 'cql_ruby/executor'
 require 'cql_ruby/crumb_collector'
 require 'cql_ruby/abstract_printer'
 require 'cql_ruby/console_printer'
 require 'cql_ruby/filter_reader'
+require 'cql_ruby/filters/assignments'
 require 'cql_ruby/filter_evaluator'
 require 'cql_ruby/pattern_matcher'

data/lib/cql_ruby/abstract_printer.rb

@@ -2,7 +2,7 @@
 
 module CqlRuby
   #
-  # Printing Cqlruby::Crumb-s.
+  # Printing CqlRuby::Crumb-s.
   #
   class AbstractPrinter
     def print(_crumb)

data/lib/cql_ruby/console_printer.rb

@@ -21,7 +21,7 @@ module CqlRuby
     end
 
     #
-    # @param crumb [Cqlruby::Crumb]
+    # @param crumb [CqlRuby::Crumb]
     #
     def print(crumb)
       parts = "##{color(97)}#{@counter}#{decor_reset}"
@@ -71,14 +71,18 @@ module CqlRuby
       end
     end
 
-    # @param [Cqlruby::Crumb] crumb
+    # @param [CqlRuby::Crumb] crumb
     # @return [String]
     def decorate_source_line(crumb)
       source = crumb.source
       from = crumb.line_col_no
       to = from + crumb.expression_size
 
-      prefix = source[0..from - 1] || ''
+      prefix = if from > 0
+        source[0..from - 1] || ''
+      else
+        ''
+      end
       subject = source[from..to - 1] || ''
       suffix = source[to..] || ''
 

data/lib/cql_ruby/crumb_collector.rb

@@ -3,7 +3,7 @@
 module CqlRuby
   class CrumbCollector
     #
-    # @param printer [Cqlruby::AbstractPrinter]
+    # @param printer [CqlRuby::AbstractPrinter]
     #
     def initialize(printer)
       super()

data/lib/cql_ruby/defs.rb

@@ -0,0 +1,3 @@
+module CqlRuby
+  MATCH_ANYTHING = '*'
+end

data/lib/cql_ruby/executor.rb

@@ -20,7 +20,7 @@ end
 #
 # Executes search and dumps results into the collector.
 #
-# @param collector [Cqlruby::CrumbCollector]
+# @param collector [CqlRuby::CrumbCollector]
 # @param pattern [String]
 # @param path [String]
 # @param filters [Array<String>]
@@ -35,7 +35,8 @@ module CqlRuby
       filters: [],
       recursive: true,
       include: nil,
-      exclude: nil
+      exclude: nil,
+      search_type: :token
     )
       @collector = collector
       @filter_reader = filter_reader
@@ -45,6 +46,7 @@ module CqlRuby
       @recursive = recursive
       @include = include
       @exclude = exclude
+      @search_type = search_type
     end
 
     def search_all
@@ -72,11 +74,17 @@ module CqlRuby
 
     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 match?(node) && CqlRuby::FilterEvaluator.pass?(filter_reader, node, ancestors)
+        if search_for_token? && match?(node) && CqlRuby::FilterEvaluator.pass?(filter_reader, ancestors, node)
           collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
         end
       end
@@ -98,6 +106,14 @@ module CqlRuby
       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
@@ -107,33 +123,55 @@ module CqlRuby
   end
 end
 
-CqlRuby::Crumb = Struct.new(:full_name, :ancestors, :source_reader) do
-  def line_no
-    ancestors.last.location.expression.line
-  end
+module CqlRuby
+  class Crumb
+    def initialize(node, ancestors, source_reader)
+      @node = node
+      @ancestors = ancestors
+      @source_reader = source_reader
+    end
 
-  def line_col_no
-    ancestors.last.location.expression.column
-  end
+    def line_no
+      anchor.location.expression.line
+    end
 
-  def source
-    source_reader.source_line(line_no)
-  end
+    def line_col_no
+      anchor.location.expression.column
+    end
 
-  def surrounding_line(offset)
-    source_reader.source_line(line_no + offset)
-  end
+    def source
+      source_reader.source_line(line_no)
+    end
 
-  def file_name
-    source_reader.file
-  end
+    def surrounding_line(offset)
+      source_reader.source_line(line_no + offset)
+    end
 
-  def expression_size
-    ancestors.last.location.expression.size
-  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
 
-  def type
-    ancestors.last.type
+    attr_reader :node
+    attr_reader :ancestors
+    attr_reader :source_reader
   end
 end
 

data/lib/cql_ruby/filter_evaluator.rb

@@ -3,18 +3,20 @@
 module CqlRuby
   class FilterEvaluator
     class << self
-      def pass?(filter_reader, node, ancestors)
+      def pass?(filter_reader, ancestors, node)
         [
           pass_type?(filter_reader, ancestors),
           pass_nesting?(filter_reader, ancestors),
-          pass_has?(filter_reader, node, ancestors),
+          pass_has?(filter_reader, ancestors, node),
+          pass_pattern?(filter_reader, ancestors, node),
+          pass_assignment?(filter_reader, ancestors, node),
         ].all?
       end
 
       private
 
       #
-      # @param [Cqlruby::FilterReader] filter_reader
+      # @param [CqlRuby::FilterReader] filter_reader
       # @param [Array<Parser::AST::Node>] ancestors
       #
       # @return [Boolean]
@@ -39,7 +41,6 @@ module CqlRuby
             next false unless ancestor.type.to_s == nest_rule.type
             next true unless nest_rule.restrict_name?
 
-            # TODO Make a proper matcher class.
             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)
@@ -53,20 +54,86 @@ module CqlRuby
 
       #
       # @param [CqlRuby::FilterReader] filter_reader
-      # @param [Parser::AST::Node] node
       # @param [Array<Parser::AST::Node>] ancestors
+      # @param [Any<Parser::AST::Node, Symbol>] node
+      #
+      # @return [Boolean]
       #
-      def pass_has?(filter_reader, node, ancestors)
+      def pass_has?(filter_reader, ancestors, node)
         return true unless filter_reader.restrict_children?
 
         filter_reader.has_leaves.all? do |has_rule|
-          anchor_node = try_get_class(ancestors) || try_get_module(ancestors) || try_get_def(ancestors)
+          anchor_node = if node.is_a?(Symbol)
+            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
+      #
+      # @return [Boolean]
+      #
+      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 [CqlRuby::FilterReader] filter_reader
+      # @param [Array<Parser::AST::Node>] ancestors
+      # @param [Parser::AST::Node] node
+      #
+      # @return [Boolean]
+      #
+      def pass_assignment?(filter_reader, ancestors, node)
+        CqlRuby::Filters::Assignments.pass?(filter_reader, ancestors, node)
+      end
+
+      #
+      # @param [Array<String>] pattern_descendants
+      # @param [Parser::AST::Node] node
+      #
+      # @return [Boolean]
+      #
+      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
       #
@@ -101,7 +168,7 @@ module CqlRuby
 
       #
       # @param [Parser::AST::Node] anchor_node
-      # @param [CqlRuby::NodeSpec]
+      # @param [CqlRuby::FilterReader::NodeSpec]
       #
       def has_node_with_name?(anchor_node, has_rule)
         return false unless anchor_node.is_a?(Parser::AST::Node)

data/lib/cql_ruby/filter_reader.rb

@@ -1,33 +1,6 @@
 # frozen_string_literal: true
 
-# TODO: Have convenience filters for type:_ such as: isclass, ismodule, isdef ...
-
 module CqlRuby
-  class NodeSpec < Struct.new(:type, :name)
-    # Make this non duplicated.
-    NAME_ANY = '*'
-
-    class << self
-      #
-      # @param [String] raw_value
-      #   Format: TYPE(=NAME|=*)
-      #   Accepted types: class, module, def, block
-      #
-      def from(raw_value)
-        type, name = raw_value.split('=')
-        name ||= NAME_ANY
-
-        raise "Type '#{type}' is not recognized. See 'cql_ruby --help' for allowed types." unless Parser::Meta::NODE_TYPES.member?(type.to_sym)
-
-        new(type, name)
-      end
-    end
-
-    def restrict_name?
-      name != NAME_ANY
-    end
-  end
-
   #
   # Reads and provides filters.
   #
@@ -39,21 +12,72 @@ module CqlRuby
   # example: type:def,send
   #
   class FilterReader
+    class HierarchyPattern
+      SELF_MARKER = 'X'
+
+      def self.from(raw_value)
+        parts = raw_value.split('-')
+        self_marker_idx = parts.index(SELF_MARKER)
+        raise "Missing self marker '#{SELF_MARKER}' in hierarchy pattern." if self_marker_idx.nil?
+
+        ancestors = parts[0...self_marker_idx]
+        descendants = parts[self_marker_idx + 1..]
+
+        new(ancestors, descendants)
+      end
+
+      attr_reader :ancestors
+      attr_reader :descendants
+
+      def initialize(ancestors, descendants)
+        @ancestors = ancestors
+        @descendants = descendants
+      end
+    end
+
+    class NodeSpec < Struct.new(:type, :name)
+      class << self
+        #
+        # @param [String] raw_value
+        #   Format: TYPE(=NAME|=*)
+        #   Accepted types: class, module, def, block
+        #
+        def from(raw_value)
+          type, name = raw_value.split('=')
+          name ||= CqlRuby::MATCH_ANYTHING
+
+          raise "Type '#{type}' is not recognized. See 'cql_ruby --help' for allowed types." unless Parser::Meta::NODE_TYPES.member?(type.to_sym)
+
+          new(type, name)
+        end
+      end
+
+      def restrict_name?
+        name != CqlRuby::MATCH_ANYTHING
+      end
+    end
+
     NESTING_ALLOWED_TYPES = %w[class module def block].freeze
 
     # @attribute [Array<Symbol>] allowed_types
     attr_reader :allowed_types
-    # @attribute [Array<CqlRuby::NodeSpec>] nest_under
+    # @attribute [Array<CqlRuby::FilterReader::NodeSpec>] nest_under
     attr_reader :nest_under
-    # @attribute [Array<CqlRuby::NodeSpec>] has_leaves
+    # @attribute [Array<CqlRuby::FilterReader::NodeSpec>] has_leaves
     attr_reader :has_leaves
+    # @attribute [Array<CqlRuby::FilterReader::HierarchyPattern>] patterns
+    attr_reader :patterns
+    # @attribute [Boolean] is_assigned
+    attr_reader :is_assigned
 
-    def initialize(raw_filters)
+    def initialize(raw_filters = [])
       super()
 
       @allowed_types = []
       @nest_under = []
       @has_leaves = []
+      @patterns = []
+      @is_assigned = false
 
       parse_raw_filters(raw_filters)
     end
@@ -70,13 +94,21 @@ module CqlRuby
       !@has_leaves.empty?
     end
 
+    def restrict_pattern?
+      !@patterns.empty?
+    end
+
+    def restrict_assignment?
+      @is_assigned
+    end
+
     private
 
     # @param [Array<String>] raw_filters
     def parse_raw_filters(raw_filters)
       raw_filters.each do |raw_filter|
         name, value = raw_filter.split(':')
-        raise "Unrecognized filter: #{raw_filter}" if name.nil? || value.nil?
+        raise "Unrecognized filter: #{raw_filter}" if name.nil?
 
         if %w[type t].include?(name)
           @allowed_types += value.split(',').map(&:to_sym)
@@ -88,6 +120,10 @@ module CqlRuby
           @nest_under << spec
         elsif %w[has h].include?(name)
           @has_leaves << NodeSpec.from(value)
+        elsif %w[pattern p].include?(name)
+          @patterns << HierarchyPattern.from(value)
+        elsif name == 'assigned'
+          @is_assigned = true
         end
       end
 

data/lib/cql_ruby/filters/assignments.rb

@@ -0,0 +1,151 @@
+module CqlRuby
+  module Filters
+    class Assignments
+      class << self
+        #
+        # @param [CqlRuby::FilterReader] filter_reader
+        # @param [Array<Parser::AST::Node>] ancestors
+        # @param [Parser::AST::Node] node
+        #
+        # @return [Boolean]
+        #
+        def pass?(filter_reader, ancestors, node)
+          return true unless filter_reader.restrict_assignment?
+          return true if lvar_assign?(ancestors, node)
+          return true if instance_attr_assign?(ancestors, node)
+          return true if array_sym_key_assign?(ancestors, node)
+          return true if array_string_key_assign?(ancestors, node)
+          return true if hash_sym_key_assign?(ancestors, node)
+          return true if hash_string_key_assign?(ancestors, node)
+          false
+        end
+
+        private
+
+        #
+        # @param [Array<Parser::AST::Node>] ancestors
+        # @param [Parser::AST::Node] node
+        #
+        # @return [Boolean]
+        #
+        def lvar_assign?(ancestors, node)
+          pattern_pass?({
+            nth_child: 0,
+            parent: {
+              type: :lvasgn
+            }
+          }, ancestors, node)
+        end
+
+        # TODO This does not work as symbol token is suffixed with =, eg foo= for bar.foo = x.
+        # Workaround for now is to use a =-alloed pattern, such as 'r/^token(|=)$/'
+        def instance_attr_assign?(ancestors, node)
+          pattern_pass?({
+            nth_child: 1,
+            parent: {
+              type: :send
+            }
+          }, ancestors, node)
+        end
+
+        def array_sym_key_assign?(ancestors, node)
+          pattern_pass?({
+            nth_child: 0,
+            parent: {
+              type: :sym,
+              nth_child: 2,
+              parent: {
+                type: :send,
+                child: {
+                  nth: 1,
+                  token: :[]=
+                }
+              }
+            }
+          }, ancestors, node)
+        end
+
+        def array_string_key_assign?(ancestors, node)
+          pattern_pass?({
+            nth_child: 0,
+            parent: {
+              type: :str,
+              nth_child: 2,
+              parent: {
+                type: :send,
+                child: {
+                  nth: 1,
+                  token: :[]=
+                }
+              }
+            }
+          }, ancestors, node)
+        end
+
+        def hash_sym_key_assign?(ancestors, node)
+          pattern_pass?({
+            nth_child: 0,
+            parent: {
+              type: :sym,
+              nth_child: 0,
+              parent: {
+                type: :pair,
+                parent: {
+                  type: :hash
+                }
+              }
+            }
+          }, ancestors, node)
+        end
+
+        def hash_string_key_assign?(ancestors, node)
+          pattern_pass?({
+            nth_child: 0,
+            parent: {
+              type: :str,
+              nth_child: 0,
+              parent: {
+                type: :pair,
+                parent: {
+                  type: :hash
+                }
+              }
+            }
+          }, ancestors, node)
+        end
+
+        def pattern_pass?(pattern, ancestors, node)
+          ancestor_idx = ancestors.size
+          current_node = node
+          current_pattern = pattern
+
+          loop do
+            if current_pattern.key?(:nth_child)
+              return false unless ancestor_idx - 1 >= 0
+              return false unless ancestors[ancestor_idx - 1].is_a?(Parser::AST::Node)
+              return false unless ancestors[ancestor_idx - 1].children[current_pattern[:nth_child]] == current_node
+            end
+
+            if current_pattern.key?(:type)
+              return false unless current_node.type == current_pattern[:type]
+            end
+
+            if current_pattern.key?(:child)
+              return false if current_node.children.size <= current_pattern[:child][:nth]
+              return false unless current_node.children[current_pattern[:child][:nth]] == current_pattern[:child][:token]
+            end
+
+            break unless current_pattern.key?(:parent)
+
+            ancestor_idx -= 1
+            return false unless ancestor_idx >= 0
+            current_node = ancestors[ancestor_idx]
+            current_pattern = current_pattern[:parent]
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/cql_ruby/pattern_matcher.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 module CqlRuby
   module PatternMatcher
-    MATCH_ANY = '*'
-
     def self.match?(pattern, subject)
       pattern = pattern.to_s
-      return true if pattern == MATCH_ANY
+      return true if pattern == CqlRuby::MATCH_ANYTHING
 
       subject = subject.to_s
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.15
 platform: ruby
 authors:
 - itarato
@@ -30,6 +30,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: it.arato@gmail.com
 executables:
@@ -42,9 +56,11 @@ files:
 - lib/cql_ruby/abstract_printer.rb
 - lib/cql_ruby/console_printer.rb
 - lib/cql_ruby/crumb_collector.rb
+- lib/cql_ruby/defs.rb
 - lib/cql_ruby/executor.rb
 - lib/cql_ruby/filter_evaluator.rb
 - lib/cql_ruby/filter_reader.rb
+- lib/cql_ruby/filters/assignments.rb
 - lib/cql_ruby/pattern_matcher.rb
 homepage: https://github.com/itarato/cql
 licenses: