yaks 0.9.0 → 0.10.0

data/spec/unit/yaks/mapper/attribute_spec.rb

@@ -1,18 +1,57 @@
 RSpec.describe Yaks::Mapper::Attribute do
   include_context 'yaks context'
 
-  subject(:attribute) { described_class.new(:the_name) }
-  fake(:mapper)
+  let(:attribute_with_block) { described_class.create(:the_name) { "Alice" } }
 
-  its(:name) { should be :the_name }
+  subject(:attribute) { described_class.create(:the_name) }
+  fake(:mapper)
 
   before do
     stub(mapper).load_attribute(:the_name) { 123 }
+    stub(mapper).object { fake(name: "Bob") }
+  end
+
+  describe ".create" do
+    its(:name) { should be :the_name }
+    its(:block) { should be_nil }
+
+    it "should accept two parameter" do
+      expect{described_class.create(:the_name, {})}.not_to raise_error()
+    end
+
+    context "with block" do
+      subject(:attribute) { attribute_with_block }
+
+      its(:block) { should_not be_nil }
+
+      it "should store the given block" do
+        expect(subject.block.call).to eq("Alice")
+      end
+    end
   end
 
-  it 'should add itself to a resource based on a lookup' do
-    expect(attribute.add_to_resource(Yaks::Resource.new, mapper , yaks_context)).to eql(
-      Yaks::Resource.new(attributes: { :the_name => 123 })
-    )
+  describe "#add_to_resource" do
+    it "should add itself to a resource based on a lookup" do
+      expect(attribute.add_to_resource(Yaks::Resource.new, mapper, yaks_context))
+        .to eql(Yaks::Resource.new(attributes: {the_name: 123}))
+    end
+
+    context "when the attribute has a block" do
+      subject(:attribute) { attribute_with_block }
+
+      it "should add itself to a resource with the block value" do
+        expect(attribute.add_to_resource(Yaks::Resource.new, mapper, yaks_context))
+          .to eql(Yaks::Resource.new(attributes: {the_name: "Alice"}))
+      end
+
+      context "using the mapper context" do
+        let(:attribute) { described_class.create(:the_name) { object.name } }
+
+        it "should add itself to a resource with the block value" do
+          expect(attribute.add_to_resource(Yaks::Resource.new, mapper, yaks_context))
+            .to eql(Yaks::Resource.new(attributes: {the_name: "Bob"}))
+        end
+      end
+    end
   end
 end

data/spec/unit/yaks/mapper/config_spec.rb

@@ -1,11 +1,10 @@
 RSpec.describe Yaks::Mapper::Config do
-
   describe '#add_attributes' do
     it 'should add attributes' do
       expect(subject.add_attributes(:bar).add_attributes(:baz)).to eql described_class.new(
         attributes: [
-          Yaks::Mapper::Attribute.new(:bar),
-          Yaks::Mapper::Attribute.new(:baz),
+          Yaks::Mapper::Attribute.create(:bar),
+          Yaks::Mapper::Attribute.create(:baz)
         ]
       )
     end

data/spec/unit/yaks/mapper/form/config_spec.rb

@@ -0,0 +1,95 @@
+RSpec.describe Yaks::Mapper::Form::Config do
+  let(:config) { described_class.new }
+
+  describe ".create" do
+    let(:config) {
+      described_class.create name: :bar, method: "POST"
+    }
+
+    it "should take an attribute hash" do
+      expect(config)
+        .to eql Yaks::Mapper::Form::Config.new(
+          name: :bar,
+          method: "POST"
+        )
+    end
+  end
+
+  describe ".build" do
+    context "with no arguments" do
+      it "should create a default Form::Config" do
+        expect(described_class.build).to eql described_class.new
+      end
+    end
+
+    context "with a block" do
+      let(:config) {
+        described_class.build name: :bar do
+          method "DELETE"
+          password :secret
+        end
+      }
+
+      it "should evaluate as Form DSL" do
+        expect(config)
+          .to eql Yaks::Mapper::Form::Config.new(
+            name: :bar,
+            method: "DELETE",
+            fields: [
+              Yaks::Mapper::Form::Field.new(name: :secret, type: :password)
+            ]
+          )
+      end
+    end
+  end
+
+  describe ".build_with_object" do
+    let(:config) {
+      described_class.build_with_object "the_object" do |obj|
+        title obj
+      end
+    }
+
+    it "should pass the object to the config block" do
+      expect(config)
+        .to eql Yaks::Mapper::Form::Config.new(
+          title: "the_object"
+        )
+    end
+  end
+
+  describe "#condition" do
+    it "should work with a lambda" do
+      expect(config.condition(->{ :okay }).if.call).to equal :okay
+    end
+
+    it "should work with a block" do
+      expect(config.condition { :okay }.if.call).to equal :okay
+    end
+  end
+
+  describe "#to_resource_fields" do
+    include_context 'yaks context'
+    let(:mapper) { Yaks::Mapper.new(yaks_context) }
+    let(:config) {
+      described_class.build do
+        fieldset do
+          text :first_name
+          text :last_name
+        end
+      end
+    }
+
+    it "should map to resource fields" do
+      expect(config.to_resource_fields(mapper))
+        .to eql [
+          Yaks::Resource::Form::Fieldset.new(
+            fields: [
+              Yaks::Resource::Form::Field.new(name: :first_name, type: :text),
+              Yaks::Resource::Form::Field.new(name: :last_name, type: :text)
+            ]
+          )
+        ]
+    end
+  end
+end

