cql_ruby 0.0.3 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ff996bf0e61aa22dd53f9eaf9768f1d2748ccf56a35bf4fb4cc2d65ed1d1e08
-  data.tar.gz: fbe683ebe25ab5f2a93a42c1f182ec665852536bf3deca9315ba6bf8084e9b24
+  metadata.gz: 17840020ae4f57f60763716ac438b33a68abb4b1add767d5f8e88cfb946439c8
+  data.tar.gz: 789aa975ced7c62036da026f7e4bd377c09b1502692ff217fb697641d5478d64
 SHA512:
-  metadata.gz: c1f7f6577eb7117f8f58057f880dd3dad25caf528a32251114aae9fb922583dcd2b6407b4ab782a4419dd040b04c47b5869fb4e49d0e5923c4ce55ae97c7f6ab
-  data.tar.gz: 58aca7b1d4323135126fd78c2b6b21df2cdd3b6ae6bdc06f211e75589349c2d286460bcf46f41211024e6bb0d07f4fe68b8364ad1a562ac9a697bdb3cf1ea16b
+  metadata.gz: ee8c4e5ea2cfde9a8837cc1e19734e0051424af9c15fe02fc5db49b11984052b70a4acb6d196b94c38820ea34bccbb8d78ff431e5bef45ac0627a55548fae324
+  data.tar.gz: 9e550d59e360717069c3198269bbe815d73aae7cc1d43b9532ed2fc4dee60b8f9decee399051ceedb9b0ae21867e785cce0423170f1f417550b3611c018d4270

data/bin/cql_ruby

@@ -1,26 +1,37 @@
 #!/usr/bin/env ruby
 
+require 'parser'
 require 'cql_ruby'
 
 def show_help
   puts <<~HELP
         
     \tSYNOPSIS
-    \tcql_ruby options pattern path filters ...
+    \t\tcql_ruby options pattern path filters ...
 
     \tDESCRIPTION
-    \tCQL (Code Query Language) is a semantic search tool for your Ruby source code.
+    \t\tCQL (Code Query Language) is a semantic search tool for your Ruby source code.
 
     \tFILTERS
-    \t\tParent node type: type:T(,T)*
+    \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-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.
     \t\t-ns (--no-source) No source code.
+    \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
-    \tcql_ruby -ns update_user_info ./ type:send,arg
+    \t\tcql_ruby user ./
+    \t\tcql_ruby -ns -nr %user_info ./ type:send,arg nest:block nest:class=r/User/i has:str=WARNING
   HELP
 
   exit
@@ -32,6 +43,8 @@ def extract_options
     show_color: true,
     show_file: true,
     show_source: true,
+    recursive_search: true,
+    surrounding_lines: 0,
   }
 
   ARGV.delete_if do |arg|
@@ -42,8 +55,15 @@ def extract_options
         options[:show_file] = false
       elsif %w[-ns --no-source].include?(arg)
         options[:show_source] = false
-      elsif %w[-h --help]
+      elsif %w[-h --help].include?(arg)
         show_help
+      elsif %w[-v -vv -vvv].include?(arg)
+        lvl = arg.chars.find_all { |c| c == 'v' }.size
+        CqlRuby::Config.debug_level = lvl
+      elsif %w[-nr --no-recursive].include?(arg)
+        options[:recursive_search] = false
+      elsif arg[0..1] == '-l' && arg[2..].to_i > 0
+        options[:surrounding_lines] = arg[2..].to_i
       else
         raise "Unknown arg #{arg}"
       end
@@ -64,24 +84,38 @@ end
 
 begin
   options = extract_options
+  CqlRuby.log "Call options: #{options}" if CqlRuby::Config.debug_level_2?
 
   raise unless ARGV.size >= 2
 
   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?
 
   # Rest must be filters - can sink ARGV now.
   filters = extract_filters
