yaks 0.7.7 → 0.8.0.alpha

data/lib/yaks/config/dsl.rb

@@ -1,174 +0,0 @@
-module Yaks
-  class Config
-    class DSL
-      # @!attribute [r] config
-      #   @return [Yaks::Config]
-      attr_reader :config
-
-      # @param [Yaks::Config] config
-      # @param [Proc] block
-      def initialize(config, &block)
-        @config       = config
-        @policy_class = Class.new(DefaultPolicy)
-        @policies     = []
-        instance_eval(&block) if block
-        @policies.each do |policy_block|
-          @policy_class.class_eval &policy_block
-        end
-        config.policy_class = @policy_class
-      end
-
-      # Set the options for a format
-      #
-      # @param [Symbol] format
-      # @param [Hash] options
-      #
-      # @example
-      #
-      #   yaks = Yaks.new do
-      #     format_options :hal, {plural_links: [:related_content]}
-      #   end
-      #
-      def format_options(format, options)
-        config.format_options[format] = options
-      end
-
-      # Set the default format
-      #
-      # Defaults to +:hal+
-      #
-      # @param [Symbol] format
-      #   Format identifier, one of +Yaks::Format.names+
-      #
-      # @example
-      #
-      #    yaks = Yaks.new do
-      #      default_fomat :json_api
-      #    end
-      #
-      def default_format(format)
-        config.default_format = format
-      end
-
-      # Configure serializer for specific output format, e.g. JSON
-      #
-      # This will override the default registered serializer. Note
-      # that extension gems can register their own serializers, see
-      # Yaks::Serializer.register
-      #
-      # @example
-      #
-      #   yaks = Yaks.new do
-      #     serializer :json, &Oj.method(:dump)
-      #   end
-      #
-      # @type [Symbol] type
-      #   Output format
-      # @param [Proc] serializer
-      #   Serialization procedure
-      #
-      def serializer(type, &serializer)
-        config.serializers[type] = serializer
-      end
-
-      # @deprecated
-      def json_serializer(&serializer)
-        serializer(:json, &serializer)
-      end
-
-      %w[before after around skip].map(&:intern).each do |hook_type|
-        define_method hook_type do |step, name = :"#{hook_type}_#{step}", &block|
-          config.hooks << [hook_type, step, name, block]
-        end
-      end
-
-      # Set a different policy implementation
-      #
-      # By default Yaks uses +Yaks::DefaultPolicy+ to derive missing
-      # information. You can swap in a class with a compatible
-      # interface to change the default behavior
-      #
-      # To override a single policy method, simply call a method with
-      # the same name as part of your Yaks configuration, passing a
-      # block to define the new behavior.
-      #
-      # @example
-      #
-      #    yaks = Yaks.new do
-      #      derive_type_from_mapper_class do |mapper_class|
-      #        mapper_class.name.sub(/Mapper^/,'')
-      #      end
-      #    end
-      #
-      # @param [Class] klass
-      #   Policy class
-      #
-      def policy(klass)
-        @policy_class = klass
-      end
-
-      # Set the template for deriving rels
-      #
-      # Used to derive rels for links and subresources.
-      #
-      # @example
-      #
-      #   yaks = Yaks.new do
-      #     rel_template 'http://api.example.com/rels/{rel}'
-      #   end
-      #
-      # @param [String] template
-      #   A valid URI template containing +{rel}+
-      #
-      def rel_template(template)
-        config.policy_options[:rel_template] = template
-      end
-
-      # Set the namespace (Ruby module) that contains your mappers
-      #
-      # When your mappers don't live at the top-level, then set this
-      # so Yaks can correctly infer the mapper class from the model
-      # class.
-      #
-      # @example
-      #
-      #   yaks = Yaks.new do
-      #     mapper_namespace API::Mappers
-      #   end
-      #
-      #   module API::Mappers
-      #     class FruitMapper < Yaks::Mapper
-      #        ...
-      #     end
-      #   end
-      #
-      #   class Fruit < BaseModel
-      #     ...
-      #   end
-      #
-      # @param [Module] namespace
-      #
-      def mapper_namespace(namespace)
-        config.policy_options[:namespace] = namespace
-      end
-      alias namespace mapper_namespace
-
-      # @param [Array] args
-      # @param [Proc] block
-      def map_to_primitive(*args, &block)
-        config.primitivize.map(*args, &block)
-      end
-
-      # Will define each method available in the DefaultPolicy upon the DSL
-      # and then make it available to apply to any Class taking on the
-      # `@policies` Array.
-      DefaultPolicy.public_instance_methods(false).each do |method|
-        define_method method do |&block|
-          @policies << proc {
-            define_method method, &block
-          }
-        end
-      end
-    end
-  end
-end

data/lib/yaks/mapper/class_methods.rb

