enumpath 0.1.1 → 0.1.2

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "enumpath"
+require 'bundler/setup'
+require 'enumpath'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "enumpath"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/enumpath.gemspec

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'enumpath/version'
 
@@ -8,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.version       = Enumpath::VERSION
   spec.license       = 'Apache-2.0'
   spec.summary       = 'A JSONPath-compatible library for navigating nested Ruby objects using path expressions'
-  spec.description = <<~EOF
+  spec.description = <<~DESC
     Enumpath is an implementation of the JSONPath spec for Ruby objects,
     plus some added sugar. It's like Ruby's native Enumerable#dig method,
     but fancier. It is designed for situations where you need to provide
@@ -16,27 +17,29 @@ Gem::Specification.new do |spec|
     objects. This makes it exceptionally well suited for flexible ETL
     (Extract, Transform, Load) processes by allowing you to define paths
     through your data in a simple, easily readable, easily storable syntax.
-  EOF
+  DESC
   spec.authors       = ['Chris Bloom']
-  spec.email         = ['open-source@youearnedit.com', 'chrisbloom7@gmail.com']
+  spec.email         = ['chrisbloom7@gmail.com']
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
   spec.require_paths = ['lib']
 
-  spec.homepage      = 'https://github.com/youearnedit/enumpath'
+  spec.homepage      = 'https://github.com/chrisbloom7/enumpath'
 
   # Enumerable#dig was added in Ruby 2.3.0
   spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_dependency 'to_regexp', '~> 0.2.1'
   spec.add_dependency 'mini_cache', '~> 1.1.0'
+  spec.add_dependency 'to_regexp', '~> 0.2.1'
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'bundler', '~> 2.1'
   spec.add_development_dependency 'null-logger', '~> 0.1'
   spec.add_development_dependency 'pry-byebug', '~> 3.6'
   spec.add_development_dependency 'rake', '~> 12.3'
-  spec.add_development_dependency 'rspec-benchmark', '~> 0.3.0'
   spec.add_development_dependency 'rspec', '~> 3.8'
+  spec.add_development_dependency 'rspec-benchmark', '~> 0.3.0'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.4'
+  spec.add_development_dependency 'yard', '~> 0.9.26'
 end

data/lib/enumpath.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require 'mini_cache'
-require "enumpath/logger"
-require "enumpath/operator"
-require "enumpath/path"
-require "enumpath/results"
-require "enumpath/resolver/simple"
-require "enumpath/resolver/property"
-require "enumpath/version"
+require 'enumpath/logger'
+require 'enumpath/operator'
+require 'enumpath/path'
+require 'enumpath/results'
+require 'enumpath/resolver/simple'
+require 'enumpath/resolver/property'
+require 'enumpath/version'
 
 # A JSONPath-compatible library for navigating Ruby objects using path expressions
 module Enumpath
@@ -48,7 +48,7 @@ module Enumpath
     # @private
     # @see Enumpath::Logger#log
     def log(title)
-      block_given? ? logger.log(title, &Proc.new) : logger.log(title)
+      block_given? ? logger.log(title, &-> { yield }) : logger.log(title)
     end
 
     # A lightweight in-memory cache for caching normalized path expressions

data/lib/enumpath/logger.rb

@@ -6,7 +6,7 @@ module Enumpath
   # A logger for providing debugging information while evaluating path expressions
   # @private
   class Logger
-    PAD = "  "
+    PAD = '  '
 
     SEPARATOR = '--------------------------------------'
 
@@ -31,17 +31,11 @@ module Enumpath
     # @yield A lazily evaluated hash of key/value pairs to include in the log message
     def log(title)
       return unless Enumpath.verbose
+
       append_log "#{padding}#{SEPARATOR}\n"
       append_log "#{padding}Enumpath: #{title}\n"
-      if block_given?
-        append_log "#{padding}#{SEPARATOR}\n"
-        vars = yield
-        return unless vars.is_a?(Hash)
-        label_size = vars.keys.map(&:size).max
-        vars.each do |label, value|
-          append_log "#{padding}#{label.to_s.ljust(label_size)}: #{massaged_value(value)}\n"
-        end
-      end
+      append_log "#{padding}#{SEPARATOR}\n" if block_given?
+      log_vars(yield) if block_given?
     end
 
     private
