yaks 0.7.7 → 0.8.0.alpha

data/lib/yaks/mapper/form/field/option.rb

@@ -0,0 +1,20 @@
+module Yaks
+  class Mapper
+    class Form
+      class Field
+        # <option>, as used in a <select>
+        class Option
+          include Attributes.new(:value, :label, selected: false)
+
+          def self.create(value, opts = {})
+            new(opts.merge(value: value))
+          end
+
+          def to_resource
+            to_h #placeholder
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,14 +2,17 @@ module Yaks
   class Mapper
     class Form
       class Field
-        extend Configurable
         include Attributes.new(
                   :name,
                   label: nil,
-                  options: []
+                  options: [].freeze
                 ).add(HTML5Forms::FIELD_OPTIONS)
 
-        Builder = StatefulBuilder.new(self, attributes.names)
+        Builder = Builder.new(self) do
+          def_set :name
+          def_set :label
+          def_add :option, create: Option, append_to: :options
+        end
 
         def self.create(*args)
           attrs = args.last.instance_of?(Hash) ? args.pop : {}
@@ -25,38 +28,22 @@ module Yaks
           Resource::Form::Field.new(
             resource_attributes.each_with_object({}) do |attr, attrs|
               attrs[attr] = mapper.expand_value(public_send(attr))
-            end.merge(options: options.map(&:to_resource))
+            end.merge(options: resource_options)
           )
         end
 
+        def resource_options
+          # make sure all empty options arrays are the same instance,
+          # makes for prettier #pp
+          options.empty? ? options : options.map(&:to_resource)
+        end
+
         # All attributes that can be converted 1-to-1 to
         # Resource::Form::Field
         def resource_attributes
           self.class.attributes.names - [:options]
         end
-
-        # <option>, as used in a <select>
-        class Option
-          include Attributes.new(:value, :label, selected: false)
-
-          def self.create(value, opts = {})
-            new(opts.merge(value: value))
-          end
-
-          def to_resource
-            to_h #placeholder
-          end
-        end
-
-        config_method :option, create: Option, append_to: :options
       end #Field
-
-      config_method :field, create: Field::Builder, append_to: :fields
-
-      HTML5Forms::INPUT_TYPES.each do |type|
-        config_method type, create: Field::Builder, append_to: :fields, defaults: { type: type }
-      end
-
     end # Form
   end # Mapper
 end # Yaks

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

@@ -0,0 +1,43 @@
+module Yaks
+  class Mapper
+    class Form
+      class Fieldset
+        extend Forwardable
+        include Concord.new(:config)
+
+        def_delegators :config, :fields, :dynamic_blocks
+
+        ConfigBuilder = Builder.new(Config) do
+          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_forward :dynamic
+        end
+
+        def self.create(_opts={}, &block)
+          new(ConfigBuilder.build(Config.new, &block))
+        end
+
+        def to_resource(mapper)
+          config = dynamic_blocks.inject(self.config) do |config, block|
+            ConfigBuilder.build(config, mapper.object, &block)
+          end
+
+          resource_fields = resource_fields(config.fields, mapper)
+
+          Resource::Form::Fieldset.new(fields: resource_fields)
+        end
+
+        def resource_fields(fields, mapper)
+          fields.map { |field| field.to_resource(mapper) }
+        end
+      end
+    end
+  end
+end

data/lib/yaks/mapper/form.rb

@@ -1,41 +1,66 @@
 module Yaks
   class Mapper
     class Form
-      extend Util::Deprecated, Configurable
-      include Attributes.new(
-        name: nil, action: nil, title: nil, method: nil, media_type: nil, fields: []
-      )
+      extend Configurable, Forwardable, Util
 
-      deprecated_alias :href, :action
+      ConfigBuilder = Builder.new(Config) 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_forward :dynamic
+      end
 
-      Builder = StatefulBuilder.new(
-        self,
-        self.attributes.names + HTML5Forms::INPUT_TYPES + [:field]
-      )
+      def_delegators :config, :name, :action, :title, :method,
+                              :media_type, :fields, :dynamic_blocks
 
-      def self.create(name = nil, options = {}, &block)
-        Builder.build(new({name: name}.merge(options)), &block)
+      def self.create(*args, &block)
+        args, options = extract_options(args)
+
+        if args.first.is_a? Symbol
+          options[:name] = args.first
+        end
+
+        new(ConfigBuilder.build(Config.new(options), &block))
       end
 
+      ############################################################
+      # instance
+
+      include Concord.new(:config)
+
       def add_to_resource(resource, mapper, _context)
         resource.add_form(to_resource(mapper))
       end
 
+      private
+
       def to_resource(mapper)
