toolchain 0.1.0

data/lib/toolchain/validations/validators.rb

@@ -0,0 +1,12 @@
+module Toolchain::Validations::Validators
+  require_relative "validators/base"
+
+  require_relative "validators/acceptance"
+  require_relative "validators/confirmation"
+  require_relative "validators/email"
+  require_relative "validators/exclusion"
+  require_relative "validators/format"
+  require_relative "validators/inclusion"
+  require_relative "validators/length"
+  require_relative "validators/presence"
+end

data/lib/toolchain/validations/validators/acceptance.rb

@@ -0,0 +1,25 @@
+module Toolchain::Validations::Validators
+
+  # Validates the acceptance of an attribute.
+  # Accepted values are as follows: `true`, `1` and `"1"`.
+  #
+  # @example
+  #   class User::Creator
+  #     validates :terms, acceptance: {
+  #       message: "the terms of service must be accepted"
+  #     }
+  #   end
+  #
+  class Acceptance < Base
+
+    def validate
+      errors.add(key_path, message || "must be accepted") if not_accepted?
+    end
+
+    private
+
+    def not_accepted?
+      ![1, "1", true].include?(value)
+    end
+  end
+end

data/lib/toolchain/validations/validators/base.rb

@@ -0,0 +1,54 @@
+class Toolchain::Validations::Validators::Base
+
+  # @return [Object] the object that contains the attribute
+  #   that'll be validated.
+  #
+  attr_reader :object
+
+  # @return [Toolchain::Validations::ValidationErrors] the errors object
+  #   of the object that's being validated.
+  #
+  attr_reader :errors
+
+  # @return [Symbol] The key_path of the attribute that's being validated.
+  #
+  attr_reader :key_path
+
+  # @return [Hash] The value that was passed in to the validator
+  #   at definition time. i.e. a Hash containing the regular expression
+  #   for Toolchain::Validations::Validators::Formatter along with a message.
+  #
+  attr_reader :data
+
+  # @return [String] A custom message to override the
+  #   default message with in case the attribute is invalid.
+  #
+  attr_reader :message
+
+  # Instantiates a new Toolchain::Validations::Validators object
+  # which'll be used to validate the target object.
+  #
+  # @param object [Object]
+  # @param key_path [Object]
+  # @param data [Object]
+  #
+  def initialize(object, key_path, data)
+    @object = object
+    @errors = object.errors
+    @key_path = key_path
+    @data = data
+    @message = data[:message] if data.is_a?(Hash)
+  end
+
+  # @return [Object] The value that's stored in the attribute of
+  #   the object that's being validated.
+  #
+  def value
+    @value ||= (
+      keys = key_path.dup
+      keys.inject(object.send(keys.shift)) do |memo, key|
+        memo[key] if memo.kind_of?(Hash)
+      end
+    )
+  end
+end

data/lib/toolchain/validations/validators/confirmation.rb

@@ -0,0 +1,39 @@
+module Toolchain::Validations::Validators
+
+  # Validates the confirmation of an attribute.
+  # In the example both `password` and `password_confirmation`
+  # attributes must match. One or more `nil` values will result in the
+  # validation error being triggered as well.
+  #
+  # @example
+  #   class User::Creator
+  #     validates :password, confirmation: {
+  #       message: "doesn't match confirmation"
+  #     }
+  #   end
+  #
+  class Confirmation < Base
+
+    def validate
+      if no_match?
+        errors.add(key_path, message || "doesn't match confirmation")
+      end
+    end
+
+    private
+
+    def no_match?
+      value.nil? || confirmation.nil? || value != confirmation
+    end
+
+    def confirmation
+      @confirmation ||= (
+        keys = key_path.dup
+        keys << :"#{keys.pop}_confirmation"
+        keys.inject(object.send(keys.shift)) do |memo, key|
+          memo[key] if memo.kind_of?(Hash)
+        end
+      )
+    end
+  end
+end

data/lib/toolchain/validations/validators/email.rb

