vladimerb 0.0.1

data/src/chain.rb

@@ -0,0 +1,13 @@
+require_relative "namespace"
+
+class Vladimerb::Chain
+  def initialize validation_1, validation_2
+    @validation_1 = validation_1
+    @validation_2 = validation_2
+  end
+
+  def validate record
+    error_1 = @validation_1.validate(record)
+    error_1.empty? ? @validation_2.validate(record) : error_1
+  end
+end

data/src/greater_than.rb

@@ -0,0 +1,14 @@
+require_relative "namespace"
+
+class Vladimerb::GreaterThan
+  def initialize field_name, minimum
+    @field_name = field_name
+    @minimum = minimum
+  end
+
+  def validate record
+    record.send(@field_name) > @minimum ?
+      [] :
+      [@field_name.to_s + " must be over " + @minimum.to_s + "." ]
+  end
+end

data/src/join.rb

@@ -0,0 +1,13 @@
+require_relative "namespace"
+
+class Vladimerb::Join
+  def initialize required_1, required_2
+    @validation_1 = required_1
+    @validation_2 = required_2
+  end
+
+  def validate record
+    @validation_1.validate(record) + @validation_2.validate(record)
+  end
+end
+

data/src/lambda.rb

@@ -0,0 +1,11 @@
+require_relative "namespace"
+
+class Vladimerb::LambdaValidation
+  def initialize &block
+    @block = block
+  end
+
+  def validate record
+    @block.call(record)
+  end
+end

data/src/namespace.rb

@@ -0,0 +1,2 @@
+module Vladimerb
+end

data/src/pattern.rb

@@ -0,0 +1,23 @@
+require_relative "namespace"
+
+class Vladimerb::Pattern
+  def initialize field_name, regex, options=nil
+    @field_name = field_name
+    @regex = regex
+    @custom_message = options[:message] unless options.nil?
+  end
+
+  def validate record
+    record.send(@field_name).match(@regex).nil? ?
+      [error_message] :
+      []
+  end
+
+  private
+
+  def error_message
+    @custom_message.nil? ?
+      @field_name.to_s + " is not formatted correctly." :
+      @custom_message
+  end
+end

data/src/predicate.rb

@@ -0,0 +1,13 @@
+require_relative "namespace"
+
+class Vladimerb::Predicate
+  def initialize field_name, method, msg
+    @field_name = field_name
+    @method = method.to_proc
+    @msg = msg
+  end
+
+  def validate record
+    @method.call(record.send(@field_name)) ? [] : [@msg]
+  end
+end

data/src/required.rb

@@ -0,0 +1,30 @@
+require_relative "namespace"
+
+class Vladimerb::Required
+  def initialize field_name, options=nil
+    @field_name = field_name
+    @custom_message = options[:message] unless options.nil?
+  end
+
+  def validate record
+    data = record.send(@field_name)
+    not_provided?(data) ? [error_message] : []
+  end
+
+  private
+  def error_message
+    @custom_message.nil? ?
+      @field_name.to_s + " is required." :
+      @custom_message
+  end
+
+  def not_provided? data
+    data.nil? or is_empty?(data)
+  end
+
+  def is_empty? data
+    data.empty? if data.respond_to?(:empty?)
+  end
+
+end
+

data/src/vladimerb.rb

@@ -0,0 +1,42 @@
+require_relative "join"
+require_relative "chain"
+require_relative "required"
+require_relative "greater_than"
+require_relative "lambda"
+require_relative "pattern"
+require_relative "predicate"
+
+module Vladimerb
+  def join *validations
+    validations.reduce{ |tree, validation|
+      Join.new tree, validation }
+  end
+
+  def chain *validations
+    validations.reduce{ |tree, validation|
+      Chain.new tree, validation }
+  end
+
+  def required field_name
+    Required.new field_name
+  end
+
+  def greater_than field_name, minimum
+    GreaterThan.new field_name, minimum
+  end
+
+  def lambda_validation &block
+    LambdaValidation.new &block
+  end
+
+  def pattern field_name, regex
+    Pattern.new field_name, regex
+  end
+
+  def predicate field_name, method, msg
+    Predicate.new field_name, method, msg
+  end
+end
+
+include Vladimerb
+

