check_please 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4e0e81da97eb41aade7d58c516519bde3d2527173b64e7d644e46458493450d
-  data.tar.gz: c633c13e0a776bdbf1691b9c01d3be3cc978cb445c2fbf8d74e95449ea0b3118
+  metadata.gz: 41ad78ce4324c1b5d9c8ac3e336d46108850d6fd7d1d51d30c13b807632d612a
+  data.tar.gz: 9191e6e52c57b6d79761a8a0258a41378cf19af1364a3e8875e727ff8e501f06
 SHA512:
-  metadata.gz: ad31ad99aef3494a2d2438b422a5fef9385c6fd05572131907d33d9e1e30a94ba0582ca4aae00c997dbe302487719da3d5ddbf715cf23422405086084f7a982c
-  data.tar.gz: 04d8e89b72894e458394ff0428192ffbe6f3b307437ce6ee8496f6e3064236498286b2fb203a399c5245172cec391656646dac39b20f0adc8a345eff13b8f015
+  metadata.gz: 388b93c0277580a37b066b7fa6aade4f8feeb5f677a4ccc2221ac060d23df153c3dc16c6cdacce740448773665200855e653d74f55cfae659511e39a4391b36f
+  data.tar.gz: 44cb45ace2a720d90035eef279f490896a785e76c77bd4bd72c63400a828300332638442599b905dad8e4bde4b329a698fd44f4116f847699b5250c586e27c86

data/Gemfile.lock

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

data/README.md

@@ -59,10 +59,15 @@ out!
 
 ### From Ruby
 
+See also: [./usage_examples.rb](usage_examples.rb).
+
 Create two strings, each containing a JSON or YAML document, and pass them to
 `CheckPlease.render_diff`.  You'll get back a third string containing a report
-of all the differences CheckPlease found in the two JSON strings.  (See also:
-[./usage_examples.rb](usage_examples.rb).)
+of all the differences CheckPlease found in the two JSON strings.
+
+Or, if you'd like to inspect the diffs in your own way, use `CheckPlease.diff`
+instead.  You'll get back a `CheckPlease::Diffs` custom collection that
+contains `CheckPlease::Diff` instances.
 
 ### Understanding the Output
 
@@ -161,21 +166,28 @@ If you want to incorporate CheckPlease into some other toolchain, it can also
 print diffs as JSON to facilitate parsing.  In Ruby, pass `format: :json` to
 `CheckPlease.render_diff`; in the CLI, use the `-f`/`--format` switch.
 
-## TODO
+## TODO (maybe)
 
 * command line flags for :allthethings:!
   * sort by path?
 * detect timestamps and compare after parsing?
   * ignore sub-second precision (option / CLI flag)?
   * possibly support plugins for other folks to add custom coercions?
-* support expressions of specific paths to ignore
-  * wildcards?  `#` for indexes, `**` to match one or more path segments?
-    (This could get ugly fast.)
 * display filters?  (e.g., { a: 1, b: 2 } ==> "Hash#3")
   * shorter descriptions of values with different classes
     (but maybe just the existing :type_mismatch diffs?)
   * another "possibly support plugins" expansion point here
 * more output formats, maybe?
+* [0xABAD1DEA] support wildcards in --select-paths and --reject-paths?
+  * `#` for indexes, `**` to match one or more path segments?
+    (This could get ugly fast.)
+* [0xABAD1DEA] look for a config file in ./.check_please_config or ~/.check_please_config,
+  combine flags found there with those in ARGV in order of precedence:
+  1) ARGV
+  2) ./.check_please
+  3) ~/.check_please
+  * but this may not actually be worth the time and complexity to implement, so
+    think about this first...
 
 ## Development
 

data/lib/check_please.rb

@@ -105,6 +105,7 @@ module CheckPlease
     flag.reentrant
     flag.mutually_exclusive_to :reject_paths
 