@@ -50,7 +44,16 @@ module Enumpath
       logger << message
     end
 
-    def massaged_value(value)
+    def log_vars(vars)
+      return unless vars.is_a?(Hash)
+
+      label_size = vars.keys.map(&:size).max
+      vars.each do |label, value|
+        append_log "#{padding}#{label.to_s.ljust(label_size)}: #{massaged_value(value)}\n"
+      end
+    end
+
+    def massaged_value(value) # rubocop:disable Metrics/MethodLength
       if value.is_a?(Enumerable)
         enum_for_log(value)
       elsif value.is_a?(TrueClass)

data/lib/enumpath/operator.rb

@@ -21,32 +21,53 @@ module Enumpath
       # @param enum [Enumerable] the enumerable to assist in detecting child operators
       # @return an instance of a subclass of Enumpath::Operator based on what was detected, or nil if nothing was
       #   detected
-      def detect(operator, enum)
-        if Enumpath::Operator::Child.detect?(operator, enum)
-          Enumpath.log('Child operator detected')
-          Enumpath::Operator::Child.new(operator)
-        elsif Enumpath::Operator::Wildcard.detect?(operator)
-          Enumpath.log('Wildcard operator detected')
-          Enumpath::Operator::Wildcard.new(operator)
-        elsif Enumpath::Operator::RecursiveDescent.detect?(operator)
-          Enumpath.log('Recursive Descent operator detected')
-          Enumpath::Operator::RecursiveDescent.new(operator)
-        elsif Enumpath::Operator::Union.detect?(operator)
-          Enumpath.log('Union operator detected')
-          Enumpath::Operator::Union.new(operator)
-        elsif Enumpath::Operator::SubscriptExpression.detect?(operator)
-          Enumpath.log('Subscript Expression operator detected')
-          Enumpath::Operator::SubscriptExpression.new(operator)
-        elsif Enumpath::Operator::FilterExpression.detect?(operator)
-          Enumpath.log('Filter Expression operator detected')
-          Enumpath::Operator::FilterExpression.new(operator)
-        elsif Enumpath::Operator::Slice.detect?(operator)
-          Enumpath.log('Slice operator detected')
-          Enumpath::Operator::Slice.new(operator)
-        else
-          Enumpath.log('Not a valid operator for enum')
-          nil
-        end
+      def detect(operator, enum) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        return operator(:Child, operator) if child?(operator, enum)
+        return operator(:Wildcard, operator) if wildcard?(operator)
+        return operator(:RecursiveDescent, operator) if recursive_descent?(operator)
+        return operator(:Union, operator) if union?(operator)
+        return operator(:SubscriptExpression, operator) if subscript_expression?(operator)
+        return operator(:FilterExpression, operator) if filter_expression?(operator)
+        return operator(:Slice, operator) if slice?(operator)
+
+        Enumpath.log('Not a valid operator for enum')
+        nil
+      end
+
+      private
+
+      def child?(operator, enum)
+        Enumpath::Operator::Child.detect?(operator, enum)
+      end
+
+      def wildcard?(operator)
+        Enumpath::Operator::Wildcard.detect?(operator)
+      end
+
+      def recursive_descent?(operator)
+        Enumpath::Operator::RecursiveDescent.detect?(operator)
+      end
+
+      def union?(operator)
+        Enumpath::Operator::Union.detect?(operator)
+      end
+
+      def subscript_expression?(operator)
+        Enumpath::Operator::SubscriptExpression.detect?(operator)
+      end
+
+      def filter_expression?(operator)
+        Enumpath::Operator::FilterExpression.detect?(operator)
+      end
+
+      def slice?(operator)
+        Enumpath::Operator::Slice.detect?(operator)
+      end
+
+      def operator(operator_class, operator)
+        Enumpath.log("#{operator_class} operator detected")
+        klass = Object.const_get("Enumpath::Operator::#{operator_class}")
+        klass.new(operator)
       end
     end
   end