+        config = dynamic_blocks.inject(self.config) do |config, block|
+          ConfigBuilder.build(config, mapper.object, &block)
+        end
+
         attrs = {
-          fields: resource_fields(mapper),
-          action: mapper.expand_uri(action, true)
+          fields: resource_fields(config.fields, mapper),
+          action: mapper.expand_uri(config.action, true)
         }
+
         [:name, :title, :method, :media_type].each do |attr|
-          attrs[attr] = mapper.expand_value(public_send(attr))
+          attrs[attr] = mapper.expand_value(config.public_send(attr))
         end
+
         Resource::Form.new(attrs)
       end
 
-      def resource_fields(mapper)
+      def resource_fields(fields, mapper)
         fields.map { |field| field.to_resource(mapper) }
       end
-
     end
   end
 end

data/lib/yaks/mapper/link.rb

@@ -24,19 +24,21 @@ module Yaks
     # @option title [#to_proc] Block that returns the title. If it takes an argument,
     #   it will receive the mapper instance as argument. Otherwise it is evaluated in the mapper context
     class Link
-      extend Forwardable
-      include Attributes.new(:rel, :template, options: {})
-      include Util
+      extend Forwardable, Util
+      include Attributes.new(:rel, :template, options: {}), Util
 
-      def self.create(rel, template, options = {})
-        new(rel: rel, template: template, options: options)
+      def self.create(*args)
+        args, options = extract_options(args)
+        new(rel: args[0], template: args[1], options: options)
       end
 
       def add_to_resource(resource, mapper, _context)
         resource_link = map_to_resource_link(mapper)
         return resource unless resource_link
-        if options[:replace]
-          resource.links(resource.links.reject {|link| link.rel?(rel)} << resource_link)
+        if options[:remove]
+          resource.with(links: resource.links.reject {|link| link.rel?(rel)})
+        elsif options[:replace]
+          resource.with(links: resource.links.reject {|link| link.rel?(rel)} << resource_link)
         else
           resource.add_link(resource_link)
         end

data/lib/yaks/mapper.rb

@@ -1,17 +1,25 @@
-# -*- coding: utf-8 -*-
-
 module Yaks
   class Mapper
-    extend ClassMethods, Forwardable
-    include Util, FP, FP::Callable
+    extend Configurable
 
-    def_delegators 'self.class', :config
-    def_delegators :config, :attributes, :links, :associations, :forms
+    def_forward :type       => :with_type
+    def_forward :attributes => :add_attributes
+    def_forward :append_to
 
-    config Config.new
+    def_add :link,      create: Link,      append_to: :links
+    def_add :has_one,   create: HasOne,    append_to: :associations
+    def_add :has_many,  create: HasMany,   append_to: :associations
+    def_add :attribute, create: Attribute, append_to: :attributes
+    def_add :form,      create: Form,      append_to: :forms
+
+    extend Forwardable
+    include Util, FP, FP::Callable
 
     attr_reader :object, :context
 
+    def_delegators 'self.class', :config
+    def_delegators :config, :attributes, :links, :associations, :forms
+
     def initialize(context)
       @context = context
     end

data/lib/yaks/null_resource.rb

@@ -18,6 +18,7 @@ module Yaks
       @collection
     end
 
+
     def null_resource?
       true
     end
@@ -31,7 +32,7 @@ module Yaks
       raise UnsupportedOperationError, "Operation #{__method__} not supported on #{self.class}"
     end
 
-    def update_attributes(_new_attrs)
+    def merge_attributes(_new_attrs)
       raise UnsupportedOperationError, "Operation #{__method__} not supported on #{self.class}"
     end
 

data/lib/yaks/pipeline.rb

@@ -0,0 +1,42 @@
+module Yaks
+  class Pipeline
+    include Concord.new(:steps)
+
+    def call(input, env)
+      steps.inject(input) {|memo, (_, step)| step.call(memo, env) }
+    end
+
+    def insert_hooks(hooks)
+      new_steps = hooks.inject(steps) do |steps, (type, target_step, name, hook)|
+        steps.flat_map do |step_name, callable|
+          if step_name.equal? target_step
+            case type
+            when :before
+              [[name, hook], [step_name, callable]]
+            when :after
+              [[step_name, callable], [name, hook]]
+            when :around
+              [[name, ->(x, env) { hook.call(x, env, &callable) }]]
+            when :skip
+              []
+            end
+          end || [[step_name, callable]]
+        end
+      end
+
+      self.class.new(new_steps)
+    end
+
+    def transitive?
+      steps.all? {|name, step| step.respond_to?(:transitive?) && step.transitive?}
+    end
+
+    def inverse
+      unless transitive?
+        raise RuntimeError, "Unable to get inverse pipeline, not all pipeline steps are transitive."
+      end
+
+      self.class.new(steps.map {|name, step| [name, step.inverse]}.reverse)
+    end
+  end
+end