data/spec/unit/yaks/mapper/form/dynamic_field_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Yaks::Mapper::Form::DynamicField do
+  describe ".create" do
+    it "take a block" do
+      expect(described_class.create { :foo }.block.call).to equal :foo
+    end
+
+    it "should ignore any options hash given" do
+      expect { described_class.create(foo: :bar) }.to_not raise_error
+    end
+  end
+
+  describe "#to_resource_fields" do
+    include_context "yaks context"
+    let(:mapper) { Yaks::Mapper.new(yaks_context) }
+    let(:field) {
+      described_class.create do |obj|
+        text :first_name, value: obj
+        text :last_name
+      end
+    }
+
+    it "should return an array of fields" do
+      mapper.call("Arne")
+      expect(field.to_resource_fields(mapper)).to eql [
+        Yaks::Resource::Form::Field.new(name: :first_name, type: :text, value: "Arne"),
+        Yaks::Resource::Form::Field.new(name: :last_name, type: :text)
+      ]
+    end
+  end
+end

data/spec/unit/yaks/mapper/form/field/option_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Yaks::Mapper::Form::Field::Option do
-  include_context 'yaks context'
+  include_context "yaks context"
 
   let(:mapper_class) do
     Class.new(Yaks::Mapper) do
@@ -10,10 +10,54 @@ RSpec.describe Yaks::Mapper::Form::Field::Option do
   end
 
   let(:mapper) { mapper_class.new(yaks_context) }
+  let(:args) {
+    {
+      value: ->{ color },
+      label: ->{ :color },
+      selected: ->{ true },
+      disabled: ->{ true }
+    }
+  }
 
-  let(:option) { described_class.new(value: ->{color}, label: :color) }
+  let(:option) { described_class.new(args) }
 
-  it 'should expand procs in the context of the mapper' do
-    expect(option.to_resource_field_option(mapper)).to eql Yaks::Resource::Form::Field::Option.new(value: :yellow, label: :color, selected: false)
+  describe ".create" do
+    it "should take the first argument as 'value'" do
+      expect(described_class.create(0, label: 'zero'))
+        .to eql Yaks::Mapper::Form::Field::Option.new(
+          value: 0,
+          label: 'zero'
+        )
+    end
+  end
+
+  describe "#to_resource_field_option" do
+    let(:resource_field_option) { option.to_resource_field_option(mapper) }
+
+    it "should expand procs in the context of the mapper" do
+      expect(resource_field_option)
+        .to eql Yaks::Resource::Form::Field::Option.new(
+          value: :yellow,
+          label: :color,
+          selected: true,
+          disabled: true
+        )
+    end
+
+    context "with a truthy condition" do
+      let(:args) { super().merge(if: ->{ true }) }
+
+      it "should return an Option instance" do
+        expect(resource_field_option).to be_a Yaks::Resource::Form::Field::Option
+      end
+    end
+
+    context "with a falsey condition" do
+      let(:args) { super().merge(if: ->{ false }) }
+
+      it "should return nil" do
+        expect(resource_field_option).to be_nil
+      end
+    end
   end
 end

data/spec/unit/yaks/mapper/form/field_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Yaks::Mapper::Form::Field do
   include_context 'yaks context'
 
-  let(:field)     { described_class.new( full_args ) }
+  let(:field)     { described_class.new(full_args) }
   let(:name)      { :the_field }
   let(:full_args) { {name: name, options: options}.merge(args) }
   let(:options)   { [] }
@@ -15,7 +15,9 @@ RSpec.describe Yaks::Mapper::Form::Field do
 
   let(:mapper) do
     Class.new(Yaks::Mapper) do
-      def month ; 'January' ; end
+      def month
+        'January'
+      end
     end.new(yaks_context)
   end
 
@@ -91,4 +93,43 @@ RSpec.describe Yaks::Mapper::Form::Field do
       end
     end
   end
+
+  describe "#resource_options" do
+    context "when empty" do
+      it "should always be the same identical object" do
+        opt1 = described_class.new(name: :foo).resource_options(mapper)
+        opt2 = described_class.new(name: :bar).resource_options(mapper)
+        expect(opt1).to eql []
+        expect(opt1).to equal opt2
+      end
+    end
+
+    context "with select options" do
+      let(:options) do
+        [
+          Yaks::Mapper::Form::Field::Option.new(value: 0, label: "zero"),
+          Yaks::Mapper::Form::Field::Option.new(value: 1, label: "one"),
+          Yaks::Mapper::Form::Field::Option.new(value: 2, label: "two", if: ->{ false })
+        ]
+      end
+
+      it "should map to Resource::Field::Option instances" do
+        expect(field.resource_options(mapper))
+          .to eql [
+            Yaks::Resource::Form::Field::Option.new(value: 0, label: "zero"),
+            Yaks::Resource::Form::Field::Option.new(value: 1, label: "one")
+          ]
+      end
+    end
+  end
+
+  describe "#resource_attributes" do
+    it "should have all the HTML form field attributes" do
+      expect(field.resource_attributes).to eql [
+        :name, :label, :type, :required, :rows, :value, :pattern,
+        :maxlength, :minlength, :size, :readonly, :multiple, :min,
+        :max, :step, :list, :placeholder, :checked, :disabled
+      ]
+    end
+  end
 end

