check_please 0.3.0 → 0.5.2

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

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/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