check_please 0.2.4 → 0.5.1

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
-    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 #####
+    autoload :Runner, "check_please/cli/parser"
+    autoload :Parser, "check_please/cli/runner"
 
-    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
+    def self.run(exe_file_name)
+      Runner.new(exe_file_name).run(*ARGV.dup)
     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
+      @exe_file_name = File.basename(exe_file_name)
     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

@@ -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 = {})
+      @flags = Flags(flags) # whoa, it's almost like Java in here
+      @diffs = Diffs.new(flags: @flags)
 
-    def perform(reference, candidate, options = {})
-      root = CheckPlease::Path.new
-      diffs = Diffs.new(options: options)
       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.options[: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,54 +41,121 @@ module CheckPlease
         }
       end
 
-      def compare_arrays(ref_array, can_array, path, diffs)
-        max_len = [ ref_array, can_array ].map(&:length).max
-        (0...max_len).each do |i|
-          n = i + 1 # count in human pls
-          new_path = path + n
+      def compare_arrays(ref_array, can_array, path)
+        if ( key = path.key_for_compare(flags) )
+          compare_arrays_by_key ref_array, can_array, path, key
+        else
+          compare_arrays_by_index ref_array, can_array, path
+        end
+      end
+
+        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)
 
-          ref = ref_array[i]
-          can = can_array[i]
+          key_values.compact! # NOTE: will break if nil is ever used as a key (but WHO WOULD DO THAT?!)
+          key_values.sort!
 
-          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
+          key_values.each do |key_value|
+            new_path = path + "#{key_name}=#{key_value}"
+            ref = refs_by_key[key_value]
+            can = cans_by_key[key_value]
+            case
+            when ref.nil? ; record_diff ref, can, new_path, :extra
+            when can.nil? ; record_diff ref, can, new_path, :missing
+            else          ; compare ref, can, new_path
+            end
           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 index_array!(array_of_hashes, path, key_name, ref_or_can)
+            elements_by_key = {}
+
+            array_of_hashes.each.with_index do |h, i|
+              # make sure we have a hash
+              unless h.is_a?(Hash)
+                raise CheckPlease::TypeMismatchError, \
+                  "The element at position #{i} in the #{ref_or_can} array is not a hash."
+              end
+
+              # try to get the value of the attribute identified by key_name
+              key_value = h.fetch(key_name) {
+                raise CheckPlease::NoSuchKeyError, \
+                  <<~EOF
+                    The #{ref_or_can} hash at position #{i} has no #{key_name.inspect} key.
+                    Keys it does have: #{h.keys.inspect}
+                  EOF
+              }
+
+              # complain about dupes
+              if elements_by_key.has_key?(key_value)
+                key_val_expr = "#{key_name}=#{key_value}"
+                raise CheckPlease::DuplicateKeyError, \
+                  "Duplicate #{ref_or_can} element found at path '#{path + key_val_expr}'."
+              end
+
+              # ok, now we can proceed
+              elements_by_key[key_value] = h
+            end
+
+            elements_by_key
+          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|
+            n = i + 1 # count in human pls
+            new_path = path + n
+
+            ref = ref_array[i]
+            can = can_array[i]
+
+            case
+            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
+            end
+          end
+        end
+
+      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/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
@@ -38,14 +43,14 @@ module CheckPlease
       @hash[diff.path] = diff
     end
 
-    def record(ref, can, path, type)
-      self << Diff.new(type, ref, can, path)
-    end
-
     def data
       @list.map(&:attributes)
     end
 
+    def to_s(flags = {})
+      CheckPlease::Printers.render(self, flags)
+    end
+
     extend Forwardable
     def_delegators :@list, *%i[
       each

data/lib/check_please/error.rb

@@ -6,4 +6,28 @@ module CheckPlease
     # instead....
   end
 
+  class DuplicateKeyError < ::IndexError
+    include CheckPlease::Error
+  end
+
+  class InvalidFlag < ArgumentError
+    include CheckPlease::Error
+  end
+
+  class InvalidPath < ArgumentError
+    include CheckPlease::Error
+  end
+
+  class InvalidPathSegment < ArgumentError
+    include CheckPlease::Error
+  end
+
+  class NoSuchKeyError < ::KeyError
+    include CheckPlease::Error
+  end
+
+  class TypeMismatchError < ::TypeError
+    include CheckPlease::Error
+  end
+
 end

data/lib/check_please/flag.rb

@@ -0,0 +1,88 @@
+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 description=(value)
+      if value.is_a?(String) && value =~ /\n/m
+        lines = value.lines
+      else
+        lines = Array(value).map(&:to_s)
+      end
+
+      @description = lines.map(&:rstrip)
+    end
+
+    def mutually_exclusive_to(flag_name)
+      @validators << ->(flags, _) { flags.send(flag_name).empty? }
+    end
+
+    def repeatable
+      @repeatable = 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 @repeatable
+        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