@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Yaks
-  class Mapper
-    module ClassMethods
-      extend Util::Deprecated
-      include Forwardable,
-              Util,
-              FP
-
-      def config(value = Undefined)
-        if value.equal? Undefined
-          @config
-        else
-          raise if value.nil?
-          @config = value
-        end
-      end
-
-      def inherited(child)
-        child.config(config)
-      end
-
-      CONFIG_METHODS = [
-        :type,
-        :attributes,
-        :link,
-        :profile,
-        :has_one,
-        :has_many,
-        :form
-      ]
-
-      CONFIG_METHODS.each do |method_name|
-        define_method method_name do |*args, &block|
-          if args.empty?
-            config.public_send(method_name, *args, &block)
-          else
-            config(config.public_send(method_name, *args, &block))
-          end
-        end
-      end
-
-      deprecated_alias :control, :form
-    end
-  end
-end

data/lib/yaks/stateful_builder.rb

@@ -1,63 +0,0 @@
-module Yaks
-  # State monad-ish thing.
-  #
-  # Generate a DSL syntax for immutable classes.
-  #
-  # @example
-  #
-  #   # This code
-  #   Form.create(:search)
-  #          .method("POST")
-  #          .action("/search")
-  #
-  #   # Can be written as
-  #   StatefulBuilder.new(Form, [:method, :action]).create(:search) do
-  #     method "POST"
-  #     action "/search"
-  #   end
-  #
-  class StatefulBuilder < BasicObject
-    def create(*args, &block)
-      build(@klass.create(*args), &block)
-    end
-
-    def build(init_state, &block)
-      @state = init_state
-      instance_eval(&block) if block
-      @state
-    end
-
-    def initialize(klass, methods = nil)
-      @klass = klass
-      @methods = methods || klass.attributes.names
-      StatefulMethods.new(@methods).send(:extend_object, self)
-    end
-
-    def validate_state(method_name, args)
-      unless @state.instance_of?(@klass)
-        ::Kernel.raise(
-          IllegalStateError,
-          "#{@klass}##{method_name}(#{args.map(&:inspect).join(', ')}) "\
-          "returned #{@state.inspect}. Expected instance of #{@klass}"
-        )
-      end
-    end
-
-    def inspect
-      "#<StatefulBuilder #{@klass} #{@methods.inspect}>"
-    end
-
-    class StatefulMethods < ::Module
-      def initialize(methods)
-        methods.each { |name| define_stateful_method(name) }
-      end
-
-      def define_stateful_method(method_name)
-        define_method method_name do |*args, &block|
-          @state = @state.public_send(method_name, *args, &block)
-          validate_state(method_name, args)
-        end
-      end
-    end
-  end
-end

data/spec/unit/yaks/config/dsl_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Config::DSL do
-  subject!(:dsl) { described_class.new(yaks_config, &config_block) }
-
-  let(:yaks_config)  { Yaks::Config.new }
-  let(:config_block) { nil }
-
-  def self.configure(&blk)
-    let(:config_block) { blk }
-  end
-
-  describe '#initialize' do
-    its(:config) { should equal yaks_config }
-
-    it 'should set a default policy' do
-      expect(yaks_config.policy_class.new).to be_a_kind_of Yaks::DefaultPolicy
-    end
-
-    it 'should execute the given block in instance scope' do
-      dsl = described_class.new(yaks_config) do
-        @config = :foo
-      end
-      expect(dsl.config).to be :foo
-    end
-
-    describe 'policy redefinitions' do
-      configure do
-        derive_type_from_mapper_class do |mapper_class|
-          :inside_redefined_policy_method
-        end
-      end
-
-      it 'should delegate and redefine' do
-        expect(yaks_config.policy.derive_type_from_mapper_class(nil)).to be :inside_redefined_policy_method
-      end
-
-      it 'should not change the original class definition' do
-        expect(Yaks::DefaultPolicy.new.derive_type_from_mapper_class(fake(name: 'FooMapper'))).to eql 'foo'
-      end
-    end
-  end
-
-  describe '#format_options' do
-    configure { format_options :hal, singular_link: [:self] }
-    specify   { expect(yaks_config.format_options[:hal]).to eq(singular_link: [:self]) }
-  end
-
-  describe '#default_format' do
-    configure { default_format :json_api }
-    specify   { expect(yaks_config.default_format).to be :json_api }
-  end
-
-  describe '#policy' do
-    configure { policy 'MyPolicyClass' }
-    specify   { expect(yaks_config.policy_class).to eql 'MyPolicyClass' }
-  end
-
-  describe '#rel_template' do
-    configure { rel_template 'rels:{rel}' }
-    specify   { expect(yaks_config.policy_options[:rel_template]).to eql 'rels:{rel}' }
-  end
-
-  describe '#serializer' do
-    configure { serializer(:json) { |i| "foo #{i}" } }
-    specify   { expect(yaks_config.serializers[:json].call(7)).to eql 'foo 7' }
-  end
-
-  describe '#json_serializer' do
-    configure { json_serializer { |i| "foo #{i}" } }
-    specify   { expect(yaks_config.serializers[:json].call(7)).to eql 'foo 7' }
-  end
-
-  describe '#mapper_namespace' do
-    configure { mapper_namespace RSpec }
-    specify   { expect(yaks_config.policy_options[:namespace]).to eql RSpec }
-  end
-
-  describe '#map_to_primitive' do
-    Foo = Class.new do
-      attr_reader :foo
-
-      def initialize(foo)
-        @foo = foo
-      end
-    end
-
-    configure { map_to_primitive(Foo) {|c| c.foo } }
-    specify   { expect(yaks_config.primitivize.call({:abc => Foo.new('hello')})).to eql 'abc' => 'hello' }
-  end
-
-end

