id 0.0.12 → 0.1

data/spec/lib/id/active_model_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'support/active_model_lint'
+
+class ActiveModelTest
+  include Id::Model
+  include Id::Form
+
+  field :sheep
+
+  def wrapped_in_plastic?
+    true
+  end
+end
+
+describe ActiveModelTest do
+
+  subject { ActiveModelTest.new.to_model }
+
+  it_behaves_like "ActiveModel"
+
+  it 'has an I18n scope of id' do
+    expect(ActiveModelTest.new.to_model.class.i18n_scope).to eq :id
+  end
+
+  it 'can return the fields of the model' do
+    model = ActiveModelTest.new(sheep: 42).to_model
+    expect(model.sheep).to eq 42
+  end
+
+  it "doesn't blow up for nil fields" do
+    model = ActiveModelTest.new.to_model
+    expect(model.sheep).to be_nil
+  end
+
+  it 'delegates method calls to the original model' do
+    model = ActiveModelTest.new.to_model
+    expect(model).to be_wrapped_in_plastic
+  end
+
+end

data/spec/lib/id/association_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+class Tail; include Id::Model; field :waggy end
+class Paw;  include Id::Model end
+
+class Dog
+  include Id::Model
+  has_one :tail
+  has_many :paws
+
+  class Nose; include Id::Model; field :wet end
+  has_one :nose
+
+  class Poo; include Id::Model end
+  has_many :poos
+end
+
+module Clothing
+  class Button; include Id::Model end
+  class Coat
+    include Id::Model
+    has_many :buttons
+  end
+  class Lapel
+    include Id::Model
+    has_one :button
+  end
+end
+
+describe Id::Association do
+
+  describe '#has_one' do
+
+    it 'infers its type' do
+      dog = Dog.new(tail: { waggy: true })
+      expect(dog.tail).to be_a Tail
+      expect(dog.tail.waggy).to be_true
+    end
+
+    it 'can deal with types nested inside the model class' do
+      dog = Dog.new(nose: { wet: true })
+      expect(dog.nose).to be_a Dog::Nose
+      expect(dog.nose.wet).to be_true
+    end
+
+    it 'can deal with types nested inside a parent module' do
+      lapel = Clothing::Lapel.new(button: {})
+      expect(lapel.button).to be_a Clothing::Button
+    end
+
+  end
+
+  describe '#has_many' do
+    it 'infers its type' do
+      dog = Dog.new(paws: [{}, {}, {}])
+      expect(dog.paws).to have(3).items
+      dog.paws.each { |paw| expect(paw).to be_a Paw }
+    end
+
+    it 'can deal with types nested inside the model class' do
+      dog = Dog.new(poos: [{}, {}, {}])
+      expect(dog.poos).to have(3).items
+      dog.poos.each { |poo| expect(poo).to be_a Dog::Poo }
+    end
+
+    it 'can deal with types nested inside a parent module' do
+      coat = Clothing::Coat.new(buttons: [{}, {}, {}])
+      expect(coat.buttons).to have(3).items
+      coat.buttons.each { |button| expect(button).to be_a Clothing::Button }
+    end
+
+  end
+end

data/spec/lib/id/boolean_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Id::Boolean do
+  it 'parses the word true as true' do
+    b = Id::Boolean.parse('true')
+    expect(b).to be_true
+  end
+
+  it 'parses the word yes as true' do
+    b = Id::Boolean.parse('yes')
+    expect(b).to be_true
+  end
+
+  it 'is case insensite when parsing a string' do
+    b = Id::Boolean.parse('tRuE')
+    expect(b).to be_true
+  end
+
+  it 'parses the character 1 as true' do
+    b = Id::Boolean.parse('1')
+    expect(b).to be_true
+  end
+
+  it 'parses the number 1 as true' do
+    b = Id::Boolean.parse(1)
+    expect(b).to be_true
+  end
+
+  it 'parses symbols as well as strings' do
+    b = Id::Boolean.parse(:true)
+    expect(b).to be_true
+  end
+
+  it 'parses everything else as false' do
+    b = Id::Boolean.parse(:cottage_cheese)
+    expect(b).to be_false
+  end
+end

