object-inspector 0.1.0

data/lib/inspector/constraint/violation.rb

@@ -0,0 +1,34 @@
+module Inspector
+  module Constraint
+    class Violation
+      autoload :List, 'inspector/constraint/violation/list'
+
+      attr_reader :constraint
+
+      def initialize(constraint)
+        @constraint = constraint
+      end
+
+      def positive?
+        @constraint.positive?
+      end
+
+      def negative?
+        !@constraint.positive?
+      end
+
+      def to_s
+        expectation = @constraint.positive? ? 'should' : 'should_not'
+
+        "#{expectation}.#{@constraint}"
+      end
+
+      def inspect
+        "#<violated %{type} constraint %{constraint}>" % {
+          :type       => @constraint.positive? ? 'positive' : 'negative',
+          :constraint => @constraint.inspect
+        }
+      end
+    end
+  end
+end

data/lib/inspector/constraint/violation/list.rb

@@ -0,0 +1,93 @@
+module Inspector
+  module Constraint
+    class Violation
+      class List
+        attr_reader :violations, :children
+
+        def initialize(violations = [], children = {})
+          @violations = violations
+          @children = children
+        end
+
+        def empty?
+          @violations.empty? && @children.empty?
+        end
+
+        def length
+          length  = @violations.length
+          length += @children.values.map(&:length).reduce(:+) unless @children.empty?
+
+          length
+        end
+
+        def <<(violation)
+          unless violation.kind_of?(Inspector::Constraint::Violation)
+            raise "#{violation.inspect} is not a Inspector::Constraint::Violation"
+          end
+
+          @violations << violation
+        end
+        alias :push :<<
+
+        def []=(property_path, violations_list)
+          unless violations_list.kind_of?(Inspector::Constraint::Violation::List)
+            raise "#{violations_list.inspect} is not a Inspector::Constraint::Violation::List"
+          end
+
+          @children[property_path.to_s] = violations_list
+        end
+
+        def [](property_path)
+          child_path, _, property_path = property_path.to_s.split(/(\.|\[|\])/, 2)
+
+          not_found       = "cannot locate violations for #{property_path}"
+          violations_list = @children.fetch(child_path) { raise not_found }
+
+          if property_path
+            violations_list[property_path]
+          else
+            violations_list
+          end
+        end
+
+        def each(path = "", &block)
+          @violations.each do |violation|
+            yield(path, violation)
+          end
+
+          @children.each do |sub_path, list|
+            prefix = "." unless path.empty? || sub_path.start_with?("[")
+
+            list.each("#{path}#{prefix}#{sub_path}", &block)
+          end
+        end
+
+        def to_s
+          string = ""
+
+          unless @violations.empty?
+            string += @violations.map(&:to_s).join("\n")
+            string += "\n"
+          end
+
+          @children.each do |path, list|
+            unless list.empty?
+              string += "#{path}:\n"
+              string += list.to_s.split("\n").map {|line| "  #{line}"}.join("\n")
+              string += "\n"
+            end
+          end
+
+          string
+        end
+
+        def inspect
+          "#<violations %{violations} children=%{children}>" % {
+            :violations    => @violations.inspect,
+            :children      => @children.inspect
+          }
+        end
+      end
+    end
+  end
+end

data/lib/inspector/constraints.rb

@@ -0,0 +1,61 @@
+module Inspector
+  module Constraints
+    autoload :Base,        'inspector/constraints/base'
+    autoload :False,       'inspector/constraints/false'
+    autoload :True,        'inspector/constraints/true'
+    autoload :Empty,       'inspector/constraints/empty'
+    autoload :Predicate,   'inspector/constraints/predicate'
+    autoload :Have,        'inspector/constraints/have'
+    autoload :Email,       'inspector/constraints/email'
+    autoload :Eq,          'inspector/constraints/eq'
+    autoload :Valid,       'inspector/constraints/valid'
+
+    def be_false
+      False.new
+    end
+
+    def be_true
+      True.new
+    end
+
+    def be_empty
+      Empty.new
+    end
+
+    def have_at_least(n)
+      Have::AtLeast.new(n)
+    end
+
+    def have_at_most(n)
+      Have::AtMost.new(n)
+    end
+
+    def have(n)
+      Have::Exactly.new(n)
+    end
+    alias :have_exactly :have
+
+    def be_email
+      Email.new
+    end
+    alias :be_an_email :be_email
+
+    def eq(expected)
+      Eq.new(expected)
+    end
+
+    def validate(options = {})
+      Valid.new(options[:as])
+    end
+
+    # be_empty => value.empty?
+    # be_nil   => value.nil?
+    def method_missing(method, *args, &block)
+      prefix, *predicate = method.to_s.split("_")
+      predicate.shift if ["a", "an"].include?(predicate.first)
+      return Inspector::Constraints::Predicate.new(predicate.join("_"), *args, &block) if prefix == "be"
+      # return Inspector::Constraints::Has.new(method, *args, &block) if method.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/lib/inspector/constraints/email.rb

