halogen 0.0.1

data/spec/halogen/definitions_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Definitions do
+  let :definitions do
+    Halogen::Definitions.new
+  end
+
+  let :definition do
+    Halogen::Definition.new(:name, {}, nil)
+  end
+
+  describe '#add' do
+    it 'validates and adds definition' do
+      expect(definitions.keys).to eq([])
+
+      definitions.add(definition)
+
+      expect(definitions.keys).to eq(['Halogen::Definition'])
+      expect(definitions['Halogen::Definition']).to eq([definition])
+    end
+  end
+end

data/spec/halogen/embeds/definition_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Embeds::Definition do
+  describe '#validate' do
+    it 'returns true with procedure' do
+      result = Halogen::Embeds::Definition.new(:name, {}, proc {}).validate
+
+      expect(result).to eq(true)
+    end
+
+    it 'raises exception without procedure' do
+      expect {
+        Halogen::Embeds::Definition.new(:name, {}, nil).validate
+      }.to raise_error do |exception|
+        expect(exception).to be_an_instance_of(Halogen::InvalidDefinition)
+        expect(exception.message).to(
+          eq('Embed name must be defined with a proc'))
+      end
+    end
+  end
+end

data/spec/halogen/embeds_spec.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Embeds do
+  let :klass do
+    Class.new do
+      include Halogen
+      include Halogen::Embeds
+    end
+  end
+
+  describe Halogen::Embeds::ClassMethods do
+    it 'adds simple embed definition' do
+      expect(klass.definitions).to receive(:add)
+
+      klass.embed(:foo, {}) { 'bar' }
+    end
+  end
+
+  describe Halogen::Embeds::InstanceMethods do
+    describe '#embedded' do
+      describe 'when no embeds are defined' do
+        it 'returns empty hash when no embeds are requested' do
+          representer = klass.new
+
+          expect(representer.embedded).to eq({})
+        end
+
+        it 'returns empty hash when embeds are requested' do
+          representer = klass.new(embed: { foo: true })
+
+          expect(representer.embedded).to eq({})
+        end
+      end
+
+      describe 'when embeds are defined' do
+        before :each do
+          klass.embed(:just_nil, {}) { nil }
+          klass.embed(:non_repr, {}) { 'some object' }
+          klass.embed(:child_repr, {}) { child }
+
+          klass.send(:define_method, :child) do
+            # just build another representer instance to be rendered
+            Class.new { include Halogen }.new
+          end
+        end
+
+        it 'returns empty hash when no embeds are requested' do
+          representer = klass.new(embed: {})
+
+          expect(representer.embedded).to eq({})
+        end
+
+        it 'builds embedded resources as expected' do
+          embed_opts = { just_nil: true, non_repr: true, child_repr: true }
+
+          representer = klass.new(embed: embed_opts)
+
+          expect(representer.embedded).to eq(child_repr: {})
+        end
+      end
+    end
+
+    describe '#embedded_child' do
+      let :representer do
+        klass.new
+      end
+
+      let :child_class do
+        Class.new do
+          include Halogen
+
+          property(:foo) { 'bar' }
+        end
+      end
+
+      let :child do
+        child_class.new
+      end
+
+      it 'returns nil if value is falsey' do
+        [nil, false, 0].each do |value|
+          expect(representer.embedded_child(:foo, value)).to be_nil
+        end
+      end
+
+      describe 'when value is an array' do
+        it 'renders children' do
+          array = [child, nil, 0, child, 1]
+
+          result = representer.embedded_child(:embed_key, array)
+
+          expect(result).to eq([{ foo: 'bar' }, { foo: 'bar' }])
+        end
+      end
+
+      describe 'when value is a representer' do
+        it 'renders child' do
+          result = representer.embedded_child(:embed_key, child)
+
+          expect(result).to eq(foo: 'bar')
+        end
+      end
+    end
+
+    describe '#child_embed_opts' do
+      it 'returns empty options for unknown key' do
+        representer = klass.new
+
+        opts = representer.send(:child_embed_opts, :unknown_key)
+
+        expect(opts).to eq({})
+      end
+
+      it 'returns empty options for known key with no child options' do
+        representer = klass.new(embed: { requested_key: 1 })
+
+        opts = representer.send(:child_embed_opts, 'requested_key')
+
+        expect(opts).to eq({})
+      end
+
+      it 'returns child options for known key with child options' do
+        representer = klass.new(embed: { requested_key: { child_key: 0 } })
+
+        opts = representer.send(:child_embed_opts, 'requested_key')
+
+        expect(opts).to eq(child_key: 0)
+      end
+
+      it 'returns deeply nested child options' do
+        representer = klass.new(
+          embed: {
+            requested_key: {
+              child_key: { grandchild_key: { great_grandchild_key: 1 } }
+            }
+          }
+        )
+
+        opts = representer.send(:child_embed_opts, 'requested_key')
+
+        expect(opts).to eq(
+          child_key: { grandchild_key: { great_grandchild_key: 1 } })
+      end
+    end
+
+    describe '#render_child' do
+      let :representer do
+        klass.new
+      end
+
+      it 'returns nil if child is not a representer' do
+        [nil, 1, ''].each do |child|
+          expect(representer.render_child(child, {})).to be_nil
+        end
+      end
+
+      it 'renders child representer with correct parent and options' do
+        child = Class.new do
+          include Halogen
+
+          property(:verify_parent) { parent.object_id }
+          property(:verify_opts)   { options[:embed] }
+        end.new
+
+        result = representer.render_child(child, foo: 'bar')
+
+        expect(result).to eq(
+          verify_parent: representer.object_id,
+          verify_opts: { foo: 'bar' })
+      end
+    end
+
+    describe '#embed_options' do
+      it 'stringifies top level keys' do
+        representer = klass.new(embed: { some: { options: 1 } })
+
+        expect(representer.embed_options).to eq('some' => { options: 1 })
+      end
+    end
+
+    describe '#embed?' do
+      it 'is true for expected values' do
+        [1, 2, true, '1', '2', 'true', 'yes'].each do |value|
+          representer = klass.new(embed: { foo: value })
+
+          expect(representer.embed?('foo')).to eq(true)
+        end
+      end
+
+      it 'is false for expected values' do
+        [0, false, '0', 'false'].each do |value|
+          representer = klass.new(embed: { foo: value })
+
+          expect(representer.embed?('foo')).to eq(false)
+        end
+      end
+    end
+  end
+end

