yaks 0.9.0 → 0.10.0

data/lib/yaks/format.rb

@@ -26,7 +26,11 @@ module Yaks
       @env = env
       serialize_resource(resource)
     end
-    alias serialize call
+    alias_method :serialize, :call
+
+    # @abstract
+    def serialize_resource(_resource)
+    end
 
     class << self
       extend Util::Deprecated
@@ -76,8 +80,8 @@ module Yaks
       end
 
       def media_types
-        Format.all.each_with_object({}) do
-          |format, memo| memo[format.format_name] = format.media_type
+        Format.all.each_with_object({}) do |format, memo|
+          memo[format.format_name] = format.media_type
         end
       end
       deprecated_alias :mime_types, :media_types

data/lib/yaks/format/collection_json.rb

@@ -29,7 +29,7 @@ module Yaks
               value: value
             }
           end
-          result = { data: attrs }
+          result = {data: attrs}
           result[:href] = item.self_link.uri if item.self_link
           item.links.each do |link|
             next if link.rel.equal? :self
@@ -43,7 +43,7 @@ module Yaks
 
       def serialize_links(resource)
         resource.links.each_with_object([]) do |link, result|
-          result << { href: link.uri, rel: link.rel }
+          result << {href: link.uri, rel: link.rel}
         end
       end
 
@@ -51,12 +51,12 @@ module Yaks
         resource.forms.each_with_object([]) do |form, result|
           next unless form_is_query? form
 
-          result << { rel: form.name, href: form.action }
+          result << {rel: form.name, href: form.action}
           result.last[:prompt] = form.title if form.title
 
           form.fields_flat.each do |field|
             result.last[:data] = [] unless result.last.key? :data
-            result.last[:data] << { name: field.name, value: nil.to_s }
+            result.last[:data] << {name: field.name, value: nil.to_s}
             result.last[:data].last[:prompt] = field.label if field.label
           end
         end

data/lib/yaks/format/hal.rb

@@ -87,7 +87,7 @@ module Yaks
       def serialize_embedded(subresources)
         subresources.each_with_object({}) do |sub, memo|
           memo[sub.rels.first] = if sub.collection?
-                                   sub.map( &method(:serialize_resource) )
+                                   sub.map(&method(:serialize_resource))
                                  elsif sub.null_resource?
                                    nil
                                  else
@@ -95,7 +95,6 @@ module Yaks
                                  end
         end
       end
-
     end
   end
 end

data/lib/yaks/format/halo.rb

@@ -33,11 +33,9 @@ module Yaks
             fields: field.fields.map(&method(:serialize_form_field))
           }
         else
-          field.to_h_compact.each_with_object({}) do |(attr,value), hsh|
+          field.to_h_compact.each_with_object({}) do |(attr, value), hsh|
             if attr == :options # <option>s of a <select>
-              if !value.empty?
-                hsh[:options] = value.map(&:to_h_compact)
-              end
+              hsh[:options] = value.map(&:to_h_compact) unless value.empty?
             else
               hsh[attr] = value
             end

data/lib/yaks/format/json_api.rb

@@ -8,76 +8,95 @@ module Yaks
       # @param [Yaks::Resource] resource
       # @return [Hash]
       def call(resource, _env = nil)
-        main_collection = resource.seq.map(&method(:serialize_resource))
+        output = {}
+        if resource.collection?
+          output[:data]  = resource.map(&method(:serialize_resource))
+          output[:links] = serialize_links(resource.links) if resource.links.any?
+        else
+          output[:data] = serialize_resource(resource)
+        end
+        included = resource.seq.each_with_object([]) do |res, array|
+          serialize_included_subresources(res.subresources, array)
+        end
+        output[:included] = included if included.any?
+        output[:meta] = resource[:meta] if resource[:meta]
+
+        output
+      end
 
-        { data: main_collection }.tap do |serialized|
-          linked = resource.seq.each_with_object([]) do |res, array|
-            serialize_linked_subresources(res.subresources, array)
-          end
-          serialized.merge!(linked: linked) unless linked.empty?
+      # @param [Yaks::Resource] resource
+      # @return [Hash]
+      def serialize_links(links)
+        links.each_with_object({}) do |link, hash|
+          hash[link.rel] = link.uri
         end
       end
 
       # @param [Yaks::Resource] resource
       # @return [Hash]
       def serialize_resource(resource)
-        result = {type: pluralize(resource.type).to_sym}.merge(resource.attributes)
+        result = {}
+        result[:type] = pluralize(resource.type)
+        result[:id]   = resource[:id].to_s if resource[:id]
 
-        links = serialize_links(resource.subresources)
-        result[:links] = links unless links.empty?
+        attributes = resource.attributes.reject { |k| k.equal?(:id) }
+        result[:attributes] = attributes if attributes.any?
 
-        if resource.self_link && !result.key?(:href)
-          result[:href]  = resource.self_link.uri
-        end
+        result[:links] = {}
+        result[:links].update(serialize_subresource_links(resource.subresources))
+        result[:links].update(serialize_links(resource.links))
+        result.delete(:links) if result[:links].empty?
 
         result
       end
 
       # @param [Yaks::Resource] subresource
       # @return [Hash]
