yaks 0.8.3 → 0.9.0

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

@@ -0,0 +1,17 @@
+module Yaks
+  class Mapper
+    class Form
+      class DynamicField
+        include Attributes.new(:block)
+
+        def self.create(_opts = nil, &block)
+          new(block: block)
+        end
+
+        def to_resource_fields(mapper)
+          Config.build_with_object(mapper.object, &block).to_resource_fields(mapper)
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,16 @@ module Yaks
         include Attributes.new(
                   :name,
                   label: nil,
-                  options: [].freeze
+                  options: [].freeze,
+                  if: nil
                 ).add(HTML5Forms::FIELD_OPTIONS)
 
         Builder = Builder.new(self) do
-          def_set :name
-          def_set :label
+          def_set :name, :label
           def_add :option, create: Option, append_to: :options
+          HTML5Forms::FIELD_OPTIONS.each do |option, _|
+            def_set option
+          end
         end
 
         def self.create(*args)
@@ -24,18 +27,18 @@ module Yaks
 
         # Convert to a Resource::Form::Field, expanding any dynamic
         # values
-        def to_resource(mapper)
-          Resource::Form::Field.new(
-            resource_attributes.each_with_object({}) do |attr, attrs|
-              attrs[attr] = mapper.expand_value(public_send(attr))
-            end.merge(options: resource_options(mapper))
-          )
+        def to_resource_fields(mapper)
+          return [] if self.if && !mapper.expand_value(self.if)
+          [ Resource::Form::Field.new(
+              (resource_attributes - [:if]).each_with_object({}) do |attr, attrs|
+                attrs[attr] = mapper.expand_value(public_send(attr))
+              end.merge(options: resource_options(mapper))) ]
         end
 
         def resource_options(mapper)
           # make sure all empty options arrays are the same instance,
           # makes for prettier #pp
-          options.empty? ? options : options.map {|opt| opt.to_resource_field_option(mapper) }
+          options.empty? ? options : options.map {|opt| opt.to_resource_field_option(mapper) }.compact
         end
 
         # All attributes that can be converted 1-to-1 to

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

@@ -4,13 +4,14 @@ module Yaks
       class Field
         # <option>, as used in a <select>
         class Option
-          include Attributes.new(:value, :label, selected: false, disabled: false)
+          include Attributes.new(:value, :label, selected: false, disabled: false, if: nil)
 
           def self.create(value, opts = {})
             new(opts.merge(value: value))
           end
 
           def to_resource_field_option(mapper)
+            return if self.if && !mapper.expand_value(self.if)
             Resource::Form::Field::Option.new(
               value: mapper.expand_value(value),
               label: mapper.expand_value(label),

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

@@ -3,39 +3,17 @@ module Yaks
     class Form
       class Fieldset
         extend Forwardable
-        include Concord.new(:config)
+        include Attributes.new(:config)
 
-        def_delegators :config, :fields, :dynamic_blocks
+        def_delegators :config, :fields
 
-        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
+        def self.create(options = {}, &block)
+          new(config: Config.build(options, &block))
         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) }
+        def to_resource_fields(mapper)
+          return [] if config.if && !mapper.expand_value(config.if)
+          [ Resource::Form::Fieldset.new(fields: config.to_resource_fields(mapper)) ]
         end
       end
     end

data/lib/yaks/reader/hal.rb

@@ -7,7 +7,6 @@ module Yaks
         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),

data/lib/yaks/reader/json_api.rb