+  CqlRuby.log "Call filters: #{filters}" if CqlRuby::Config.debug_level_2?
+
   filter_reader = CqlRuby::FilterReader.new(filters)
 
   printer = CqlRuby::ConsolePrinter.new
   printer.color_on = options[:show_color]
   printer.file_on = options[:show_file]
   printer.source_on = options[:show_source]
+  printer.surrounding_lines = options[:surrounding_lines]
 
   collector = CqlRuby::CrumbCollector.new(printer)
-  CqlRuby::Executor.new(collector, filter_reader, pattern, path, filters).search_all
+  CqlRuby::Executor.new(
+    collector: collector,
+    filter_reader: filter_reader,
+    pattern: pattern,
+    path: path,
+    filters: filters,
+    recursive: options[:recursive_search],
+  ).search_all
 rescue => e
   puts "Error: #{e}"
   show_help

data/lib/cql_ruby.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-module CqlRuby
-  ; end
+module CqlRuby;
+  def self.log(txt)
+    p txt
+  end
+end
 
-require 'cql/executor'
-require 'cql/crumb_collector'
-require 'cql/abstract_printer'
-require 'cql/console_printer'
-require 'cql/filter_reader'
-require 'cql/filter_evaluator'
-require 'cql/pattern_matcher'
+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/filter_evaluator'
+require 'cql_ruby/pattern_matcher'

data/lib/cql_ruby/console_printer.rb

@@ -8,6 +8,7 @@ module CqlRuby
     attr_writer :color_on
     attr_writer :file_on
     attr_writer :source_on
+    attr_writer :surrounding_lines
 
     def initialize
       super
@@ -15,14 +16,33 @@ module CqlRuby
       @color_on = true
       @file_on = true
       @source_on = true
+      @surrounding_lines = 0
+      @counter = 0
     end
 
     #
     # @param crumb [Cqlruby::Crumb]
     #
     def print(crumb)
-      puts "#{color(94)}#{crumb.file_name}#{decor_reset}:#{color(33)}#{crumb.line_no}#{decor_reset} #{color(93)}#{crumb.type}#{decor_reset}" if @file_on
-      puts decorate_source_line(crumb) if @source_on
+      parts = "##{color(97)}#{@counter}#{decor_reset}"
+      parts += " #{color(94)}#{crumb.file_name}#{decor_reset}:#{color(33)}#{crumb.line_no}#{decor_reset} #{color(93)}#{crumb.type}#{decor_reset}" if @file_on
+
+      if @source_on && @surrounding_lines.positive?
+        parts_visible_len = parts.gsub(/\e\[\d+m/, '').size + 1
+        indent = ' ' * parts_visible_len
+        (-@surrounding_lines).upto(-1).each { |offs| puts "#{indent}#{crumb.surrounding_line(offs)}" }
+      end
+
+      parts += ' ' + decorate_source_line(crumb) if @source_on
+
+      puts parts
+
+      if @source_on && @surrounding_lines.positive?
+        1.upto(@surrounding_lines).each { |offs| puts "#{indent}#{crumb.surrounding_line(offs)}" }
+        puts '--'
+      end
+
+      @counter += 1
     end
 
     private
@@ -54,7 +74,6 @@ module CqlRuby
     # @param [Cqlruby::Crumb] crumb
     # @return [String]
     def decorate_source_line(crumb)
-      # TODO add +- line surrounding options
       source = crumb.source
       from = crumb.line_col_no
       to = from + crumb.expression_size
@@ -63,14 +82,14 @@ module CqlRuby
       subject = source[from..to - 1] || ''
       suffix = source[to..] || ''
 
-      color(90) +
+      color(97) +
         prefix +
         decor_reset +
         color(31) +
         bold +
         subject +
         decor_reset +
-        color(90) +
+        color(97) +
         suffix +
         decor_reset
     end

data/lib/cql_ruby/executor.rb

@@ -1,6 +1,21 @@
 # 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.
@@ -10,43 +25,77 @@ require 'parser/current'
 # @param path [String]
 # @param filters [Array<String>]
 #
-CqlRuby::Executor = Struct.new(:collector, :filter_reader, :pattern, :path, :filters) do
-  def search_all
-    files.flat_map do |file|
-      search(file)
+module CqlRuby
+  class Executor
+    def initialize(
+      collector:,
+      filter_reader:,
+      pattern:,
+      path:,
+      filters: [],
+      recursive: true
+    )
+      @collector = collector
+      @filter_reader = filter_reader
+      @pattern = pattern
+      @path = path
+      @filters = filters
+      @recursive = recursive
     end
-  end
 
-  private
+    def search_all
+      files.flat_map do |file|
+        CqlRuby.log "File check: #{file}" if CqlRuby::Config.debug_level_3?
+        search(file)
+      end
+    end
 
-  def search(file)
-    ast = Parser::CurrentRuby.parse(File.read(file))
-    source_reader = CqlRuby::SourceReader.new(file)
-    walk(ast, [], source_reader)
+    private
 
-    nil
-  end
+    def search(file)
+      ast = Parser::CurrentRuby.parse(File.read(file))
+      source_reader = CqlRuby::SourceReader.new(file)
+      walk(ast, [], source_reader)
 
-  def walk(node, ancestors, source_reader)
-    if node.is_a?(Parser::AST::Node)
-      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)
-        collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
+      nil
+    rescue => e
+      CqlRuby.log "File #{file} cannot be parsed: #{e}"
+    end
+
+    def walk(node, ancestors, source_reader)
+      if node.is_a?(Parser::AST::Node)
+        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)
+          collector.add(CqlRuby::Crumb.new(node, ancestors, source_reader))
+        end
       end