-      def serialize_links(subresources)
+      def serialize_subresource_links(subresources)
         subresources.each_with_object({}) do |resource, hsh|
           next if resource.null_resource?
-          hsh[resource.type] = serialize_link(resource)
+          hsh[resource.rels.first.sub(/^rel:/, '')] = serialize_subresource_link(resource)
         end
       end
 
       # @param [Yaks::Resource] resource
       # @return [Array, String]
-      def serialize_link(resource)
+      def serialize_subresource_link(resource)
         if resource.collection?
-          {type: resource.type, ids: resource.map(&send_with_args(:[], :id))}
+          {linkage: resource.map{|r| {type: pluralize(r.type), id: r[:id].to_s} }}
         else
-          {type: pluralize(resource.type), id: resource[:id]}
+          {linkage: {type: pluralize(resource.type), id: resource[:id].to_s}}
         end
       end
 
       # @param [Hash] subresources
       # @param [Array] array
       # @return [Array]
-      def serialize_linked_subresources(subresources, array)
+      def serialize_included_subresources(subresources, array)
         subresources.each do |resources|
-          serialize_linked_resources(resources, array)
+          serialize_included_resources(resources, array)
         end
       end
 
       # @param [Array] resources
-      # @param [Array] linked
+      # @param [Array] included
       # @return [Array]
-      def serialize_linked_resources(subresource, linked)
-        subresource.seq.each_with_object(linked) do |resource, memo|
+      def serialize_included_resources(subresource, included)
+        subresource.seq.each_with_object(included) do |resource, memo|
           serialize_subresource(resource, memo)
         end
       end
 
-      # {shows => [{id: 3, name: 'foo'}]}
+      # {shows => [{id: '3', name: 'foo'}]}
       #
       # @param [Yaks::Resource] resource
-      # @param [Hash] linked
+      # @param [Hash] included
       # @return [Hash]
-      def serialize_subresource(resource, linked)
-        linked << serialize_resource(resource)
-        serialize_linked_subresources(resource.subresources, linked)
+      def serialize_subresource(resource, included)
+        included << serialize_resource(resource) unless included.any? do |item|
+          item[:id].eql?(resource[:id].to_s) && item[:type].eql?(pluralize(resource.type))
+        end
+        serialize_included_subresources(resource.subresources, included)
       end
 
       def inverse

data/lib/yaks/html5_forms.rb

@@ -4,7 +4,6 @@ module Yaks
   #
   # Does not aim to be complete, does aim to be a strict subset.
   module HTML5Forms
-
     INPUT_TYPES = [
       :checkbox,
       :color,
@@ -53,6 +52,5 @@ module Yaks
       checked: false,
       disabled: false
     }
-
   end
 end

data/lib/yaks/mapper.rb

@@ -4,7 +4,7 @@ module Yaks
 
     def_set :type
 
-    def_forward :attributes => :add_attributes
+    def_forward attributes: :add_attributes
     def_forward :append_to
 
     def_add :link,      create: Link,      append_to: :links
@@ -45,7 +45,7 @@ module Yaks
       self.class.mapper_name(policy)
     end
 
-    def call(object, env = {})
+    def call(object, _env = nil)
       @object = object
 
       return NullResource.new if object.nil?
@@ -55,20 +55,20 @@ module Yaks
         :map_subresources,
         :map_forms
       ].inject(Resource.new(type: mapper_name)) do |resource, method|
-        send(method, resource)
+        __send__(method, resource)
       end
     end
 
     def load_attribute(name)
       respond_to?(name) ? public_send(name) : object.public_send(name)
     end
-    alias load_association load_attribute
+    alias_method :load_association, :load_attribute
 
     def expand_value(value)
       Resolve(value, self)
     end
 
-    def expand_uri(uri, expand)
+    def expand_uri(uri, expand = true)
       return if uri.nil?
       return Resolve(uri, self) if uri.respond_to?(:to_proc)
 

data/lib/yaks/mapper/association.rb

@@ -1,7 +1,7 @@
 module Yaks
   class Mapper
     class Association