+    flag.cli_short = "-s PATH_EXPR"
     flag.cli_long = "--select-paths PATH_EXPR"
     flag.description = [
       "ONLY record diffs matching the provided PATH expression.",
@@ -117,6 +118,7 @@ module CheckPlease
     flag.reentrant
     flag.mutually_exclusive_to :select_paths
 
+    flag.cli_short = "-r PATH_EXPR"
     flag.cli_long = "--reject-paths PATH_EXPR"
     flag.description = [
       "DON'T record diffs matching the provided PATH expression.",

data/lib/check_please/cli.rb

@@ -5,7 +5,7 @@ module CheckPlease
     autoload :Parser, "check_please/cli/runner"
 
     def self.run(exe_file_name)
-      Runner.new(__FILE__).run(*ARGV.dup)
+      Runner.new(exe_file_name).run(*ARGV.dup)
     end
   end
 

data/lib/check_please/cli/parser.rb

@@ -5,7 +5,7 @@ module CLI
 
   class Parser
     def initialize(exe_file_name)
-      @exe_file_name = exe_file_name
+      @exe_file_name = File.basename(exe_file_name)
     end
 
     # Unfortunately, OptionParser *really* wants to use closures.  I haven't

data/lib/check_please/comparison.rb

@@ -1,30 +1,33 @@
 module CheckPlease
+  using Refinements
 
-  module Comparison
-    extend self
+  class Comparison
+    def self.perform(reference, candidate, flags = {})
+      new.perform(reference, candidate, flags)
+    end
 
     def perform(reference, candidate, flags = {})
-      root = CheckPlease::Path.new
-      diffs = Diffs.new(flags: flags)
+      @flags = Flags(flags) # whoa, it's almost like Java in here
+      @diffs = Diffs.new(flags: @flags)
+
       catch(:max_diffs_reached) do
-        compare reference, candidate, root, diffs
+        compare reference, candidate, CheckPlease::Path.root
       end
       diffs
     end
 
     private
+    attr_reader :diffs, :flags
 
-    def compare(ref, can, path, diffs)
-      if (d = diffs.flags.max_depth)
-        return if path.depth > d + 1
-      end
+    def compare(ref, can, path)
+      return if path.excluded?(flags)
 
       case types(ref, can)
-      when [ :array, :array ] ; compare_arrays ref, can, path, diffs
-      when [ :hash,  :hash  ] ; compare_hashes ref, can, path, diffs
-      when [ :other, :other ] ; compare_others ref, can, path, diffs
+      when [ :array, :array ] ; compare_arrays ref, can, path
+      when [ :hash,  :hash  ] ; compare_hashes ref, can, path
+      when [ :other, :other ] ; compare_others ref, can, path
       else
-        diffs.record ref, can, path, :type_mismatch
+        record_diff ref, can, path, :type_mismatch
       end
     end
 
@@ -38,7 +41,7 @@ module CheckPlease
         }
       end
 
-      def compare_arrays(ref_array, can_array, path, diffs)
+      def compare_arrays(ref_array, can_array, path)
         max_len = [ ref_array, can_array ].map(&:length).max
         (0...max_len).each do |i|
           n = i + 1 # count in human pls
@@ -48,45 +51,50 @@ module CheckPlease
           can = can_array[i]
 
           case
-          when ref_array.length < n ; diffs.record ref, can, new_path, :extra
-          when can_array.length < n ; diffs.record ref, can, new_path, :missing
+          when ref_array.length < n ; record_diff ref, can, new_path, :extra
+          when can_array.length < n ; record_diff ref, can, new_path, :missing
           else
-            compare ref, can, new_path, diffs
+            compare ref, can, new_path
           end
         end
       end
 
-      def compare_hashes(ref_hash, can_hash, path, diffs)
-        record_missing_keys ref_hash, can_hash, path, diffs
-        compare_common_keys ref_hash, can_hash, path, diffs
-        record_extra_keys   ref_hash, can_hash, path, diffs
+      def compare_hashes(ref_hash, can_hash, path)
+        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 record_missing_keys(ref_hash, can_hash, path, diffs)
+        def record_missing_keys(ref_hash, can_hash, path)
           keys = ref_hash.keys - can_hash.keys
           keys.each do |k|
-            diffs.record ref_hash[k], nil, path + k, :missing
+            record_diff ref_hash[k], nil, path + k, :missing
           end
         end
 
-        def compare_common_keys(ref_hash, can_hash, path, diffs)
+        def compare_common_keys(ref_hash, can_hash, path)
           keys = ref_hash.keys & can_hash.keys
           keys.each do |k|
-            compare ref_hash[k], can_hash[k], path + k, diffs
+            compare ref_hash[k], can_hash[k], path + k
           end
         end
 
-        def record_extra_keys(ref_hash, can_hash, path, diffs)
+        def record_extra_keys(ref_hash, can_hash, path)
           keys = can_hash.keys - ref_hash.keys
           keys.each do |k|
-            diffs.record nil, can_hash[k], path + k, :extra
+            record_diff nil, can_hash[k], path + k, :extra
           end
         end
 
-      def compare_others(ref, can, path, diffs)
+      def compare_others(ref, can, path)
         return if ref == can
-        diffs.record ref, can, path, :mismatch
+        record_diff ref, can, path, :mismatch
       end
+
+    def record_diff(ref, can, path, type)
+      diff = Diff.new(type, path, ref, can)
+      diffs << diff
+    end
   end
 
 end

data/lib/check_please/diffs.rb

@@ -43,11 +43,6 @@ module CheckPlease
       @hash[diff.path] = diff
     end
 
-    def record(ref, can, path, type)
-      return if path.excluded?(flags)
-      self << Diff.new(type, path, ref, can)
-    end
-
     def data
       @list.map(&:attributes)
     end

data/lib/check_please/path.rb

@@ -3,8 +3,15 @@ module CheckPlease
   class Path
     SEPARATOR = "/"
 
+    def self.root
+      new
+    end
+
+    attr_reader :to_s
     def initialize(segments = [])
       @segments = Array(segments)
+      @to_s = SEPARATOR + @segments.join(SEPARATOR)
+      freeze
     end
 
     def +(new_basename)
@@ -16,22 +23,42 @@ module CheckPlease
     end
 
     def excluded?(flags)
-      s = to_s ; matches = ->(path_expr) { s.include?(path_expr) }
-      if flags.select_paths.length > 0
-        return flags.select_paths.none?(&matches)
-      end
-      if flags.reject_paths.length > 0
-        return flags.reject_paths.any?(&matches)
-      end
+      return false if root?
+
+      return true if too_deep?(flags)
+      return true if explicitly_excluded?(flags)
+      return true if implicitly_excluded?(flags)
+
       false
     end
 
-    def to_s
-      SEPARATOR + @segments.join(SEPARATOR)
+    def inspect
+      "<CheckPlease::Path '#{to_s}'>"
     end
 
-    def inspect
-      to_s
+    def root?
+      to_s == SEPARATOR
+    end
+
+    private
+
+    def explicitly_excluded?(flags)
+      flags.reject_paths.any?( &method(:match?) )
+    end
+
+    def implicitly_excluded?(flags)
+      return false if flags.select_paths.empty?
+      flags.select_paths.none?( &method(:match?) )
+    end
+
+    # leaving this here for a while in case it needs to grow into a public method
+    def match?(path_expr)
+      to_s.include?(path_expr)
+    end
+
+    def too_deep?(flags)
+      return false if flags.max_depth.nil?
+      flags.max_depth + 1 < depth
     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.4.0"
+  VERSION = "0.4.1"
 end

data/usage_examples.rb

@@ -3,6 +3,10 @@ require 'check_please'
 reference = { foo: "wibble" }
 candidate = { bar: "wibble" }
 
+
+
+##### Printing diffs #####
+
 puts CheckPlease.render_diff(reference, candidate)
 
 # this should print the following to stdout:
@@ -12,3 +16,15 @@ _ = <<EOF
   missing | /foo | wibble    |
   extra   | /bar |           | wibble
 EOF
+
+
+
+##### Doing your own thing with diffs #####
+
+diffs = CheckPlease.diff(reference, candidate)
+
+# `diffs` is a custom collection (type: CheckPlease::Diffs) that contains
+# individual Diff objects for you to inspect as you see fit.
+#
+# If you come up with a useful way to present these, feel free to submit a PR
+# with a new class in `lib/check_please/printers` !

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: check_please
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Sam Livingston-Gray
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-25 00:00:00.000000000 Z
+date: 2020-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: table_print