halogen 0.0.1

data/lib/halogen/embeds/definition.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+#
+module Halogen
+  module Embeds
+    class Definition < Halogen::Definition # :nodoc:
+      # @return [true] if nothing is raised
+      #
+      # @raise [Halogen::InvalidDefinition] if the definition is invalid
+      #
+      def validate
+        super
+
+        return true if procedure
+
+        fail InvalidDefinition, "Embed #{name} must be defined with a proc"
+      end
+    end
+  end
+end

data/lib/halogen/errors.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+#
+module Halogen
+  class InvalidCollection < StandardError; end # :nodoc
+  class InvalidDefinition < StandardError; end # :nodoc
+  class InvalidResource   < StandardError; end # :nodoc
+end

data/lib/halogen/hash_util.rb

@@ -0,0 +1,37 @@
+module Halogen
+  module HashUtil # :nodoc:
+    extend self
+
+    # Transform hash keys into strings if necessary
+    #
+    # @param hash [Hash]
+    #
+    # @return [Hash]
+    #
+    def stringify_keys!(hash)
+      transform_keys!(hash, &:to_s)
+    end
+
+    # Transform hash keys into symbols if necessary
+    #
+    # @param hash [Hash]
+    #
+    # @return [Hash]
+    #
+    def symbolize_keys!(hash)
+      transform_keys!(hash, &:to_sym)
+    end
+
+    # Transform hash keys according to block
+    #
+    # @param hash [Hash]
+    #
+    # @return [Hash]
+    #
+    def transform_keys!(hash)
+      hash.keys.each { |key| hash[yield(key)] = hash.delete(key) }
+
+      hash
+    end
+  end
+end

data/lib/halogen/links.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+#
+module Halogen
+  module Links # :nodoc:
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods # :nodoc:
+      # @return [Halogen::Embeds::Definition]
+      #
+      def link(name, *args, &procedure)
+        definitions.add(Definition.new(name, *args, procedure))
+      end
+    end
+
+    module InstanceMethods # :nodoc:
+      # @return [Hash] the rendered hash with links, if any
+      #
+      def render
+        decorate_render :links, super
+      end
+
+      # @return [Hash] links from definitions
+      #
+      def links
+        render_definitions(Definition.name) do |definition, result|
+          attrs = definition.options.fetch(:attrs, {})
+
+          href = definition.value(self)
+
+          result[definition.name] = attrs.merge(href: href) if href
+        end
+      end
+    end
+  end
+end
+
+require 'halogen/links/definition'

data/lib/halogen/links/definition.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+#
+module Halogen
+  module Links
+    class Definition < Halogen::Definition # :nodoc
+      # Links have special keywords that other definitions don't, so override
+      # the standard initializer to build options from keywords
+      #
+      def initialize(name, *args, procedure)
+        super name, self.class.build_options(args), procedure
+      end
+
+      # @return [true] if nothing is raised
+      #
+      # @raise [Halogen::InvalidDefinition] if the definition is invalid
+      #
+      def validate
+        super
+
+        return true if procedure || options.key?(:value)
+
+        fail InvalidDefinition,
+             'Link requires either procedure or explicit value'
+      end
+
+      class << self
+        # Build hash of options from flexible definition arguments
+        #
+        # @param args [Array] the raw definition arguments
+        #
+        # @return [Hash] standardized hash of options
+        #
+        def build_options(args)
+          {}.tap do |options|
+            options.merge!(args.pop) if args.last.is_a?(Hash)
+
+            options[:attrs] ||= {}
+            options[:attrs].merge!(build_attrs(args))
+          end
+        end
+
+        # @param keywords [Array] array of special keywords
+        #
+        # @raise [Halogen::InvalidDefinition] if a keyword is unrecognized
+        #
+        def build_attrs(keywords)
+          keywords.each_with_object({}) do |keyword, attrs|
+            case keyword
+            when :templated, 'templated'
+              attrs[:templated] = true
+            else
+              fail InvalidDefinition, "Unrecognized link keyword: #{keyword}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/halogen/properties.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+#
+module Halogen
+  module Properties # :nodoc:
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods # :nodoc:
+      # @param name [Symbol, String]
+      # @param options [nil, Hash]
+      #
+      # @return [Halogen::Embeds::Definition]
+      #
+      def property(name, options = {}, &procedure)
+        definitions.add(Definition.new(name, options, procedure))
+      end
+    end
+
+    module InstanceMethods # :nodoc:
+      # @return [Hash] the rendered hash with properties, if any
+      #
+      def render
+        super.merge(properties)
+      end
+
+      # @return [Hash] properties from definitions
+      #
+      def properties
+        render_definitions(Definition.name) do |definition, result|
+          result[definition.name] = definition.value(self)
+        end
+      end
+    end
+  end
+end
+
+require 'halogen/properties/definition'

