cql_ruby 0.0.6 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a856d1a192105ae54c8af21e06b28b8653d982b770eed3d7ad7d64b4a62b56e2
-  data.tar.gz: e11a83d4c61b8ce16ff9540869cf9d1c4da4664812d20881a0b6455d85875d7a
+  metadata.gz: d117740a94a14a7c3f8a6a62f7bb22ae3dbbc450a909de2c9d5c3a9d5eb6fb91
+  data.tar.gz: 1850b47222e7d5be2caf3b50221f2facececedff355873f4b752d08a9aabf096
 SHA512:
-  metadata.gz: 1e4c5d6c18e49543ff3776f31bcc42cbb6eb8c2709a9e764dcc947bf43f411725e3e32af7089a9f7059d6e502dc3b155dd94842833a81c557586b39390d5a505
-  data.tar.gz: 8317d7378cd86da7ea32b09b9e505eaa461a8f60d87a443e44ed82eafc02d32992d483224a221b2d0558a2796d428088d84bcc8205a74cb00f3adafe3c4a86f1
+  metadata.gz: 37a8dc083b6a7ee31d93ad01e01a1028bf58a0e5cf4ddee3fdb676ac3af606aeab679d6f9e8498865b42797cb159da93fa65479bce432811ead57f1c8827e0d9
+  data.tar.gz: a78b4f787e661d21e02f914058b6877ef863de7ed21beef8502f1ab278fa61799da32dd0a3956f54f4c0a7a9d3af95f34e7203819090f4f1189879333f0d4b70

data/bin/cql_ruby

@@ -1,12 +1,14 @@
 #!/usr/bin/env ruby
 
+require 'parser'
 require 'cql_ruby'
 
 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.
@@ -14,8 +16,11 @@ def show_help
     \tFILTERS
     \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?
 
     \tOPTIONS
+    \t\t--include=PATTERN Parses only files whose name matches the pattern.
+    \t\t--exclude=PATTERN Parses only files whose name does not match the pattern.
     \t\t-lN (N is integer) Add N surrounding line before and after.
     \t\t-nc (--no-color) No color on output.
     \t\t-nf (--no-file) No file names.
@@ -23,9 +28,13 @@ def show_help
     \t\t-nr (--no-recursion) Non-recursive search.
     \t\t-v -vv -vvv Debug output levels.
 
+    \tALLOWED NODE TYPES
+    \t\tWhen defining filters only valid AST types can be defined. They are:
+    #{Parser::Meta::NODE_TYPES.to_a.join(' ')}
+
     \tEXAMPLES
     \t\tcql_ruby user ./
-    \t\tcql_ruby -ns -nr %user_info ./ type:send,arg nest:block nest:class=r/User/i
+    \t\tcql_ruby -ns -nr %user_info ./ type:send,arg nest:block nest:class=r/User/i has:str=WARNING
   HELP
 
   exit
@@ -39,6 +48,9 @@ def extract_options
     show_source: true,
     recursive_search: true,
     surrounding_lines: 0,
+    include_pattern: nil,
+    exclude_pattern: nil,
+    search_type: :token,
   }
 
   ARGV.delete_if do |arg|
@@ -58,6 +70,14 @@ def extract_options
         options[:recursive_search] = false
       elsif arg[0..1] == '-l' && arg[2..].to_i > 0
         options[:surrounding_lines] = arg[2..].to_i
+      elsif arg.start_with?('--include=')
+        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
@@ -85,7 +105,6 @@ begin
   pattern = ARGV.shift
   CqlRuby.log "Call pattern: <#{pattern}>" if CqlRuby::Config.debug_level_2?
 
-  # TODO Make path patterns universal.
   path = ARGV.shift
   CqlRuby.log "Call path: <#{path}>" if CqlRuby::Config.debug_level_2?
 
@@ -109,8 +128,11 @@ begin
     path: path,
     filters: filters,
     recursive: options[:recursive_search],
+    include: options[:include_pattern],
+    exclude: options[:exclude_pattern],
+    search_type: options[:search_type],
   ).search_all
-rescue => e
-  puts "Error: #{e}"
+rescue
+  puts "Error: #{$!}"
   show_help
 end

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,7 +71,7 @@ module CqlRuby
       end
     end
 
