yaks 0.9.0 → 0.10.0

data/spec/unit/yaks/primitivize_spec.rb

@@ -1,6 +1,12 @@
 RSpec.describe Yaks::Primitivize do
   subject(:primitivizer) { described_class.create }
 
+  describe "#initialize" do
+    it "should not create any mappings" do
+      expect(described_class.new.mappings).to eql Hash[]
+    end
+  end
+
   describe '.create' do
     it 'should map String, true, false, nil, numbers to themselves' do
       [
@@ -22,14 +28,17 @@ RSpec.describe Yaks::Primitivize do
 
     it 'should recursively handle hashes' do
       expect(primitivizer.call(
-          :foo => {:wassup => :friends, 123 => '456'}
+          foo: {:wassup => :friends, 123 => '456'}
       )).to eql('foo' => {'wassup' => 'friends', 123 => '456'})
     end
 
     it 'should handle arrays recursively' do
-      expect(primitivizer.call(
-          [:foo, [:wassup, :friends], 123, '456']
-      )).to eql( ['foo', ['wassup', 'friends'], 123, '456'] )
+      expect(primitivizer.call([:foo, [:wassup, :friends], 123, '456']))
+        .to eql(['foo', %w[wassup friends], 123, '456'])
+    end
+
+    it "should handle URIs by turning them to strings" do
+      expect(primitivizer.call(URI("http://foo.bar/baz"))).to eql "http://foo.bar/baz"
     end
   end
 
@@ -45,7 +54,8 @@ RSpec.describe Yaks::Primitivize do
         "I am funny"
       end
 
-      expect { primitivizer.call(funny_object) }.to raise_error "don't know how to turn OpenStruct (I am funny) into a primitive"
+      expect { primitivizer.call(funny_object) }
+        .to raise_error Yaks::PrimitivizeError, "don't know how to turn OpenStruct (I am funny) into a primitive"
     end
 
     context 'with custom mapping' do
@@ -66,10 +76,19 @@ RSpec.describe Yaks::Primitivize do
       end
 
       it 'should evaluate in the context of primitivize' do
-        expect( primitivizer.call( Vector[:foo, :baxxx, :bazz] ) ).to eql( [3, 5, 4] )
+        expect(primitivizer.call(Vector[:foo, :baxxx, :bazz])).to eql([3, 5, 4])
       end
     end
+  end
 
+  describe "#map" do
+    let(:primitivizer) { described_class.new }
 
+    it "should add new mappings" do
+      primitivizer.map(String) {|s| s.upcase }
+      primitivizer.map(Numeric) {|n| n.next }
+
+      expect(primitivizer.call("foo")).to eql "FOO"
+    end
   end
 end

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

@@ -11,12 +11,12 @@ RSpec.describe Yaks::Resource::Form::Field do
         described_class.new(name: 'foo', type: :select, options: [
           Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 1),
           Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: true, value: 2),
-          Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 3),
+          Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 3)
         ])
       end
 
       it 'should return the selected value' do
-        expect( subject.value ).to eql 2
+        expect(subject.value).to eql 2
       end
     end
 
@@ -25,12 +25,12 @@ RSpec.describe Yaks::Resource::Form::Field do
         described_class.new(name: 'foo', type: :select, options: [
           Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 1),
           Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 2),
-          Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 3),
+          Yaks::Resource::Form::Field::Option.new(label: 'foo', selected: false, value: 3)
         ])
       end
 
       it 'should return nothing' do
-        expect( subject.value ).to be nil
+        expect(subject.value).to be nil
       end
     end
   end
@@ -48,7 +48,7 @@ RSpec.describe Yaks::Resource::Form::Field do
           Yaks::Resource::Form::Field::Option.new(label: 'f', selected: true,  value: "1"),
           Yaks::Resource::Form::Field::Option.new(label: 'f', selected: false, value: "2"),
           Yaks::Resource::Form::Field::Option.new(label: 'f', selected: true,  value: "3"),
-          Yaks::Resource::Form::Field::Option.new(label: 'f', selected: false, value: "4"),
+          Yaks::Resource::Form::Field::Option.new(label: 'f', selected: false, value: "4")
         ])
       end
 

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