data/lib/halogen/properties/definition.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+#
+module Halogen
+  module Properties
+    class Definition < Halogen::Definition # :nodoc
+    end
+  end
+end

data/lib/halogen/railtie.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+#
+module Halogen
+  # Provide Rails-specific extensions if loaded in a Rails application
+  #
+  class Railtie < ::Rails::Railtie
+    initializer 'halogen' do |_app|
+      Halogen.config.extensions << ::Rails.application.routes.url_helpers
+    end
+  end
+end

data/lib/halogen/resource.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+#
+module Halogen
+  # Behavior for representers with a single primary resource
+  #
+  module Resource
+    def self.included(base) # :nodoc:
+      if base.included_modules.include?(Collection)
+        fail InvalidResource, "#{base.name} has already defined a collection"
+      end
+
+      base.extend ClassMethods
+
+      base.send :include, InstanceMethods
+
+      base.send :attr_reader, :resource
+
+      base.class.send :attr_accessor, :resource_name
+    end
+
+    module ClassMethods # :nodoc:
+      # @param name [Symbol, String] name of the resource
+      #
+      # @return [Module] self
+      #
+      def define_resource(name)
+        self.resource_name = name.to_s
+
+        alias_method name, :resource
+      end
+
+      # Override standard property definition for resource-based representers
+      #
+      # @param name [Symbol, String] name of the property
+      # @param options [nil, Hash] property options for definition
+      #
+      def property(name, options = {}, &procedure)
+        super.tap do |definition|
+          unless definition.procedure || definition.options.key?(:value)
+            definition.procedure = proc { resource.send(name) }
+          end
+        end
+      end
+    end
+
+    module InstanceMethods # :nodoc:
+      # Override standard initializer to assign primary resource
+      #
+      # @param resource [Object] the primary resource
+      #
+      def initialize(resource, *args)
+        @resource = resource
+
+        super *args
+      end
+    end
+  end
+end

data/lib/halogen/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+#
+module Halogen
+  VERSION = '0.0.1' # :nodoc:
+end

data/spec/halogen/collection_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Collection do
+  let :klass do
+    Class.new do
+      include Halogen
+      include Halogen::Collection
+    end
+  end
+
+  describe '.included' do
+    it 'raises error if base is already a resource' do
+      resource_class = Class.new do
+        include Halogen
+        include Halogen::Resource
+      end
+
+      expect {
+        resource_class.send :include, Halogen::Collection
+      }.to raise_error do |exception|
+        expect(exception).to be_an_instance_of(Halogen::InvalidCollection)
+        expect(exception.message).to match(/has already defined a resource/i)
+      end
+    end
+  end
+
+  describe Halogen::Collection::ClassMethods do
+    describe '#define_collection' do
+      it 'handles string argument' do
+        klass.define_collection 'goats'
+
+        expect(klass.collection_name).to eq('goats')
+      end
+
+      it 'handles symbol argument' do
+        klass.define_collection :goats
+
+        expect(klass.collection_name).to eq('goats')
+      end
+    end
+  end
+
+  describe Halogen::Collection::InstanceMethods do
+    describe '#embed?' do
+      it 'returns true if super is true' do
+        klass.collection_name = 'bar'
+
+        klass.embed(:foo) { klass.new }
+
+        repr = klass.new(embed: { foo: 1 })
+
+        expect(repr.embed?('foo')).to eq(true)
+      end
+
+      it 'returns true if key matches collection name' do
+        klass.collection_name = 'foo'
+
+        klass.embed(:foo) { klass.new }
+
+        repr = klass.new(embed: { foo: 0 })
+
+        expect(repr.embed?('foo')).to eq(true)
+      end
+
+      it 'returns false if no conditions match' do
+        klass.collection_name = 'bar'
+
+        klass.embed(:foo) { klass.new }
+
+        repr = klass.new(embed: { foo: 0 })
+
+        expect(repr.embed?('foo')).to eq(false)
+      end
+    end
+  end
+end