data/lib/yaks/primitivize.rb

@@ -1,6 +1,5 @@
 module Yaks
   class Primitivize
-
     attr_reader :mappings
 
     def initialize

data/lib/yaks/reader/hal.rb

@@ -0,0 +1,63 @@
+module Yaks
+  module Reader
+    class Hal
+
+      def call(parsed_json, env = {})
+        attributes = parsed_json.dup
+        links      = convert_links(attributes.delete('_links') || {})
+        embedded   = convert_embedded(attributes.delete('_embedded') || {})
+
+
+        Resource.new(
+          type: attributes.delete('type') || type_from_links(links),
+          attributes: Util.symbolize_keys(attributes),
+          links: links,
+          subresources: embedded
+        )
+      end
+
+      def type_from_links(links)
+        profile = links.detect {|l| l.rel?(:profile)}
+        profile.uri[/\w+$/] if profile
+      end
+
+      def convert_links(links)
+        Set[*
+            links.flat_map do |rel, link|
+              array(link).map do |l|
+                options = Util.symbolize_keys(Util.slice_hash(l, 'title', 'templated'))
+                rel = rel.to_sym if Yaks::Identifier::LinkRelation.iana?(rel)
+                Resource::Link.new(rel: rel, uri: l['href'], options: options)
+              end
+            end
+           ]
+      end
+
+      def array(x)
+        x.instance_of?(Array) ? x : [x]
+      end
+
+
+      def convert_embedded(embedded)
+        embedded.flat_map do |rel, resource|
+          case resource
+          when nil
+            NullResource.new
+          when Array
+            if resource.empty?
+              NullResource.new(collection: true)
+            else
+              CollectionResource.new(
+                members: resource.map { |r|
+                  call(r).with(type: Util.singularize(rel[/\w+$/])) }
+              )
+            end
+          else
+            call(resource)
+          end.with(rels: [rel])
+        end
+      end
+
+    end
+  end
+end

data/lib/yaks/resource/form/field.rb

@@ -0,0 +1,19 @@
+module Yaks
+  class Resource
+    class Form
+      class Field
+        include Yaks::Mapper::Form::Field.attributes.add(:error => nil)
+
+        def value(arg = Undefined)
+          return @value if arg.eql?(Undefined)
+          if type == :select
+            selected = options.find { |option| option.selected }
+            selected.value if selected
+          else
+            with(value: arg)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yaks/resource/form/fieldset.rb

@@ -0,0 +1,13 @@
+module Yaks
+  class Resource
+    class Form
+      class Fieldset
+        include Attributes.new(:fields)
+
+        def type
+          :fieldset
+        end
+      end
+    end
+  end
+end

data/lib/yaks/resource/form.rb

@@ -1,7 +1,7 @@
 module Yaks
   class Resource
     class Form
-      include Yaks::Mapper::Form.attributes
+      include Yaks::Mapper::Form::Config.attributes.remove(:dynamic_blocks)
 
       def [](name)
         fields.find {|field| field.name == name}.value
@@ -13,16 +13,12 @@ module Yaks
         end
       end
 
-      class Field
-        include Yaks::Mapper::Form::Field.attributes.add(:error => nil)
-
-        def value(arg = Undefined)
-          return @value if arg.eql?(Undefined)
-          if type == :select
-            selected = options.find { |option| option.selected }
-            selected.value if selected
+      def fields_flat(fields = fields)
+        fields.each_with_object([]) do |field, acc|
+          if field.type == :fieldset
+            acc.concat(fields_flat field.fields)
           else
-            update(value: arg)
+            acc << field
           end
         end
       end

data/lib/yaks/resource.rb

@@ -8,6 +8,7 @@ module Yaks
               subresources: [],
               forms: []
             )
+    extend Util::Deprecated
 
     def initialize(attrs = {})
       raise attrs.inspect if attrs.key?(:subresources) && !attrs[:subresources].instance_of?(Array)
@@ -27,6 +28,16 @@ module Yaks
     end
 
     def self_link
+      # This reverse is there so that the last :self link specified
+      # "wins". The use case is having a self link defined in a base
+      # mapper class, but having it overridden in specific
+      # subclasses. In combination with formats that expect resources
+      # to have up to one self link, this is the preferred behavior.
+      # However since 0.7.5 links take a "replace: true" option to
+      # specifiy they should replace previous defintions with the same
+      # rel, wich should be used instead. The behavior that the last
+      # link "wins" will be deprecated, the result of multiple links
+      # with the same rel will be unspecified.
       links.reverse.find do |link|
         link.rel.equal? :self
       end
@@ -37,6 +48,10 @@ module Yaks
     end
     alias collection collection?
 