@@ -0,0 +1,7 @@
+RSpec.describe Yaks::Resource::Form::Fieldset do
+  subject(:fieldset) { described_class.new(fields: []) }
+
+  describe '#type' do
+    its(:type) { should equal :fieldset }
+  end
+end

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

@@ -0,0 +1,8 @@
+RSpec.describe Yaks::Resource::Form::Legend do
+  subject(:legend) { described_class.new(label: 'a legend') }
+
+  describe '#initialize' do
+    its(:type) { should equal :legend }
+    its(:label) { should eql 'a legend' }
+  end
+end

data/spec/unit/yaks/resource/form_spec.rb

@@ -23,65 +23,45 @@ RSpec.describe Yaks::Resource::Form do
     end
   end
 
-  describe '#fields_flat' do
-    let(:fields) do
-      [
-        Yaks::Resource::Form::Fieldset.new(fields: [
-          Yaks::Resource::Form::Field.new(name: :foo, value: '123', type: 'text'),
-          Yaks::Resource::Form::Field.new(name: :bar, value: '+32 477 123 123', type: 'tel')
-        ]),
-        Yaks::Resource::Form::Fieldset.new(fields: [
-          Yaks::Resource::Form::Fieldset.new(fields: [
-            Yaks::Resource::Form::Field.new(name: :qux, value: '777', type: 'text'),
-          ]),
-          Yaks::Resource::Form::Field.new(name: :quux, value: '999', type: 'tel')
-        ])
-      ]
-    end
-
-    it 'should flatten fieldsets' do
-      expect(subject.fields_flat).to eql [
-        Yaks::Resource::Form::Field.new(name: :foo, value: '123', type: 'text'),
-        Yaks::Resource::Form::Field.new(name: :bar, value: '+32 477 123 123', type: 'tel'),
-        Yaks::Resource::Form::Field.new(name: :qux, value: '777', type: 'text'),
-        Yaks::Resource::Form::Field.new(name: :quux, value: '999', type: 'tel')
-      ]
-    end
-  end
-
   describe "#method?" do
     it 'should return true if method matches' do
       form_sym = Yaks::Resource::Form.new(name: :foo, method: :get)
       form_str = Yaks::Resource::Form.new(name: :foo, method: 'GET')
 
-      expect(form_sym.method?(:get)).to eq(true)
-      expect(form_sym.method?('get')).to eq(true)
-      expect(form_str.method?(:get)).to eq(true)
-      expect(form_str.method?('GET')).to eq(true)
+      expect(form_sym.method?(:get)).to be true
+      expect(form_sym.method?('get')).to be true
+      expect(form_str.method?(:get)).to be true
+      expect(form_str.method?('GET')).to be true
     end
 
     it 'should return false if method does not match' do
       form_sym = Yaks::Resource::Form.new(name: :foo, method: :get)
       form_str = Yaks::Resource::Form.new(name: :foo, method: 'GET')
 
-      expect(form_sym.method?(:post)).to eq(false)
-      expect(form_sym.method?('patch')).to eq(false)
-      expect(form_str.method?(:delete)).to eq(false)
-      expect(form_str.method?('PUT')).to eq(false)
+      expect(form_sym.method?(:post)).to be false
+      expect(form_sym.method?('patch')).to be false
+      expect(form_str.method?(:delete)).to be false
+      expect(form_str.method?('PUT')).to be false
+    end
+
+    it 'should always be false when method is not specified' do
+      form = Yaks::Resource::Form.new(name: :foo)
+
+      expect(form.method?(:post)).to be false
     end
   end
 
   describe "#has_action?" do
-     it 'should return true if form has an action url' do
+    it 'should return true if form has an action url' do
       form = Yaks::Resource::Form.new(name: :foo, action: "/my-action")
 
-      expect(form.has_action?).to eq(true)
+      expect(form.has_action?).to be true
     end
 
     it 'should return false if form has not an action url' do
       form = Yaks::Resource::Form.new(name: :foo)
 
-      expect(form.has_action?).to eq(false)
+      expect(form.has_action?).to be false
     end
   end
 end

