object-inspector 0.1.0

data/features/error_display.feature

@@ -0,0 +1,80 @@
+Feature: error display
+
+  It is important to be able to render validation failures with correct error messages
+
+  Scenario: object attributes
+    Given a file named "object.rb" with:
+      """
+      require 'inspector'
+
+      Profile     = Struct.new(:first_name, :last_name, :date_of_birth, :preferences)
+      User        = Struct.new(:username, :email, :profile)
+
+      Inspector.valid(Profile) do
+        attribute(:first_name) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(8).characters
+          should have_at_most(32).characters
+        end
+
+        attribute(:last_name) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(8).characters
+          should have_at_most(32).characters
+        end
+
+        attribute(:date_of_birth) do
+          should_not be_empty
+          should be_kind_of(Date)
+        end
+
+        attribute(:preferences) do
+          property("terms_and_conditions").should be_true
+          property("show_email").should_not be_empty
+        end
+      end
+
+      Inspector.valid(User) do
+        attribute(:username) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(8).characters
+          should have_at_most(32).characters
+          # attribute(:length) do
+          #   should == 10
+          # end
+        end
+
+        attribute(:email) do
+          should_not be_empty
+          should be_kind_of(String)
+          should be_an_email
+        end
+
+        attribute(:profile) do
+          should be_valid(Profile)
+        end
+      end
+
+      errors = Inspector.validate(User.new("", "bademail", Profile.new("", nil, false, {
+        "terms_and_conditions" => false,
+        "show_email" => nil
+      })))
+
+      errors.each do |violation|
+        puts violation.path
+        violation.constraints.each do |constraint|
+          puts "  #{constraint}"
+        end
+      end
+
+      errors[:profile][:preferences]["show_email"]
+
+      errors.at(".profile.preferences[show_email]")
+
+      errors.at(".profile.preferences[show_email]")
+      """
+    When I run `ruby object.rb`
+

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/features/syntax.feature

@@ -0,0 +1,223 @@
+Feature: syntax
+
+  In order to be able to check an object's validity
+  As a developer
+  I want to specify what a valid object looks like
+
+  Scenario: true is true
+    Given a file named "true_is_true.rb" with:
+      """
+      require 'inspector'
+
+      Inspector.valid("true value") do
+        should be_true
+      end
+
+      violations = Inspector.validate(true, :as => "true value")
+      if violations.empty?
+        puts "true is true"
+        exit 0
+      else
+        puts "true is not true"
+        exit 1
+      end
+      """
+    When I run `ruby true_is_true.rb`
+    Then it should pass with:
+      """
+      true is true
+      """
+
+  Scenario: false is not true
+    Given a file named "false_is_not_true.rb" with:
+      """
+      require 'inspector'
+
+      Inspector.valid("true value") do
+        should be_true
+      end
+
+      violations = Inspector.validate(false, :as => "true value")
+      if violations.empty?
+        puts "true is true"
+        exit 0
+      else
+        puts "false is not true"
+        exit 1
+      end
+      """
+    When I run `ruby false_is_not_true.rb`
+    Then it should fail with:
+      """
+      false is not true
+      """
+
+  Scenario: object attributes
+    Given a file named "object.rb" with:
+      """
+      require 'inspector'
+
+      User = Struct.new(:username, :email)
+
+      Inspector.valid(User) do
+        attribute(:username) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(8).characters
+          should have_at_most(32).characters
+        end
+
+        attribute(:email) do
+          should_not be_empty
+          should be_kind_of(String)
+          should be_an_email
+        end
+      end
+
+      user       = User.new("", "bademail")
+      violations = Inspector.validate(user)
+
+      if violations.empty?
+        puts "user #{user.inspect} is valid"
+      else
+        puts "invalid user #{user.inspect}:"
+        puts violations.to_s.split("\n").map { |line| "  #{line}" }.join("\n")
+      end
+      """
+    When I run `ruby object.rb`
+    Then the output should contain:
+      """
+      invalid user #<struct User username="", email="bademail">:
+        username:
+          should_not.be_empty
+          should.have_at_least
+        email:
+          should.be_an_email
+      """
+
+  Scenario: nested objects
+    Given a file named "post_and_author.rb" with:
+      """
+      require 'inspector'
+
+      Post   = Struct.new(:title, :body, :author)
+      Author = Struct.new(:email, :first_name, :last_name)
+
+      Inspector.valid(Post) do
+        attribute(:title) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(3).characters
+        end
+
+        attribute(:body) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(3).characters
+        end
+
+        attribute(:author).should validate(:as => Author)
+      end
+
+      Inspector.valid(Author) do
+        attribute(:email) do
+          should_not be_empty
+          should be_an_email
+        end
+
+        attribute(:first_name) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(1).character
+          should have_at_most(32).characters
+        end
+
+        attribute(:last_name) do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(1).character
+          should have_at_most(32).characters
+        end
+      end
+
+      author = Author.new("not an email", "John", "Smith")
+      post   = Post.new(123, nil, author)
+
+      violations = Inspector.validate(post)
+
+      if violations.empty?
+        puts "post #{post.inspect} is valid"
+      else
+        puts "invalid post #{post.inspect}:"
+        puts violations.to_s.split("\n").map { |line| "  #{line}" }.join("\n")
+      end
+      """
+    When I run `ruby post_and_author.rb`
+    Then the output should contain:
+      """
+      invalid post #<struct Post title=123, body=nil, author=#<struct Author email="not an email", first_name="John", last_name="Smith">>:
+        title:
+          should.be_kind_of
+        body:
+          should_not.be_empty
+          should.be_kind_of
+          should.have_at_least
+        author:
+          email:
+            should.be_an_email
+      """
+
+  Scenario: hash validation
+    Given a file named "request.rb" with:
+      """
+      require 'inspector'
+
+      Inspector.valid("request parameters") do
+        property("title") do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(3).characters
+        end
+
+        property("body") do
+          should_not be_empty
+          should be_kind_of(String)
+          should have_at_least(3).characters
+        end
+      end
+
+      violations = Inspector.validate({
+        "title" => 123,
+        "body"  => nil
+      }, :as => "request parameters")
+
+      puts violations unless violations.empty?
+      """
+    When I run `ruby request.rb`
+    Then the output should contain:
+      """
+      [title]:
+        should.be_kind_of
+      [body]:
+        should_not.be_empty
+        should.be_kind_of
+        should.have_at_least
+      """
+
+    Scenario: array validation
+      Given a file named "request.rb" with:
+        """
+        require 'inspector'
+
+        Inspector.valid("emails") do
+          each_item.should be_an_email
+        end
+
+        puts Inspector.validate(["not an email", "username@example.com"], :as => "emails")
+        """
+      When I run `ruby request.rb`
+      Then the output should contain:
+        """
+        [0]:
+          should.be_an_email
+        """