@@ -0,0 +1,49 @@
+module Yaks
+  module Reader
+    class JsonAPI
+      def call(parsed_json, env = {})
+        attributes = parsed_json['data'].first.dup
+        links = attributes.delete('links') || {}
+        linked = parsed_json['linked'].nil? ? {} : parsed_json['linked'].dup
+        embedded   = convert_embedded(links, linked)
+        Resource.new(
+            type: Util.singularize(attributes.delete('type')[/\w+$/]),
+            attributes: Util.symbolize_keys(attributes),
+            subresources: embedded,
+            links: []
+        )
+      end
+
+      def convert_embedded(links, linked)
+        links.flat_map do |rel, link_data|
+          # If this is a compound link, the link_data will contain either
+          # * 'type' and 'id' for a one to one
+          # * 'type' and 'ids' for a homogeneous to-many relationship
+          # * 'data' being an array where each member has 'type' and 'id' for heterogeneous
+          if !link_data['type'].nil? && !link_data['id'].nil?
+            resource = linked.find{ |item| (item['id'] == link_data['id']) && (item['type'] == link_data['type']) }
+            call({'data'  => [resource], 'linked' => linked}).with(rels: [rel])
+          elsif !link_data['type'].nil? && !link_data['ids'].nil?
+            resources = linked.select{ |item| (link_data['ids'].include? item['id']) && (item['type'] == link_data['type']) }
+            members = resources.map { |r|
+              call({'data'  => [r], 'linked' => linked})
+            }
+            CollectionResource.new(
+                members: members,
+                type: link_data['type'],
+                rels: [rel]
+            )
+          elsif link_data['data'].present?
+            CollectionResource.new(
+                members: link_data['data'].map { |link|
+                  resource = linked.find{ |item| (item['id'] == link['id']) && (item['type'] == link['type']) }
+                  call({'data'  => [resource], 'linked' => linked})
+                },
+                rels: [rel]
+            )
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/yaks/version.rb

@@ -1,3 +1,3 @@
 module Yaks
-  VERSION = '0.8.3'
+  VERSION = '0.9.0'
 end

data/spec/acceptance/acceptance_spec.rb

@@ -40,6 +40,7 @@ RSpec.describe Yaks::Format::JsonAPI do
   end
 
   include_examples 'JSON output format', config, :json_api, 'confucius'
+  include_examples 'JSON round trip',    config, :json_api, 'confucius'
 end
 
 RSpec.describe Yaks::Format::CollectionJson do

data/spec/json/confucius.json_api.json

@@ -1,51 +1,50 @@
 {
-  "scholars": [
+  "data": [
     {
       "id": 9,
+      "type": "scholars",
       "href": "http://literature.example.com/authors/kongzi",
       "name": "孔子",
       "pinyin": "Kongzi",
       "latinized": "Confucius",
       "links": {
-        "works": [11,12]
+        "works": {"type": "works", "ids": [11,12]}
       }
     }
   ],
-  "linked": {
-    "works": [
+  "linked": [
       {
         "id": 11,
+        "type": "works",
         "href": "http://literature.example.com/work/11",
         "chinese_name": "論語",
         "english_name": "Analects",
         "links": {
-          "quotes": [17, 18],
-          "era": 99
+          "quotes": {"type": "quotes", "ids": [17, 18]},
+          "era": {"type": "erae", "id": 99}
         }
       },
-      {
-        "id": 12,
-        "href": "http://literature.example.com/work/12",
-        "chinese_name": "易經",
-        "english_name": "Commentaries to the Yi-jing",
-        "links": {}
-      }
-    ],
-    "quotes": [
       {
         "id": 17,
+        "type": "quotes",
         "chinese": "廄焚。子退朝，曰：“傷人乎？” 不問馬。"
       },
       {
         "id": 18,
+        "type": "quotes",
         "chinese": "子曰：“其恕乎！己所不欲、勿施於人。”"
-      }
-    ],
-    "erae": [
+      },
       {
         "id": 99,
+        "type": "erae",
         "name": "Zhou Dynasty"
+      },
+      {
+        "id": 12,
+        "type": "works",
+        "href": "http://literature.example.com/work/12",
+        "chinese_name": "易經",
+        "english_name": "Commentaries to the Yi-jing"
       }
-    ]
-  }
+  ]
 }

data/spec/unit/yaks/attributes_spec.rb

@@ -38,7 +38,7 @@ RSpec.describe Yaks::Attributes do
   end
 
   context 'when extending' do