data/spec/unit/yaks/resource/has_fields_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe Yaks::Resource::HasFields do
   let(:class_with_fields) do
     Class.new do
       include Yaks::Resource::HasFields
-      include Yaks::Attributes.new(:fields)
+      include Attribs.new(:fields)
     end
   end
 
@@ -24,10 +24,9 @@ RSpec.describe Yaks::Resource::HasFields do
   subject(:with_fields) { class_with_fields.new(fields: fields) }
 
   describe '#map_fields' do
-
     let(:update_fields) do
       ->(field) do
-        field.with({ value: "updated" })
+        field.with(value: "updated")
       end
     end
 
@@ -47,4 +46,46 @@ RSpec.describe Yaks::Resource::HasFields do
     end
   end
 
+  describe '#fields_flat' do
+    let(:fields) do
+      [
+        Yaks::Resource::Form::Fieldset.new(fields: [
+          Yaks::Resource::Form::Legend.new(label: 'a legend'),
+          Yaks::Resource::Form::Field.new(name: :foo, value: '123', type: 'text'),
+          Yaks::Resource::Form::Field.new(name: :bar, value: '+32 477 123 123', type: 'tel')
+        ]),
+        Yaks::Resource::Form::Fieldset.new(fields: [
+          Yaks::Resource::Form::Fieldset.new(fields: [
+            Yaks::Resource::Form::Field.new(name: :qux, value: '777', type: 'text')
+          ]),
+          Yaks::Resource::Form::Field.new(name: :quux, value: '999', type: 'tel')
+        ])
+      ]
+    end
+
+    it 'should flatten fieldsets, skipping legends' do
+      expect(subject.fields_flat.to_a).to eql [
+        Yaks::Resource::Form::Field.new(name: :foo, value: '123', type: 'text'),
+        Yaks::Resource::Form::Field.new(name: :bar, value: '+32 477 123 123', type: 'tel'),
+        Yaks::Resource::Form::Field.new(name: :qux, value: '777', type: 'text'),
+        Yaks::Resource::Form::Field.new(name: :quux, value: '999', type: 'tel')
+      ]
+    end
+
+    it 'should work like #map, collecting block return values, maintaining nesting' do
+      expect(subject.fields_flat {|f| f.with(required: true) }).to eql [
+        Yaks::Resource::Form::Fieldset.new(fields: [
+          Yaks::Resource::Form::Legend.new(label: 'a legend'),
+          Yaks::Resource::Form::Field.new(name: :foo, value: '123', type: 'text', required: true),
+          Yaks::Resource::Form::Field.new(name: :bar, value: '+32 477 123 123', type: 'tel', required: true)
+        ]),
+        Yaks::Resource::Form::Fieldset.new(fields: [
+          Yaks::Resource::Form::Fieldset.new(fields: [
+            Yaks::Resource::Form::Field.new(name: :qux, value: '777', type: 'text', required: true)
+          ]),
+          Yaks::Resource::Form::Field.new(name: :quux, value: '999', type: 'tel', required: true)
+        ])
+      ]
+    end
+  end
 end

data/spec/unit/yaks/resource/link_spec.rb

@@ -3,18 +3,23 @@ RSpec.describe Yaks::Resource::Link do
 
   let(:rel)      { :foo_rel }
   let(:uri)      { 'http://api.example.org/rel/foo' }
-  let(:options)  { { title: 'mr. spectacular' } }
+  let(:options)  { {title: 'mr. spectacular'} }
 
   its(:rel)     { should eql :foo_rel }
   its(:uri)     { should eql 'http://api.example.org/rel/foo' }
   its(:options) { should eql(title: 'mr. spectacular') }
 
-  its(:title)      { should eql('mr. spectacular') }
-  its(:templated?) { should be false }
+  describe '#title' do
+    its(:title)      { should eql('mr. spectacular') }
+  end
+
+  describe '#templated?' do
+    its(:templated?) { should be false }
 
-  context 'with explicit templated option' do
-    let(:options) { super().merge(templated: true) }
-    its(:templated?) { should be true }
+    context 'with explicit templated option' do
+      let(:options) { super().merge(templated: true) }
+      its(:templated?) { should be true }
+    end
   end
 
   describe '#rel?' do

