check_please 0.5.1 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d25dd7c99923b45110f0bfb0903006414f50a60f89e0e3f4385487a3cf11d68b
-  data.tar.gz: c1e4457594ba8f1234692a431acf859f9f708e26e14512c2c7a348359ef0ab04
+  metadata.gz: 9c5a664d82f1f1d267e0e45d5e259f6443e23f19d2d53aafdeca8a908984d6fe
+  data.tar.gz: 9296b3b4c859c7e07d96991dbaaaaf48ae005ac9c4c09d9be9353b85f668f33b
 SHA512:
-  metadata.gz: 38b21a94a84943dabc03fda78f8054b36340363a932e53754a437f8a813cfa72fbd04d232d924a16e3897dab019951b35bc47e03f6f46aa0deaea050d64553b4
-  data.tar.gz: 45bedfd9641c128f1e0f21c308f323fa497ef0bf0c91e255fe3e0afde528a90e2e84c15103de32ed1020fd0a71862b143d812bce498570394d9be37fcd9aea17
+  metadata.gz: f5e0293242c66c30aa1f093d78427183263e9be492577e081a8daa810e16250827401c7ee81e1764dcade73fd7934932430595f14ea9aecb5bf67219d2422124
+  data.tar.gz: 4bbe14148472e8c49d0af0a6b7eaf2ee3acd7f29ec26af23fd6f2fd23181ce5510886773a835474d0e53102d9c360702a3a5de90311ccb38bb552e0982055ced

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    check_please (0.5.1)
+    check_please (0.5.6)
       table_print
 
 GEM

data/README.md