data/test/chain.rb

@@ -0,0 +1,19 @@
+require_relative "test_helper"
+
+class ChainTest < Test::Unit::TestCase
+  def test_shows_first_error
+    assert_errors Candidate.new(nil, nil),
+                  chain(required(:name),
+                        required(:age)),
+                  ["name is required."]
+  end
+
+  def test_shows_first_error_set_in_tree
+    assert_errors Candidate.new(nil, nil),
+                  Chain.new(
+                    join(required(:name),
+                         required(:age)),
+                    greater_than(:age, 18)),
+                  ["name is required.", "age is required."]
+  end
+end

data/test/greater_than.rb

@@ -0,0 +1,17 @@
+require_relative "test_helper"
+
+
+class GreaterThanTest < Test::Unit::TestCase
+  def tests_fails_when_number_not_greater
+    assert_errors Candidate.new("Jill", 12),
+                  GreaterThan.new(:age, 18),
+                  ["age must be over 18."]
+  end
+
+  def tests_passes_when_number_is_greater
+    assert_errors Candidate.new("Jill", 24),
+                  GreaterThan.new(:age, 18),
+                  []
+  end
+end
+

data/test/helpers.rb

@@ -0,0 +1,61 @@
+require_relative "test_helper.rb"
+
+class HelpersTest < Test::Unit::TestCase
+  include Helpers
+
+  def test_join_can_compose_multiple_validations
+    assert_errors Candidate.new("Fred", 50),
+                  join(required(:name),
+                       required(:age),
+                       greater_than(:age, 40)),
+                  []
+  end
+
+  def test_chain_can_compose_multiple_validations
+    assert_errors Candidate.new(nil, nil),
+                  chain(required(:name),
+                        required(:age),
+                        greater_than(:age, 40)),
+                  ["name is required."]
+  end
+
+  def test_can_build_composite_validation_attractively
+    validation = join(required(:name),
+                      chain(required(:age),
+                            greater_than(:age, 40)))
+
+    assert_errors Candidate.new("Fred", 50), validation,
+                  []
+
+    assert_errors Candidate.new("Fred", 30), validation,
+                  ["age must be over 40."]
+
+    assert_errors Candidate.new("", 50), validation,
+                  ["name is required."]
+
+    assert_errors Candidate.new(nil, nil), validation,
+                  ["name is required.", "age is required."]
+  end
+
+  def test_lambda_validations_can_be_built_with_blocks
+    assert_errors Candidate.new("Colin Logan Campbell-McPherson", 24),
+                  (lambda_validation do |candidate|
+                    (candidate.name.to_s + candidate.age.to_s).length > 10 ?
+                      ["Name and Age combined take up too much room to display"] : []
+                  end),
+                 ["Name and Age combined take up too much room to display"]
+  end
+
+  def test_pattern_validations_can_be_built_with_blocks
+    assert_errors Candidate.new("Logan Campbell-McPherson", 24),
+                  pattern(:name, /^[a-zA-Z]+$/),
+                  ["name is not formatted correctly."]
+  end
+
+  def test_predicate_can_be_built_with_blocks
+    assert_errors Candidate.new("Jill", 24),
+                  predicate(:name, :nil?, "Name must be nil."),
+                  ["Name must be nil."]
+  end
+end
+

data/test/join.rb

@@ -0,0 +1,10 @@
+require_relative "test_helper.rb"
+
+class JoinTest < Test::Unit::TestCase
+  def test_shows_all_errors
+    assert_errors Candidate.new(nil, nil),
+                  join(required(:name),
+                       required(:age)),
+                  ["name is required.", "age is required."]
+  end
+end

data/test/lambda.rb

@@ -0,0 +1,12 @@
+require_relative "test_helper.rb"
+
+class LambdaTest < Test::Unit::TestCase
+  def tests_against_lambda_and_fails
+    assert_errors Candidate.new(nil, 24),
+                  (lambda_validation do |record|
+                    record.name.nil? ? ["Name is required."] : []
+                  end),
+                  ["Name is required."]
+  end
+end
+

data/test/pattern.rb

