object-inspector 0.1.0

data/lib/inspector/constraints/valid.rb

@@ -0,0 +1,31 @@
+module Inspector
+  module Constraints
+    class Valid
+      include Constraint
+
+      def initialize(*args)
+        if args.length == 1
+          @use_custom_type = true
+          @type = args.first
+        end
+      end
+
+      def validate_as(value)
+        return @type if @use_custom_type
+        value.class
+      end
+
+      def validator
+        :validity
+      end
+
+      def to_s
+        "validate"
+      end
+
+      def inspect
+        "#<valid%{type}>" % { :type => " #{@type}".rstrip }
+      end
+    end
+  end
+end

data/lib/inspector/metadata.rb

@@ -0,0 +1,75 @@
+module Inspector
+  module Metadata
+    autoload :Map,    'inspector/metadata/map'
+    autoload :Walker, 'inspector/metadata/walker'
+
+    include Constraints
+
+    attr_reader :type, \
+                :constraints, \
+                :children_metadata
+
+    def initialize(type)
+      @type = type
+      @constraints = []
+      @property_metadatas = {}
+      @attribute_metadatas = {}
+    end
+
+    def attribute(name, &block)
+      @attribute_metadatas[name] ||= AttributeMetadata.new(@type, name)
+      if block_given?
+        block.arity == 1 ? yield(@attribute_metadatas[name]) : @attribute_metadatas[name].instance_eval(&block)
+      end
+      @attribute_metadatas[name]
+    end
+
+    def property(name, &block)
+      @property_metadatas[name] ||= PropertyMetadata.new(@type, name)
+      if block_given?
+        block.arity == 1 ? yield(@property_metadatas[name]) : @property_metadatas[name].instance_eval(&block)
+      end
+      @property_metadatas[name]
+    end
+
+    def each_item(&block)
+      @children_metadata ||= TypeMetadata.new(@type)
+      if block_given?
+        block.arity == 1 ? yield(@children_metadata) : @children_metadata.instance_eval(&block)
+      end
+      @children_metadata
+    end
+
+    def should(constraint = nil)
+      return PositiveComparator.new(self) if constraint.nil?
+
+      @constraints << constraint
+
+      self
+    end
+
+    def should_not(constraint = nil)
+      return NegativeComparator.new(self) if constraint.nil?
+
+      constraint.negate!
+      @constraints << constraint
+
+      self
+    end
+
+    def attribute_metadatas
+      @attribute_metadatas.values
+    end
+
+    def property_metadatas
+      @property_metadatas.values
+    end
+
+    def children(object, &block)
+      object.each_with_index(&block)
+    rescue NoMethodError
+      raise "metadata for #{@type.inspect} contains children metadata, however " +
+            "#{object.inspect}.each_with_index is not defined"
+    end
+  end
+end

data/lib/inspector/metadata/map.rb

@@ -0,0 +1,24 @@
+module Inspector
+  module Metadata
+    class Map
+      def initialize
+        @map = {}
+      end
+
+      def []=(type, metadata)
+        unless metadata.kind_of?(Metadata)
+          raise "#{metadata.inspect} is not a Inspector::Metadata"
+        end
+
+        @map[type] = metadata
+      end
+
+      def [](type)
+        @map.fetch(type)
+      rescue KeyError
+        raise "validation information for #{type.inspect} doesn't exist, use " +
+              "Inspector.valid(#{type.inspect}) to define it"
+      end
+    end
+  end
+end

data/lib/inspector/metadata/walker.rb

@@ -0,0 +1,46 @@
+module Inspector
+  module Metadata
+    class Walker
+      def initialize(violation_list_class, validator_map)
+        @violation_list_class = violation_list_class
+        @validator_map        = validator_map
+      end
+
+      def walk_object(metadata, object)
+        violations = @violation_list_class.new
+
+        metadata.constraints.each do |constraint|
+          not_found = "validator #{constraint.validator} cannot be found"
+          validator = @validator_map.fetch(constraint.validator) { raise not_found }
+
+          validator.validate(object, constraint, violations)
+        end
+
+        # walk object attributes, properties and children if object constraints passed
+        if violations.empty?
+          metadata.attribute_metadatas.each do |metadata|
+            path  = metadata.attribute_name
+            value = metadata.attribute_value(object)
+
+            violations[path] = walk_object(metadata, value)
+          end
+
+          metadata.property_metadatas.each do |metadata|
+            path  = "[#{metadata.property_name}]"
+            value = metadata.property_value(object)
+
+            violations[path] = walk_object(metadata, value)
+          end
+
+          metadata.children_metadata.children(object) do |child, index|
+            path = "[#{index}]"
+
+            violations[path] = walk_object(metadata.children_metadata, child)
+          end unless metadata.children_metadata.nil?
+        end
+
+        violations
+      end
+    end
+  end
+end

