check_please 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33a26fc2e249e7ff6bba107ba2da856f0f70a9e232862b3650893b1844117cac
-  data.tar.gz: c8624e0cfc38a4f7bcd9db9af22215f0d2d6311ab061ec156318894fa8a01b60
+  metadata.gz: c4e0e81da97eb41aade7d58c516519bde3d2527173b64e7d644e46458493450d
+  data.tar.gz: c633c13e0a776bdbf1691b9c01d3be3cc978cb445c2fbf8d74e95449ea0b3118
 SHA512:
-  metadata.gz: 93c0b1d909dbdaf606a0376f38062eaaa26bd19573413ce0d81002b120aa247176d7a564752b83f6ac9a359974df32a7a5c2997f20468f95d683b28369d5548b
-  data.tar.gz: 78fe71950e42986ef0b9857984310fa51955d08a5b1b9b432d2b277fb9191b188b173f78575d0f88a927d4668065ac35fc32f1d74bba082894f897c0d9896267
+  metadata.gz: ad31ad99aef3494a2d2438b422a5fef9385c6fd05572131907d33d9e1e30a94ba0582ca4aae00c997dbe302487719da3d5ddbf715cf23422405086084f7a982c
+  data.tar.gz: 04d8e89b72894e458394ff0428192ffbe6f3b307437ce6ee8496f6e3064236498286b2fb203a399c5245172cec391656646dac39b20f0adc8a345eff13b8f015

data/Gemfile.lock

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

data/README.md

@@ -1,6 +1,7 @@
 # check_please
 
-Check for differences between two JSON strings (or Ruby data structures parsed from them).
+Check for differences between two JSON documents, YAML documents, or Ruby data
+structures parsed from either of those.
 
 ## Installation
 
@@ -18,11 +19,10 @@ Or install it yourself as:
 
     $ gem install check_please
 
-## Usage
-
-### Terminology
+## Terminology
 
-CheckPlease uses a few words in a jargony way:
+I know, you just want to see how to use this thing.  Feel free to scroll down,
+but be aware that CheckPlease uses a few words in a jargony way:
 
 * **Reference** is always used to refer to the "target" or "source of truth."
   We assume you're comparing two things because you want one of them to be like
@@ -35,7 +35,9 @@ CheckPlease uses a few words in a jargony way:
   **reference** and the **candidate**.  More on this in "Understanding the Output",
   below.
 
-### CLI
+## Usage
+
+### From the Terminal
 
 Use the `bin/check_please` executable.  (To get started, run it with the '-h' flag.)
 
