check_please 0.2.3 → 0.5.0

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

@@ -1,27 +1,172 @@
 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 to_s
-      SEPARATOR + @segments.join(SEPARATOR)
+    def excluded?(flags)
+      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
-      to_s
+      "<#{self.class.name} '#{to_s}'>"
     end
+
+		# TODO: Naming Things
+    def key_for_compare(flags)
+      mbk_exprs = unpack_mbk_exprs(flags)
+      matches = mbk_exprs.select { |mbk_expr|
+        # NOTE: matching on parent because MBK '/foo/:id' should return 'id' for path '/foo'
+        mbk_expr.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?(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 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
+
+    # 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_mbk_exprs(flags)
+      flags.match_by_key
+        .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

data/lib/check_please/path_segment.rb

@@ -0,0 +1,88 @@
+module CheckPlease
+
+  class PathSegment
+    include CheckPlease::Reification
+    can_reify String, Symbol, Numeric, nil
+
+    KEY_EXPR = %r{
+      ^
+      \:       # a literal colon
+      (        # capture key
+        [^\:]+ # followed by one or more things that aren't colons
+      )        # end capture key
+      $
+    }x
+
+    KEY_VAL_EXPR = %r{
+      ^
+      (       # capture key
+        [^=]+ # stuff (just not an equal sign)
+      )       # end capture key
+      \=      # an equal sign
+      (       # capture key value
+        [^=]+ # stuff (just not an equal sign)
+      )       # end capture key value
+      $
+    }x
+
+    attr_reader :name, :key, :key_value
+    alias_method :to_s, :name
+
+    def initialize(name = nil)
+      @name = name.to_s.strip
+      if @name =~ %r(\s) # has any whitespace
+        raise InvalidPathSegment, <<~EOF
+          #{name.inspect} is not a valid #{self.class} name
+        EOF
+      end
+      parse_key_and_value
+      freeze
+    end
+
+    def empty?
+      name.empty?
+    end
+
+    def key_expr?
+      name.match?(KEY_EXPR)
+    end
+
+    def key_val_expr?
+      name.match?(KEY_VAL_EXPR)
+    end
+
+    def match?(other_segment_or_string)
+      other = self.class.reify(other_segment_or_string)
+
+      match_types = [ self.match_type, other.match_type ]
+      case match_types
+      when [ :plain,     :plain     ] ; self.name == other.name
+      when [ :key,       :key_value ] ; self.key  == other.key
+      when [ :key_value, :key       ] ; self.key  == other.key
+      else                            ; false
+      end
+    end
+
+    protected
+
+    def match_type
+      return :key       if key_expr?
+      return :key_value if key_val_expr?
+      :plain
+    end
+
+    private
+
+    def parse_key_and_value
+      case name
+      when KEY_EXPR
+        @key = $1
+      when KEY_VAL_EXPR
+        @key, @key_value = $1, $2
+      else
+        # :nothingtodohere:
+      end
+    end
+  end
+
+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/table_print.rb

@@ -4,11 +4,19 @@ 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

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/reification.rb

@@ -0,0 +1,50 @@
+module CheckPlease
+
+  module Reification
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+      def reifiable
+        @_reifiable ||= []
+      end
+
+      def can_reify(*klasses)
+        klasses.flatten!
+
+        unless ( klasses - [nil] ).all? { |e| e.is_a?(Class) }
+          raise ArgumentError, "classes (or nil) only, please"
+        end
+
+        reifiable.concat klasses
+        reifiable.uniq!
+        nil
+      end
+
+      def reify(primitive_or_object)
+        case primitive_or_object
+        when self       ; return primitive_or_object
+        when Array      ; return primitive_or_object.map { |e| reify(e) }
+        when *reifiable ; return new(primitive_or_object)
+        end
+        # note early return ^^^
+
+        # that didn't work? complain!
+        acceptable = reifiable.map { |e| Class === e ? e.name : e.inspect }
+        raise ArgumentError, <<~EOF
+          #{self}.reify was given: #{primitive_or_object.inspect}
+          but only accepts: #{acceptable.join(", ")}
+        EOF
+      end
+    end
+
+    module InstanceMethods
+      def reify(x)
+        self.class.reify(x)
+      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.3"
+  VERSION = "0.5.0"
 end

data/usage_examples.rb

@@ -1,7 +1,11 @@
 require 'check_please'
 
-reference = { foo: "wibble" }
-candidate = { bar: "wibble" }
+reference = { "foo" => "wibble" }
+candidate = { "bar" => "wibble" }
+
+
+
+##### Printing diffs #####
 
 puts CheckPlease.render_diff(reference, candidate)
 
@@ -12,3 +16,21 @@ _ = <<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` !
+
+# To print these in the console, you can just do:
+puts diffs
+
+# If for some reason you want to print the JSON version, it gets a little more verbose:
+puts diffs.to_s(format: :json)