@@ -0,0 +1,26 @@
+module Toolchain::Validations::Validators
+
+  # Validates the format of an email address.
+  #
+  # @example
+  #   class User::Creator
+  #     validates :email, email: {
+  #       message: "isn't valid"
+  #     }
+  #   end
+  #
+  class Email < Base
+
+    PATTERN = /\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/
+
+    def validate
+      errors.add(key_path, message || "is invalid") if no_email?
+    end
+
+    private
+
+    def no_email?
+      value.nil? || !value.match(PATTERN)
+    end
+  end
+end

data/lib/toolchain/validations/validators/exclusion.rb

@@ -0,0 +1,29 @@
+module Toolchain::Validations::Validators
+
+  # Validates the exclusion of values in an attribute.
+  # In the example only games without a pegi rating
+  # of 12, 16, 18 are valid.
+  #
+  # @example
+  #   class Game::Creator
+  #     validates :pegi, exclusion: {
+  #       in: [12, 16, 18],
+  #       message: "invalid pegi rating"
+  #     }
+  #   end
+  #
+  class Exclusion < Base
+
+    def validate
+      if included?
+        errors.add(key_path, message || "is invalid")
+      end
+    end
+
+    private
+
+    def included?
+      data[:in].include?(value)
+    end
+  end
+end

data/lib/toolchain/validations/validators/format.rb

@@ -0,0 +1,25 @@
+module Toolchain::Validations::Validators
+
+  # Validates the format of an attribute using a regular expression.
+  #
+  # @example
+  #   class Company::Creator
+  #     validates :credit_card, format: {
+  #       with: /^\d+{4}-$\d+{4}-\d+{4}-\d+{4}/,
+  #       message: "invalid credit card format"
+  #     }
+  #   end
+  #
+  class Format < Base
+
+    def validate
+      errors.add(key_path, message || "is invalid") if no_match?
+    end
+
+    private
+
+    def no_match?
+      value.nil? || !value.match(data[:with])
+    end
+  end
+end

data/lib/toolchain/validations/validators/inclusion.rb

@@ -0,0 +1,29 @@
+module Toolchain::Validations::Validators
+
+  # Validates the inclusion of values in an attribute.
+  # In the example, only `pending` and `dispatched` are
+  # allowed to be set.
+  #
+  # @example
+  #   class Shipment::Creator
+  #     validates :status, inclusion: {
+  #       in: ["pending", "dispatched"],
+  #       message: "available options are: pending, dispatched"
+  #     }
+  #   end
+  #
+  class Inclusion < Base
+
+    def validate
+      if not_included?
+        errors.add(key_path, message || "is invalid")
+      end
+    end
+
+    private
+
+    def not_included?
+      !data.include?(value)
+    end
+  end
+end

data/lib/toolchain/validations/validators/length.rb

@@ -0,0 +1,60 @@
+module Toolchain::Validations::Validators
+
+  # Validates the lengt of an attribute.
+  #
+  # @example
+  #   class User::Creator
+  #     validates :password, length: {
+  #       between: 5..100,
+  #       message: "must be between 5 and 100 characters long"
+  #     }
+  #   end
+  #
+  #   class User::Creator
+  #     validates :password, length: {
+  #       greater_than: 5,
+  #       less_than 100,
+  #       message: "must be between 5 and 100 characters long"
+  #     }
+  #   end
+  #
+  class Length < Base
+
+    def validate
+      errors.add(key_path, message || "is invalid") unless valid?
+    end
+
+    private
+
+    def valid?
+      val =
+        if value.kind_of?(String) && value =~ /^\d+$/
+          value.to_i
+        elsif value.kind_of?(String) && value =~ /^\d+\.\d+$/
+          value.to_f
+        elsif value.kind_of?(String)
+          value.length
+        else
+          value
+        end
+
+      if data[:between]
+        return data[:between].include?(val)
+      end
+
+      if data[:greater_than] && data[:less_than]
+        return val > data[:greater_than] && val < data[:less_than]
+      end
+
+      if data[:greater_than]
+        return val > data[:greater_than]
+      end
+
+      if data[:less_than]
+        return val < data[:less_than]
+      end
+
+      false
+    end
+  end
+end