@@ -22,6 +22,7 @@ structures parsed from either of those.
          * [Repeatable Flags](#repeatable-flags)
          * [Expanded Documentation for Specific Flags](#expanded-documentation-for-specific-flags)
             * [Flag: match_by_key](#flag-match_by_key)
+            * [Flag: normalize_values](#flag-normalize_values)
    * [TODO (maybe)](#todo-maybe)
    * [Development](#development)
    * [Contributing](#contributing)
@@ -420,6 +421,37 @@ the following path expression: `/authors/id=1/books/isbn=12345`
 **This syntax is intended to be readable by humans first.**  If you need to
 build tooling that consumes it... well, I'm open to suggestions.  :)
 
+#### Flag: `normalize_values`
+
+NOTE: This flag is only accessible via the Ruby API.
+(I have no idea how to reasonably express it in a CLI flag.)
+
+Before comparing values at specified paths, normalize both values using
+the provided message or Proc.
+
+To use an example from the tests, the following reference/candidate pair would
+normally create three "mismatch" diffs:
+
+```ruby
+  ref = { list: [ "foo", "bar", "yak" ] }
+  can = { list: [ :foo,  :bar,  :yak ] }
+```
+
+However, the values can be converted to String before comparison via any of the following:
+
+```ruby
+  CheckPlease.diff(ref, can, normalize_values: { "/list/*" => ->(v) { v.to_s } })
+  CheckPlease.diff(ref, can, normalize_values: { "/list/*" => :to_s })
+  CheckPlease.diff(ref, can, normalize_values: { "/list/*" => "to_s" })
+```
+
+Note that the value of the flag is a Hash.
+* Its keys must be strings representing path expressions.
+* If the value associated with a given path is a lambda/proc, it will be
+  called with both the reference value and the candidate value.
+* If the value is a String or Symbol, it will be sent as a message to
+  both the reference and candidate values using Object#send.
+
 -----
 
 # TODO (maybe)

data/lib/check_please.rb

@@ -7,17 +7,17 @@ require "check_please/error"
 require "check_please/version"
 
 module CheckPlease
-  autoload :Reification, "check_please/reification"
-  autoload :CLI,         "check_please/cli"
-  autoload :Comparison,  "check_please/comparison"
-  autoload :Diff,        "check_please/diff"
-  autoload :Diffs,       "check_please/diffs"
-  autoload :Flag,        "check_please/flag"
-  autoload :Flags,       "check_please/flags"
-  autoload :Path,        "check_please/path"
-  autoload :PathSegment, "check_please/path_segment"
-  autoload :Printers,    "check_please/printers"
-  autoload :Refinements, "check_please/refinements"
+  autoload :Reification,        "check_please/reification"
+  autoload :CLI,                "check_please/cli"
+  autoload :Comparison,         "check_please/comparison"
+  autoload :Diff,               "check_please/diff"
+  autoload :Diffs,              "check_please/diffs"
+  autoload :Flag,               "check_please/flag"
+  autoload :Flags,              "check_please/flags"
+  autoload :Path,               "check_please/path"
+  autoload :PathSegment,        "check_please/path_segment"
+  autoload :PathSegmentMatcher, "check_please/path_segment_matcher"
+  autoload :Printers,           "check_please/printers"
 end
 
 
@@ -143,4 +143,43 @@ module CheckPlease
     EOF
   end
 
+  Flags.define :match_by_value do |flag|
+    flag.repeatable
+    flag.coerce { |value| CheckPlease::Path.reify(value) }
+
+    flag.cli_long = "--match-by-value FOO"
+    flag.description = <<~EOF
+      When comparing two arrays that match a specified path, the candidate
+      array will be scanned for each element in the reference array.
+        May be repeated; values will be treated as an 'OR' list.
+        NOTE: explodes if either array at a given path contains other collections.
+        NOTE: paths of 'extra' diffs use the index in the candidate array.
+    EOF
+  end
+
+  Flags.define :indifferent_keys do |flag|
+    flag.default = false
+    flag.coerce { |value| !!value }
+
+    flag.cli_long = "--indifferent-keys"
+    flag.description = <<~EOF
+      When comparing hashes, convert symbol keys to strings
+    EOF
+  end
+
+  Flags.define :indifferent_values do |flag|
+    flag.default = false
+    flag.coerce { |value| !!value }
+
+    flag.cli_long = "--indifferent-values"
+    flag.description = <<~EOF
+      When comparing values (that aren't arrays or hashes), convert symbols to strings
+    EOF
+  end
+
+  Flags.define :normalize_values do |flag|
+    # NOTE: This flag is only accessible via the Ruby API.
+    #       See the README for documentation.
+  end
+
 end

data/lib/check_please/comparison.rb

@@ -1,5 +1,4 @@
 module CheckPlease
-  using Refinements
 
   class Comparison
     def self.perform(reference, candidate, flags = {})
@@ -7,13 +6,13 @@ module CheckPlease
     end
 
     def perform(reference, candidate, flags = {})
-      @flags = Flags(flags) # whoa, it's almost like Java in here
+      @flags = Flags.reify(flags)
       @diffs = Diffs.new(flags: @flags)
 
       catch(:max_diffs_reached) do
         compare reference, candidate, CheckPlease::Path.root
       end
-      diffs
+      diffs.filter_by_flags(@flags)
     end
 
     private
@@ -22,7 +21,7 @@ module CheckPlease
     def compare(ref, can, path)
       return if path.excluded?(flags)
 
-      case types(ref, can)
+      case types_for_compare(ref, can)
       when [ :array, :array ] ; compare_arrays ref, can, path
       when [ :hash,  :hash  ] ; compare_hashes ref, can, path
       when [ :other, :other ] ; compare_others ref, can, path
@@ -31,7 +30,7 @@ module CheckPlease
       end
     end
 
-      def types(*list)
+      def types_for_compare(*list)
         list.map { |e|
           case e
           when Array ; :array
@@ -42,8 +41,11 @@ module CheckPlease
       end
 
       def compare_arrays(ref_array, can_array, path)
-        if ( key = path.key_for_compare(flags) )
+        case
+        when ( key = path.key_to_match_by(flags) )
           compare_arrays_by_key ref_array, can_array, path, key
+        when path.match_by_value?(flags)
+          compare_arrays_by_value ref_array, can_array, path
         else
           compare_arrays_by_index ref_array, can_array, path
         end
@@ -52,6 +54,7 @@ module CheckPlease
         def compare_arrays_by_key(ref_array, can_array, path, key_name)
           refs_by_key = index_array!(ref_array, path, key_name, "reference")
           cans_by_key = index_array!(can_array, path, key_name, "candidate")
+
           key_values = (refs_by_key.keys | cans_by_key.keys)
 
           key_values.compact! # NOTE: will break if nil is ever used as a key (but WHO WOULD DO THAT?!)
@@ -79,6 +82,10 @@ module CheckPlease
                   "The element at position #{i} in the #{ref_or_can} array is not a hash."
               end
 
+              if flags.indifferent_keys
+                h = stringify_symbol_keys(h)
+              end
+
               # try to get the value of the attribute identified by key_name
               key_value = h.fetch(key_name) {
                 raise CheckPlease::NoSuchKeyError, \
@@ -102,6 +109,45 @@ module CheckPlease
             elements_by_key
           end
 
+        # FIXME: this can generate duplicate paths.
+        # Time to introduce lft_path, rgt_path ?
+        def compare_arrays_by_value(ref_array, can_array, path)
+          assert_can_match_by_value! ref_array
+          assert_can_match_by_value! can_array
+
+          matches = can_array.map { false }
+
+          # Look for missing values
+          ref_array.each.with_index do |ref, i|
+            new_path = path + (i+1) # count in human pls
+
+            # Weird, but necessary to handle duplicates properly
+            j = can_array.index.with_index { |can, j|
+              matches[j] == false && can == ref
+            }
+
+            if j
+              matches[j] = true
+            else
+              record_diff ref, nil, new_path, :missing
+            end
+          end
+
+          # Look for extra values
+          can_array.zip(matches).each.with_index do |(can, match), i|
+            next if match
+            new_path = path + (i+1) # count in human pls
+            record_diff nil, can, new_path, :extra
+          end
+        end
+
+          def assert_can_match_by_value!(array)
+            if array.any? { |e| Array === e || Hash === e }
+              raise CheckPlease::BehaviorUndefined,
+                "match_by_value behavior is not defined for collections!"
+            end
+          end
+
         def compare_arrays_by_index(ref_array, can_array, path)
           max_len = [ ref_array, can_array ].map(&:length).max
           (0...max_len).each do |i|
@@ -121,11 +167,27 @@ module CheckPlease
         end
 
       def compare_hashes(ref_hash, can_hash, path)
+        if flags.indifferent_keys
+          ref_hash = stringify_symbol_keys(ref_hash)
+          can_hash = stringify_symbol_keys(can_hash)
+        end
         record_missing_keys ref_hash, can_hash, path
         compare_common_keys ref_hash, can_hash, path
         record_extra_keys   ref_hash, can_hash, path
       end
 
+        def stringify_symbol_keys(h)
+          Hash[
+            h.map { |k,v|
+              [ stringify_symbol(k), v ]
+            }
+          ]
+        end
+
+          def stringify_symbol(x)
+            Symbol === x ? x.to_s : x
+          end
+
         def record_missing_keys(ref_hash, can_hash, path)
           keys = ref_hash.keys - can_hash.keys
           keys.each do |k|
@@ -148,10 +210,36 @@ module CheckPlease
         end
 
       def compare_others(ref, can, path)
+        ref = normalize_value(path, ref)
+        can = normalize_value(path, can)
+
         return if ref == can
         record_diff ref, can, path, :mismatch
       end
 
+        def normalize_value(path, value)
+          if flags.indifferent_values
+            value = stringify_symbol(value)
+          end
+
+          if flags.normalize_values
+            # We assume that normalize_values is a hash of path expression strings to a proc, string, or symbol that will be used to normalize the value
+            _, normalizer = flags.normalize_values.detect { |path_string, a_proc|
+              path.match?(path_string)
+            }
+
+            case normalizer
+            when nil            ; value
+            when Proc           ; normalizer.call(value)
+            when String, Symbol ; value.send(normalizer)
+            else                ; raise ArgumentError, "Not sure how to use #{normalizer.inspect} to normalize #{value.inspect}"
+            end
+          else
+            return value
+          end
+
+        end
+
     def record_diff(ref, can, path, type)
       diff = Diff.new(type, path, ref, can)
       diffs << diff

data/lib/check_please/diffs.rb

@@ -1,14 +1,13 @@
 require 'forwardable'
 
 module CheckPlease
-  using Refinements
 
   # Custom collection class for Diff instances.
   # Can retrieve members using indexes or paths.
   class Diffs
     attr_reader :flags
     def initialize(diff_list = nil, flags: {})
-      @flags = Flags(flags)
+      @flags = Flags.reify(flags)
       @list = []
       @hash = {}
       Array(diff_list).each do |diff|
@@ -47,10 +46,27 @@ module CheckPlease
       @list.map(&:attributes)
     end
 
+    def filter_by_flags(flags)
+      new_list = @list.reject { |diff| Path.new(diff.path).excluded?(flags) }
+      self.class.new(new_list, flags: flags)
+    end
+
     def to_s(flags = {})
       CheckPlease::Printers.render(self, flags)
     end
 
+    def method_missing(meth, *args, &blk)
+      if formats.include?(meth.to_sym)
+        CheckPlease::Printers.render(self, format: meth)
+      else
+        super
+      end
+    end
+
+    def formats
+      CheckPlease::Printers::FORMATS
+    end
+
     extend Forwardable
     def_delegators :@list, *%i[
       each

data/lib/check_please/error.rb

@@ -6,6 +6,10 @@ module CheckPlease
     # instead....
   end
 
+  class BehaviorUndefined < ::StandardError
+    include CheckPlease::Error
+  end
+
   class DuplicateKeyError < ::IndexError
     include CheckPlease::Error
   end

data/lib/check_please/flags.rb

@@ -3,6 +3,9 @@ module CheckPlease
   # NOTE: this gets all of its attributes defined (via .define) in ../check_please.rb
 
   class Flags
+    include CheckPlease::Reification
+    can_reify Hash
+
     BY_NAME = {} ; private_constant :BY_NAME
 
     def self.[](name)

data/lib/check_please/path.rb

@@ -17,7 +17,12 @@ module CheckPlease
     def initialize(name_or_segments = [])
       case name_or_segments
       when String, Symbol, Numeric, nil
-        names = name_or_segments.to_s.split(SEPARATOR)
+        string = name_or_segments.to_s
+        if string =~ %r(//)
+          raise InvalidPath, "paths cannot have empty segments"
+        end
+
+        names = string.split(SEPARATOR)
         names.shift until names.empty? || names.first =~ /\S/
         segments = PathSegment.reify(names)
       when Array
@@ -26,10 +31,6 @@ module CheckPlease
         raise InvalidPath, "not sure what to do with #{name_or_segments.inspect}"
       end
 
-      if segments.any?(&:empty?)
-        raise InvalidPath, "#{self.class.name} cannot contain empty segments"
-      end
-
       @segments = Array(segments)
 
       @to_s = SEPARATOR + @segments.join(SEPARATOR)
@@ -81,13 +82,10 @@ module CheckPlease
       "<#{self.class.name} '#{to_s}'>"
     end
 
-		# TODO: Naming Things
-    def key_for_compare(flags)
-      mbk_exprs = unpack_mbk_exprs(flags)
-      matches = mbk_exprs.select { |mbk_expr|
-        # NOTE: matching on parent because MBK '/foo/:id' should return 'id' for path '/foo'
-        mbk_expr.parent.match?(self)
-      }
+    def key_to_match_by(flags)
+      key_exprs = unpack_key_exprs(flags.match_by_key)
+      # NOTE: match on parent because if self.to_s == '/foo', MBK '/foo/:id' should return 'id'
+      matches = key_exprs.select { |e| e.parent.match?(self) }
 
       case matches.length
       when 0 ; nil
@@ -96,6 +94,10 @@ module CheckPlease
       end
     end
 
+    def match_by_value?(flags)
+      flags.match_by_value.any? { |e| e.match?(self) }
+    end
+
     def match?(path_or_string)
       # If the strings are literally equal, we're good..
       return true if self == path_or_string
@@ -123,7 +125,7 @@ module CheckPlease
     # (as of this writing, this should never actually happen, but I'm being thorough)
     def ancestor_on_list?(paths)
       paths.any? { |path|
-        ancestors.any? { |ancestor| ancestor == path }
+        ancestors.any? { |ancestor| ancestor.match?(path) }
       }
     end
 
@@ -152,7 +154,7 @@ module CheckPlease
 
     # O(n) check to see if the path itself is on a list
     def self_on_list?(paths)
-      paths.any? { |path| self == path }
+      paths.any? { |path| self.match?(path) }
     end
 
     def too_deep?(flags)
@@ -160,8 +162,8 @@ module CheckPlease
       depth > flags.max_depth
     end
 
-    def unpack_mbk_exprs(flags)
-      flags.match_by_key
+    def unpack_key_exprs(path_list)
+      path_list
         .map { |path| path.send(:key_exprs) }
         .flatten
         .uniq { |e| e.to_s } # use the block form so we don't have to implement #hash and #eql? in horrible ways

data/lib/check_please/path_segment.rb

@@ -30,19 +30,16 @@ module CheckPlease
 
     def initialize(name = nil)
       @name = name.to_s.strip
-      if @name =~ %r(\s) # has any whitespace
-        raise InvalidPathSegment, <<~EOF
-          #{name.inspect} is not a valid #{self.class} name
-        EOF
+
+      case @name
+      when "", /\s/ # blank or has any whitespace
+        raise InvalidPathSegment, "#{name.inspect} is not a valid #{self.class} name"
       end
+
       parse_key_and_value
       freeze
     end
 
-    def empty?
-      name.empty?
-    end
-
     def key_expr?
       name.match?(KEY_EXPR)
     end
@@ -52,23 +49,12 @@ module CheckPlease
     end
 
     def match?(other_segment_or_string)
-      other = self.class.reify(other_segment_or_string)
-
-      match_types = [ self.match_type, other.match_type ]
-      case match_types
-      when [ :plain,     :plain     ] ; self.name == other.name
-      when [ :key,       :key_value ] ; self.key  == other.key
-      when [ :key_value, :key       ] ; self.key  == other.key
-      else                            ; false
-      end
+      other = reify(other_segment_or_string)
+      PathSegmentMatcher.call(self, other)
     end
 
-    protected
-
-    def match_type
-      return :key       if key_expr?
-      return :key_value if key_val_expr?
-      :plain
+    def splat?
+      name == '*'
     end
 
     private

data/lib/check_please/path_segment_matcher.rb

@@ -0,0 +1,44 @@
+module CheckPlease
+
+  class PathSegmentMatcher
+    def self.call(a,b)
+      new(a,b).call
+    end
+
+    attr_reader :a, :b, :types
+    def initialize(a, b)
+      @a, @b = a, b
+      @types = [ _type(a), _type(b) ].sort
+    end
+
+    def call
+      return true             if either?(:splat)
+      return a.name == b.name if both?(:plain)
+      return a.key  == b.key  if key_and_key_value?
+
+      false
+    end
+
+    private
+
+    def _type(x)
+      return :splat     if x.splat?
+      return :key       if x.key_expr?
+      return :key_value if x.key_val_expr?
+      :plain
+    end
+
+    def both?(type)
+      types.uniq == [type]
+    end
+
+    def either?(type)
+      types.include?(type)
+    end
+
+    def key_and_key_value?
+      types == [ :key, :key_value ]
+    end
+  end
+
+end

data/lib/check_please/printers.rb

@@ -1,20 +1,21 @@
 module CheckPlease
-  using Refinements
 
   module Printers
     autoload :Base,       "check_please/printers/base"
     autoload :JSON,       "check_please/printers/json"
+    autoload :Long,       "check_please/printers/long"
     autoload :TablePrint, "check_please/printers/table_print"
 
     PRINTERS_BY_FORMAT = {
       table: Printers::TablePrint,
       json:  Printers::JSON,
+      long:  Printers::Long,
     }
     FORMATS = PRINTERS_BY_FORMAT.keys.sort
     DEFAULT_FORMAT = :table
 
     def self.render(diffs, flags = {})
-      flags = Flags(flags)
+      flags = Flags.reify(flags)
       printer = PRINTERS_BY_FORMAT[flags.format]
       printer.render(diffs)
     end

data/lib/check_please/printers/long.rb

@@ -0,0 +1,31 @@
+module CheckPlease
+module Printers
+
+  class Long < Base
+    def to_s
+      return "" if diffs.empty?
+
+      out = build_string do |io|
+        diffs.each do |diff|
+          t = diff.type.to_sym
+          ref, can = *[ diff.reference, diff.candidate ].map(&:inspect)
+          diff_string = <<~EOF.strip
+            #{diff.path} [#{diff.type}]
+              reference: #{( t == :extra   ) ? "[no value]" : ref}
+              candidate: #{( t == :missing ) ? "[no value]" : can}
+          EOF
+
+          io.puts diff_string
+          io.puts
+        end
+      end
+
+      out.strip
+    end
+
+    private
+  end
+
+end
+end
+

data/lib/check_please/version.rb

@@ -1,5 +1,5 @@
 module CheckPlease
   # NOTE: 'check_please_rspec_matcher' depends on this,
   #       so try to keep them roughly in sync
-  VERSION = "0.5.1" # about to release? rerun `bundle check` to update Gemfile.lock also
+  VERSION = "0.5.6" # about to release? rerun `bundle lock` to update Gemfile.lock
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: check_please
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.6
 platform: ruby
 authors:
 - Sam Livingston-Gray
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-26 00:00:00.000000000 Z
+date: 2021-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: table_print
@@ -87,11 +87,12 @@ files:
 - lib/check_please/flags.rb
 - lib/check_please/path.rb
 - lib/check_please/path_segment.rb
+- lib/check_please/path_segment_matcher.rb
 - lib/check_please/printers.rb
 - lib/check_please/printers/base.rb
 - lib/check_please/printers/json.rb
+- lib/check_please/printers/long.rb
 - lib/check_please/printers/table_print.rb
-- lib/check_please/refinements.rb
 - lib/check_please/reification.rb
 - lib/check_please/version.rb
 - usage_examples.rb

data/lib/check_please/refinements.rb

@@ -1,16 +0,0 @@
-module CheckPlease
-
-  module Refinements
-    refine Kernel do
-      def Flags(flags_or_hash)
-        case flags_or_hash
-        when Flags ; return flags_or_hash
-        when Hash  ; return Flags.new(flags_or_hash)
-        else
-          raise ArgumentError, "Expected either a CheckPlease::Flags or a Hash; got #{flags_or_hash.inspect}"
-        end
-      end
-    end
-  end
-
-end