-    subject { Class.new(super()) { include attributes.add(baz: 7) } }
+    subject { Class.new(super()) { include attributes.add(baz: 7, bar: 4) } }
 
     it 'should make the new attributes available' do
       expect(subject.new(foo: 3, baz: 6).baz).to equal 6
@@ -48,6 +48,14 @@ RSpec.describe Yaks::Attributes do
       expect(subject.new(foo: 3, baz: 6).foo).to equal 3
     end
 
+    it 'should take new default values' do
+      expect(subject.new(foo: 3, baz: 6).bar).to equal 4
+    end
+
+    it 'should make sure attribute names are uniq' do
+      expect(subject.attributes.names.length).to equal 3
+    end
+
     context 'without any defaults' do
       subject { Class.new(super()) { include attributes.add(:bax) } }
 
@@ -60,6 +68,34 @@ RSpec.describe Yaks::Attributes do
       end
     end
   end
+
+  context 'when removing an attribute with a default' do
+    subject { Class.new(super()) { include attributes.remove(:bar) } }
+
+    it 'should still recognize attributes that were kept' do
+      expect(subject.new(foo: 2).foo).to equal 2
+    end
+
+    it 'should no longer recognize the old attributes' do
+      expect { subject.new(foo: 3, bar: 3).bar }.to raise_error
+    end
+  end
+
+  context 'when removing an attribute without a default' do
+    subject { Class.new(super()) { include attributes.remove(:foo) } }
+
+    it 'should still recognize attributes that were kept' do
+      expect(subject.new(bar: 2).bar).to equal 2
+    end
+
+    it 'should no longer recognize the old attributes' do
+      expect { subject.new(foo: 3).foo }.to raise_error
+    end
+
+    it 'should keep the defaults' do
+      expect(subject.new.bar).to equal 3
+    end
+  end
 end
 
 RSpec.describe Yaks::Attributes::InstanceMethods do

data/spec/unit/yaks/builder_spec.rb

@@ -13,13 +13,12 @@ RSpec.describe Yaks::Builder do
     def wrong_type(x, y)
       "foo #{x} #{y}"
     end
-
   end
 
   subject do
-    Yaks::Builder.new(Buildable) do
+    Yaks::Builder.new(Buildable, [:finalize]) do
       def_set :foo, :bar
-      def_forward :finalize, :wrong_type, :update
+      def_forward :wrong_type, :update
     end
   end
 
@@ -36,4 +35,36 @@ RSpec.describe Yaks::Builder do
     expect( subject.create(3, 4) { finalize } ).to eql Buildable.new(foo: 7, bar: 8)
   end
 
+  context 'with no methods to forward' do
+    subject do
+      Yaks::Builder.new(Buildable)
+    end
+
+    it 'should still work' do
+      expect(subject.create(3,4)).to eql Buildable.new(foo: 3, bar: 4)
+    end
+  end
+
+  describe '#build' do
+    it 'should pass on the initial state if no block is given' do
+      expect(subject.build(:foo)).to equal :foo
+    end
+
+    it 'should pass any extra args to the block' do
+      expect(subject.build(Buildable.new(foo: 1, bar: 2), 9) {|f| foo(f)}).to eql(
+        Buildable.new(foo: 9, bar: 2)
+      )
+    end
+  end
+
+  describe '#inspect' do
+    subject do
+      Yaks::Builder.new(Buildable, [:foo, :bar])
+    end
+
+    it 'should show the class and methods' do
+      expect(subject.inspect).to eql '#<Builder Buildable [:foo, :bar]>'
+    end
+  end
+
 end

data/spec/unit/yaks/collection_mapper_spec.rb

@@ -3,12 +3,13 @@ RSpec.describe Yaks::CollectionMapper do
 
   subject(:mapper) { mapper_class.new(context) }
   let(:mapper_class) { described_class }
+  let(:mapper_stack) { [] }
 
   let(:context) {
     { item_mapper: item_mapper,
       policy: policy,
       env: {},
-      mapper_stack: [] }
+      mapper_stack: mapper_stack }
   }
 
   let(:collection) { [] }