@@ -46,19 +48,21 @@ of giving it a second filename as the argument.  (This is especially useful if
 you're copying an XHR response out of a web browser's dev tools and have a tool
 like MacOS's `pbpaste` utility.)
 
-### RSpec Matcher
+### From RSpec
 
 See [check_please_rspec_matcher](https://github.com/RealGeeks/check_please_rspec_matcher).
 
-### From Within Ruby
+If you'd like more control over the output formatting, and especially if you'd
+like to provide custom logic for diffing your own classes, you might be better
+served by the [super_diff](https://github.com/mcmire/super_diff) gem.  Check it
+out!
 
-Create two JSON strings and pass them to `CheckPlease.render_diff`.  You'll get
-back a third string containing a nicely formatted report of all the differences
-CheckPlease found in the two JSON strings.  (See also:  [./usage_examples.rb](usage_examples.rb).)
+### From Ruby
 
-(You can also parse the JSON strings yourself and pass the resulting data
-structures in, if you're into that.  I mean, I wrote this to help compare JSON
-data that's too big and complicated to scan through visually, but you do you!
+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).)
 
 ### Understanding the Output
 
@@ -70,9 +74,7 @@ tool because you want a human-friendly summary of all the places that your
 **candidate** fell short.
 
 When CheckPlease compares your two samples, it generates a list of diffs to
-describe any discrepancies it encounters.  (By default, it prints that list in a
-tabular format, but if you want to incorporate this into another toolchain,
-CheckPlease can also print these diffs as JSON to facilitate parsing.)
+describe any discrepancies it encounters.
 
 An example would probably help here.
 
@@ -124,23 +126,22 @@ CheckPlease defines:
 * **type_mismatch** means that both the **reference** and the **candidate** had
   a value at the given path, but one value was an Array or a Hash and the other
   was not.  **When CheckPlease encounters a type mismatch, it does not compare
-  anything "below" the given path.** producing a lot of "garbage" diffs.
-  _(Technical note:  CheckPlease uses a "recursive descent" strategy to
-  traverse the **reference** data structure, and it stops when it encounters a
-  type mismatch in order to avoid producing a lot of "garbage" diff output.
-  Also, the way these get displayed is likely to change.)_
+  anything "below" the given path.**  _(Technical note:  CheckPlease uses a
+  "recursive descent" strategy to traverse the **reference** data structure,
+  and it stops when it encounters a type mismatch in order to avoid producing a
+  lot of "garbage" diff output.)_
 * **mismatch** means that both the **reference** and the **candidate** had a
   value at the given path, and neither value was an Array or a Hash.
-* "**extra**" means that, inside an Array or a Hash, the **candidate**
-  contained values that were not found in the **reference**.
-* "**missing**" is the opposite of **extra**:  inside an Array or a Hash, the
+* **extra** means that, inside an Array or a Hash, the **candidate** contained
+  values that were not found in the **reference**.
+* **missing** is the opposite of **extra**:  inside an Array or a Hash, the
   **reference** contained values that were not found in the **candidate**.
 
 #### Paths
 
-The second column contains a path expression.  This is extremely basic:
+The second column contains a path expression.  This is extremely lo-fi:
 
-* The first element in the data structure is defined as "/".
+* The root of the data structure is defined as "/".
 * If an element in the data structure is an array, its child elements will have
   a **one-based** index appended to their parent's path.
 * If an element in the data structure is an object ("Hash" in Ruby), the key
@@ -164,7 +165,6 @@ print diffs as JSON to facilitate parsing.  In Ruby, pass `format: :json` to
 
 * command line flags for :allthethings:!
   * sort by path?
-  * max depth (for iterative refinement?)
 * detect timestamps and compare after parsing?
   * ignore sub-second precision (option / CLI flag)?
   * possibly support plugins for other folks to add custom coercions?

data/{bin → exe}/check_please

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/check_please'
+require 'check_please'
 CheckPlease::CLI.run(__FILE__)

data/lib/check_please.rb

@@ -1,40 +1,128 @@
-require_relative "check_please/version"
-require_relative "check_please/error"
-require_relative "check_please/path"
-require_relative "check_please/comparison"
-require_relative "check_please/diff"
-require_relative "check_please/diffs"
-require_relative "check_please/printers"
-require_relative "check_please/cli"
+require 'yaml'
+require 'json'
+
+
+# easier to just require these
+require "check_please/error"
+require "check_please/version"
+
+module CheckPlease
+  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 :Printers,    "check_please/printers"
+  autoload :Refinements, "check_please/refinements"
+end
+
+
 
 module CheckPlease
   ELEVATOR_PITCH = "Tool for parsing and diffing two JSON documents."
 
-  def self.diff(reference, candidate, options = {})
+  def self.diff(reference, candidate, flags = {})
     reference = maybe_parse(reference)
     candidate = maybe_parse(candidate)
-    Comparison.perform(reference, candidate, options)
+    Comparison.perform(reference, candidate, flags)
   end
 
-  def self.render_diff(reference, candidate, options = {})
-    diffs = diff(reference, candidate, options)
-    Printers.render(diffs, options)
+  def self.render_diff(reference, candidate, flags = {})
+    diffs = diff(reference, candidate, flags)
+    Printers.render(diffs, flags)
   end
 
   class << self
     private
 
     # Maybe you gave us JSON strings, maybe you gave us Ruby objects.
-    # We just don't know!  That's what makes it so exciting!
-    def maybe_parse(maybe_json)
+    # Heck, maybe you even gave us some YAML!  We just don't know!
+    # That's what makes it so exciting!
+    def maybe_parse(document)
 
-      case maybe_json
-      when String ; JSON.parse(maybe_json) # don't worry, if this raises we'll assume you've already parsed it
-      else        ; maybe_json
+      case document
+      when String ; return YAML.load(document) # don't worry, if this raises we'll assume you've already parsed it
+      else        ; return document
       end
 
-    rescue JSON::ParserError
-      return maybe_json
+    rescue JSON::ParserError, Psych::SyntaxError
+      return document
     end
   end
+
+
+
+  Flags.define :format do |flag|
+    allowed_values = CheckPlease::Printers::FORMATS.sort
+
+    flag.coerce &:to_sym
+    flag.default = CheckPlease::Printers::DEFAULT_FORMAT
+    flag.validate { |flags, value| allowed_values.include?(value) }
+
+    flag.cli_long = "--format FORMAT"
+    flag.cli_short = "-f FORMAT"
+    flag.description = [
+      "Format in which to present diffs.",
+      "  (Allowed values: [#{allowed_values.join(", ")}])",
+    ]
+  end
+
+  Flags.define :max_diffs do |flag|
+    flag.coerce &:to_i
+    flag.validate { |flags, value| value.to_i > 0 }
+
+    flag.cli_long = "--max-diffs MAX_DIFFS"
+    flag.cli_short = "-n MAX_DIFFS"
+    flag.description = "Stop after encountering a specified number of diffs."
+  end
+
+  Flags.define :fail_fast do |flag|
+    flag.default = false
+    flag.coerce { |value| !!value }
+
+    flag.cli_long = "--fail-fast"
+    flag.description = [
+      "Stop after encountering the first diff.",
+      "  (equivalent to '--max-diffs 1')",
+    ]
+  end
+
+  Flags.define :max_depth do |flag|
+    flag.coerce &:to_i
+    flag.validate { |flags, value| value.to_i > 0 }
+
+    flag.cli_long = "--max_depth MAX_DEPTH"
+    flag.cli_short = "-d MAX_DEPTH"
+    flag.description = [
+      "Limit the number of levels to descend when comparing documents.",
+      "  (NOTE: root has depth = 1)",
+    ]
+  end
+
+  Flags.define :select_paths do |flag|
+    flag.reentrant
+    flag.mutually_exclusive_to :reject_paths
+
+    flag.cli_long = "--select-paths PATH_EXPR"
+    flag.description = [
+      "ONLY record diffs matching the provided PATH expression.",
+      "  May be repeated; values will be treated as an 'OR' list.",
+      "  Can't be combined with --reject-paths.",
+    ]
+  end
+
+  Flags.define :reject_paths do |flag|
+    flag.reentrant
+    flag.mutually_exclusive_to :select_paths
+
+    flag.cli_long = "--reject-paths PATH_EXPR"
+    flag.description = [
+      "DON'T record diffs matching the provided PATH expression.",
+      "  May be repeated; values will be treated as an 'OR' list.",
+      "  Can't be combined with --select-paths.",
+    ]
+  end
+
 end

data/lib/check_please/cli.rb

@@ -1,45 +1,12 @@
-require_relative 'cli/flag'
-# require_relative 'cli/flags'
-require_relative 'cli/parser'
-require_relative 'cli/runner'
-
 module CheckPlease
 
   module CLI
+    autoload :Runner, "check_please/cli/parser"
+    autoload :Parser, "check_please/cli/runner"
+
     def self.run(exe_file_name)
       Runner.new(__FILE__).run(*ARGV.dup)
     end
-
-
-
-    FLAGS = []
-    def self.flag(long:, short: nil, &block)
-      flag = Flag.new(short, long, &block)
-      FLAGS << flag
-    end
-
-    ##### Define CLI flags here #####
-
-    flag short: "-f FORMAT", long: "--format FORMAT" do |f|
-      f.desc = "format in which to present diffs (available options: [#{CheckPlease::Printers::FORMATS.join(", ")}])"
-      f.set_key :format, :to_sym
-    end
-
-    flag short: "-n MAX_DIFFS", long: "--max-diffs MAX_DIFFS" do |f|
-      f.desc = "Stop after encountering a specified number of diffs"
-      f.set_key :max_diffs, :to_i
-    end
-
-    flag long: "--fail-fast" do |f|
-      f.desc = "Stop after encountering the very first diff"
-      f.set_key(:max_diffs) { 1 }
-    end
-
-    flag short: "-d MAX_DEPTH", long: "--max-depth MAX_DEPTH" do |f|
-      f.desc = "Limit the number of levels to descend when comparing documents (NOTE: root has depth=1)"
-      f.set_key :max_depth, :to_i
-    end
-
   end
 
 end

data/lib/check_please/cli/parser.rb

@@ -4,36 +4,41 @@ module CheckPlease
 module CLI
 
   class Parser
-    class UnrecognizedOption < StandardError
-      include CheckPlease::Error
-    end
-
     def initialize(exe_file_name)
       @exe_file_name = exe_file_name
-      @optparse = OptionParser.new
-      @optparse.banner = banner
-
-      @options = {} # yuck
-      CheckPlease::CLI::FLAGS.each do |flag|
-        flag.visit_option_parser(@optparse, @options)
-      end
     end
 
-    # Unfortunately, OptionParser *really* wants to use closures.
-    # I haven't yet figured out how to get around this...
-    def consume_flags!(args)
-      @optparse.parse!(args) # removes recognized flags from `args`
-      return @options
+    # Unfortunately, OptionParser *really* wants to use closures.  I haven't
+    # yet figured out how to get around this, but at least it's closing on a
+    # local instead of an ivar... progress?
+    def flags_from_args!(args)
+      flags = Flags.new
+      optparse = option_parser(flags: flags)
+      optparse.parse!(args) # removes recognized flags from `args`
+      return flags
     rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption => e
-      raise UnrecognizedOption, e.message, cause: e
+      raise InvalidFlag, e.message, cause: e
     end
 
     def help
-      @optparse.help
+      option_parser.help
     end
 
     private
 
+    # NOTE: if flags is nil, you'll get something that can print help, but will explode when sent :parse
+    def option_parser(flags: nil)
+      OptionParser.new.tap do |optparse|
+        optparse.banner = banner
+        CheckPlease::Flags.each_flag do |flag|
+          args = [ flag.cli_short, flag.cli_long, flag.description ].flatten.compact
+          optparse.on(*args) do |value|
+            flags.send "#{flag.name}=", value
+          end
+        end
+      end
+    end
+
     def banner
       <<~EOF
         Usage: #{@exe_file_name} <reference> <candidate> [FLAGS]

data/lib/check_please/cli/runner.rb

@@ -14,8 +14,8 @@ module CLI
       print_help_and_exit if args.empty?
 
       begin
-        options = @parser.consume_flags!(args)
-      rescue Parser::UnrecognizedOption => e
+        flags = @parser.flags_from_args!(args)
+      rescue InvalidFlag => e
         print_help_and_exit e.message
       end
 
@@ -31,7 +31,7 @@ module CLI
         or print_help_and_exit "Missing <candidate> argument, AND nothing was piped in"
 
       # Looks like we're good to go!
-      diff_view = CheckPlease.render_diff(reference, candidate, options)
+      diff_view = CheckPlease.render_diff(reference, candidate, flags)
       puts diff_view
     end
 

data/lib/check_please/comparison.rb

@@ -3,9 +3,9 @@ module CheckPlease
   module Comparison
     extend self
 
-    def perform(reference, candidate, options = {})
+    def perform(reference, candidate, flags = {})
       root = CheckPlease::Path.new
-      diffs = Diffs.new(options: options)
+      diffs = Diffs.new(flags: flags)
       catch(:max_diffs_reached) do
         compare reference, candidate, root, diffs
       end
@@ -15,8 +15,8 @@ module CheckPlease
     private
 
     def compare(ref, can, path, diffs)
-      if (d = diffs.options[:max_depth])
-        return if path.depth > d
+      if (d = diffs.flags.max_depth)
+        return if path.depth > d + 1
       end
 
       case types(ref, can)
@@ -50,7 +50,8 @@ module CheckPlease
           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
-          else                      ; compare ref, can, new_path, diffs
+          else
+            compare ref, can, new_path, diffs
           end
         end
       end

data/lib/check_please/diff.rb

@@ -3,20 +3,12 @@ module CheckPlease
   class Diff
     COLUMNS = %i[ type path reference candidate ]
 
-    attr_reader :type, :reference, :candidate, :path
-    def initialize(type, reference, candidate, path)
+    attr_reader(*COLUMNS)
+    def initialize(type, path, reference, candidate)
       @type      = type
+      @path      = path.to_s
       @reference = reference
       @candidate = candidate
-      @path      = path.to_s
-    end
-
-    def ref_display
-      reference.inspect
-    end
-
-    def can_display
-      candidate.inspect
     end
 
     def attributes
@@ -28,8 +20,8 @@ module CheckPlease
       s << self.class.name
       s << " type=#{type}"
       s << " path=#{path}"
-      s << " ref=#{ref_display}"
-      s << " can=#{can_display}"
+      s << " ref=#{reference.inspect}"
+      s << " can=#{candidate.inspect}"
       s << ">"
       s
     end

data/lib/check_please/diffs.rb

@@ -1,13 +1,14 @@
 require 'forwardable'
 
 module CheckPlease
+  using Refinements
 
   # Custom collection class for Diff instances.
   # Can retrieve members using indexes or paths.
   class Diffs
-    attr_reader :options
-    def initialize(diff_list = nil, options: {})
-      @options = options
+    attr_reader :flags
+    def initialize(diff_list = nil, flags: {})
+      @flags = Flags(flags)
       @list = []
       @hash = {}
       Array(diff_list).each do |diff|
@@ -29,7 +30,11 @@ module CheckPlease
     end
 
     def <<(diff)
-      if (n = options[:max_diffs])
+      if flags.fail_fast && length > 0
+        throw :max_diffs_reached
+      end
+
+      if (n = flags.max_diffs)
         # It seems no one can help me now / I'm in too deep, there's no way out
         throw :max_diffs_reached if length >= n
       end
@@ -39,7 +44,8 @@ module CheckPlease
     end
 
     def record(ref, can, path, type)
-      self << Diff.new(type, ref, can, path)
+      return if path.excluded?(flags)
+      self << Diff.new(type, path, ref, can)
     end
 
     def data

data/lib/check_please/error.rb

@@ -6,4 +6,8 @@ module CheckPlease
     # instead....
   end
 
+  class InvalidFlag < ArgumentError
+    include CheckPlease::Error
+  end
+
 end

data/lib/check_please/flag.rb

@@ -0,0 +1,78 @@
+module CheckPlease
+
+  class Flag
+    attr_accessor :name
+    attr_writer   :default # reader is defined below
+    attr_accessor :default_proc
+    attr_accessor :description
+    attr_accessor :cli_long
+    attr_accessor :cli_short
+
+    def initialize(attrs = {})
+      @validators = []
+      attrs.each do |name, value|
+        set_attribute! name, value
+      end
+      yield self if block_given?
+      freeze
+    end
+
+    def default
+      if default_proc
+        default_proc.call
+      else
+        @default
+      end
+    end
+
+    def coerce(&block)
+      @coercer = block
+    end
+
+    def mutually_exclusive_to(flag_name)
+      @validators << ->(flags, _) { flags.send(flag_name).empty? }
+    end
+
+    def reentrant
+      @reentrant = true
+      self.default_proc = ->{ Array.new }
+    end
+
+    def validate(&block)
+      @validators << block
+    end
+
+    protected
+
+    def __set__(value, on:, flags:)
+      val = _coerce(value)
+      _validate(flags, val)
+      if @reentrant
+        on[name] ||= []
+        on[name].concat(Array(val))
+      else
+        on[name] = val
+      end
+    end
+
+    private
+
+    def _coerce(value)
+      return value if @coercer.nil?
+      @coercer.call(value)
+    end
+
+    def _validate(flags, value)
+      return if @validators.empty?
+      return if @validators.all? { |block| block.call(flags, value) }
+      raise InvalidFlag, "#{value.inspect} is not a legal value for #{name}"
+    end
+
+    def set_attribute!(name, value)
+      self.send "#{name}=", value
+    rescue NoMethodError
+      raise ArgumentError, "unrecognized attribute: #{name}"
+    end
+  end
+
+end

data/lib/check_please/flags.rb

@@ -0,0 +1,46 @@
+module CheckPlease
+
+  # NOTE: this gets all of its attributes defined (via .define) in ../check_please.rb
+
+  class Flags
+    BY_NAME = {} ; private_constant :BY_NAME
+
+    def self.[](name)
+      BY_NAME[name.to_sym]
+    end
+
+    def self.define(name, &block)
+      flag = Flag.new(name: name.to_sym, &block)
+      BY_NAME[flag.name] = flag
+      define_accessors flag
+
+      nil
+    end
+
+    def self.each_flag
+      BY_NAME.each do |_, flag|
+        yield flag
+      end
+    end
+
+    def self.define_accessors(flag)
+      getter = flag.name
+      define_method(getter) {
+        @attributes.fetch(flag.name) { flag.default }
+      }
+
+      setter = :"#{flag.name}="
+      define_method(setter) { |value|
+        flag.send :__set__, value, on: @attributes, flags: self
+      }
+    end
+
+    def initialize(attrs = {})
+      @attributes = {}
+      attrs.each do |name, value|
+        send "#{name}=", value
+      end
+    end
+  end
+
+end

data/lib/check_please/path.rb

@@ -15,6 +15,17 @@ module CheckPlease
       1 + @segments.length
     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
+      false
+    end
+
     def to_s
       SEPARATOR + @segments.join(SEPARATOR)
     end

data/lib/check_please/printers.rb

@@ -1,10 +1,11 @@
-require_relative 'printers/base'
-require_relative 'printers/json'
-require_relative 'printers/table_print'
-
 module CheckPlease
+  using Refinements
 
   module Printers
+    autoload :Base,       "check_please/printers/base"
+    autoload :JSON,       "check_please/printers/json"
+    autoload :TablePrint, "check_please/printers/table_print"
+
     PRINTERS_BY_FORMAT = {
       table: Printers::TablePrint,
       json:  Printers::JSON,
@@ -12,9 +13,9 @@ module CheckPlease
     FORMATS = PRINTERS_BY_FORMAT.keys.sort
     DEFAULT_FORMAT = :table
 
-    def self.render(diffs, options = {})
-      format = options[:format] || DEFAULT_FORMAT
-      printer = PRINTERS_BY_FORMAT[format.to_sym]
+    def self.render(diffs, flags = {})
+      flags = Flags(flags)
+      printer = PRINTERS_BY_FORMAT[flags.format]
       printer.render(diffs)
     end
   end

data/lib/check_please/printers/json.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 module CheckPlease
 module Printers
 

data/lib/check_please/printers/table_print.rb

@@ -4,21 +4,30 @@ module CheckPlease
 module Printers
 
   class TablePrint < Base
+    InspectStrings = Object.new.tap do |obj|
+      def obj.format(value)
+        value.is_a?(String) ? value.inspect : value
+      end
+    end
+
+    PATH_MAX_WIDTH = 250 # if you hit this limit, you have other problems
+
     TP_OPTS = [
-      :type,
-      { :path => { width: 250 } }, # if you hit this limit, you have other problems
-      :reference,
-      :candidate,
+      { type:      { display_name: "Type" } },
+      { path:      { display_name: "Path",      width: PATH_MAX_WIDTH } },
+      { reference: { display_name: "Reference", formatters: [ InspectStrings ] } },
+      { candidate: { display_name: "Candidate", formatters: [ InspectStrings ] } },
     ]
 
     def to_s
       return "" if diffs.empty?
 
-      build_string do |io|
+      out = build_string do |io|
         switch_tableprint_io(io) do
           tp diffs.data, *TP_OPTS
         end
       end
+      strip_trailing_whitespace(out)
     end
 
     private
@@ -31,6 +40,10 @@ module Printers
     ensure
       config.io = @old_io
     end
+
+    def strip_trailing_whitespace(s)
+      s.lines.map(&:rstrip).join("\n")
+    end
   end
 
 end

data/lib/check_please/refinements.rb

@@ -0,0 +1,16 @@
+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

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.2.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: check_please
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Sam Livingston-Gray
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: table_print
@@ -56,7 +56,8 @@ description: Check for differences between two JSON strings (or Ruby data struct
   parsed from them)
 email:
 - geeksam@gmail.com
-executables: []
+executables:
+- check_please
 extensions: []
 extra_rdoc_files: []
 files:
@@ -69,24 +70,26 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/check_please
 - bin/console
 - bin/setup
 - check_please.gemspec
+- exe/check_please
 - lib/check_please.rb
 - lib/check_please/cli.rb
-- lib/check_please/cli/flag.rb
 - lib/check_please/cli/parser.rb
 - lib/check_please/cli/runner.rb
 - lib/check_please/comparison.rb
 - lib/check_please/diff.rb
 - lib/check_please/diffs.rb
 - lib/check_please/error.rb
+- lib/check_please/flag.rb
+- lib/check_please/flags.rb
 - lib/check_please/path.rb
 - lib/check_please/printers.rb
 - lib/check_please/printers/base.rb
 - lib/check_please/printers/json.rb
 - lib/check_please/printers/table_print.rb
+- lib/check_please/refinements.rb
 - lib/check_please/version.rb
 - usage_examples.rb
 homepage: https://github.com/RealGeeks/check_please

data/lib/check_please/cli/flag.rb

@@ -1,40 +0,0 @@
-module CheckPlease
-module CLI
-
-  class Flag
-    ATTR_NAMES = %i[ short long desc key block ]
-    attr_accessor(*ATTR_NAMES)
-
-    def initialize(*args)
-      self.short = args.shift if args.any?
-      self.long  = args.shift if args.any?
-
-      yield self if block_given?
-
-      missing = ATTR_NAMES.select { |e| self.send(e).nil? }
-      missing -= %i[ short ] # short is optional!
-      if missing.any?
-        raise ArgumentError, "Missing attributes: #{missing.join(', ')}"
-      end
-    end
-
-    def visit_option_parser(parser, options)
-      parser.on(short, long, desc) do |value|
-        block.call options, value
-      end
-    end
-
-    def set_key(key, message = nil, &b)
-      raise ArgumentError if message && b
-      raise ArgumentError if !message && !b
-
-      self.key = key
-      self.block = ->(options, value) {
-        b ||= message.to_sym.to_proc
-        options[key] = b.call(value)
-      }
-    end
-  end
-
-end
-end