data/spec/halogen/links/definition_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Links::Definition do
+  describe '#validate' do
+    it 'returns true with procedure' do
+      result = Halogen::Links::Definition.new(:name, proc {}).validate
+
+      expect(result).to eq(true)
+    end
+
+    it 'raises exception without procedure or explicit value' do
+      expect {
+        Halogen::Links::Definition.new(:name, nil).validate
+      }.to raise_error do |exception|
+        expect(exception).to be_an_instance_of(Halogen::InvalidDefinition)
+        expect(exception.message).to(
+          eq('Link requires either procedure or explicit value'))
+      end
+    end
+  end
+
+  describe '.build_options' do
+    it 'has expected value without options hash' do
+      options = Halogen::Links::Definition.build_options([])
+
+      expect(options).to eq(attrs: {})
+    end
+
+    it 'has expected value with options hash' do
+      options = Halogen::Links::Definition.build_options([foo: 'bar'])
+
+      expect(options).to eq(attrs: {}, foo: 'bar')
+    end
+
+    it 'merges attrs from options' do
+      options = Halogen::Links::Definition.build_options([
+        :templated,
+        attrs: { properties: {} },
+        foo: 'bar'])
+
+      expect(options).to(
+        eq(attrs: { properties: {}, templated: true }, foo: 'bar'))
+    end
+  end
+
+  describe '.build_attrs' do
+    it 'returns empty hash if no keywords are provided' do
+      expect(Halogen::Links::Definition.build_attrs([])).to eq({})
+    end
+
+    it 'builds expected hash with recognized keywords' do
+      attrs = Halogen::Links::Definition.build_attrs([:templated])
+
+      expect(attrs).to eq(templated: true)
+    end
+
+    it 'raises exception if unrecognized keyword is included' do
+      expect {
+        Halogen::Links::Definition.build_attrs([:templated, :wat])
+      }.to raise_error do |exception|
+        expect(exception.class).to eq(Halogen::InvalidDefinition)
+        expect(exception.message).to eq('Unrecognized link keyword: wat')
+      end
+    end
+  end
+end

