check_please 0.4.0 → 0.5.3

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,34 +1,37 @@
 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
+      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
       else
-        diffs.record ref, can, path, :type_mismatch
+        record_diff ref, can, path, :type_mismatch
       end
     end
 
-      def types(*list)
+      def types_for_compare(*list)
         list.map { |e|
           case e
           when Array ; :array
@@ -38,55 +41,188 @@ 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)
+        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
+      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
+
+              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, \
+                  <<~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
+
+        # 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|
+            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)
+        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 record_missing_keys(ref_hash, can_hash, path, diffs)
+        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|
-            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)
+        if flags.indifferent_values
+          ref = stringify_symbol(ref)
+          can = stringify_symbol(can)
+        end
         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,15 +43,14 @@ 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
 
+    def to_s(flags = {})
+      CheckPlease::Printers.render(self, flags)
+    end
+
     extend Forwardable
     def_delegators :@list, *%i[
       each

data/lib/check_please/error.rb

@@ -6,8 +6,32 @@ module CheckPlease
     # instead....
   end
 
+  class BehaviorUndefined < ::StandardError
+    include CheckPlease::Error
+  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

@@ -29,12 +29,22 @@ module CheckPlease
       @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 reentrant
-      @reentrant = true
+    def repeatable
+      @repeatable = true
       self.default_proc = ->{ Array.new }
     end
 
@@ -47,7 +57,7 @@ module CheckPlease
     def __set__(value, on:, flags:)
       val = _coerce(value)
       _validate(flags, val)
-      if @reentrant
+      if @repeatable
         on[name] ||= []
         on[name].concat(Array(val))
       else

data/lib/check_please/path.rb

@@ -1,38 +1,173 @@
 module CheckPlease
 
+  # TODO: this class is getting a bit large; maybe split out some of the stuff that uses flags?
   class Path
+    include CheckPlease::Reification
+    can_reify String, Symbol, Numeric, nil
+
     SEPARATOR = "/"
 
-    def initialize(segments = [])
+    def self.root
+      new('/')
+    end
+
+
+
+    attr_reader :to_s, :segments
+    def initialize(name_or_segments = [])
+      case name_or_segments
+      when String, Symbol, Numeric, nil
+        names = name_or_segments.to_s.split(SEPARATOR)
+        names.shift until names.empty? || names.first =~ /\S/
+        segments = PathSegment.reify(names)
+      when Array
+        segments = PathSegment.reify(name_or_segments)
+      else
+        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)
+      freeze
+    rescue InvalidPathSegment => e
+      raise InvalidPath, e.message
     end
 
     def +(new_basename)
-      self.class.new( Array(@segments) + Array(new_basename.to_s) )
+      new_segments = self.segments.dup
+      new_segments << new_basename # don't reify here; it'll get done on Path#initialize
+      self.class.new(new_segments)
+    end
+
+    def ==(other)
+      self.to_s == other.to_s
+    end
+
+    def ancestors
+      list = []
+      p = self
+      loop do
+        break if p.root?
+        p = p.parent
+        list.unshift p
+      end
+      list.reverse
+    end
+
+    def basename
+      segments.last.to_s
     end
 
     def depth
-      1 + @segments.length
+      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)
+      return false if root? # that would just be silly
+
+      return true if too_deep?(flags)
+      return true if explicitly_excluded?(flags)
+      return true if implicitly_excluded?(flags)
+
+      false
+    end
+
+    def inspect
+      "<#{self.class.name} '#{to_s}'>"
+    end
+
+    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
+      when 1 ; matches.first.segments.last.key
+      else   ; raise "More than one match_by_key expression for path '#{self}': #{matches.map(&:to_s).inspect}"
       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
+
+      # Otherwise, compare segments: do we have the same number, and do they all #match?
+      other = reify(path_or_string)
+      return false if other.depth != self.depth
+
+      seg_pairs = self.segments.zip(other.segments)
+      seg_pairs.all? { |a, b| a.match?(b) }
+    end
+
+    def parent
+      return nil if root? # TODO: consider the Null Object pattern
+      self.class.new(segments[0..-2])
+    end
+
+    def root?
+      @segments.empty?
+    end
+
+    private
+
+    # O(n^2) check to see if any of the path's ancestors are on a list
+    # (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 }
+      }
+    end
+
+    def explicitly_excluded?(flags)
+      return false if flags.reject_paths.empty?
+      return true if self_on_list?(flags.reject_paths)
+      return true if ancestor_on_list?(flags.reject_paths)
       false
     end
 
-    def to_s
-      SEPARATOR + @segments.join(SEPARATOR)
+    def implicitly_excluded?(flags)
+      return false if flags.select_paths.empty?
+      return false if self_on_list?(flags.select_paths)
+      return false if ancestor_on_list?(flags.select_paths)
+      true
     end
 
-    def inspect
-      to_s
+    # A path of "/foo/:id/bar/:name" has two key expressions:
+    # - "/foo/:id"
+    # - "/foo/:id/bar/:name"
+    def key_exprs
+      ( [self] + ancestors )
+        .reject { |path| path.root? }
+        .select { |path| path.segments.last&.key_expr? }
+    end
+
+    # O(n) check to see if the path itself is on a list
+    def self_on_list?(paths)
+      paths.any? { |path| self == path }
+    end
+
+    def too_deep?(flags)
+      return false if flags.max_depth.nil?
+      depth > flags.max_depth
     end
+
+    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
+    end
+
   end
 
 end