@@ -0,0 +1,23 @@
+require_relative "test_helper.rb"
+
+class PatternTest < Test::Unit::TestCase
+  def tests_a_value_matches_a_regex
+    assert_errors Candidate.new("Fred", 50),
+                  pattern(:name, /ed/),
+                  []
+  end
+
+  def tests_a_value_does_not_match_a_regex
+    assert_errors Candidate.new("Fred", 24),
+                  pattern(:name, /ill/),
+                  ["name is not formatted correctly."]
+  end
+
+  def tests_a_value_does_not_match_a_regex_and_gives_custom_error_message
+    assert_errors Candidate.new("Fred", 24),
+                  pattern(:name, /ill/, message: "Name is insufficiently ill"),
+                  ["Name is insufficiently ill"]
+  end
+
+end
+

data/test/predicate.rb

@@ -0,0 +1,17 @@
+require File.dirname(File.expand_path(__FILE__)) + "/test_helper.rb"
+require File.dirname(File.expand_path(__FILE__)) + "/../src/predicate.rb"
+
+
+class PredicateTest < Test::Unit::TestCase
+  def tests_against_predicate_and_fails
+    assert_errors Candidate.new("Jill", 24),
+                  Predicate.new(:name, :nil?, "Name must be nil."),
+                  ["Name must be nil."]
+  end
+
+  def tests_against_predicate_and_succeeds
+    assert_errors Candidate.new(nil, 24),
+                  Predicate.new(:name, :nil?, "Name must be nil."),
+                  []
+  end
+end

data/test/require.rb

@@ -0,0 +1,41 @@
+require File.dirname(File.expand_path(__FILE__)) + "/test_helper.rb"
+require File.dirname(File.expand_path(__FILE__)) + "/../src/required.rb"
+
+class RequiredTest < Test::Unit::TestCase
+  def test_succeeds_for_candidate_with_name
+    assert_errors Candidate.new("Fred", 50),
+                  Required.new(:name),
+                  []
+  end
+
+  def test_fails_for_candidate_without_name
+    assert_errors Candidate.new(nil, 24),
+                  Required.new(:name),
+                  ["name is required."]
+  end
+
+  def test_fails_for_candidate_with_blank_name
+    assert_errors Candidate.new("", 24),
+                  Required.new(:name),
+                  ["name is required."]
+  end
+
+  def test_fails_for_candidate_without_age
+    assert_errors Candidate.new("Bob", nil),
+                  Required.new(:age),
+                  ["age is required."]
+  end
+
+  def test_fails_for_required_data_that_do_not_have_empty_method
+    assert_errors Candidate.new("Bob", 20),
+                  Required.new(:age),
+                  []
+  end
+
+  def test_fails_with_custom_error_message
+    assert_errors Candidate.new(nil, 24),
+                  Required.new(:name, message: "You gotta have a name!"),
+                  ["You gotta have a name!"]
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require "rubygems"
+gem "test-unit", "2.5.0"
+require "test/unit"
+require_relative "../src/vladimerb"
+
+class Candidate
+  attr_accessor :name, :age
+
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+end
+
+def assert_errors(data, validation, expected_errors)
+  actual_errors = validation.validate(data)
+  assert_equal(expected_errors, actual_errors)
+end
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: vladimerb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Logan Campbell
+- Pei Shi Yong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-20 00:00:00.000000000Z
+dependencies: []
+description: Composable data validators
+email: colin@logaan.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- src/chain.rb
+- src/greater_than.rb
+- src/join.rb
+- src/lambda.rb
+- src/namespace.rb
+- src/pattern.rb
+- src/predicate.rb
+- src/required.rb
+- src/vladimerb.rb
+- test/chain.rb
+- test/greater_than.rb
+- test/helpers.rb
+- test/join.rb
+- test/lambda.rb
+- test/pattern.rb
+- test/predicate.rb
+- test/require.rb
+- test/test_helper.rb
+homepage: https://github.com/logaan/vladimerb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- src
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Composable data validators
+test_files:
+- test/chain.rb
+- test/greater_than.rb
+- test/helpers.rb
+- test/join.rb
+- test/lambda.rb
+- test/pattern.rb
+- test/predicate.rb
+- test/require.rb
+- test/test_helper.rb