yaks-html 0.6.0.alpha → 0.6.0.alpha.1

data/yaks/spec/unit/yaks/null_resource_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::NullResource do
-  subject(:null_resource) { described_class.new }
-
-  its(:attributes)     { should eq Hash[] }
-  its(:links)          { should eq [] }
-  its(:subresources)   { should eq Hash[] }
-  its(:collection?)    { should be false }
-  its(:null_resource?) { should be true }
-
-  it { should respond_to :[] }
-
-  its(:type) { should be_nil }
-
-  describe '#each' do
-    its(:each)         { should be_a Enumerator }
-
-    it 'should not yield anything' do
-      null_resource.each { fail }
-    end
-  end
-
-  it 'should contain nothing' do
-    expect( null_resource[:key] ).to be_nil
-  end
-
-  context 'when a collection' do
-    subject(:null_resource) { described_class.new( collection: true ) }
-    its(:collection?) { should be true }
-  end
-end

data/yaks/spec/unit/yaks/primitivize_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Primitivize do
-  subject(:primitivizer) { described_class.create }
-
-  describe '.create' do
-    it 'should map String, true, false, nil, numbers to themselves' do
-      [
-        'hello',
-        true,
-        false,
-        nil,
-        100,
-        99.99,
-        -95.33333
-      ].each do |object|
-        expect(primitivizer.call(object)).to eql object
-      end
-    end
-
-    it 'should stringify symbols' do
-      expect(primitivizer.call(:foo)).to eql 'foo'
-    end
-
-    it 'should recursively handle hashes' do
-      expect(primitivizer.call(
-          :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'] )
-    end
-  end
-
-  describe '#call' do
-    require 'ostruct'
-
-    let(:funny_object) {
-      OpenStruct.new('a' => 'b')
-    }
-
-    it 'should raise an error when passed an unkown type' do
-      def funny_object.inspect
-        "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"
-    end
-
-    context 'with custom mapping' do
-      require 'matrix'
-
-      let(:primitivizer) do
-        described_class.new.tap do |p|
-          p.map Vector do |vec|
-            vec.map do |i|
-              call(i)
-            end.to_a
-          end
-
-          p.map Symbol do |sym|
-            sym.to_s.length
-          end
-        end
-      end
-
-      it 'should evaluate in the context of primitivize' do
-        expect( primitivizer.call( Vector[:foo, :baxxx, :bazz] ) ).to eql( [3, 5, 4] )
-      end
-    end
-
-
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Resource::Link do
-  subject(:link) { described_class.new(rel, uri, options) }
-  let(:rel)      { :foo_rel }
-  let(:uri)      { 'http://api.example.org/rel/foo' }
-  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 }
-
-  context 'with explicit templated option' do
-    let(:options) { super().merge(templated: true) }
-    its(:templated?) { should be true }
-  end
-end

data/yaks/spec/unit/yaks/resource_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-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(:profile, '/foo/bar/profile', {}),
-          Yaks::Resource::Link.new(:self, '/foo/bar', {})
-        ]
-      }
-    }
-    its(:links) { should eql [
-        Yaks::Resource::Link.new(:profile, '/foo/bar/profile', {}),
-        Yaks::Resource::Link.new(:self, '/foo/bar', {})
-      ]
-    }
-
-    its(:self_link) { should eql Yaks::Resource::Link.new(:self, '/foo/bar', {}) }
-  end
-
-  context 'with subresources' do
-    let(:init_opts) { { subresources: { 'comments' => [Yaks::Resource.new(type: 'comment')] } } }
-    its(:subresources) { should eql 'comments' => [Yaks::Resource.new(type: 'comment')]  }
-
-    it 'should return an enumerator for #each' do
-      expect(resource.each.with_index.to_a).to eq  [ [resource, 0] ]
-    end
-  end
-
-
-  it 'should act as a collection of one' do
-    expect(resource.each.to_a).to eql [resource]
-  end
-
-  describe 'persistent updates' do
-    let(:resource) {
-      Yaks::Resource.new(
-        attributes: {x: :y},
-        links: [:one],
-        subresources: {foo_rel: :subres}
-      )
-    }
-
-    it 'should do updates without modifying the original' do
-      expect(
-        resource
-          .update_attributes(foo: :bar)
-          .add_link(:a_link)
-          .add_subresource(:rel, :a_subresource)
-          .update_attributes(foo: :baz)
-      ).to eq Yaks::Resource.new(
-        attributes: {x: :y, foo: :baz},
-        links: [:one, :a_link],
-        subresources: {foo_rel: :subres, rel: :a_subresource}
-      )
-
-      expect(resource).to eq Yaks::Resource.new(
-        attributes: {x: :y},
-        links: [:one],
-        subresources: {foo_rel: :subres}
-      )
-    end
-  end
-
-  describe '#self_link' do
-    let(:init_opts) {
-      { links:
-        [
-          Yaks::Resource::Link.new(:self, 'foo', {}),
-          Yaks::Resource::Link.new(:self, 'bar', {}),
-          Yaks::Resource::Link.new(:profile, 'baz', {})
-        ]
-      }
-    }
-    it 'should return the last self link' do
-      expect(resource.self_link).to eql Yaks::Resource::Link.new(:self, 'bar', {})
-    end
-  end
-end

