check_please 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 889dea37051513ced2de5a716db086a1ad1793af6e095704be6cc39a0fc64822
-  data.tar.gz: 2a21aeeb5a686b46a4657dd2d50163b07e0e6e2f1effb8fdbe652bbc835f5c02
+  metadata.gz: c4e0e81da97eb41aade7d58c516519bde3d2527173b64e7d644e46458493450d
+  data.tar.gz: c633c13e0a776bdbf1691b9c01d3be3cc978cb445c2fbf8d74e95449ea0b3118
 SHA512:
-  metadata.gz: 72b705dc899a841fadce3a9d67c538012d83d7e9fce7e69d8b7da4d6795eb84ac6eb4c8feedc8f721b07c0894c4a87079584081350ade4a3a184aa7ba7fad0d2
-  data.tar.gz: c13e453a1032c1ad9b57e7e20c272851044dce1c80ca63bde5b173e05f547b2f43c39c3910cd1decebbe4da28eb2e71ba2fbeb4c23f145c40176bf3391292431
+  metadata.gz: ad31ad99aef3494a2d2438b422a5fef9385c6fd05572131907d33d9e1e30a94ba0582ca4aae00c997dbe302487719da3d5ddbf715cf23422405086084f7a982c
+  data.tar.gz: 04d8e89b72894e458394ff0428192ffbe6f3b307437ce6ee8496f6e3064236498286b2fb203a399c5245172cec391656646dac39b20f0adc8a345eff13b8f015

data/Gemfile.lock

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

data/README.md

@@ -52,6 +52,11 @@ like MacOS's `pbpaste` utility.)
 
 See [check_please_rspec_matcher](https://github.com/RealGeeks/check_please_rspec_matcher).
 
+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!
+
 ### From Ruby
 
 Create two strings, each containing a JSON or YAML document, and pass them to

data/lib/check_please.rb

@@ -1,27 +1,37 @@
-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
@@ -41,4 +51,78 @@ module CheckPlease
       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,7 +15,7 @@ module CheckPlease
     private
 
     def compare(ref, can, path, diffs)
-      if (d = diffs.options[:max_depth])
+      if (d = diffs.flags.max_depth)
         return if path.depth > d + 1
       end
 
@@ -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,12 +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 attributes

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: check_please
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Sam Livingston-Gray
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-19 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: table_print
@@ -76,18 +76,20 @@ files:
 - 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