data/spec/lib/id/coercion_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Id::Coercion do
+
+  it 'can coerce basic types' do
+    coerced = Id::Coercion.coerce("2", Integer)
+    expect(coerced).to eq 2
+  end
+
+  it 'can coerce strings into dates' do
+    coerced = Id::Coercion.coerce("01/01/2001", Date)
+    expect(coerced).to eq Date.new(2001, 1, 1)
+  end
+
+  it 'can coerce strings into times' do
+    coerced = Id::Coercion.coerce("01/01/2001", Time)
+    expect(coerced).to eq Time.new(2001, 1, 1)
+  end
+
+  it 'can coerce strings into booleans' do
+    coerced = Id::Coercion.coerce("yes", Id::Boolean)
+    expect(coerced).to be_true
+  end
+
+  it 'can have new coercions added, even stupid ones' do
+    Id::Coercion.register(Fixnum, String) { |value| (value + 1).to_s }
+    coerced = Id::Coercion.coerce(2, String)
+    expect(coerced).to eq "3"
+  end
+
+  it 'throws an error if there is no registered coercion for the given types' do
+    expect { Id::Coercion.coerce(2, Proc) }.to raise_error Id::CoercionError
+  end
+
+  it 'can coerce data into id models' do
+    c = Class.new { include Id::Model ; field :cats }
+    coerced = Id::Coercion.coerce({cats: 3}, c)
+    expect(coerced.cats).to eq 3
+  end
+
+  it 'can coerce arrays of a type' do
+    c = Class.new { include Id::Model }
+    coerced = Id::Coercion.coerce([{},{},{}], Array[c])
+    expect(coerced).to have(3).items
+    coerced.each { |item| expect(item).to be_a c }
+  end
+
+  it 'can coerce optional types' do
+    c = Class.new { include Id::Model; field :foot, optional: true, type: Integer }
+    expect(c.new.foot).to be_none
+    expect(c.new(foot: '4').foot).to eq Some[4]
+  end
+end

data/spec/lib/id/eta_expansion_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class Foot
+  include Id::Model
+end
+
+describe Id::EtaExpansion do
+  it 'eta expands an id model class into its constructor' do
+    feet = [{},{},{}].map(&Foot)
+    expect(feet).to have(3).items
+    feet.each { |foot| expect(foot).to be_a Foot }
+  end
+end

data/spec/lib/id/field/definition_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Id::Field
+  describe Definition do
+
+    it 'has a name' do
+      definition = Definition.new(:cats, {})
+      expect(definition.name).to eq :cats
+    end
+
+    it 'can be optional' do
+      definition = Definition.new(:cats, optional: true)
+      expect(definition).to be_optional
+    end
+
+    it 'has a type' do
+      definition = Definition.new(:cats, type: String)
+      expect(definition.type).to eq String
+    end
+
+    it 'has a string key' do
+      definition = Definition.new(:cats, key: 'kitten')
+      expect(definition.key).to eq 'kitten'
+    end
+
+    it 'has a default' do
+      definition = Definition.new(:cats, default: ->{ Time.now })
+      expect(definition.default).to be_a Proc
+    end
+
+    it 'has a default! method which executes the default if it is a lambda' do
+      definition = Definition.new(:cats, default: ->{ Time.now })
+      expect(definition.default!).to be_a Time
+    end
+
+  end
+end

data/spec/lib/id/field/summary_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Id::Field
+  describe Summary do
+    it 'constructs a summary of the definition' do
+      definition = Id::Field::Definition.new(:cats,
+                                             optional: true,
+                                             key: 'kittens',
+                                             type: String,
+                                             default: -> { "KITTEH!"})
+      summary = definition.to_s
+      expect(summary).to eq "Name: cats\n"   +
+                            "Type: String\n" +
+                            "Key in hash: kittens\n" +
+                            "Optional: true\n" +
+                            "Default: Lambda"
+    end
+
+    it 'omits info for options that are not specified' do
+      definition = Id::Field::Definition.new(:cats, type: String)
+      summary = definition.to_s
+      expect(summary).to eq "Name: cats\n"   +
+                            "Type: String"
+    end
+  end
+end