data/spec/unit/yaks/mapper/form/fieldset_spec.rb

@@ -2,18 +2,55 @@ RSpec.describe Yaks::Mapper::Form::Fieldset do
   include_context 'yaks context'
   let(:mapper) { Yaks::Mapper.new(yaks_context) }
 
-  describe '#to_resource_fields' do
-    context 'with dynamic elements' do
-      let(:fieldset) do
-        described_class.create({}) do
+  describe ".create" do
+    let(:fieldset) {
+      described_class.create do
+        text :first_name
+        text :last_name
+      end
+    }
+
+    it "should take a config block" do
+      expect(fieldset.config)
+        .to eql Yaks::Mapper::Form::Config.new(
+          fields: [
+            Yaks::Mapper::Form::Field.new(name: :first_name, type: :text),
+            Yaks::Mapper::Form::Field.new(name: :last_name, type: :text)
+          ]
+        )
+    end
+
+    context "with extra options" do
+      let(:fieldset) {
+        described_class.create if: true  do
+          text :first_name
+        end
+      }
+
+      it "should take an :if option (the rest doesn't make sense for a fieldset)" do
+        expect(fieldset.config)
+          .to eql Yaks::Mapper::Form::Config.new(
+            fields: [
+              Yaks::Mapper::Form::Field.new(name: :first_name, type: :text)
+            ],
+            if: true
+          )
+      end
+    end
+  end
+
+  describe "#to_resource_fields" do
+    context "with dynamic elements" do
+      let(:fieldset) {
+        described_class.create do
           dynamic do |object|
             text object.name
           end
         end
-      end
+      }
 
-      it 'should render them based on the mapped object' do
-        mapper.call(fake(name: :anthony)) # hack to set the mapper's object
+      it "should render them based on the mapped object" do
+        mapper.call(fake(name: :anthony)) # HACK: set the mapper's object
         expect(fieldset.to_resource_fields(mapper)).to eql(
           [
             Yaks::Resource::Form::Fieldset.new(
@@ -25,6 +62,28 @@ RSpec.describe Yaks::Mapper::Form::Fieldset do
         )
       end
     end
-  end
 
+    context "with a truthy `:if` condition" do
+      let(:fieldset) {
+        described_class.create if: ->{ true } do
+        end
+      }
+
+      it "should return an array of fieldsets" do
+        expect(fieldset.to_resource_fields(mapper).first)
+          .to be_a Yaks::Resource::Form::Fieldset
+      end
+    end
+
+    context "with a falsey `:if` condition" do
+      let(:fieldset) {
+        described_class.create if: ->{ false } do
+        end
+      }
+
+      it "should return nil" do
+        expect(fieldset.to_resource_fields(mapper).first).to be_nil
+      end
+    end
+  end
 end

data/spec/unit/yaks/mapper/form/legend_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe Yaks::Mapper::Form::Legend do
+  subject(:legend) { described_class.create("a legend") }
+
+  describe ".create" do
+    its(:type) { should equal :legend }
+    its(:label) { should eql "a legend" }
+
+    context "with an `:if` option" do
+      subject(:legend) { described_class.create("a legend", if: ->{ true }) }
+
+      it "should set the attribute" do
+        expect(legend.if.call).to be true
+      end
+    end
+  end
+
+  describe "#to_resource_fields" do
+    include_context "yaks context"
+    let(:mapper) { Yaks::Mapper.new(yaks_context) }
+
+    it "should return an array of Resource::Form::Legend" do
+      expect(legend.to_resource_fields(mapper))
+        .to eql [Yaks::Resource::Form::Legend.new(label: "a legend", type: :legend)]
+    end
+
+    context "with a truthy condition" do
+      subject(:legend) { described_class.create("a legend", if: ->{ true }) }
+
+      it "should return an array of Resource::Form::Legend" do
+        expect(legend.to_resource_fields(mapper).first)
+          .to be_a Yaks::Resource::Form::Legend
+      end
+    end
+
+    context "with a falsey condition" do
+      subject(:legend) { described_class.create("a legend", if: ->{ false }) }
+
+      it "should return an empty array" do
+        expect(legend.to_resource_fields(mapper)).to eql []
+      end
+    end
+
+    context "with a lambda for a label" do
+      subject(:legend) { described_class.create(->{ self.class.to_s }) }
+
+      it "should expand the lambda in the context of the mapper" do
+        expect(legend.to_resource_fields(mapper))
+          .to eql [Yaks::Resource::Form::Legend.new(label: "Yaks::Mapper", type: :legend)]
+      end
+    end
+  end
+end