data/lib/enumpath/operator/base.rb

@@ -16,7 +16,7 @@ module Enumpath
         # @param enum [Enumerable] an enum that can be used to assist in detection. Not all subclasses require an enum
         #   for detection.
         # @return [true, false] whether the operator param appears to represent the operator class
-        def detect?(operator, enum = nil)
+        def detect?(_operator, _enum = nil)
           raise NotImplementedError
         end
       end
@@ -47,7 +47,7 @@ module Enumpath
       # @yieldparam enum [Enumerable] the new enum after applying the operator
       # @yieldparam resolved_path [Array] the new resolved_path after applying the operator
       # @yieldreturn [void]
-      def apply(remaining_path, enum, resolved_path, &block)
+      def apply(_remaining_path, _enum, _resolved_path)
         raise NotImplementedError
       end
 

data/lib/enumpath/operator/child.rb

@@ -24,10 +24,10 @@ module Enumpath
       # @yieldparam remaining_path [Array] remaining_path
       # @yieldparam enum [Enumerable] the resolved value of the enumerable
       # @yieldparam resolved_path [Array] resolved_path plus the child operator
-      def apply(remaining_path, enum, resolved_path, &block)
+      def apply(remaining_path, enum, resolved_path)
         value = Enumpath::Resolver::Simple.resolve(operator, enum)
         value = Enumpath::Resolver::Property.resolve(operator, enum) if value.nil?
-        yield(remaining_path, value, resolved_path + [operator]) if !value.nil?
+        yield(remaining_path, value, resolved_path + [operator]) unless value.nil?
       end
     end
   end

data/lib/enumpath/operator/filter_expression.rb

@@ -17,7 +17,7 @@ module Enumpath
         # @param operator (see Enumpath::Operator::Base.detect?)
         # @return (see Enumpath::Operator::Base.detect?)
         def detect?(operator)
-          !!(operator =~ OPERATOR_REGEX)
+          !(operator =~ OPERATOR_REGEX).nil?
         end
       end
 
@@ -31,26 +31,26 @@ module Enumpath
       #   the filter
       def apply(remaining_path, enum, resolved_path, &block)
         Enumpath.log('Evaluating filter expression') { { expression: operator, to: enum } }
-
         _match, unpacked_operator = OPERATOR_REGEX.match(operator).to_a
         expressions = unpacked_operator.split(LOGICAL_OPERATORS_REGEX).map(&:strip)
-
-        keys(enum).each do |key|
-          value = Enumpath::Resolver::Simple.resolve(key, enum)
-          Enumpath.log('Applying filter to key') { { key: key, enum: value } }
-          if pass?(expressions.dup, value)
-            Enumpath.log('Applying filtered key') { { 'filtered key': key, 'filtered enum': value } }
-            yield(remaining_path, value, resolved_path + [key.to_s])
-          end
-        end
+        keys(enum).each { |key| apply_to_key(key, expressions, remaining_path, enum, resolved_path, &block) }
       end
 
       private
 
+      def apply_to_key(key, expressions, remaining_path, enum, resolved_path)
+        value = Enumpath::Resolver::Simple.resolve(key, enum)
+        Enumpath.log('Applying filter to key') { { key: key, enum: value } }
+        return unless pass?(expressions.dup, value)
+
+        Enumpath.log('Applying filtered key') { { 'filtered key': key, 'filtered enum': value } }
+        yield(remaining_path, value, resolved_path + [key.to_s])
+      end
+
       def pass?(expressions, enum)
         running_result = evaluate(expressions.shift, enum)
         Enumpath.log('Initial result') { { result: running_result } }
-        while expressions.any? do
+        while expressions.any?
           logical_operator, expression = expressions.shift(2)
           running_result = evaluate(expression, enum, logical_operator, running_result)
           Enumpath.log('Running result') { { result: running_result } }
@@ -66,34 +66,28 @@ module Enumpath
           { property => value, operator: operator, operand: operand, result: expression_result,
             logical_operator: logical_operator }.compact
         end
