check_please 0.5.0 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe333e55fbfdb89d0ea68b3f9ceefde98f3aa4b798792e9dd13745b76757a499
-  data.tar.gz: cf8cfc0205d3b8d7a3d10ec1c0c5487ac140dd7bc41c0c640eb2d72ec3d1e3f7
+  metadata.gz: 9c80defc851cfda5e74a5590da7be40388643084c1e06818639685bfe05e8a46
+  data.tar.gz: fe1a9a3b8be29b8e148917ed19052ae2d0195218624b0bf195421cc29c83c20b
 SHA512:
-  metadata.gz: 918e8b6edec715a8096872c46fa12adc029244b886525c704e9b769fecae6595d38d0b658ebe64a53ebe3474d6ddba76f7d8222baefbef582da4c7dec27e686e
-  data.tar.gz: 4e0da6a791cc4e539ed75f893a3950336bcf5703e6dbb6435e02bac23f94e3207c06dca5cf13551a4a81980474e4e796a911ea333bfec42b5d97aa1e6ef0f3c8
+  metadata.gz: 0b70a2c80630b51d789327c36e9b288aa2484d2b80cc888f5e8a94acf6bed1d7eef67c659f7ac17a9e7ed6c14aacc8cad9c18414881b2cfe07bf4e96aaad785e
+  data.tar.gz: 2cde0b422e2ae297517680f2408201b3f7c88e2e1f81da667d2c875dfddd31b544bef57864dff3ac8739be01b09676e5fd22ff1cbb54677e64f791ff606d3a05

data/Gemfile.lock

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

data/README.md

@@ -19,7 +19,7 @@ structures parsed from either of those.
       * [Flags](#flags)
          * [Setting Flags in the CLI](#setting-flags-in-the-cli)
          * [Setting Flags in Ruby](#setting-flags-in-ruby)
-         * ["Reentrant" Flags](#reentrant-flags)
+         * [Repeatable Flags](#repeatable-flags)
          * [Expanded Documentation for Specific Flags](#expanded-documentation-for-specific-flags)
             * [Flag: match_by_key](#flag-match_by_key)
    * [TODO (maybe)](#todo-maybe)

data/Rakefile

@@ -59,6 +59,10 @@ task :toc do
   end
 end
 
-# By making TOC generation a prerequisite of release, we *should* at least be
-# forced to update the TOC whenever we publish a new version of the gem...
-task :release => :toc
+# Okay, so.  We want the TOC to be up to date *before* the `release` task runs.
+#
+# We tried making the 'toc' task a dependency of 'release', but that just adds
+# it to the end of the dependencies, and generates the TOC after publishing.
+#
+# Trying the 'build' task instead...
+task :build => :toc

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,38 @@ 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
+
 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,6 +210,10 @@ module CheckPlease
         end
 
       def compare_others(ref, can, path)
+        if flags.indifferent_values
+          ref = stringify_symbol(ref)
+          can = stringify_symbol(can)
+        end
         return if ref == can
         record_diff ref, can, path, :mismatch
       end

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.0"
+  VERSION = "0.5.5" # 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.0
+  version: 0.5.5
 platform: ruby
 authors:
 - Sam Livingston-Gray
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-26 00:00:00.000000000 Z
+date: 2021-02-11 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