cql_ruby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6255a37c5d7ad3bb69be36d10bf4056eb8b40729a5989db72ecdc81e30a2784a
+  data.tar.gz: e60a47023bf3062f83157f1d414dfc8122c58df9a4c6898f6048ac91727accea
+SHA512:
+  metadata.gz: 773f82e313c1ce9ad9a3c7f24d243d7045d7ad731d508ec082a5b8f3dce7a0d13078a9f21a0930bd535b2d3b530d801ee534eabcfa70ab44eada8af01b6adc65
+  data.tar.gz: 9dbca8f1684162d99e81a8729cd1544fae6fc32bb7a327e184fa47b44939892a97940dc11e8880bfe99eac7e9d6793a235bfd0e0cae78b3053bc2ad5bf2c286e

data/lib/cql_ruby.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CqlRuby
+  ; 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'

data/lib/cql_ruby/abstract_printer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CqlRuby
+  #
+  # Printing Cqlruby::Crumb-s.
+  #
+  class AbstractPrinter
+    def print(_crumb)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/cql_ruby/console_printer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module CqlRuby
+  #
+  # Prints to console.
+  #
+  class ConsolePrinter < ::CqlRuby::AbstractPrinter
+    attr_writer :color_on
+    attr_writer :file_on
+    attr_writer :source_on
+
+    def initialize
+      super
+
+      @color_on = true
+      @file_on = true
+      @source_on = true
+    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
+    end
+
+    private
+
+    def color(code)
+      if @color_on
+        "\e[#{code}m"
+      else
+        ''
+      end
+    end
+
+    def bold
+      if @color_on
+        "\e[1m"
+      else
+        ''
+      end
+    end
+
+    def decor_reset
+      if @color_on
+        "\e[0m"
+      else
+        ''
+      end
+    end
+
+    # @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
+
+      prefix = source[0..from - 1] || ''
+      subject = source[from..to - 1] || ''
+      suffix = source[to..] || ''
+
+      color(90) +
+        prefix +
+        decor_reset +
+        color(31) +
+        bold +
+        subject +
+        decor_reset +
+        color(90) +
+        suffix +
+        decor_reset
+    end
+  end
+end

data/lib/cql_ruby/crumb_collector.rb

@@ -0,0 +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

data/lib/cql_ruby/executor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+#
+# Executes search and dumps results into the collector.
+#
+# @param collector [Cqlruby::CrumbCollector]
+# @param pattern [String]
+# @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)
+    end
+  end
+
+  private
+
+  def search(file)
+    ast = Parser::CurrentRuby.parse(File.read(file))
+    source_reader = CqlRuby::SourceReader.new(file)
+    walk(ast, [], source_reader)
+
+    nil
+  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
+
+  def match?(target)
+    CqlRuby::PatternMatcher.match?(pattern, target)
+  end
+
+  def files
+    Dir.glob(path)
+  end
+end
+
+CqlRuby::Crumb = Struct.new(:full_name, :ancestors, :source_reader) do
+  def line_no
+    ancestors.last.location.expression.line
+  end
+
+  def line_col_no
+    ancestors.last.location.expression.column
+  end
+
+  def source
+    source_reader.source_line(line_no)
+  end
+
+  def file_name
+    source_reader.file
+  end
+
+  def expression_size
+    ancestors.last.location.expression.size
+  end
+
+  def type
+    ancestors.last.type
+  end
+end
+
+CqlRuby::SourceReader = Struct.new(:file) do
+  def initialize(*args)
+    super
+  end
+
+  def source_line(n)
+    lines[n - 1].chop
+  end
+
+  private
+
+  def lines
+    @lines ||= IO.readlines(file)
+  end
+end

data/lib/cql_ruby/filter_evaluator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CqlRuby
+  class FilterEvaluator
+    class << self
+      def pass?(filter_reader, node, ancestors)
+        [
+          pass_type?(filter_reader, ancestors),
+          pass_nesting?(filter_reader, ancestors),
+        ].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?
+
+            # 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)
+              CqlRuby::PatternMatcher.match?(nest_rule.name, ancestor.children[0])
+            else
+              raise 'Unknown type.'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cql_ruby/filter_reader.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module CqlRuby
+  class NestRule < Struct.new(:type, :name)
+    NAME_ANY = '*'
+    ALLOWED_TYPE = %w[class module def block].freeze
+
+    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 "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
+
+        new(type, name)
+      end
+    end
+
+    def restrict_name?
+      name != NAME_ANY
+    end
+  end
+
+  #
+  # Reads and provides filters.
+  #
+  # Accepted filters and syntax:
+  #
+  # Type:
+  #
+  # type:[name](,[name])*
+  # example: type:def,send
+  #
+  class FilterReader
+    # @attribute [Parser::AST::Node] allowed_types
+    attr_reader :allowed_types
+    # @attribute [Array<Cqlruby::NestRule>] nest_under
+    attr_reader :nest_under
+
+    def initialize(raw_filters)
+      super()
+
+      @allowed_types = []
+      @nest_under = []
+
+      parse_raw_filters(raw_filters)
+    end
+
+    def restrict_types?
+      !@allowed_types.empty?
+    end
+
+    def restrict_nesting?
+      !@nest_under.empty?
+    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?
+
+        if %w[type t].include?(name)
+          @allowed_types += value.split(',').map(&:to_sym)
+        elsif %w[nest n].include?(name)
+          @nest_under << NestRule.from(value)
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/cql_ruby/pattern_matcher.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module CqlRuby
+  module PatternMatcher
+    def self.match?(pattern, subject)
+      subject = subject.to_s
+      pattern = pattern.to_s
+
+      if regex?(pattern)
+        regex_match?(pattern, subject)
+      elsif partial_string?(pattern)
+        partial_string_match?(pattern, subject)
+      else
+        full_string_match?(pattern, subject)
+      end
+    end
+
+    def self.regex?(pattern)
+      pattern[0..1] == 'r:'
+    end
+    private_class_method :regex?
+
+    def self.partial_string?(pattern)
+      pattern[0] == '%'
+    end
+    private_class_method :partial_string?
+
+    def self.regex_match?(pattern, subject)
+      pattern = pattern[2..]
+      pattern, *mods = pattern.split('+')
+
+      fops = 0
+      fops |= Regexp::IGNORECASE if mods.include?('i')
+      fops |= Regexp::MULTILINE if mods.include?('m')
+      fops |= Regexp::EXTENDED if mods.include?('x')
+      fops |= Regexp::FIXEDENCODING if mods.include?('f')
+      fops |= Regexp::NOENCODING if mods.include?('n')
+      Regexp.new(pattern, fops).match?(subject)
+    end
+    private_class_method :regex_match?
+
+    def self.full_string_match?(pattern, subject)
+      pattern == subject
+    end
+    private_class_method :full_string_match?
+
+    def self.partial_string_match?(pattern, subject)
+      !subject.index(pattern[1..]).nil?
+    end
+    private_class_method :partial_string_match?
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: cql_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- itarato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-05 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: it.arato@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cql_ruby.rb
+- lib/cql_ruby/abstract_printer.rb
+- lib/cql_ruby/console_printer.rb
+- lib/cql_ruby/crumb_collector.rb
+- lib/cql_ruby/executor.rb
+- lib/cql_ruby/filter_evaluator.rb
+- lib/cql_ruby/filter_reader.rb
+- lib/cql_ruby/pattern_matcher.rb
+homepage: https://github.com/itarato/cql
+licenses:
+- GPL-3.0-or-later
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Code Query Language for Ruby
+test_files: []