-        if logical_operator == '&&'
-          Enumpath.log('&&=')
-          running_result &&= expression_result
-        elsif logical_operator == '||'
-          Enumpath.log('||=')
-          running_result ||= expression_result
-        else
-          expression_result
-        end
+        running_result(logical_operator, running_result, expression_result)
       end
 
       def resolve(property, enum)
         return enum if property == '@'
+
         value = Enumpath::Resolver::Simple.resolve(property.gsub(/^@\./, ''), enum)
         value = Enumpath::Resolver::Property.resolve(property.gsub(/^@\./, ''), enum) if value.nil?
         value
       end
 
       def test(operator, operand, value)
-        return !!value if operator.nil? || operand.nil?
+        return (value ? true : false) if operator.nil? || operand.nil?
+
         typecast_operand = variable_typecaster(operand)
-        !!value.public_send(operator.to_sym, typecast_operand)
+        value.public_send(operator.to_sym, typecast_operand) ? true : false
       rescue NoMethodError
         Enumpath.log('Filter could not be evaluated!')
         false
       end
 
-      def variable_typecaster(variable)
+      def variable_typecaster(variable) # rubocop:disable Metrics/MethodLength
         if variable =~ /\A('|").+\1\z/
           # It quacks like a string
           variable.gsub(/\A('|")|('|")\z/, '')
@@ -102,8 +96,8 @@ module Enumpath
           variable.gsub(/\A:/, '').to_sym
         elsif variable =~ /true|false|nil/i
           # It quacks like an unquoted boolean operator
-          variable == 'true' ? true : false
-        elsif regexp = variable.to_regexp(literal: false, detect: false)
+          variable == 'true'
+        elsif (regexp = variable.to_regexp(literal: false, detect: false))
           # It quacks like a regex
           regexp
         else
@@ -111,6 +105,18 @@ module Enumpath
           variable.to_f
         end
       end
+
+      def running_result(logical_operator, running_result, expression_result)
+        if logical_operator == '&&'
+          Enumpath.log('&&=')
+          running_result && expression_result
+        elsif logical_operator == '||'
+          Enumpath.log('||=')
+          running_result || expression_result
+        else
+          expression_result
+        end
+      end
     end
   end
 end

data/lib/enumpath/operator/recursive_descent.rb

@@ -13,7 +13,7 @@ module Enumpath
         # @param operator (see Enumpath::Operator::Base.detect?)
         # @return (see Enumpath::Operator::Base.detect?)
         def detect?(operator)
-          !!(operator == OPERATOR)
+          operator == OPERATOR
         end
       end
 
@@ -28,17 +28,17 @@ module Enumpath
       #   enumerable member
       # @yieldparam resolved_path [Array] resolved_path for the enumerable itself, or resolved_path plus the key for
       #   each direct enumerable member
-      def apply(remaining_path, enum, resolved_path, &block)
+      def apply(remaining_path, enum, resolved_path)
         Enumpath.log('Applying remaining path recursively to enum') { { 'remaining path': remaining_path } }
         yield(remaining_path, enum, resolved_path)
         keys(enum).each do |key|
           value = Enumpath::Resolver::Simple.resolve(key, enum)
-          if recursable?(value)
-            Enumpath.log('Applying remaining path recursively to key') do
-              { key: key, 'remaining path': ['..'] + remaining_path }
-            end
-            yield(['..'] + remaining_path, value, resolved_path + [key])
+          next unless recursable?(value)
+
+          Enumpath.log('Applying remaining path recursively to key') do
+            { key: key, 'remaining path': ['..'] + remaining_path }
           end
+          yield(['..'] + remaining_path, value, resolved_path + [key])
         end
       end
 

data/lib/enumpath/operator/slice.rb

@@ -12,7 +12,7 @@ module Enumpath
         # @param operator (see Enumpath::Operator::Base.detect?)
         # @return (see Enumpath::Operator::Base.detect?)
         def detect?(operator)
-          !!(operator =~ OPERATOR_REGEX)
+          !(operator =~ OPERATOR_REGEX).nil?
         end
       end
 
@@ -25,7 +25,7 @@ module Enumpath
       # @yieldparam remaining_path [Array] the included index plus remaining_path
       # @yieldparam enum [Enumerable] enum
       # @yieldparam resolved_path [Array] resolved_path
-      def apply(remaining_path, enum, resolved_path, &block)
+      def apply(remaining_path, enum, resolved_path)
         _match, start, length, step = OPERATOR_REGEX.match(operator).to_a
         max_length = enum.size
         slices(start, length, step, max_length).each do |index|

data/lib/enumpath/operator/subscript_expression.rb

@@ -5,7 +5,7 @@ module Enumpath
     # Implements JSONPath subscript expressions operator syntax. See
     # {file:README.md#label-Subscript+expressions+operator} for syntax and examples
     class SubscriptExpression < Base
-      ARITHMETIC_OPERATOR_REGEX = /(\+|-|\*\*|\*|\/|%)/
+      ARITHMETIC_OPERATOR_REGEX = %r{(\+|-|\*\*|\*|\/|%)}
       OPERATOR_REGEX = /^\((.*)\)$/
 
       class << self
@@ -14,7 +14,7 @@ module Enumpath
         # @param operator (see Enumpath::Operator::Base.detect?)
         # @return (see Enumpath::Operator::Base.detect?)
         def detect?(operator)
-          !!(operator =~ OPERATOR_REGEX)
+          !(operator =~ OPERATOR_REGEX).nil?
         end
       end
 
@@ -25,17 +25,15 @@ module Enumpath
       # @yieldparam remaining_path [Array] remaining_path
       # @yieldparam enum [Enumerable] the member of the enumerable at the value of the subscript expression
       # @yieldparam resolved_path [Array] resolved_path plus the value of the subscript expression
-      def apply(remaining_path, enum, resolved_path, &block)
+      def apply(remaining_path, enum, resolved_path)
         Enumpath.log('Applying subscript expression') { { expression: operator, to: enum } }
 
         _match, unpacked_operator = OPERATOR_REGEX.match(operator).to_a
         result = evaluate(unpacked_operator, enum)
 
         value = Enumpath::Resolver::Simple.resolve(result, enum)
-        if !value.nil?
-          Enumpath.log('Applying subscript') { { 'enum at subscript': value } }
-          yield(remaining_path, value, resolved_path + [result.to_s])
-        end
+        Enumpath.log('Applying subscript') { { 'enum at subscript': value } } unless value.nil?
+        yield(remaining_path, value, resolved_path + [result.to_s]) unless value.nil?
       end
 
       private
@@ -47,6 +45,7 @@ module Enumpath
 
       def resolve(property, enum)
         return enum if property == '@'
+
         value = Enumpath::Resolver::Simple.resolve(property.gsub(/^@\./, ''), enum)
         value = Enumpath::Resolver::Property.resolve(property.gsub(/^@\./, ''), enum) if value.nil?
         value
@@ -57,19 +56,22 @@ module Enumpath
           Enumpath.log('Simple subscript') { { subscript: value } }
           value
         else
-          # Evaluate expression using operator
-          typecast_operand = variable_typecaster(operand)
-          result = value.public_send(operator.to_sym, typecast_operand)
-          Enumpath.log('Evaluated subscript') do
-            { value: value, operator: operator, operand: typecast_operand, result: result }
-          end
-          result
+          evaluate_with_operator(operator, operand, value)
         end
       rescue NoMethodError
         Enumpath.log('Subscript could not be evaluated') { { subscript: nil } }
         nil
       end
 
+      def evaluate_with_operator(operator, operand, value)
+        typecast_operand = variable_typecaster(operand)
+        result = value.public_send(operator.to_sym, typecast_operand)
+        Enumpath.log('Evaluated subscript') do
+          { value: value, operator: operator, operand: typecast_operand, result: result }
+        end
+        result
+      end
+
       def variable_typecaster(variable)
         if variable =~ /\A('|").+\1\z/ || variable =~ /^:.+/
           # It quacks like a string or symbol