@@ -25,6 +26,24 @@ RSpec.describe Yaks::CollectionMapper do
     )
   end
 
+  it 'should accept a second "env" argument' do
+    expect(mapper.call(collection, {})).to be_a Yaks::CollectionResource
+  end
+
+  context 'when at the top of the stack' do
+    it 'should have a "collection" rel derived from the type' do
+      expect(mapper.call(collection).rels).to eql  ['rel:the_types']
+    end
+  end
+
+  context 'when not at the top of the stack' do
+    let(:mapper_stack) { [ :foo ]}
+
+    it 'should not have a rel' do
+      expect(mapper.call(collection).rels).to eql []
+    end
+  end
+
   context 'with members' do
     let(:collection) { [boingboing, wassup]}
     let(:item_mapper) { PetMapper }

data/spec/unit/yaks/collection_resource_spec.rb

@@ -52,6 +52,13 @@ RSpec.describe Yaks::CollectionResource do
     its(:rels) { should eq ['http://api.example.org/rels/orders'] }
 
     its(:subresources) { should eql [] }
+  end
+
+  describe '#seq' do
+    let(:init_opts) { { members: [1,2,3] } }
 
+    it 'iterates over the members' do
+      expect(subject.seq.map(&:next)).to eql [2,3,4]
+    end
   end
 end

data/spec/unit/yaks/configurable_spec.rb

@@ -0,0 +1,84 @@
+class Kitten
+  include Yaks::Attributes.new(:furriness)
+
+  def self.create(opts, &block)
+    level = opts[:fur_level]
+    level = block.call(level) if block
+    new(furriness: level)
+  end
+end
+
+class Hanky
+  include Yaks::Attributes.new(:stickyness, :size, :color)
+
+  def self.create(sticky, opts = {})
+    new(stickyness: sticky, size: opts[:size], color: opts[:color])
+  end
+end
+
+RSpec.describe Yaks::Configurable do
+  let(:suffix) { SecureRandom.hex(16) }
+  subject do
+    eval %Q<
+class TestConfigurable#{suffix}
+  class Config
+    include Yaks::Attributes.new(color: 'blue', taste: 'sour', contents: [])
+  end
+  extend Yaks::Configurable
+
+  def_add :kitten, create: Kitten, append_to: :contents, defaults: {fur_level: 7}
+  def_add :cat, create: Kitten, append_to: :contents
+  def_add :hanky, create: Hanky, append_to: :contents, defaults: {size: 12, color: :red}
+end
+>
+    Kernel.const_get("TestConfigurable#{suffix}")
+  end
+
+  describe '.extended' do
+    it 'should initialize an empty config object' do
+      expect(subject.config).to eql subject::Config.new
+    end
+  end
+
+  describe '#def_add' do
+    it 'should add' do
+      subject.kitten(fur_level: 9)
+      expect(subject.config.contents).to eql [Kitten.new(furriness: 9)]
+    end
+
+    it 'should use defaults if configured' do
+      subject.kitten
+      expect(subject.config.contents).to eql [Kitten.new(furriness: 7)]
+    end
+
+    it 'should work without defaults configured' do
+      subject.cat(fur_level: 3)
+      expect(subject.config.contents).to eql [Kitten.new(furriness: 3)]
+    end
+
+    it 'should pass on a block' do
+      subject.cat(fur_level: 3) {|l| l+3}
+      expect(subject.config.contents).to eql [Kitten.new(furriness: 6)]
+    end
+
+    it 'should work with a create with positional arguments - defaults' do
+      subject.hanky(3)
+      expect(subject.config.contents).to eql [Hanky.new(stickyness: 3, size: 12, color: :red)]
+    end
+
+    it 'should work with a create with positional arguments' do
+      subject.hanky(5, size: 15)
+      expect(subject.config.contents).to eql [Hanky.new(stickyness: 5, size: 15, color: :red)]
+    end
+  end
+
+
+  describe '#def_set' do
+    it 'should set' do
+    end
+  end
+  describe '#def_forward' do
+    it 'should forward' do
+    end
+  end
+end