yaks 0.7.6 → 0.7.7

data/spec/unit/yaks/configurable_spec.rb

@@ -9,9 +9,11 @@ RSpec.describe Yaks::Configurable do
 
   subject do
     Class.new do
-      include Yaks::Attributes.new(foo: []), Yaks::Configurable
+      extend Yaks::Configurable
+      include Yaks::Attributes.new(foo: [])
 
       config_method :bar, append_to: :foo, create: Creatable
+      config_method :baz, append_to: :foo, create: Creatable, defaults: {bar: 'baz'}
     end
   end
 
@@ -20,6 +22,34 @@ RSpec.describe Yaks::Configurable do
       subject.new.bar(1,2,3) { 4 }
                  .bar(:baz)  { :booz }
                  .foo
-    ).to eql [["->", 1, 2, 3, 4], ["->", :baz, :booz]]
+    ).to eql [["->", 1, 2, 3, {}, 4], ["->", :baz, {}, :booz]]
+  end
+
+  it 'should allow setting defaults' do
+    expect(
+      subject.new.baz(1,2,3, foo: 'bar') { 4 }
+                 .foo
+    ).to eql [["->", 1, 2, 3, {foo: 'bar', bar: 'baz'}, 4]]
+  end
+
+  it 'should allow overriding defaults' do
+    expect(
+      subject.new.baz(1,2,3, bar: 'qux') { 4 }
+                 .foo
+    ).to eql [["->", 1, 2, 3, {bar: 'qux'}, 4]]
+  end
+
+  it 'should be able to take an already instantiated object of the right type' do
+    instance = Creatable.new
+    expect(
+      subject.new.bar(instance).foo
+    ).to eql [instance]
+  end
+
+  it 'should only take the instance verbatim if it is the only argument' do
+    instance = Creatable.new
+    expect(
+      subject.new.bar(instance, 1) {}.foo
+    ).to eql [["->", instance, 1, {}, nil]]
   end
 end

data/spec/unit/yaks/format/collection_json_spec.rb

@@ -9,33 +9,65 @@ RSpec.describe Yaks::Format::CollectionJson do
     it { should deep_eql(load_json_fixture('plant_collection.collection')) }
   end
 
-  context 'with a link without title' do
-    let(:resource) {
-      Yaks::Resource.new(
-        attributes: {foo: 'fooval', bar: 'barval'},
-        links: [Yaks::Resource::Link.new(rel: 'the_rel', uri: 'the_uri')]
-      )
-    }
-
-    subject {
-      Yaks::Primitivize.create.call(described_class.new.call(resource))
-    }
-
-    it 'should not render a name' do
-      should deep_eql(
-        "collection" => {
-          "version" => "1.0",
-          "items" => [
-            {
-              "data" => [
-                { "name"=>"foo", "value"=>"fooval" },
-                { "name"=>"bar", "value"=>"barval" }
-              ],
-              "links" => [{"rel"=>"the_rel", "href"=>"the_uri"}]
-            }
-          ]
-        }
-      )
+  context 'link' do
+    context 'without title' do
+      let(:resource) {
+        Yaks::Resource.new(
+          attributes: {foo: 'fooval', bar: 'barval'},
+          links: [Yaks::Resource::Link.new(rel: 'the_rel', uri: 'the_uri')]
+        )
+      }
+
+      subject {
+        Yaks::Primitivize.create.call(described_class.new.call(resource))
+      }
+
+      it 'should not render a name' do
+        should deep_eql(
+          "collection" => {
+            "version" => "1.0",
+            "items" => [
+              {
+                "data" => [
+                  { "name"=>"foo", "value"=>"fooval" },
+                  { "name"=>"bar", "value"=>"barval" }
+                ],
+                "links" => [{"rel"=>"the_rel", "href"=>"the_uri"}]
+              }
+            ]
+          }
+        )
+      end
+    end
+
+    context 'with a title' do
+      let(:resource) {
+        Yaks::Resource.new(
+          attributes: {foo: 'fooval', bar: 'barval'},
+          links: [Yaks::Resource::Link.new(options: {title: 'the_name'}, rel: 'the_rel', uri: 'the_uri')]
+        )
+      }
+
+      subject {
+        Yaks::Primitivize.create.call(described_class.new.call(resource))
+      }
+
+      it 'should render a name' do
+        should deep_eql(
+          "collection" => {
+            "version" => "1.0",
+            "items" => [
+              {
+                "data" => [
+                  { "name"=>"foo", "value"=>"fooval" },
+                  { "name"=>"bar", "value"=>"barval" }
+                ],
+                "links" => [{"name"=>"the_name", "rel"=>"the_rel", "href"=>"the_uri"}]
+              }
+            ]
+          }
+        )
+      end
     end
   end
 end