data/spec/unit/yaks/resource_spec.rb

@@ -2,95 +2,20 @@ RSpec.describe Yaks::Resource do
   subject(:resource) { described_class.new(init_opts) }
   let(:init_opts) { {} }
 
-  context 'with a zero-arg constructor' do
-    subject(:resource) { described_class.new }
-
-    its(:type)           { should be_nil }
-    its(:attributes)     { should eql({}) }
-    its(:links)          { should eql [] }
-    its(:subresources)   { should eql [] }
-    its(:self_link)      { should be_nil }
-    its(:null_resource?) { should be false }
-    its(:collection?)    { should be false }
-  end
-
-  context 'with a type' do
-    let(:init_opts) { { type: 'post' } }
-    its(:type) { should eql 'post' }
-  end
-
-  context 'with attributes' do
-    let(:init_opts) { { attributes: {name: 'Arne', age: 31} } }
-
-    it 'should delegate [] to attribute access' do
-      expect(resource[:name]).to eql 'Arne'
-    end
-  end
-
-  context 'with links' do
-    let(:init_opts) {
-      {
-        links: [
-          Yaks::Resource::Link.new(rel: :profile, uri: '/foo/bar/profile'),
-          Yaks::Resource::Link.new(rel: :self, uri: '/foo/bar')
-        ]
-      }
-    }
-    its(:links) { should eql [
-        Yaks::Resource::Link.new(rel: :profile, uri: '/foo/bar/profile'),
-        Yaks::Resource::Link.new(rel: :self, uri: '/foo/bar')
-      ]
-    }
-
-    its(:self_link) { should eql Yaks::Resource::Link.new(rel: :self, uri: '/foo/bar') }
-  end
-
-  context 'with subresources' do
-    let(:init_opts) { { subresources: [ Yaks::Resource.new(type: 'comment', rels: ['comments']) ] } }
-    its(:subresources) { should eql [Yaks::Resource.new(type: 'comment', rels: ['comments'])]  }
-
-    it 'should return an enumerable for #seq' do
-      expect(resource.seq.each.with_index.to_a).to eq  [ [resource, 0] ]
-    end
-  end
-
-  it 'should act as a collection of one' do
-    expect(resource.seq.each.to_a).to eql [resource]
-  end
-
-  describe 'persistent updates' do
-    let(:resource) {
-      Yaks::Resource.new(
-        attributes: {x: :y},
-        links: [:one],
-        subresources: [ :subres ]
-      )
-    }
-
-    it 'should do updates without modifying the original' do
-      expect(
-        resource
-          .merge_attributes(foo: :bar)
-          .add_link(:a_link)
-          .add_subresource(:a_subresource)
-          .merge_attributes(foo: :baz)
-      ).to eq Yaks::Resource.new(
-        attributes: {x: :y, foo: :baz},
-        links: [:one, :a_link],
-        subresources: [:subres, :a_subresource]
-      )
-
-      expect(resource).to eq Yaks::Resource.new(
-        attributes: {x: :y},
-        links: [:one],
-        subresources: [:subres]
-      )
+  describe '#initialize' do
+    context 'with a zero-arg constructor' do
+      subject(:resource) { described_class.new }
+
+      its(:type)           { should be_nil }
+      its(:attributes)     { should eql({}) }
+      its(:links)          { should eql [] }
+      its(:subresources)   { should eql [] }
+      its(:self_link)      { should be_nil }
+      its(:null_resource?) { should be false }
     end
-  end
 
-  describe '#initialize' do
     it 'should verify subresources is an array' do
-      expect { Yaks::Resource.new(subresources: { '/rel/comments' => []}) }
+      expect { Yaks::Resource.new(subresources: {'/rel/comments' => []}) }
         .to raise_exception /comments/
     end
 
@@ -100,17 +25,39 @@ RSpec.describe Yaks::Resource do
     end
 
     it 'should work without args' do
-      expect( Yaks::Resource.new ).to be_a Yaks::Resource
+      expect(Yaks::Resource.new).to be_a Yaks::Resource
     end
 
     it 'should take defaults when no args are passed' do