-    # @param [Cqlruby::Crumb] crumb
+    # @param [CqlRuby::Crumb] crumb
     # @return [String]
     def decorate_source_line(crumb)
       source = crumb.source

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/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>]
@@ -33,7 +33,10 @@ module CqlRuby
       pattern:,
       path:,
       filters: [],
-      recursive: true
+      recursive: true,
+      include: nil,
+      exclude: nil,
+      search_type: :token
     )
       @collector = collector
       @filter_reader = filter_reader
@@ -41,10 +44,16 @@ module CqlRuby
       @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
@@ -58,17 +67,24 @@ module CqlRuby
       walk(ast, [], source_reader)
 
       nil
-    rescue => e
-      CqlRuby.log "File #{file} cannot be parsed: #{e}"
+    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 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
@@ -90,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
@@ -99,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?(Symbol)
+        ancestors.last
+      else
+        node
+      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,17 +3,18 @@
 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, ancestors, node),
         ].all?
       end
 
       private
 
       #
-      # @param [Cqlruby::FilterReader] filter_reader
+      # @param [CqlRuby::FilterReader] filter_reader
       # @param [Array<Parser::AST::Node>] ancestors
       #
       # @return [Boolean]
@@ -25,7 +26,7 @@ module CqlRuby
       end
 
       #
-      # @param [Cqlruby::FilterReader] filter_reader
+      # @param [CqlRuby::FilterReader] filter_reader
       # @param [Array<Parser::AST::Node>] ancestors
       #
       # @return [Boolean]
@@ -38,7 +39,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)
@@ -49,6 +49,84 @@ module CqlRuby
           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

data/lib/cql_ruby/filter_reader.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+# TODO: Have convenience filters for type:_ such as: isclass, ismodule, isdef ...
+
 module CqlRuby
-  class NestRule < Struct.new(:type, :name)
+  class NodeSpec < Struct.new(:type, :name)
+    # Make this non duplicated.
     NAME_ANY = '*'
-    ALLOWED_TYPE = %w[class module def block].freeze
 
     class << self
       #
@@ -15,8 +17,7 @@ module CqlRuby
         type, name = raw_value.split('=')
         name ||= NAME_ANY
 
-        raise "Unknown type: #{type}. Allowed: #{ALLOWED_TYPE}" unless ALLOWED_TYPE.include?(type)
-        raise "Type #{type} cannot have a name." if %w[block].include?(type) && 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
@@ -38,16 +39,21 @@ module CqlRuby
   # example: type:def,send
   #
   class FilterReader
-    # @attribute [Parser::AST::Node] allowed_types
+    NESTING_ALLOWED_TYPES = %w[class module def block].freeze
+
+    # @attribute [Array<Symbol>] allowed_types
     attr_reader :allowed_types
-    # @attribute [Array<Cqlruby::NestRule>] nest_under
+    # @attribute [Array<CqlRuby::NodeSpec>] nest_under
     attr_reader :nest_under
+    # @attribute [Array<CqlRuby::NodeSpec>] has_leaves
+    attr_reader :has_leaves
 
     def initialize(raw_filters)
       super()
 
       @allowed_types = []
       @nest_under = []
+      @has_leaves = []
 
       parse_raw_filters(raw_filters)
     end
@@ -60,6 +66,10 @@ module CqlRuby
       !@nest_under.empty?
     end
 
+    def restrict_children?
+      !@has_leaves.empty?
+    end
+
     private
 
     # @param [Array<String>] raw_filters
@@ -71,7 +81,13 @@ module CqlRuby
         if %w[type t].include?(name)
           @allowed_types += value.split(',').map(&:to_sym)
         elsif %w[nest n].include?(name)
-          @nest_under << NestRule.from(value)
+          spec = NodeSpec.from(value)
+          raise "Unknown type for nesting: '#{spec.type}' from '#{raw_filter}'. Allowed: #{NESTING_ALLOWED_TYPES}" unless NESTING_ALLOWED_TYPES.include?(spec.type)
+          raise "Type #{spec.type} cannot have a name." if %w[block].include?(spec.type) && spec.restrict_name?
+
+          @nest_under << spec
+        elsif %w[has h].include?(name)
+          @has_leaves << NodeSpec.from(value)
         end
       end
 

data/lib/cql_ruby/pattern_matcher.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.11
 platform: ruby
 authors:
 - itarato