data/inspector.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path("../lib/inspector/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "object-inspector"
+  gem.version       = Inspector::VERSION
+  gem.license       = 'MIT'
+  gem.authors       = ["Bulat Shakirzyanov"]
+  gem.email         = ["mallluhuct@gmail.com"]
+  gem.homepage      = "http://avalanche123.github.com/inspector"
+  gem.summary       = "inspector - ruby validation library"
+  gem.description   = "Inspector is a validation library for Ruby with zero assumptions"
+
+  gem.required_ruby_version = '>= 1.9.2'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rspec', '~> 2.6'
+  gem.add_development_dependency 'cucumber', '~> 1.2'
+  gem.add_development_dependency 'aruba', '~> 0.4'
+  gem.add_development_dependency 'rake', '~> 0.9'
+end

data/lib/inspector.rb

@@ -0,0 +1,27 @@
+require 'forwardable'
+
+module Inspector
+  autoload :Validator,           'inspector/validator'
+  autoload :DSL,                 'inspector/dsl'
+  autoload :Constraints,         'inspector/constraints'
+  autoload :Constraint,          'inspector/constraint'
+  autoload :Metadata,            'inspector/metadata'
+  autoload :TypeMetadata,        'inspector/type_metadata'
+  autoload :AttributeMetadata,   'inspector/attribute_metadata'
+  autoload :PropertyMetadata,    'inspector/property_metadata'
+
+  class << self
+    extend Forwardable
+    def_delegators :@validator, :validate, :valid
+  end
+
+  @validators_map = {}
+  @validator      = Validator.new(
+    Metadata::Map.new,
+    Metadata::Walker.new(Constraint::Violation::List, @validators_map),
+    TypeMetadata
+  )
+
+  @validators_map[:simple]   = Constraint::Validators::Simple.new
+  @validators_map[:validity] = Constraint::Validators::Validity.new(@validator)
+end

data/lib/inspector/attribute_metadata.rb

@@ -0,0 +1,19 @@
+module Inspector
+  class AttributeMetadata
+    include Metadata
+
+    attr_reader :attribute_name
+
+    def initialize(type, attribute_name)
+      @attribute_name = attribute_name.to_sym
+      super(type)
+    end
+
+    def attribute_value(object)
+      object.__send__(@attribute_name)
+    rescue NoMethodError
+      raise "metadata for #{@type.inspect} contains attribute metadata, however " +
+            "#{object.inspect}.#{@attribute_name.inspect} is not defined"
+    end
+  end
+end

data/lib/inspector/constraint.rb

@@ -0,0 +1,18 @@
+module Inspector
+  module Constraint
+    autoload :Violation,  'inspector/constraint/violation'
+    autoload :Validators, 'inspector/constraint/validators'
+
+    def negate!
+      @negative = true
+    end
+
+    def positive?
+      !@negative
+    end
+
+    def validator
+      :simple
+    end
+  end
+end

data/lib/inspector/constraint/validators.rb

@@ -0,0 +1,8 @@
+module Inspector
+  module Constraint
+    module Validators
+      autoload :Validity, 'inspector/constraint/validators/validity'
+      autoload :Simple,   'inspector/constraint/validators/simple'
+    end
+  end
+end

data/lib/inspector/constraint/validators/simple.rb

@@ -0,0 +1,13 @@
+module Inspector
+  module Constraint
+    module Validators
+      class Simple
+        def validate(value, constraint, violations_list)
+          if constraint.positive? ^ constraint.valid?(value)
+            violations_list << Constraint::Violation.new(constraint)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inspector/constraint/validators/validity.rb

@@ -0,0 +1,24 @@
+module Inspector
+  module Constraint
+    module Validators
+      class Validity
+        def initialize(validator)
+          @validator = validator
+        end
+
+        def validate(value, constraint, violations_list)
+          violations = @validator.validate(value, :as => constraint.validate_as(value))
+
+          if constraint.positive?
+            violations.violations.each { |violation| violations_list << violation }
+            violations.children.each { |path, list| violations_list[path] = list }
+          else
+            if violations.empty?
+              violations_list << Constraint::Violation.new(constraint)
+            end
+          end
+        end
+      end
+    end
+  end
+end