-      expect( Yaks::Resource.new.rels ).to eq []
+      expect(Yaks::Resource.new.rels).to eq []
+    end
+  end
+
+  describe "#[]" do
+    it "should access attributes" do
+      expect(described_class.new(attributes: {foo: :bar})[:foo]).to eql :bar
+    end
+  end
+
+  describe '#find_form' do
+    it 'should find a form by name' do
+      expect(resource
+              .add_form(Yaks::Resource::Form.new(name: :a_form))
+              .add_form(Yaks::Resource::Form.new(name: :b_form))
+              .find_form(:b_form))
+        .to eq Yaks::Resource::Form.new(name: :b_form)
+    end
+  end
+
+  describe "#seq" do
+    it "should provide an enumerable that yields this resource once" do
+      expect(resource.seq.each.to_a).to eql [resource]
     end
   end
 
   describe '#self_link' do
     let(:init_opts) {
-      { links:
+      {links:
         [
           Yaks::Resource::Link.new(rel: :self, uri: 'foo'),
           Yaks::Resource::Link.new(rel: :self, uri: 'bar'),
@@ -123,6 +70,18 @@ RSpec.describe Yaks::Resource do
     end
   end
 
+  describe "#collection?" do
+    it "should be false" do
+      expect(resource.collection?).to be false
+    end
+  end
+
+  describe "#null_resource?" do
+    it "should be false" do
+      expect(resource.null_resource?).to be false
+    end
+  end
+
   describe '#add_rel' do
     it 'should add to the rels' do
       expect(resource.add_rel(:foo).add_rel(:bar))
@@ -130,6 +89,22 @@ RSpec.describe Yaks::Resource do
     end
   end
 
+  describe "#add_link" do
+    let(:init_opts) {
+      {
+        links: [Yaks::Resource::Link.new(rel: :next, uri: '/next')]
+      }
+    }
+
+    it "should append to the links list" do
+      expect(resource.add_link(Yaks::Resource::Link.new(rel: :previous, uri: '/previous')))
+        .to eql Yaks::Resource.new(links: [
+          Yaks::Resource::Link.new(rel: :next, uri: '/next'),
+          Yaks::Resource::Link.new(rel: :previous, uri: '/previous')
+        ])
+    end
+  end
+
   describe '#add_form' do
     it 'should append to the forms' do
       expect(resource.add_form(Yaks::Resource::Form.new(name: :a_form)))
@@ -137,13 +112,20 @@ RSpec.describe Yaks::Resource do
     end
   end
 
-  describe '#find_form' do
-    it 'should find a form by name' do
-      expect(resource
-              .add_form(Yaks::Resource::Form.new(name: :a_form))
-              .add_form(Yaks::Resource::Form.new(name: :b_form))
-              .find_form(:b_form))
-        .to eq Yaks::Resource::Form.new(name: :b_form)
+  describe "#add_subresource" do
+    let(:init_opts) {
+      {
+        subresources: [Yaks::Resource.new(attributes: {foo: 1})]
+      }
+    }
+    it "should append to the subresources list" do
+      expect(resource.add_subresource(Yaks::Resource.new(attributes: {bar: 2})))
+        .to eql Yaks::Resource.new(
+          subresources: [
+            Yaks::Resource.new(attributes: {foo: 1}),
+            Yaks::Resource.new(attributes: {bar: 2})
+          ]
+        )
     end
   end
 
@@ -155,10 +137,17 @@ RSpec.describe Yaks::Resource do
     end
   end
 
+  describe "#merge_attributes" do
+    let(:init_opts) {{attributes: {foo: 1, bar: 2}}}
+    it "should merge attributes into any existing attributes" do
+      expect(resource.merge_attributes(bar: 3, baz: 4))
+        .to eql Yaks::Resource.new(attributes: {foo: 1, bar: 3, baz: 4})
+    end
+  end
+
   describe '#with_collection' do
     it 'should be a no-op' do
-      expect(Yaks::Resource.new.with_collection([:foo])).to eql Yaks::Resource.new
+      expect(described_class.new.with_collection([:foo])).to eql Yaks::Resource.new
     end
   end
-
 end