toolchain 0.1.0

data/spec/toolchain/attributes/base_helper.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "#{TOOLCHAIN_ROOT}/attributes"
+
+require "time"
+
+class ModelData
+  include Toolchain::Attributes
+
+  attribute :string, String
+  attribute :string_default, String, ""
+  attribute :integer, Integer
+  attribute :integer_default, Integer, 0
+  attribute :float, Float
+  attribute :float_default, Float, 0.0
+  attribute :array, Array
+  attribute :array_default, Array, []
+  attribute :hash, Hash
+  attribute :hash_default, Hash, {}
+  attribute :boolean, Boolean
+  attribute :boolean_default, Boolean, false
+  attribute :time, Time
+  attribute :time_default, Time, -> { Time.now }
+  attribute :date, Date
+  attribute :date_default, Date, -> { Date.today }
+  attribute :date_time, DateTime
+  attribute :date_time_default, DateTime, -> { DateTime.now }
+end
+
+RSpec.configure do |config|
+
+  config.before do
+    Toolchain::Attributes::Configuration.configure do |config|
+      config.hash_transformation = :symbolize_keys
+      config.include_nil_in_attributes = false
+    end
+  end
+end

data/spec/toolchain/attributes/boolean_spec.rb

@@ -0,0 +1,38 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "Boolean" do
+
+  let(:model) { ModelData.new }
+
+  it "should set the boolean to true" do
+    expect { model.boolean = true }.
+      to change { model.boolean }.from(nil).to(true)
+  end
+
+  it "should accept '1' as true" do
+    expect { model.boolean = "1" }.
+      to change { model.boolean }.from(nil).to(true)
+  end
+
+  it "should accept 1 as true" do
+    expect { model.boolean = 1 }.
+      to change { model.boolean }.from(nil).to(true)
+  end
+
+  it "should accept '0' as false" do
+    expect { model.boolean = '0' }.
+      to change { model.boolean }.from(nil).to(false)
+  end
+  it "should accept 0 as false" do
+    expect { model.boolean = 0 }.
+      to change { model.boolean }.from(nil).to(false)
+  end
+
+  it "should raise exception unless type is TrueClass or FalseClass" do
+    expect { model.boolean = "Example" }.
+      to raise_error(
+        Toolchain::Attributes::Errors::TypeMismatch,
+        "ModelData#boolean expected [TrueClass, FalseClass] type, " +
+        "but received String (Example).")
+  end
+end

data/spec/toolchain/attributes/configuration_spec.rb

@@ -0,0 +1,33 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes::Configuration do
+
+  let(:config) { Toolchain::Attributes::Configuration }
+
+  it "should configure for symbol" do
+    config.hash_transformation.should == :symbolize_keys
+  end
+
+  it "should configure for string" do
+    expect { config.hash_transformation = :stringify_keys }.
+      to change { config.hash_transformation }.
+      from(:symbolize_keys).to(:stringify_keys)
+  end
+
+  it "should raise an exception on invalid type" do
+    expect { config.configure { |c| c.hash_transformation = :foo } }.
+      to raise_error(
+        Toolchain::Attributes::Errors::InvalidHashTransformation,
+        "valid types: :symbolize_keys, :stringify_keys."
+    )
+  end
+
+  it "should configure to omit nil values in attributes" do
+    config.include_nil_in_attributes.should == false
+  end
+
+  it "should configure to omit nil values in attributes" do
+    expect { config.configure { |c| c.include_nil_in_attributes = true } }.
+      to change { config.include_nil_in_attributes }.from(false).to(true)
+  end
+end

data/spec/toolchain/attributes/date_time_spec.rb

@@ -0,0 +1,21 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "Date, Time, DateTime" do
+
+  let(:model) { ModelData.new }
+
+  it "should parse the time if string" do
+    expect { model.time = Time.new(2000).to_s }.
+      to change { model.time }.from(nil).to(Time.new(2000))
+  end
+
+  it "should parse the date if string" do
+    expect { model.date = Date.new(2000).to_s }.
+      to change { model.date }.from(nil).to(Date.new(2000))
+  end
+
+  it "should parse the date_time if string" do
+    expect { model.date_time = DateTime.new(2000).to_s }.
+      to change { model.date_time }.from(nil).to(DateTime.new(2000))
+  end
+end

data/spec/toolchain/attributes/hash_spec.rb