-      include Attributes.new(
+      include Attribs.new(
                 name:        Undefined,
                 item_mapper: Undefined,
                 rel:         Undefined,
@@ -9,7 +9,8 @@ module Yaks
                 link_if:     Undefined,
                 if:          Undefined
               ),
-              Util
+              Util,
+              AbstractType
 
       def self.create(name, options = {})
         if options.key?(:mapper)
@@ -22,7 +23,7 @@ module Yaks
       end
 
       def add_to_resource(resource, parent_mapper, context)
-        return resource if self.if != Undefined && !parent_mapper.expand_value(self.if)
+        return resource unless parent_mapper.expand_value(self.if)
         AssociationMapper.new(parent_mapper, self, context).call(resource)
       end
 
@@ -35,16 +36,15 @@ module Yaks
         policy.derive_rel_from_association(self)
       end
 
-      # @abstract
-      def map_resource(_object, _context)
-      end
+      # @param object
+      # @param context
+      abstract_method :map_resource
 
       # support for HasOne and HasMany
       def resolve_association_mapper(policy)
         return item_mapper unless item_mapper.equal?(Undefined)
         policy.derive_mapper_from_association(self)
       end
-
     end
   end
 end

data/lib/yaks/mapper/association_mapper.rb

@@ -24,6 +24,8 @@ module Yaks
         end
       end
 
+      private
+
       def add_link(resource)
         Link.create(rel, association.href)
           .add_to_resource(resource, parent_mapper, nil)

data/lib/yaks/mapper/attribute.rb

@@ -1,14 +1,20 @@
 module Yaks
   class Mapper
     class Attribute
-      include Attributes.new(:name)
+      include Attribs.new(:name, :block)
+      include Util
 
-      def initialize(name)
-        super(name: name)
+      def self.create(name, _options = nil, &block)
+        new(name: name, block: block)
       end
 
       def add_to_resource(resource, mapper, _context)
-        resource.merge_attributes(name => mapper.load_attribute(name))
+        if block
+          attribute = Resolve(block, mapper)
+        else
+          attribute = mapper.load_attribute(name)
+        end
+        resource.merge_attributes(name => attribute)
       end
     end
   end

data/lib/yaks/mapper/config.rb

@@ -1,12 +1,12 @@
 module Yaks
   class Mapper
     class Config
-      include Attributes.new(
+      include Attribs.new(
                 type: nil, attributes: [], links: [], associations: [], forms: []
               )
 
       def add_attributes(*attrs)
-        append_to(:attributes, *attrs.map(&Attribute.method(:new)))
+        append_to(:attributes, *attrs.map(&Attribute.method(:create)))
       end
     end
   end

data/lib/yaks/mapper/form.rb

@@ -3,24 +3,19 @@ module Yaks
     class Form
       extend Forwardable, Util
 
-
       def_delegators :config, :name, :action, :title, :method,
                               :media_type, :fields, :dynamic_blocks
 
       def self.create(*args, &block)
         args, options = extract_options(args)
-
-        if args.first.is_a? Symbol
-          options[:name] = args.first
-        end
-
+        options[:name] = args.first if args.first
         new(config: Config.build(options, &block))
       end
 
       ############################################################
       # instance
 
-      include Attributes.new(:config)
+      include Attribs.new(:config)
 
       def add_to_resource(resource, mapper, _context)
         return resource if config.if && !mapper.expand_value(config.if)
@@ -30,16 +25,15 @@ module Yaks
       def to_resource_form(mapper)
         attrs = {
           fields: config.to_resource_fields(mapper),
-          action: mapper.expand_uri(config.action, true)
+          action: mapper.expand_uri(action)
         }
 
         [:name, :title, :method, :media_type].each do |attr|
-          attrs[attr] = mapper.expand_value(config.public_send(attr))
+          attrs[attr] = mapper.expand_value(public_send(attr))
         end
 
         Resource::Form.new(attrs)
       end
-
     end
   end
 end

data/lib/yaks/mapper/form/config.rb

@@ -2,30 +2,29 @@ module Yaks
   class Mapper
     class Form
       class Config
-        include Attributes.new(
+        include Attribs.new(
                   name: nil,
                   action: nil,
                   title: nil,
                   method: nil,
                   media_type: nil,
-                  fields: [],
+                  fields: [].freeze,
                   if: nil
                 )
 
-        def self.builder
-          @builder ||= Builder.new(self) do
-            def_set :action, :title, :method, :media_type
-            def_add :field, create: Field::Builder, append_to: :fields
-            def_add :fieldset, create: Fieldset, append_to: :fields
-            HTML5Forms::INPUT_TYPES.each do |type|
-              def_add(type,
-                      create: Field::Builder,
-                      append_to: :fields,
-                      defaults: { type: type })
-            end
-            def_add :dynamic, create: DynamicField, append_to: :fields
-            def_forward :condition
+        Builder = Yaks::Builder.new(self) do
+          def_set :action, :title, :method, :media_type
+          def_add :field, create: Field::Builder, append_to: :fields
+          def_add :fieldset, create: Fieldset, append_to: :fields
+          HTML5Forms::INPUT_TYPES.each do |type|
+            def_add(type,
+                    create: Field::Builder,
+                    append_to: :fields,
+                    defaults: {type: type})
           end
+          def_add :legend, create: Legend, append_to: :fields
+          def_add :dynamic, create: DynamicField, append_to: :fields
+          def_forward :condition
         end
 
         # Builder expects a `create' method. Alias to constructor
@@ -36,13 +35,13 @@ module Yaks
         # Build up a configuration based on an initial set of
         # attributes, and a configuration block
         def self.build(options = {}, &block)
-          builder.create(options, &block)
+          Builder.create(options, &block)
         end
 
         # Build up a configuration based on a config block. Provide an
         # object to be supplied to the block
         def self.build_with_object(object, &block)
-          builder.build(new, object, &block)
+          Builder.build(new, object, &block)
         end
 
         def condition(prc = nil, &blk)