data/lib/toolchain/validations/validators/presence.rb

@@ -0,0 +1,25 @@
+module Toolchain::Validations::Validators
+
+  # Validates the presence of an attribute. If the attribute
+  # is either `nil` or `""` (empty String) it is considered invalid.
+  #
+  # @example
+  #   class User::Creator
+  #     validates :name, presence: {
+  #       message: "is required"
+  #     }
+  #   end
+  #
+  class Presence < Base
+
+    def validate
+      errors.add(key_path, message || "can't be blank") if blank?
+    end
+
+    private
+
+    def blank?
+      [nil, ""].include?(value)
+    end
+  end
+end

data/lib/toolchain/version.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "bundler"
+Bundler.require(:test)
+
+require "simplecov"
+SimpleCov.start
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+
+TOOLCHAIN_ROOT = File.expand_path("../../lib/toolchain", __FILE__)

data/spec/toolchain/attributes/attribute_spec.rb

@@ -0,0 +1,47 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "Attribute" do
+
+  let(:model) { ModelData.new }
+
+  it "should be nil by default" do
+    model.string.should == nil
+  end
+
+  it "should be empty by default" do
+    model.string_default.should == ""
+  end
+
+  it "should set a new String" do
+    expect { model.string = "Example" }.
+      to change { model.string }.from(nil).to("Example")
+  end
+
+  it "should set to nil, resulting in default" do
+    model.string_default = "Example"
+    expect { model.string_default = nil }.
+      to change { model.string_default }.from("Example").to("")
+  end
+
+  it "should instance-variable cache the result" do
+    model.time_default.should == model.time_default
+  end
+
+  it "requires the type to match the configured type" do
+    expect { model.string = 0 }.to raise_error(
+      Toolchain::Attributes::Errors::TypeMismatch,
+      "ModelData#string expected String type, but received Fixnum (0).")
+  end
+
+  it "should not allow defaults of other data-type" do
+    expect {
+      class InvalidModelData
+        include Toolchain::Attributes
+        attribute :string, String, 0
+      end
+    }.to raise_error(
+      Toolchain::Attributes::Errors::TypeMismatch,
+      "expected InvalidModelData#string to have default value "+
+      "of String type, but received Fixnum (0).")
+  end
+end

data/spec/toolchain/attributes/attributes_spec.rb