@@ -0,0 +1,61 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "Hash" do
+
+  let(:model) { ModelData.new }
+
+  it "should symbolize keys" do
+    model.hash = {
+      "foo" => "bar",
+      baz: true,
+      "deep" => {
+        nested: "hash",
+        "become" => "symbolized",
+        once: {
+          "more" => :is_enough
+        }
+      }
+    }
+
+    model.hash.should == {
+      foo: "bar",
+      baz: true,
+      deep: {
+        nested: "hash",
+        become: "symbolized",
+        once: {
+          more: :is_enough
+        }
+      }
+    }
+  end
+
+  it "should stringify keys" do
+    Toolchain::Attributes::Configuration.
+      hash_transformation = :stringify_keys
+
+    model.hash = {
+      "foo" => "bar",
+      baz: true,
+      "deep" => {
+        nested: "hash",
+        "become" => "symbolized",
+        once: {
+          "more" => :is_enough
+        }
+      }
+    }
+
+    model.hash.should == {
+      "foo" => "bar",
+      "baz" => true,
+      "deep" => {
+        "nested" => "hash",
+        "become" => "symbolized",
+        "once" => {
+          "more" => :is_enough
+        }
+      }
+    }
+  end
+end

data/spec/toolchain/attributes/include_attributes_spec.rb

@@ -0,0 +1,19 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "includeAttributes" do
+
+  UserExternalAttributes = Proc.new do
+    attribute :name, String
+  end
+
+  class UserIncludedAttributes
+    include Toolchain::Attributes
+    include_attributes UserExternalAttributes
+  end
+
+  it "should include validations" do
+    user = UserIncludedAttributes.new
+    user.name = "Michael"
+    user.name.should == "Michael"
+  end
+end

data/spec/toolchain/attributes/initializer_spec.rb

@@ -0,0 +1,32 @@
+require_relative "base_helper"
+
+describe Toolchain::Attributes, "Initializer" do
+
+  it "should initialize with attributes" do
+    date, time, date_time = Date.today, Time.now, DateTime.now
+
+    model = ModelData.new(
+      array_default: [1, 2, 3],
+      boolean_default: true,
+      float_default: 1.23,
+      hash_default: {foo: :bar},
+      integer_default: 123,
+      string_default: "value",
+      date_default: date,
+      time_default: time,
+      date_time_default: date_time
+    )
+
+    model.attributes.should == {
+      array_default: [1, 2, 3],
+      boolean_default: true,
+      float_default: 1.23,
+      hash_default: {foo: :bar},
+      integer_default: 123,
+      string_default: "value",
+      date_default: date,
+      time_default: time,
+      date_time_default: date_time
+    }
+  end
+end

data/spec/toolchain/validations/base_helper.rb

@@ -0,0 +1,2 @@
+require "spec_helper"
+require "#{TOOLCHAIN_ROOT}/validations"

data/spec/toolchain/validations/custom_validations_spec.rb

@@ -0,0 +1,26 @@
+require_relative "base_helper"
+
+describe Toolchain::Validations, "Custom Validations" do
+
+  class UserCustomValidation
+    include Toolchain::Validations
+    attr_accessor :name
+    attr_accessor :error_out
+    validate :name_validation
+
+    def name_validation
+      errors.add(:name, "custom validation error") if error_out
+    end
+  end
+
+  it "should be valid" do
+    UserCustomValidation.new.should be_valid
+  end
+
+  it "should be invalid" do
+    user = UserCustomValidation.new
+    user.error_out = true
+    user.should_not be_valid
+    user.errors.should == { name: ["custom validation error"] }
+  end
+end

data/spec/toolchain/validations/delegation_spec.rb

@@ -0,0 +1,70 @@
+require_relative "base_helper"
+
+describe Toolchain::Validations, "Delegation" do
+
+  module PersonAttributes
+    attr_accessor :name, :email, :terms, :new
+
+    def keys
+      [:name, :email, :terms, :new]
+    end
+
+    def attributes
+      { name: name, email: email, terms: terms, new: new }
+    end
+
+    def attributes=(attrs)
+      attrs.each do |key, value|
+        send("#{key}=", value) if keys.include?(key)
+      end
+    end
+  end
+
+  class BasePersonValidator
+    include PersonAttributes
+    include Toolchain::Validations
+    include Toolchain::Validations::Delegation
+    validates :name, presence: true
+    validates :email, email: true
+  end
+
+  class NewPersonValidator < BasePersonValidator
+    validates :terms, acceptance: true
+  end
+
+  class ExistingPersonValidator < BasePersonValidator
+  end
+
+  class PersonDelegatorValidation
+    include PersonAttributes
+    include Toolchain::Validations::Delegator
+
+    validate_with do |i|
+      if i.new
+        NewPersonValidator
+      else
+        ExistingPersonValidator
+      end
+    end
+  end
+
+  it "should validate name, email, terms" do
+    person = PersonDelegatorValidation.new
+    person.new = true
+    person.should_not be_valid
+    person.errors.to_hash.should == {
+      name: ["can't be blank"],
+      email: ["is invalid"],
+      terms: ["must be accepted"]
+    }
+  end
+
+  it "should validate name, email" do
+    person = PersonDelegatorValidation.new
+    person.should_not be_valid
+    person.errors.to_hash.should == {
+      name: ["can't be blank"],
+      email: ["is invalid"]
+    }
+  end
+end