+    def with_collection(*)
+      self
+    end
+
     def null_resource?
       false
     end
@@ -47,10 +62,12 @@ module Yaks
     alias each members
     alias map members
     alias each_with_object members
+    alias with_members members
 
-    def update_attributes(new_attrs)
-      update(attributes: @attributes.merge(new_attrs))
+    def merge_attributes(new_attrs)
+      with(attributes: @attributes.merge(new_attrs))
     end
+    deprecated_alias :update_attributes, :merge_attributes
 
     def add_rel(rel)
       append_to(:rels, rel)

data/lib/yaks/runner.rb

@@ -5,18 +5,20 @@ module Yaks
     include Adamantium::Flat
     extend Forwardable
 
-    def_delegators :config, :policy, :default_format, :format_options, :primitivize, :serializers
+    def_delegators :config,        :policy, :default_format, :format_options_hash,
+                                   :primitivize, :serializers
+    def_delegators :format_class,  :media_type, :format_name
 
     def call
-      process(steps, object)
+      Pipeline.new(steps).insert_hooks(hooks).call(object, env)
     end
 
-    def map(object)
-      process(insert_hooks([[:map, mapper]]), object)
+    def read
+      Pipeline.new([[:parse, serializer.inverse], [:format, formatter.inverse]]).insert_hooks(hooks).call(object, env)
     end
 
-    def process(operations, input)
-      operations.inject(input) {|memo, (_, step)| step.call(memo, env) }
+    def map
+      Pipeline.new([[:map, mapper]]).insert_hooks(hooks).call(object, env)
     end
 
     def context
@@ -41,20 +43,11 @@ module Yaks
     end
     memoize :format_class
 
-    def media_type
-      format_class.media_type
-    end
-
-    def format_name
-      format_class.format_name
-    end
-
     def steps
-      insert_hooks(
-        [[ :map, mapper ],
-         [ :format, formatter ],
-         [ :primitivize, primitivizer],
-         [ :serialize, serializer ]])
+      [[ :map, mapper ],
+       [ :format, formatter ],
+       [ :primitivize, primitivizer],
+       [ :serialize, serializer ]]
     end
     memoize :steps
 
@@ -66,7 +59,7 @@ module Yaks
     memoize :mapper, freezer: :noop
 
     def formatter
-      format_class.new(format_options[format_name])
+      format_class.new(format_options_hash[format_name])
     end
     memoize :formatter
 
@@ -90,23 +83,5 @@ module Yaks
       config.hooks + options.fetch(:hooks, [])
     end
 
-    def insert_hooks(steps)
-      hooks.inject(steps) do |steps, (type, target_step, name, hook)|
-        steps.flat_map do |step_name, callable|
-          if step_name.equal? target_step
-            case type
-            when :before
-              [[name, hook], [step_name, callable]]
-            when :after
-              [[step_name, callable], [name, hook]]
-            when :around
-              [[step_name, ->(x, env) { hook.call(x, env, &callable) }]]
-            when :skip
-              []
-            end
-          end || [[step_name, callable]]
-        end
-      end
-    end
   end
 end

data/lib/yaks/serializer.rb

@@ -6,7 +6,40 @@ module Yaks
     end
 
     def self.all
-      @serializers ||= {json: ->(data, env) { JSON.pretty_generate(data) }}
+      @serializers ||= {json: JSONWriter}
     end
+
+    module JSONWriter
+      extend Yaks::FP::Callable
+
+      def self.call(data, env)
+        JSON.pretty_generate(data)
+      end
+
+      def self.transitive?
+        true
+      end
+
+      def self.inverse
+        JSONReader
+      end
+    end
+
+    module JSONReader
+      extend Yaks::FP::Callable
+
+      def self.call(data, env)
+        JSON.parse(data)
+      end
+
+      def self.transitive?
+        true
+      end
+
+      def self.inverse
+        JSONWriter
+      end
+    end
+
   end
 end

data/lib/yaks/util.rb

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 module Yaks
   module Util
     extend self
@@ -23,6 +21,14 @@ module Yaks
       keys.each_with_object({}) {|k,dest| dest[k] = hash[k] if hash.key?(k) }
     end
 
+    def symbolize_keys(hash)
+      hash.each_with_object({}) {|(k,v), hsh| hsh[k.to_sym] = v}
+    end
+
+    def extract_options(args)
+      args.last.is_a?(Hash) ? [args[0..-2], args.last] : [args, {}]
+    end
+
     # Turn what is maybe a Proc into its result (or itself)
     #
     # When input can be either a value or a proc that returns a value,

data/lib/yaks/version.rb

@@ -1,3 +1,3 @@
 module Yaks
-  VERSION = '0.7.7'
+  VERSION = '0.8.0.alpha'
 end