data/lib/inspector/property_metadata.rb

@@ -0,0 +1,19 @@
+module Inspector
+  class PropertyMetadata
+    include Metadata
+
+    attr_reader :property_name
+
+    def initialize(type, property_name)
+      @property_name = property_name
+      super(type)
+    end
+
+    def property_value(object)
+      object.__send__(:[], @property_name)
+    rescue NoMethodError
+      raise "metadata for #{@type.inspect} contains property metadata, however " +
+            "#{object.inspect}[#{@property_name.inspect}] is not defined"
+    end
+  end
+end

data/lib/inspector/type_metadata.rb

@@ -0,0 +1,5 @@
+module Inspector
+  class TypeMetadata
+    include Metadata
+  end
+end

data/lib/inspector/validator.rb

@@ -0,0 +1,26 @@
+module Inspector
+  class Validator
+    def initialize(metadata_map, walker, type_metadata_class)
+      @metadata_map = metadata_map
+      @walker = walker
+      @type_metadata_class = type_metadata_class
+    end
+
+    def valid(type, &block)
+      metadata = @type_metadata_class.new(type)
+      if block_given?
+        block.arity == 1 ? yield(metadata) : metadata.instance_eval(&block)
+      end
+      @metadata_map[type] = metadata
+
+      nil
+    end
+
+    def validate(object, opts = {})
+      type       = opts.fetch(:as) { object.class }
+      metadata   = @metadata_map[type]
+
+      @walker.walk_object(metadata, object)
+    end
+  end
+end

data/lib/inspector/version.rb

@@ -0,0 +1,3 @@
+module Inspector
+  VERSION = "0.1.0"
+end

data/lib/object_inspector.rb

@@ -0,0 +1 @@
+require_relative 'inspector'

data/spec/inspector/attribute_metadata_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe(Inspector::AttributeMetadata) do
+  let(:attribute) { 'name' }
+  let(:metadata) { Inspector::AttributeMetadata.new(type, attribute) }
+
+  it_behaves_like Inspector::Metadata
+end

data/spec/inspector/constraint/violation/list_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe(Inspector::Constraint::Violation::List) do
+  let(:list) { Inspector::Constraint::Violation::List.new }
+
+  describe "#<<" do
+    let(:violation) { double() }
+
+    it "adds constraints" do
+      violation.stub(:kind_of?) { true }
+
+      expect { list << violation }.to change(list, :length).from(0).to(1)
+    end
+
+    it "raises when adding not a constraint violation" do
+      expect {
+        list << violation
+      }.to raise_error("#{violation.inspect} is not a Inspector::Constraint::Violation")
+    end
+  end
+
+  describe "#[]=" do
+    let(:property_path) { 'username' }
+    let(:violation_list) { nil }
+
+    it "raises when adding not a constraint violation list" do
+      expect {
+        list[property_path] = violation_list
+      }.to raise_error("#{violation_list.inspect} is not a Inspector::Constraint::Violation::List")
+    end
+  end
+
+  describe "#[]" do
+    before(:each) do
+      list["attribute"] = Inspector::Constraint::Violation::List.new([
+        Inspector::Constraint::Violation.new(nil),
+        Inspector::Constraint::Violation.new(nil)
+      ])
+    end
+
+    it "returns list of matching violations" do
+      list["attribute"].length.should == 2
+    end
+  end
+end

data/spec/inspector/constraints/false_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Inspector::Constraints::False do
+  let(:constraint) { Inspector::Constraints::False.new }
+
+  [
+    [true, false],
+    [false, true],
+    [nil, true],
+    ["string", false]
+  ].each do |value, expected|
+    describe "#valid?(#{value.inspect})" do
+      it "is #{expected}" do
+        constraint.valid?(value).should be(expected)
+      end
+    end
+  end
+end