data/spec/toolchain/validations/include_validations_spec.rb

@@ -0,0 +1,20 @@
+require_relative "base_helper"
+
+describe Toolchain::Validations, "IncludeValidations" do
+
+  UserExternalValidations = Proc.new do
+    validates :name, presence: true
+  end
+
+  class UserIncludedValidations
+    include Toolchain::Validations
+    include_validations UserExternalValidations
+    attr_accessor :name
+  end
+
+  it "should include validations" do
+    user = UserIncludedValidations.new
+    user.should_not be_valid
+    user.errors[:name].should == ["can't be blank"]
+  end
+end

data/spec/toolchain/validations/inheritence_spec.rb

@@ -0,0 +1,26 @@
+require_relative "base_helper"
+
+describe Toolchain::Validations, "Inheritence" do
+
+  class UserInheritingValidations
+    include Toolchain::Validations
+    attr_reader :name
+    validates :name, presence: true
+    validate :name_validation
+
+    private
+
+    def name_validation
+      errors.add(:name, "custom name error")
+    end
+  end
+
+  class UserInheritedValidations < UserInheritingValidations
+  end
+
+  it "should be invalid" do
+    user = UserInheritedValidations.new
+    user.should_not be_valid
+    user.errors.should == { name: ["can't be blank", "custom name error"] }
+  end
+end

data/spec/toolchain/validations/multiple_validations_spec.rb

@@ -0,0 +1,19 @@
+require_relative "base_helper"
+
+describe Toolchain::Validations, "Multiple Validations" do
+
+  class UserMultipleValidator
+    include Toolchain::Validations
+    attr_accessor :email
+    validates :email,
+      presence: { message: "provide an email address" },
+      email: { message: "email address isn't valid" }
+  end
+
+  it "should use multiple validators" do
+    user = UserMultipleValidator.new
+    user.should_not be_valid
+    user.errors[:email].should ==
+      ["provide an email address", "email address isn't valid"]
+  end
+end

data/spec/toolchain/validations/nested_validations_spec.rb

@@ -0,0 +1,68 @@
+require_relative "base_helper"
+
+describe Toolchain::Validations, "Nested Validation" do
+
+  class UserNestedValidation
+    include Toolchain::Validations
+    attr_accessor :config
+    validates :config, :name, presence: true
+    validates :config, :email, email: true
+  end
+
+  let(:user) { UserNestedValidation.new }
+
+  it "should be valid" do
+    user.config = {
+      name: "Example",
+      email: "example@machinery.io"
+    }
+    user.should be_valid
+  end
+
+  it "is invalid if nil" do
+    user.should_not be_valid
+    user.errors[:config][:name].should == ["can't be blank"]
+    user.errors[:config][:email].should == ["is invalid"]
+  end
+
+  class UserDeeplyNestedValidation
+    include Toolchain::Validations
+    attr_accessor :config
+    validates :config, :deep, :name, presence: true
+    validates :config, :deep, :email, email: true
+  end
+
+  it "should be valid" do
+    user = UserDeeplyNestedValidation.new
+    user.config = {
+      deep: {
+        name: "Example",
+        email: "example@machinery.io"
+      }
+    }
+    user.should be_valid
+  end
+
+  it "is invalid if nil" do
+    user = UserDeeplyNestedValidation.new
+    user.config = {}
+    user.should_not be_valid
+    user.errors[:config][:deep][:name].should == ["can't be blank"]
+  end
+
+  class UserCustomNestedValidation
+    include Toolchain::Validations
+    attr_accessor :config
+    validate :name_validation
+
+    def name_validation
+      errors.add(:config, :name, "custom validation error")
+    end
+  end
+
+  it "should be invalid" do
+    user = UserCustomNestedValidation.new
+    user.should_not be_valid
+    user.errors.should == { config: { name: ["custom validation error"] } }
+  end
+end