data/spec/lib/id/field_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Id::Field do
+
+  it 'allows key aliases to be defined' do
+    c = Class.new { include Id::Model ; field :cats, key: 'kittehs' }.new(kittehs: 3)
+    expect(c.cats).to eq 3
+  end
+
+  it 'blows up with an informative error if you try to request a nil value' do
+    class TestClass; include Id::Model; field :cats end
+    c = TestClass.new
+    expect { c.cats }.to raise_error Id::MissingAttributeError, /TestClass had a nil value for 'cats'./
+  end
+
+  describe 'type coercion' do
+
+    it 'can coerce basic types' do
+      c = Class.new { include Id::Model ; field :cats, type: Integer }.new(cats: "3")
+      expect(c.cats).to eq 3
+    end
+  end
+
+  describe 'defaults' do
+
+    it 'can be initialised with a default value' do
+      c = Class.new { include Id::Model ; field :cats, default: 7 }.new
+      expect(c.cats).to eq 7
+    end
+
+    it 'can take a lambda as a default value' do
+      c = Class.new { include Id::Model ; field :cats, default: -> { 7 } }.new
+      expect(c.cats).to eq 7
+    end
+
+    it 'runs lambda defaults at the point of first access of the field' do
+      c = Class.new { include Id::Model ; field :time, default: -> { Time.now } }.new
+      d = Class.new { include Id::Model ; field :time, default: -> { Time.now } }.new
+      t1 = c.time; sleep 0.0001; t2 = d.time
+      expect(t2).to be > t1
+    end
+
+    it 'memoizes lambda generated values so they are created only once' do
+      c = Class.new { include Id::Model ; field :time, default: -> { Time.now } }.new
+      t1 = c.time; sleep 0.0001; t2 = c.time
+      expect(t2).to eq t1
+    end
+
+  end
+
+  it 'can test for the presence of values' do
+    c = Class.new { include Id::Model ; field :foo }.new
+    expect(c.foo?).to be_false
+    d = c.set(foo: 4)
+    expect(d.foo?).to be_true
+  end
+
+  it 'makes the fields of the model enumerable' do
+    c = Class.new { include Id::Model ; field :foo }.new
+    expect(c.fields.keys.map(&:to_s).map(&:upcase)).to eq ["FOO"]
+  end
+end

data/spec/lib/id/form_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Id::Form do
+
+  class FormTest
+    include Id::Model
+    include Id::Form
+  end
+
+  it 'defines self.model_name' do
+    expect(FormTest.new.to_model.class.model_name).to eq 'FormTest'
+  end
+
+  module Enclosing
+    class FormTest2
+      include Id::Model
+      include Id::Form
+
+      def self.model_name
+        ActiveModel::Name.new(self, nil, "Harry")
+      end
+    end
+  end
+
+  it "defers to the class' implementation of model_name if it has one" do
+    expect(Enclosing::FormTest2.new.to_model.class.model_name).to eq 'Harry'
+    expect(Enclosing::FormTest2.new.to_model.class.model_name.plural).to eq 'harries'
+  end
+
+  class FormTest3
+    include Id::Model
+    include Id::Form
+
+    def to_partial_path
+      'Jemima'
+    end
+  end
+
+  it "defers to the class' implementation of to_partial_path if it has one" do
+    expect(FormTest3.new.to_model.to_partial_path).to eq 'Jemima'
+  end
+
+  class Octopus
+    include Id::Model
+    include Id::Form
+  end
+
+  it 'defines a sensible default implementation of to_partial_path' do
+    expect(Octopus.new.to_model.to_partial_path).to eq 'octopi/octopus'
+  end
+
+  it 'still allows the use of as_form, but this is deprecated' do
+    octopus = Octopus.new
+    expect(octopus.as_form).to eq octopus.to_model
+  end
+
+  class Cheetah
+    include Id::Model
+    include Id::Form
+    field :foo
+    form do
+      validates_presence_of :foo
+    end
+  end
+
+  it 'still allows the use of form, but this is deprecated' do
+    expect(Cheetah.new).not_to be_valid
+  end
+end
+
+
+describe Id::FormBuilder do
+  it 'calls to_model on id models used as form objects' do
+    cat = Class.new { include Id::Model ; field :foo }.new
+    cat.expects(:to_model).returns(cat)
+    builder = Id::FormBuilder.new('cat', cat, 'cat.html.erb', {})
+  end
+
+  it 'does not call to_model on other objects' do
+    dog = Class.new.new
+    dog.expects(:to_model).never
+    builder = Id::FormBuilder.new('dog', dog, 'dog.html.erb', {})
+  end
+end

data/spec/lib/id/hashifier_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Id::Hashifier do
+
+  it 'enhashes nested hashes of id models' do
+    t = Class.new { include Id::Model ; field :waggy }
+    c = Class.new { include Id::Model ; has_one :tail, type: t }
+    cat = c.new(tail: {waggy: false})
+    expect(Id::Hashifier.enhash cat).to eq("tail" => { "waggy" => false })
+  end
+
+  it 'enhashes nested arrays of id models' do
+    p = Class.new { include Id::Model }
+    c = Class.new { include Id::Model ; has_many :paws, type: p }
+    cat = c.new(paws: [{},{},{}])
+    expect(Id::Hashifier.enhash cat).to eq("paws" => [{},{},{}])
+  end
+
+end