data/spec/unit/yaks/configurable_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Configurable do
-  class Creatable
-    def self.create(*args, &block)
-      ["->", *args, block.call]
-    end
-  end
-
-  subject do
-    Class.new do
-      extend Yaks::Configurable
-      include Yaks::Attributes.new(foo: [])
-
-      config_method :bar, append_to: :foo, create: Creatable
-      config_method :baz, append_to: :foo, create: Creatable, defaults: {bar: 'baz'}
-    end
-  end
-
-  it 'should generate the config method' do
-    expect(
-      subject.new.bar(1,2,3) { 4 }
-                 .bar(:baz)  { :booz }
-                 .foo
-    ).to eql [["->", 1, 2, 3, {}, 4], ["->", :baz, {}, :booz]]
-  end
-
-  it 'should allow setting defaults' do
-    expect(
-      subject.new.baz(1,2,3, foo: 'bar') { 4 }
-                 .foo
-    ).to eql [["->", 1, 2, 3, {foo: 'bar', bar: 'baz'}, 4]]
-  end
-
-  it 'should allow overriding defaults' do
-    expect(
-      subject.new.baz(1,2,3, bar: 'qux') { 4 }
-                 .foo
-    ).to eql [["->", 1, 2, 3, {bar: 'qux'}, 4]]
-  end
-
-  it 'should be able to take an already instantiated object of the right type' do
-    instance = Creatable.new
-    expect(
-      subject.new.bar(instance).foo
-    ).to eql [instance]
-  end
-
-  it 'should only take the instance verbatim if it is the only argument' do
-    instance = Creatable.new
-    expect(
-      subject.new.bar(instance, 1) {}.foo
-    ).to eql [["->", instance, 1, {}, nil]]
-  end
-end

data/spec/unit/yaks/mapper/class_methods_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::ClassMethods do
-  subject(:mapper_class) do
-    Class.new do
-      extend Yaks::Mapper::ClassMethods
-      config Yaks::Mapper::Config.new
-      attributes :foo, :bar
-      link :some_rel, 'http://some_link'
-      has_one :thing
-      has_many :thingies
-    end
-  end
-
-  describe 'attributes' do
-    it 'should allow setting them' do
-      expect( mapper_class.attributes ).to eq [
-        Yaks::Mapper::Attribute.new(:foo),
-        Yaks::Mapper::Attribute.new(:bar)
-      ]
-    end
-
-    describe 'with inheritance' do
-      let(:child_class) do
-        Class.new(mapper_class) do
-          attributes :baz
-        end
-      end
-
-      let(:grandchild_class) do
-        Class.new(child_class)
-      end
-
-      it 'should inherit attributes from the parent' do
-        expect(child_class.attributes).to eq [
-          Yaks::Mapper::Attribute.new(:foo),
-          Yaks::Mapper::Attribute.new(:bar),
-          Yaks::Mapper::Attribute.new(:baz)
-        ]
-      end
-
-      it 'should create a valid config' do
-        expect(grandchild_class.config).to be_a Yaks::Mapper::Config
-      end
-
-      it 'should not alter the parent' do
-        expect(mapper_class.attributes).to eq [
-          Yaks::Mapper::Attribute.new(:foo),
-          Yaks::Mapper::Attribute.new(:bar),
-        ]
-      end
-    end
-  end
-
-  it 'should register links' do
-    expect(mapper_class.config.links).to eq [
-      Yaks::Mapper::Link.new(rel: :some_rel, template: 'http://some_link')
-    ]
-  end
-
-  it 'should register associations' do
-    expect(mapper_class.config.associations).to eq [
-      Yaks::Mapper::HasOne.new(name: :thing),
-      Yaks::Mapper::HasMany.new(name: :thingies)
-    ]
-  end
-
-  describe '#config' do
-    it 'should allow getting the config' do
-      expect(subject.config).to be_a Yaks::Mapper::Config
-    end
-
-    it 'should allow setting the config' do
-      subject.config(:foo)
-      expect(subject.config).to be :foo
-    end
-
-    it 'raise an exception when the config is nil' do
-      expect { subject.config(nil) }.to raise_exception
-    end
-  end
-
-end