data/spec/inspector/constraints_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe(Inspector::Constraints) do
+  let(:constraint_helper) { Object.new }
+
+  before(:each) do
+    constraint_helper.extend Inspector::Constraints
+  end
+
+  describe ".be_false" do
+    it "creates False constraint" do
+      expect(constraint_helper.be_false).to be_kind_of(Inspector::Constraints::False)
+    end
+  end
+end

data/spec/inspector/metadata/map_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe(Inspector::Metadata::Map) do
+  let(:metadata_map) { Inspector::Metadata::Map.new }
+
+  describe "#[]=" do
+    let(:metadata) { double() }
+
+    it "raises if not a Metadata given" do
+      expect {
+        metadata_map[NilClass] = metadata
+      }.to raise_error("#{metadata.inspect} is not a Inspector::Metadata")
+    end
+
+    it "returns Metadata" do
+      metadata.stub(:kind_of?) { true }
+
+      expect(metadata_map[NilClass] = metadata).to be(metadata)
+    end
+  end
+
+  describe "#[]" do
+    it "raises if no Metadata registered" do
+      expect {
+        metadata_map[NilClass]
+      }.to raise_error("validation information for NilClass doesn't exist, use " +
+                       "Inspector.valid(NilClass) to define it")
+    end
+
+    it "fetches pre-registered metadata" do
+      metadata = double()
+      metadata.stub(:kind_of?) { true }
+      metadata_map[NilClass] = metadata
+
+      expect(metadata_map[NilClass]).to be(metadata)
+    end
+  end
+end

data/spec/inspector/metadata/walker_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe(Inspector::Metadata::Walker) do
+  describe "#walk_object" do
+    it ""
+  end
+end

data/spec/inspector/property_metadata_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe(Inspector::PropertyMetadata) do
+  let(:property) { 'name' }
+  let(:metadata) { Inspector::PropertyMetadata.new(type, property) }
+
+  it_behaves_like Inspector::Metadata
+end

data/spec/inspector/type_metadata_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe(Inspector::TypeMetadata) do
+  let(:metadata) { Inspector::TypeMetadata.new(type) }
+
+  it_behaves_like Inspector::Metadata
+end

data/spec/inspector/validator_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe(Inspector::Validator) do
+  let(:metadata_map) { double() }
+  let(:walker) { double() }
+  let(:type_metadata_class) { double() }
+  let(:validator) {
+    Inspector::Validator.new(
+      metadata_map,
+      walker,
+      type_metadata_class
+    )
+  }
+
+  describe "#valid" do
+    let(:metadata) { double() }
+
+    before(:each) do
+      type_metadata_class.should_receive(:new).with(NilClass).and_return(metadata)
+      metadata_map.should_receive(:[]=).with(NilClass, metadata).and_return(metadata)
+    end
+
+    it "registers new TypeMetadata in metadata map" do
+      expect(validator.valid(NilClass)).to be(nil)
+    end
+
+    it "yields registered TypeMetadata" do
+      validator.valid(NilClass) do |nil_metadata|
+        expect(nil_metadata).to be(metadata)
+      end
+    end
+
+    it "evaluates block in context of registered TypeMetadata" do
+      context = nil
+      validator.valid(NilClass) do
+        context = self
+      end
+
+      expect(context).to be(metadata)
+    end
+  end
+
+  describe "#validate" do
+    let(:metadata) { double() }
+    let(:violations) { double() }
+    let(:object) { double() }
+
+    before(:each) do
+      walker.should_receive(:walk_object).with(metadata, object).and_return(violations)
+    end
+
+    it "walks object using its class" do
+      object.stub(:class) { NilClass }
+      metadata_map.should_receive(:[]).with(NilClass).and_return(metadata)
+
+      expect(validator.validate(object)).to be(violations)
+    end
+
+    it "walks object using metadata type specified" do
+      metadata_map.should_receive(:[]).with("metadata type").and_return(metadata)
+
+      expect(validator.validate(object, :as => "metadata type")).to be(violations)
+    end
+  end
+end