data/spec/halogen/links_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Links do
+  let :klass do
+    Class.new { include Halogen }
+  end
+
+  describe Halogen::Links::ClassMethods do
+    describe '#link' do
+      describe 'with procedure' do
+        it 'builds simple definition' do
+          link = klass.link(:self) { 'path' }
+
+          expect(link.name).to eq(:self)
+          expect(link.options).to eq(attrs: {})
+          expect(link.procedure.call).to eq('path')
+        end
+
+        it 'builds complex definition' do
+          link = klass.link(
+            :self, :templated, foo: 'foo', attrs: { bar: 'bar' }) { 'path' }
+
+          expect(link.name).to eq(:self)
+          expect(link.options).to eq(
+            foo: 'foo', attrs: { templated: true, bar: 'bar' })
+          expect(link.procedure.call).to eq('path')
+        end
+      end
+
+      describe 'without procedure' do
+        describe 'with explicit value' do
+          it 'builds simple definition' do
+            link = klass.link(:self, value: 'path')
+
+            expect(link.name).to eq(:self)
+            expect(link.options).to eq(attrs: {}, value: 'path')
+            expect(link.procedure).to be_nil
+          end
+
+          it 'builds complex definition' do
+            link = klass.link(
+              :self,
+              :templated,
+              foo: 'foo', attrs: { bar: 'bar' }, value: 'path')
+
+            expect(link.name).to eq(:self)
+            expect(link.options).to eq(
+              foo: 'foo',
+              attrs: { templated: true, bar: 'bar' },
+              value: 'path')
+            expect(link.procedure).to be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/halogen/properties_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Properties do
+  let :klass do
+    Class.new { include Halogen }
+  end
+
+  describe Halogen::Properties::ClassMethods do
+    describe '#property' do
+      it 'defines property 'do
+        expect {
+          klass.property(:foo)
+        }.to change(klass.definitions, :size).by(1)
+      end
+    end
+  end
+
+  describe Halogen::Properties::InstanceMethods do
+    let :repr do
+      klass.new
+    end
+
+    describe '#render' do
+      it 'merges super with rendered properties' do
+        allow(repr).to receive(:properties).and_return(foo: 'bar')
+
+        expect(repr.render).to eq(foo: 'bar')
+      end
+    end
+
+    describe '#properties' do
+      it 'builds properties from definitions' do
+        klass.property(:foo, value: 'bar')
+
+        expect(repr.properties).to eq(foo: 'bar')
+      end
+    end
+  end
+end

data/spec/halogen/resource_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Resource do
+  let :klass do
+    Class.new do
+      include Halogen
+      include Halogen::Resource
+    end
+  end
+
+  describe '.included' do
+    it 'raises error if base is already a collection' do
+      resource_class = Class.new do
+        include Halogen
+        include Halogen::Collection
+      end
+
+      expect {
+        resource_class.send :include, Halogen::Resource
+      }.to raise_error do |exception|
+        expect(exception).to be_an_instance_of(Halogen::InvalidResource)
+        expect(exception.message).to match(/has already defined a collection/i)
+      end
+    end
+  end
+
+  describe Halogen::Resource::ClassMethods do
+    describe '#define_resource' do
+      it 'defines resource' do
+        klass.define_resource :foo
+
+        expect(klass.resource_name).to eq('foo')
+        expect(klass.new(nil).respond_to?(:foo)).to eq(true)
+      end
+    end
+
+    describe '#property' do
+      it 'returns result of super if procedure is present' do
+        original = proc { 'bar' }
+
+        definition = klass.property(:foo, &original)
+
+        expect(definition.procedure).to eq(original)
+      end
+
+      it 'returns result of super if value is present' do
+        definition = klass.property(:foo, value: 'bar')
+
+        expect(definition.procedure).to be_nil
+      end
+
+      it 'assigns procedure without original procedure or value' do
+        definition = klass.property(:foo)
+
+        expect(definition.procedure).to be_an_instance_of(Proc)
+      end
+    end
+  end
+
+  describe Halogen::Resource::InstanceMethods do
+    describe '#initialize' do
+      it 'raises error if resource is not provided' do
+        expect { klass.new }.to raise_error(ArgumentError)
+      end
+
+      it 'assigns resource' do
+        resource = double(:resource)
+
+        repr = klass.new(resource)
+
+        expect(repr.instance_variable_get(:@resource)).to eq(resource)
+      end
+    end
+  end
+end