data/spec/unit/yaks/format/halo_spec.rb

@@ -0,0 +1,3 @@
+
+RSpec.describe Yaks::Format::Halo do
+end

data/spec/unit/yaks/mapper/{control → form}/field_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Yaks::Mapper::Control::Field do
+RSpec.describe Yaks::Mapper::Form::Field do
   include_context 'yaks context'
 
   let(:field)   { described_class.new( full_args ) }
@@ -31,8 +31,8 @@ RSpec.describe Yaks::Mapper::Control::Field do
   end
 
   describe '#to_resource_field' do
-    it 'creates a Yaks::Resource::Control::Field with the same attributes' do
-      expect(field.to_resource(mapper)).to eql Yaks::Resource::Control::Field.new(full_args)
+    it 'creates a Yaks::Resource::Form::Field with the same attributes' do
+      expect(field.to_resource(mapper)).to eql Yaks::Resource::Form::Field.new(full_args)
     end
   end
 end

data/spec/unit/yaks/mapper/{control_spec.rb → form_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-RSpec.describe Yaks::Mapper::Control do
-  let(:control)   { described_class.new( full_args ) }
+RSpec.describe Yaks::Mapper::Form do
+  let(:form)   { described_class.new( full_args ) }
   let(:name)      { :the_name }
   let(:full_args) { {name: name}.merge(args) }
   let(:args) {
@@ -18,7 +18,7 @@ RSpec.describe Yaks::Mapper::Control do
   describe '.create' do
     it 'should create an instance, first arg is the name' do
 
-      expect( described_class.create(name, args) ).to eql control
+      expect( described_class.create(name, args) ).to eql form
     end
 
     it 'should have a name of nil when ommitted' do
@@ -27,20 +27,20 @@ RSpec.describe Yaks::Mapper::Control do
   end
 
   describe '#add_to_resource' do
-    let(:resource) { control.add_to_resource(Yaks::Resource.new, Yaks::Mapper.new(nil), nil) }
+    let(:resource) { form.add_to_resource(Yaks::Resource.new, Yaks::Mapper.new(nil), nil) }
 
-    it 'should add a control to the resource' do
-      expect(resource.controls.length).to be 1
+    it 'should add a form to the resource' do
+      expect(resource.forms.length).to be 1
     end
 
-    it 'should create a Yaks::Resource::Control with corresponding fields' do
-      expect(resource.controls.first).to eql Yaks::Resource::Control.new( full_args )
+    it 'should create a Yaks::Resource::Form with corresponding fields' do
+      expect(resource.forms.first).to eql Yaks::Resource::Form.new( full_args )
     end
 
     context 'with fields' do
       let(:fields) {
         [
-          Yaks::Mapper::Control::Field.new(
+          Yaks::Mapper::Form::Field.new(
             name: 'field name',
             label: 'field label',
             type: 'text',
@@ -49,9 +49,9 @@ RSpec.describe Yaks::Mapper::Control do
         ]
       }
 
-      it 'should map to Yaks::Resource::Control::Field instances' do
-        expect(resource.controls.first.fields).to eql [
-          Yaks::Resource::Control::Field.new(
+      it 'should map to Yaks::Resource::Form::Field instances' do
+        expect(resource.forms.first.fields).to eql [
+          Yaks::Resource::Form::Field.new(
             name: 'field name',
             label: 'field label',
             type: 'text',

data/spec/unit/yaks/mapper_spec.rb

@@ -202,24 +202,24 @@ RSpec.describe Yaks::Mapper do
       end
     end
 
-    context 'with a control' do
+    context 'with a form' do
       before do
         mapper_class.module_eval do
-          control :foo_control do
+          form :foo_form do
             field :bar_field, label: 'a label', type: 'number', value: 7
           end
         end
       end
 
-      it 'should render the control' do
+      it 'should render the form' do
         expect(mapper.call(fake))
           .to eql Yaks::Resource.new(
                     type: 'foo',
-                    controls: [
-                      Yaks::Resource::Control.new(
-                        name: :foo_control,
+                    forms: [
+                      Yaks::Resource::Form.new(
+                        name: :foo_form,
                         fields: [
-                          Yaks::Resource::Control::Field.new(
+                          Yaks::Resource::Form::Field.new(
                             name: :bar_field,
                             label: 'a label',
                             type: 'number',
@@ -316,9 +316,9 @@ RSpec.describe Yaks::Mapper do
     it_should_behave_like 'something that can be added to a resource'
   end
 
-  describe '#map_controls' do
-    let(:object) { fake('Control') }
-    before { mapper.config(mapper.config.append_to(:controls, object)) }
+  describe '#map_forms' do
+    let(:object) { fake('Form') }
+    before { mapper.config(mapper.config.append_to(:forms, object)) }
     it_should_behave_like 'something that can be added to a resource'
   end
 

data/spec/unit/yaks/null_resource_spec.rb

@@ -3,18 +3,20 @@ require 'spec_helper'
 RSpec.describe Yaks::NullResource do
   subject(:null_resource) { described_class.new }
 
-  its(:attributes)     { should eq({}) }
-  its(:links)          { should eq [] }
-  its(:subresources)   { should eq [] }
+  its(:attributes)     { should eql({}) }
+  its(:links)          { should eql [] }
+  its(:rels)           { should eql [] }
+  its(:subresources)   { should eql [] }
   its(:collection?)    { should be false }
   its(:null_resource?) { should be true }
+  its(:seq)            { should eql [] }
 
   it { should respond_to :[] }
 
   its(:type) { should be_nil }
 
   describe '#each' do
-    its(:each)         { should be_a Enumerator }
+    its(:each) { should be_a Enumerator }
 
     it 'should not yield anything' do
       null_resource.each { fail }
@@ -42,9 +44,9 @@ RSpec.describe Yaks::NullResource do
     )
   end
 
-  it 'should not allow adding controls' do
-    expect { null_resource.add_control(nil) }.to raise_error(
-      Yaks::UnsupportedOperationError, "Operation add_control not supported on Yaks::NullResource"
+  it 'should not allow adding forms' do
+    expect { null_resource.add_form(nil) }.to raise_error(
+      Yaks::UnsupportedOperationError, "Operation add_form not supported on Yaks::NullResource"
     )
   end
 
@@ -53,4 +55,45 @@ RSpec.describe Yaks::NullResource do
       Yaks::UnsupportedOperationError, "Operation add_subresource not supported on Yaks::NullResource"
     )
   end
+
+  describe '#initialize' do
+    it 'should have defaults for everything' do
+      expect( described_class.new.to_h ).to eql({
+        type: nil,
+        rels: [],
+        links: [],
+        attributes: {},
+        subresources: [],
+        forms: [],
+        collection: false})
+    end
+
+    it 'should allow setting rels' do
+      expect( described_class.new(rels: [:self]).rels ).to eql [:self]
+    end
+
+    it 'should allow setting the collection flag' do
+      expect( described_class.new(collection: true).collection ).to be true
+    end
+
+    it 'should not allow attributes in the contstructor' do
+      expect( described_class.new(attributes: {foo: :bar}).attributes ).to eql({})
+    end
+  end
+
+  describe '#map' do
+    context 'when a collection' do
+      it 'should always return []' do
+        expect( described_class.new(collection: true).map{} ).to eql []
+      end
+    end
+
+    context 'when not a collection' do
+      it 'should raise an error' do
+        expect { null_resource.map{} }.to raise_error(
+          Yaks::UnsupportedOperationError, "Operation map not supported on Yaks::NullResource"
+        )
+      end
+    end
+  end
 end

data/spec/unit/yaks/resource_spec.rb

@@ -105,10 +105,10 @@ RSpec.describe Yaks::Resource do
     end
   end
 
-  describe '#add_control' do
-    it 'should append to the controls' do
-      expect(resource.add_control(:a_control))
-        .to eq Yaks::Resource.new(controls: [:a_control])
+  describe '#add_form' do
+    it 'should append to the forms' do
+      expect(resource.add_form(:a_form))
+        .to eq Yaks::Resource.new(forms: [:a_form])
     end
   end
 

data/spec/unit/yaks/runner_spec.rb

@@ -120,6 +120,26 @@ RSpec.describe Yaks::Runner do
       expect(formatter).to be_a Yaks::Format::JsonAPI
       expect(formatter.send(:options)).to eql(format_option: [:foo])
     end
+
+    it 'should memoize' do
+      expect(runner.formatter).to be runner.formatter
+    end
+  end
+
+  describe '#env' do
+    describe 'when env is set in the options' do
+      let(:options) { { env: 123 } }
+
+      it 'returns the env passed in' do
+        expect(runner.env).to be 123
+      end
+    end
+
+    describe 'when no env is given' do
+      it 'falls back to an empty hash' do
+        expect(runner.env).to eql({})
+      end
+    end
   end
 
   describe '#insert_hooks' do
@@ -273,8 +293,24 @@ RSpec.describe Yaks::Runner do
     end
   end
 
-  it 'should memoize' do
-    expect(runner.formatter).to be runner.formatter
+  describe '#hooks' do
+    before do
+      Yaks::Config::DSL.new(config) do
+        after(:map, :this_happens_after_map)
+      end
+    end
+
+    it 'should contain the hooks from the config' do
+      expect(runner.hooks).to eql [[:after, :map, :this_happens_after_map, nil]]
+    end
+
+    context 'with extra blocks in the options' do
+      let(:options) { { hooks: [[:foo]] } }
+
+      it 'should combine the hooks' do
+        expect(runner.hooks).to eql [[:after, :map, :this_happens_after_map, nil], [:foo]]
+      end
+    end
   end
 
 end

data/spec/unit/yaks/util_spec.rb

@@ -27,6 +27,14 @@ RSpec.describe Yaks::Util do
     it 'should work with method objects' do
       expect(Resolve('foo'.method(:upcase))).to eql 'FOO'
     end
+
+    it 'should resolve a symbol to itself' do
+      expect(Resolve(:foo)).to eql :foo
+    end
+
+    it 'should resolve custom callables by calling to_proc first' do
+      expect(Resolve(fake(to_proc: ->{->{3}}))).to eql 3
+    end
   end
 
   describe '#camelize' do
@@ -46,4 +54,38 @@ RSpec.describe Yaks::Util do
       expect(slice_hash({a: 1, b:2, c:3}, :a, :c, :d)).to eql(a: 1, c:3)
     end
   end
+
+end
+
+RSpec.describe Yaks::Util::Deprecated do
+  let(:klass) {
+    Class.new do
+      extend Yaks::Util::Deprecated
+
+      def self.to_s ; 'FancyClass' end
+      def foo(x); "#{x}yz#{yield}" end
+      deprecated_alias :bar, :foo
+    end
+  }
+
+  def capture_stderr
+    stderr, $stderr = $stderr, StringIO.new
+    yield
+    io, $stderr = $stderr, stderr
+    io.string
+  end
+
+  it 'should set up an alias' do
+    capture_stderr do
+      expect(klass.new.bar('x') { 'a' }).to eql 'xyza'
+    end
+  end
+
+  it 'should output a warning' do
+    expect(
+      capture_stderr do
+        expect(klass.new.bar('x') {'a'}).to eql 'xyza'
+      end
+    ).to match /WARNING: FancyClass#bar is deprecated, use `foo'\. at \/.*util_spec.rb:#{__LINE__ - 2}:in/
+  end
 end