cql_ruby 0.0.7 → 0.0.12

data/lib/cql_ruby/filter_reader.rb

@@ -1,81 +1,130 @@
-# 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
+# frozen_string_literal: true
+
+# TODO: Have convenience filters for type:_ such as: isclass, ismodule, isdef ...
+
+module CqlRuby
+  # TODO Move this under filter reader namespace.
+  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)
+    # 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.
+  #
+  # Accepted filters and syntax:
+  #
+  # Type:
+  #
+  # type:[name](,[name])*
+  # example: type:def,send
+  #
+  class FilterReader
+    NESTING_ALLOWED_TYPES = %w[class module def block].freeze
+
+    # @attribute [Array<Symbol>] allowed_types
+    attr_reader :allowed_types
+    # @attribute [Array<CqlRuby::NodeSpec>] nest_under
+    attr_reader :nest_under
+    # @attribute [Array<CqlRuby::NodeSpec>] has_leaves
+    attr_reader :has_leaves
+    # @attribute [Array<CqlRuby::HierarchyPattern>] patterns
+    attr_reader :patterns
+
+    def initialize(raw_filters)
+      super()
+
+      @allowed_types = []
+      @nest_under = []
+      @has_leaves = []
+      @patterns = []
+
+      parse_raw_filters(raw_filters)
+    end
+
+    def restrict_types?
+      !@allowed_types.empty?
+    end
+
+    def restrict_nesting?
+      !@nest_under.empty?
+    end
+
+    def restrict_children?
+      !@has_leaves.empty?
+    end
+
+    def restrict_pattern?
+      !@patterns.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)
+          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)
+        elsif %w[pattern p].include?(name)
+          @patterns << HierarchyPattern.from(value)
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/cql_ruby/pattern_matcher.rb

@@ -1,53 +1,57 @@
-# 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..]
-      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')
-      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
+# 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
+
+      subject = subject.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..]
+      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')
+      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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.12
 platform: ruby
 authors:
 - itarato
@@ -65,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Code Query Language for Ruby