+
+      nil
     end
 
-    nil
-  end
+    def match?(target)
+      CqlRuby::PatternMatcher.match?(pattern, target)
+    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'
 
-  def files
-    Dir.glob(path)
+      Dir.glob(clean_path)
+    end
+
+    attr_reader :collector
+    attr_reader :filter_reader
+    attr_reader :pattern
+    attr_reader :path
+    attr_reader :filters
+    attr_reader :recursive
   end
 end
 
@@ -63,6 +112,10 @@ CqlRuby::Crumb = Struct.new(:full_name, :ancestors, :source_reader) do
     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
@@ -82,6 +135,8 @@ CqlRuby::SourceReader = Struct.new(:file) do
   end
 
   def source_line(n)
+    return nil unless lines.size >= n
+
     lines[n - 1].chop
   end
 

data/lib/cql_ruby/filter_evaluator.rb

@@ -7,6 +7,7 @@ module CqlRuby
         [
           pass_type?(filter_reader, ancestors),
           pass_nesting?(filter_reader, ancestors),
+          pass_has?(filter_reader, node, ancestors),
         ].all?
       end
 
@@ -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]
@@ -49,6 +50,79 @@ module CqlRuby
           end
         end
       end
+
+      #
+      # @param [CqlRuby::FilterReader] filter_reader
+      # @param [Parser::AST::Node] node
+      # @param [Array<Parser::AST::Node>] ancestors
+      #
+      def pass_has?(filter_reader, node, ancestors)
+        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)
+          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)
@@ -15,7 +19,7 @@ module CqlRuby
     end
 
     def self.regex?(pattern)
-      pattern[0..1] == 'r:'
+      pattern[0..1] == 'r/'
     end
     private_class_method :regex?
 
@@ -26,7 +30,9 @@ module CqlRuby
 
     def self.regex_match?(pattern, subject)
       pattern = pattern[2..]
-      pattern, *mods = pattern.split('+')
+      delim_idx = pattern.rindex('/')
+      mods = pattern[delim_idx + 1..].chars
+      pattern = pattern[0..delim_idx - 1]
 
       fops = 0
       fops |= Regexp::IGNORECASE if mods.include?('i')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.8
 platform: ruby
 authors:
 - itarato
@@ -9,7 +9,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2020-07-05 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.1
 description: 
 email: it.arato@gmail.com
 executables:
@@ -38,7 +58,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="