@@ -0,0 +1,193 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "Attributes (Method)" do
+
+  let(:model) { ModelData.new }
+
+  def expect_date_time
+    [
+      Date.today.tap { |d| Date.stubs(:today).returns(d) },
+      Time.now.tap { |t| Time.stubs(:now).returns(t) },
+      DateTime.now.tap { |dt| DateTime.stubs(:now).returns(dt) }
+    ]
+  end
+
+  it "should return attributes with Symbol keys" do
+    date, time, date_time = expect_date_time
+
+    model.attributes.should == {
+      array_default: [],
+      boolean_default: false,
+      float_default: 0.0,
+      hash_default: {},
+      integer_default: 0,
+      string_default: "",
+      date_default: date,
+      time_default: time,
+      date_time_default: date_time
+    }
+  end
+
+  it "should return attributes with String keys" do
+    Toolchain::Attributes::Configuration.
+      hash_transformation = :stringify_keys
+
+    date, time, date_time = expect_date_time
+
+    model.attributes.should == {
+      "array_default" => [],
+      "boolean_default" => false,
+      "float_default" => 0.0,
+      "hash_default" => {},
+      "integer_default" => 0,
+      "string_default" => "",
+      "date_default" => date,
+      "time_default" => time,
+      "date_time_default" => date_time
+    }
+  end
+
+  it "should symbolize hash, hash_default" do
+    model.hash = { "key" => { "value" => true } }
+    model.hash_default = { "key" => { "value" => true } }
+    model.attributes.tap do |attrs|
+      attrs[:hash].should == { key: { value: true } }
+      attrs[:hash_default].should == { key: { value: true } }
+    end
+  end
+
+  it "should stringify hash, hash_default" do
+    Toolchain::Attributes::Configuration.
+      hash_transformation = :stringify_keys
+
+    model.hash = { key: { value: true } }
+    model.hash_default = { key: { value: true } }
+    model.attributes.tap do |attrs|
+      attrs["hash"].should == { "key" => { "value" => true } }
+      attrs["hash_default"].should == { "key" => { "value" => true } }
+    end
+  end
+
+  it "should include nil attributes" do
+    Toolchain::Attributes::Configuration.
+      include_nil_in_attributes = true
+
+    date, time, date_time = expect_date_time
+
+    model.attributes.should == {
+      array: nil,
+      array_default: [],
+      boolean: nil,
+      boolean_default: false,
+      float: nil,
+      float_default: 0.0,
+      hash: nil,
+      hash_default: {},
+      integer: nil,
+      integer_default: 0,
+      string: nil,
+      string_default: "",
+      date: nil,
+      date_default: date,
+      time: nil,
+      time_default: time,
+      date_time: nil,
+      date_time_default: date_time
+    }
+  end
+
+  it "should mass-assign attributes" do
+    date, time, date_time = expect_date_time
+
+    model.attributes = {
+      string: "Example",
+      integer: 123,
+      float: 1.23,
+      hash: { foo: "bar" },
+      array: [1, 2, 3],
+      boolean: true,
+      date: date,
+      date_default: date,
+      time: time,
+      time_default: time,
+      date_time: date_time,
+      date_time_default: date_time,
+    }
+
+    model.attributes.should == {
+      array: [1, 2, 3],
+      array_default: [],
+      boolean: true,
+      boolean_default: false,
+      float: 1.23,
+      float_default: 0.0,
+      hash: { foo: "bar" },
+      hash_default: {},
+      integer: 123,
+      integer_default: 0,
+      string: "Example",
+      string_default: "",
+      date: date,
+      date_default: date,
+      time: time,
+      time_default: time,
+      date_time: date_time,
+      date_time_default: date_time
+    }
+  end
+
+  it "should not assign undefined attributes" do
+    date, time, date_time = expect_date_time
+    model.attributes = { unknown_attribute: true }
+    model.attributes.should == {
+      array_default: [],
+      boolean_default: false,
+      float_default: 0.0,
+      hash_default: {},
+      integer_default: 0,
+      string_default: "",
+      date_default: date,
+      time_default: time,
+      date_time_default: date_time,
+    }
+  end
+
+  it "should raise an exception non-Hash type is passed" do
+    expect { model.attributes = 0 }.
+      to raise_error(
+        Toolchain::Attributes::Errors::InvalidMassAssignment,
+        "Can't mass-assign Fixnum (0) type to ModelData#attributes.")
+  end
+
+  class InheritedModelData < ModelData
+  end
+
+  it "should inherit all attribute definitions" do
+    date, time, date_time = expect_date_time
+    InheritedModelData.new.attributes.should == {
+      array_default: [],
+      boolean_default: false,
+      float_default: 0.0,
+      hash_default: {},
+      integer_default: 0,
+      string_default: "",
+      date_default: date,
+      time_default: time,
+      date_time_default: date_time
+    }
+  end
+
+  it "should mass-assign superclass keys" do
+    date, time, date_time = expect_date_time
+    model = InheritedModelData.new
+    model.attributes = { string: "Michael" }
+    model.string.should == "Michael"
+  end
+
+  it "should mass-assing superclass string keys" do
+    date, time, date_time = expect_date_time
+    model = InheritedModelData.new
+    model.attributes = { "string" => "Michael" }
+    model.string.should == "Michael"
+  end
+end