@@ -0,0 +1,57 @@
+module Inspector
+  module Constraints
+    class Email
+      include Constraint
+
+      PATTERN = begin
+        if (RUBY_VERSION == '1.9.2' && RUBY_ENGINE == 'jruby' && JRUBY_VERSION <= '1.6.3') || RUBY_VERSION >= '1.9.2'
+          # There is an obscure bug in jruby 1.6 that prevents matching
+          # on unicode properties here. Remove this logic branch once
+          # a stable jruby release fixes this.
+          #
+          # http://jira.codehaus.org/browse/JRUBY-5622
+          #
+          # There is a similar bug in preview releases of 1.9.3
+          #
+          # http://redmine.ruby-lang.org/issues/5126
+          letter = 'a-zA-Z'
+        else
+          letter = 'a-zA-Z\p{L}'  # Changed from RFC2822 to include unicode chars
+        end
+        digit          = '0-9'
+        atext          = "[#{letter}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+        dot_atom_text  = "#{atext}+([.]#{atext}*)+"
+        dot_atom       = dot_atom_text
+        no_ws_ctl      = '\x01-\x08\x11\x12\x14-\x1f\x7f'
+        qtext          = "[^#{no_ws_ctl}\\x0d\\x22\\x5c]"  # Non-whitespace, non-control character except for \ and "
+        text           = '[\x01-\x09\x11\x12\x14-\x7f]'
+        quoted_pair    = "(\\x5c#{text})"
+        qcontent       = "(?:#{qtext}|#{quoted_pair})"
+        quoted_string  = "[\"]#{qcontent}+[\"]"
+        atom           = "#{atext}+"
+        word           = "(?:#{atom}|#{quoted_string})"
+        obs_local_part = "#{word}([.]#{word})*"
+        local_part     = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+        dtext          = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+        dcontent       = "(?:#{dtext}|#{quoted_pair})"
+        domain_literal = "\\[#{dcontent}+\\]"
+        obs_domain     = "#{atom}([.]#{atom})+"
+        domain         = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+        addr_spec      = "#{local_part}\@#{domain}"
+        pattern        = /\A#{addr_spec}\z/u
+      end
+
+      def valid?(email)
+        !(PATTERN =~ email).nil?
+      end
+
+      def to_s
+        "be_an_email"
+      end
+
+      def inspect
+        "#<email>"
+      end
+    end
+  end
+end

data/lib/inspector/constraints/empty.rb

@@ -0,0 +1,21 @@
+module Inspector
+  module Constraints
+    class Empty
+      include Constraint
+
+      def valid?(actual)
+        actual = actual.to_s unless actual.respond_to?(:empty?)
+
+        actual.empty?
+      end
+
+      def to_s
+        "be_empty"
+      end
+
+      def inspect
+        "#<empty>"
+      end
+    end
+  end
+end

data/lib/inspector/constraints/eq.rb

@@ -0,0 +1,23 @@
+module Inspector
+  module Constraints
+    include Constraint
+
+    class Eq
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def valid?(actual)
+        actual == @expected
+      end
+
+      def to_s
+        "eq"
+      end
+
+      def inspect
+        "#<== #{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/inspector/constraints/false.rb

@@ -0,0 +1,19 @@
+module Inspector
+  module Constraints
+    class False
+      include Constraint
+
+      def valid?(actual)
+        !actual
+      end
+
+      def to_s
+        "be_false"
+      end
+
+      def inspect
+        "#<false>"
+      end
+    end
+  end
+end

data/lib/inspector/constraints/have.rb

@@ -0,0 +1,85 @@
+module Inspector
+  module Constraints
+    module Have
+      include Constraint
+
+      class AtLeast
+        include Have
+
+        def to_s
+          "have_at_least"
+        end
+
+        def compare(actual)
+          actual >= @expected
+        end
+      end
+
+      class AtMost
+        include Have
+
+        def to_s
+          "have_at_most"
+        end
+
+        def compare(actual)
+          actual <= @expected
+        end
+      end
+
+      class Exactly
+        include Have
+
+        def to_s
+          "have_exactly"
+        end
+
+        def compare(actual)
+          actual == @expected
+        end
+      end
+
+      def initialize(expected)
+        @expected        = expected.to_i
+      end
+
+      def valid?(collection_or_owner)
+        collection = determine_collection(collection_or_owner)
+        return false if collection.nil?
+        query_method = determine_query_method(collection)
+        compare(collection.__send__(query_method))
+      end
+
+      def inspect
+        "#<%{constraint} %{expected}%{collection}>" % {
+          :constraint => to_s.split('_').join(' '),
+          :expected   => @expected.inspect,
+          :collection => " #{@collection_name}".rstrip
+        }
+      end
+
+      def method_missing(method, *args, &block)
+        @collection_name = method
+        @args = args
+        @block = block
+        self
+      end
+
+      private
+
+      def determine_collection(collection_or_owner)
+        collection_or_owner.__send__(@collection_name, *@args, &@block) if collection_or_owner.respond_to?(@collection_name)
+        collection_or_owner if determine_query_method(collection_or_owner)
+        # elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
+        #   collection_or_owner.__send__(@plural_collection_name, *@args, &@block)
+        # else
+        #   collection_or_owner.__send__(@collection_name, *@args, &@block)
+        # end
+      end
+
+      def determine_query_method(collection)
+        [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+      end
+    end
+  end
+end

data/lib/inspector/constraints/predicate.rb

@@ -0,0 +1,38 @@
+module Inspector
+  module Constraints
+    class Predicate
+      include Constraint
+
+      def initialize(method, *args, &block)
+        @method = method
+        @args = args
+        @block = block
+      end
+
+      def valid?(actual)
+        result = false
+
+        begin
+          result = actual.__send__("#{@method}?", *@args, &@block)
+        rescue NameError
+        end
+
+        begin
+          result  = actual.__send__("#{@method}s?", *@args, &@block)
+          @method = "#{@method}s"
+        rescue NameError
+        end
+
+        return result
+      end
+
+      def to_s
+        "be_#{@method}"
+      end
+
+      def inspect
+        "#<#{@method}>"
+      end
+    end
+  end
+end

data/lib/inspector/constraints/true.rb

@@ -0,0 +1,19 @@
+module Inspector
+  module Constraints
+    class True
+      include Constraint
+
+      def valid?(actual)
+        !!actual
+      end
+
+      def to_s
+        "be_true"
+      end
+
+      def inspect
+        "#<true>"
+      end
+    end
+  end
+end