data/yaks/spec/unit/yaks/runner_spec.rb

@@ -1,260 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Runner do
-  subject(:runner) {
-    described_class.new(object: object, config: config, options: options)
-  }
-
-  let(:object) { Object.new }
-  let(:config) { Yaks::Config.new }
-  let(:options) { {} }
-
-  describe '#call' do
-    let(:runner) {
-      Class.new(described_class) do
-        def steps
-          [ [:step1, ->(x) { x + 35     }],
-            [:step2, ->(x) { "#{x} #{x}"}] ]
-        end
-      end.new(object: object, config: config, options: options)
-    }
-
-    let(:object) { 7 }
-
-    it 'should go through all the steps' do
-      expect(runner.call).to eql "42 42"
-    end
-  end
-
-  describe '#context' do
-    it 'should contain the policy, env, and an empty mapper_stack' do
-      expect(runner.context).to eql(policy: config.policy, env: {}, mapper_stack: [])
-    end
-
-    context 'with an item mapper' do
-      let(:options) { { item_mapper: :foo } }
-
-      it 'should contain the item_mapper' do
-        expect(runner.context).to eql(policy: config.policy, env: {}, mapper_stack: [], item_mapper: :foo)
-      end
-    end
-  end
-
-  describe '#format_class' do
-    let(:config) do
-      Yaks::Config.new do
-        default_format :collection_json
-      end
-    end
-
-    let(:rack_env) {
-      { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json' }
-    }
-
-    it 'should fall back to the default when no HTTP_ACCEPT key is present' do
-      runner = described_class.new(object: nil, config: config, options: { env: {} })
-      expect(runner.format_class).to equal Yaks::Format::CollectionJson
-    end
-
-    it 'should detect format based on accept header' do
-      rack_env = { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json' }
-      runner = described_class.new(object: nil, config: config, options: { env: rack_env })
-      expect(runner.format_class).to equal Yaks::Format::JsonAPI
-    end
-
-    it 'should know to pick the best match' do
-      rack_env = { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json;q=0.7' }
-      runner = described_class.new(object: nil, config: config, options: { env: rack_env })
-      expect(runner.format_class).to equal Yaks::Format::Hal
-    end
-
-    it 'should pick the one given in the options if no header matches' do
-      rack_env = { 'HTTP_ACCEPT' => 'text/html, application/json' }
-      runner = described_class.new(object: nil, config: config, options: { format: :hal, env: rack_env })
-      expect(runner.format_class).to equal Yaks::Format::Hal
-    end
-
-    it 'should fall back to the default when no mime type is recognized' do
-      rack_env = { 'HTTP_ACCEPT' => 'text/html, application/json' }
-      runner = described_class.new(object: nil, config: config, options: { env: rack_env })
-      expect(runner.format_class).to equal Yaks::Format::CollectionJson
-    end
-  end
-
-  describe '#format_name' do
-    context 'with no format specified' do
-      it 'should default to :hal' do
-        expect(runner.format_name).to eql :hal
-      end
-    end
-
-    context 'with a default format specified' do
-      let(:config) { Yaks::Config.new { default_format :collection_json } }
-
-      context 'with a format in the options' do
-        let(:options) { { format: :json_api } }
-        it 'should give preference to that one' do
-          expect(runner.format_name).to eql :json_api
-        end
-      end
-
-      context 'without a format in the options' do
-        it 'should take the specified default' do
-          expect(runner.format_name).to eql :collection_json
-        end
-      end
-    end
-  end
-
-  describe '#formatter' do
-    let(:config) {
-      Yaks::Config.new do
-        default_format :json_api
-        format_options :json_api, {format_option: [:foo]}
-      end
-    }
-
-    let(:formatter) { runner.formatter }
-
-    it 'should create a formatter based on class and options' do
-      expect(formatter).to be_a Yaks::Format::JsonAPI
-      expect(formatter.send(:options)).to eql(format_option: [:foo])
-    end
-  end
-
-  describe '#insert_hooks' do
-    let(:options) { { mapper: Yaks::Mapper } }
-      let(:config) { Yaks::Config.new(&hooks) }
-
-    describe 'before' do
-      let(:hooks) { proc { before(:map) { :before_map_impl } } }
-
-      it 'should insert a hook before the step' do
-        expect(runner.steps.map(&:first)).to eql [
-          :before_map, :map, :format, :primitivize, :serialize
-        ]
-        expect(runner.steps.assoc(:before_map).last.call).to be :before_map_impl
-      end
-    end
-
-    describe 'after' do
-      let(:hooks) { proc { after(:format) { :after_format_impl } } }
-
-      it 'should insert a hook after the step' do
-        expect(runner.steps.map(&:first)).to eql [
-          :map, :format, :after_format, :primitivize, :serialize
-        ]
-        expect(runner.steps.assoc(:after_format).last.call).to be :after_format_impl
-      end
-    end
-
-    describe 'around' do
-      let(:hooks) { proc { around(:format) { :around_format_impl } } }
-
-      it 'should insert a hook around the step' do
-        expect(runner.steps.map(&:first)).to eql [
-          :map, :format, :primitivize, :serialize
-        ]
-        expect(runner.steps.assoc(:format).last.call(nil)).to be :around_format_impl
-      end
-    end
-
-    describe 'around' do
-      let(:hooks) { proc { skip(:serialize) } }
-
-      it 'should insert a hook before the step' do
-        expect(runner.steps.map(&:first)).to eql [
-          :map, :format, :primitivize
-        ]
-      end
-    end
-
-    describe 'multiple hooks' do
-      let(:hooks) {
-        proc {
-          after(:format) { :after_format_impl }
-          skip(:serialize)
-        }
-      }
-
-      it 'should insert the hooks' do
-        expect(runner.steps.map(&:first)).to eql [
-          :map, :format, :after_format, :primitivize
-        ]
-      end
-    end
-  end
-
-  describe '#mapper' do
-    context 'with an explicit mapper in the options' do
-      let(:mapper_class) { Class.new(Yaks::Mapper) }
-      let(:options) { { mapper: mapper_class } }
-
-      it 'should take the mapper from options' do
-        expect(runner.mapper).to be_a mapper_class
-      end
-    end
-
-    context 'without a mapper specified' do
-      let(:object) { Pet.new(id: 7, name: 'fifi', species: 'cat') }
-
-      it 'should infer one from the object to be mapped' do
-        expect(runner.mapper).to be_a PetMapper
-      end
-
-      it 'should pass the context to the mapper' do
-        expect(runner.mapper.context).to be runner.context
-      end
-    end
-  end
-
-  describe '#serializer' do
-    context 'with a serializer configured' do
-      let(:config) {
-        Yaks::Config.new do
-          json_serializer do |input|
-            "serialized #{input}"
-          end
-        end
-      }
-
-      it 'should try to find an explicitly configured serializer' do
-        expect(runner.serializer.call('42')).to eql 'serialized 42'
-      end
-    end
-
-    it 'should fall back to the policy' do
-      expect(runner.serializer.call([1,2,3])).to eql "[\n  1,\n  2,\n  3\n]"
-    end
-  end
-
-  describe '#steps' do
-    let(:options) {{ mapper: Yaks::Mapper }}
-
-    it 'should have all four steps' do
-      expect(runner.steps).to eql [
-        [ :map, runner.mapper ],
-        [ :format, runner.formatter ],
-        [ :primitivize, runner.primitivizer],
-        [ :serialize, runner.serializer ]
-      ]
-    end
-
-    context 'with hooks' do
-      let(:config) {
-        Yaks::Config.new do
-          after(:format, :my_hook) { :foo }
-        end
-      }
-
-      it 'should insert hooks' do
-        expect(runner.steps.map(&:first)).to eql [:map, :format, :my_hook, :primitivize, :serialize]
-      end
-    end
-  end
-
-  it 'should memoize' do
-    expect(runner.formatter).to be runner.formatter
-  end
-
-end