data/spec/halogen/configuration_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Configuration do
+  describe '#extensions' do
+    it 'is empty array by default' do
+      expect(Halogen::Configuration.new.extensions).to eq([])
+    end
+  end
+end

data/spec/halogen/definition_spec.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Halogen::Definition do
+  describe '#initialize' do
+    it 'symbolizes option keys' do
+      definition = Halogen::Definition.new(
+        :name, { 'value' => 'some value', 'foo' => 'bar' }, nil)
+
+      expect(definition.options.keys).to eq([:value, :foo])
+    end
+  end
+
+  describe '#value' do
+    it 'returns value from options if present' do
+      definition = Halogen::Definition.new(:name, { value: 'some value' }, nil)
+
+      expect(definition.value(nil)).to eq('some value')
+    end
+
+    it 'evaluates procedure if value from options is missing' do
+      definition = Halogen::Definition.new(:name, {}, proc { size })
+
+      expect(definition.value('foo')).to eq(3)
+    end
+  end
+
+  describe '#enabled?' do
+    it 'is true if definition is not guarded' do
+      definition = Halogen::Definition.new(:name, {}, nil)
+
+      expect(definition.enabled?(nil)).to eq(true)
+    end
+
+    describe 'when guard is a proc' do
+      let :definition do
+        Halogen::Definition.new(:name, { if: proc { empty? } }, nil)
+      end
+
+      it 'is true if condition passes' do
+        expect(definition.enabled?('')).to eq(true)
+      end
+
+      it 'is false if condition fails' do
+        expect(definition.enabled?('foo')).to eq(false)
+      end
+    end
+
+    describe 'when guard is a method name' do
+      let :definition do
+        Halogen::Definition.new(:name, { if: :empty? }, nil)
+      end
+
+      it 'is true if condition passes' do
+        expect(definition.enabled?('')).to eq(true)
+      end
+
+      it 'is false if condition fails' do
+        expect(definition.enabled?('foo')).to eq(false)
+      end
+    end
+
+    describe 'when guard is truthy' do
+      it 'is true if condition passes' do
+        definition = Halogen::Definition.new(:name, { if: true }, nil)
+
+        expect(definition.enabled?(nil)).to eq(true)
+      end
+
+      it 'is false if condition fails' do
+        definition = Halogen::Definition.new(:name, { if: false }, nil)
+
+        expect(definition.enabled?(nil)).to eq(false)
+      end
+    end
+
+    describe 'when guard is negated' do
+      let :definition do
+        Halogen::Definition.new(:name, { unless: proc { empty? } }, nil)
+      end
+
+      it 'is false if condition passes' do
+        expect(definition.enabled?('')).to eq(false)
+      end
+    end
+  end
+
+  describe '#validate' do
+    it 'returns true for valid definition' do
+      definition = Halogen::Definition.new(:name, { value: 'value' }, nil)
+
+      expect(definition.validate).to eq(true)
+    end
+
+    it 'raises error for invalid definition' do
+      definition = Halogen::Definition.new(
+        :name, { value: 'value' }, proc { 'value' })
+
+      expect {
+        definition.validate
+      }.to raise_error(Halogen::InvalidDefinition) do |exception|
+        expect(exception.message).to(
+          eq('Cannot specify both value and procedure for name'))
+      end
+    end
+  end
+end