yaks 0.0.0 → 0.1.0

data/lib/yaks/null_resource.rb

@@ -0,0 +1,28 @@
+module Yaks
+  class NullResource
+    include Enumerable
+
+    def each
+      return to_enum unless block_given?
+    end
+
+    def attributes
+      Yaks::Hash()
+    end
+
+    def links
+      Yaks::List()
+    end
+
+    def subresources
+      Yaks::Hash()
+    end
+
+    def [](*)
+    end
+
+    def collection?
+      false
+    end
+  end
+end

data/lib/yaks/primitivize.rb

@@ -1,24 +1,43 @@
 module Yaks
   class Primitivize
+    include Concord.new(:object)
+
+    # TODO Global config, make this extensible in a per-instance way
+    MAPPINGS = {}
+
     def self.call(object)
-      new.call(object)
+      new(object).call
+    end
+
+    def self.map(*types, &blk)
+      types.each do |type|
+        MAPPINGS[type] = blk
+      end
+    end
+
+    map String, TrueClass, FalseClass, NilClass, Numeric do
+      object
+    end
+
+    map Symbol do
+      object.to_s
+    end
+
+    map Hash, Hamster::Hash do
+      object.to_enum(:each).with_object({}) do |(key, value), output|
+        output[self.class.(key)] = self.class.(value)
+      end
+    end
+
+    map Enumerable, Hamster::Enumerable do
+      object.map(&self.class.method(:call)).to_a
     end
 
-    def call(object)
-      case object
-      when String, TrueClass, FalseClass, NilClass, Numeric
-        object
-      when Symbol
-        object.to_s
-      when Hash, Hamster::Hash
-        object.to_enum(:each).with_object({}) do |(key, value), output|
-          output[self.(key)] = self.(value)
-        end
-      when Enumerable, Hamster::Enumerable
-        object.map(&method(:call)).to_a
-      else
-        raise "don't know how to turn #{object.class} (#{object.inspect}) into a primitive"
+    def call
+      MAPPINGS.each do |pattern, block|
+        return instance_eval(&block) if pattern === object
       end
+      raise "don't know how to turn #{object.class} (#{object.inspect}) into a primitive"
     end
   end
 end

data/lib/yaks/profile_registry.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+module Yaks
+  # RFC6906 The "profile" link relation http://tools.ietf.org/search/rfc6906
+  class ProfileRegistry
+    class << self
+      include Util
+
+      def create(&blk)
+        blk ||= ->{}
+        Class.new(self).tap(&σ(:instance_eval, &blk)).new
+      end
+
+      def profile(type, uri)
+        profiles {|reg| reg.put(type, uri)}
+      end
+
+      def profiles
+        @profiles ||= Yaks::Hash()
+        @profiles = yield(@profiles) if block_given?
+        @profiles
+      end
+
+      def inherited(child)
+        child.profiles { @profiles }
+      end
+    end
+
+    def find_by_type(type)
+      self.class.profiles[type]
+    end
+
+    def find_by_uri(by_uri)
+      self.class.profiles.detect {|type, uri| uri == by_uri}.first
+    end
+  end
+
+  class NullProfileRegistry
+    def find_by_type(type)
+      type.to_s
+    end
+
+    def find_by_uri(uri)
+      uri.to_sym
+    end
+  end
+
+  class TemplateProfileRegistry
+    def initialize(template)
+      @template = URITemplate.new(template)
+    end
+
+    def find_by_type(type)
+      @template.expand(type: type)
+    end
+
+    def find_by_uri(uri)
+      @template.extract(uri).fetch(:type) { uri }.to_sym
+    end
+  end
+end

data/lib/yaks/rel_registry.rb

@@ -0,0 +1,20 @@
+module Yaks
+  class RelRegistry
+  end
+
+  class TemplateRelRegistry < RelRegistry
+    def initialize(template)
+      @template = URITemplate.new(template)
+    end
+
+    def lookup(source, destination)
+      @template.expand(:src => source, :dest => destination)
+    end
+  end
+
+  class NullRelRegistry < TemplateRelRegistry
+    def initialize
+      super('rel:src={src}&dest={dest}')
+    end
+  end
+end

data/lib/yaks/resource.rb

@@ -0,0 +1,28 @@
+module Yaks
+  class Resource
+    include Equalizer.new(:links, :attributes, :subresources)
+    include Enumerable, LinkLookup
+
+    attr_reader :attributes, :links, :subresources
+
+    def initialize(attributes, links, subresources)
+      @attributes   = Yaks::Hash(attributes)
+      @links        = Yaks::List(links)
+      @subresources = Yaks::Hash(subresources)
+    end
+
+    def [](attr)
+      attributes[attr]
+    end
+
+    def each
+      return to_enum unless block_given?
+      yield self
+    end
+
+    def collection?
+      false
+    end
+
+  end
+end

data/lib/yaks/resource/link.rb

@@ -0,0 +1,21 @@
+module Yaks
+  class Resource
+    class Link
+      include Equalizer.new(:rel, :uri, :options)
+
+      attr_reader :rel, :uri, :options
+
+      def initialize(rel, uri, options)
+        @rel, @uri, @options = rel, uri, options
+      end
+
+      def name
+        options[:name]
+      end
+
+      def templated?
+        options.fetch(:templated) { false }
+      end
+    end
+  end
+end

data/lib/yaks/serializer.rb

@@ -1,64 +1,22 @@
 module Yaks
   class Serializer
-    include Yaks
-    extend ClassMethods
+    extend Forwardable
+    include Util, SharedOptions
 
-    attr_accessor :object
-    attr_reader :serializer_lookup, :root_key
+    attr_reader :resource, :options
+    def_delegators :resource, :links, :attributes, :subresources
 
-    def initialize(options = {})
-      @serializer_lookup = options.fetch(:serializer_lookup) { Yaks.default_serializer_lookup }
-      @root_key = options.fetch(:root_key) { self.class._root_key }
-    end
-
-    def identity_key
-      self.class._identity_key
-    end
-
-    def attributes
-      self.class._attributes
-    end
-
-    def associations
-      self.class._associations
-    end
-
-    def filter(attributes)
-      attributes
-    end
+    protected :resource, :links, :attributes, :subresources, :options
 
-    def serializable_collection(enumerable)
-      SerializableCollection.new(root_key, identity_key, enumerable.map(&method(:serializable_object)))
+    def initialize(resource, options = {})
+      @resource = resource
+      @options  = YAKS_DEFAULT_OPTIONS.merge(options)
     end
 
-    def serializable_object(object)
-      self.object = object
-      SerializableObject.new(
-        serializable_attributes(object),
-        serializable_associations(object)
-      )
+    def profile_name
+      (profile = resource.profile) &&
+        profile_registry.find_by_uri(profile)
     end
 
-    def serializable_attributes(object)
-      Hash(filter(attributes).map {|attr| [attr, send(attr)] })
-    end
-
-    def serializable_associations(object)
-      Hamster.enumerate(filter(associations.map(&:last)).each).map do |name|
-        type = associations.detect {|type, n| name == n }.first
-        if type == :has_one
-          obj        = send(name)
-          serializer = serializer_lookup.(obj).new
-          objects    = List(serializer.serializable_object(obj))
-        else
-          serializer = nil
-          objects = Hamster.enumerate(send(name).each).map do |obj|
-            serializer ||= serializer_lookup.(obj).new
-            serializer.serializable_object(obj)
-          end
-        end
-        SerializableAssociation.new( SerializableCollection.new(name, :id, objects), type == :has_one )
-      end
-    end
   end
 end

data/lib/yaks/shared_options.rb

@@ -0,0 +1,15 @@
+module Yaks
+  module SharedOptions
+    def policy
+      options[:policy]
+    end
+
+    def profile_registry
+      options[:profile_registry]
+    end
+
+    def rel_registry
+      options[:rel_registry]
+    end
+  end
+end

data/lib/yaks/util.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 module Yaks
   module Util
     extend self
@@ -7,14 +8,84 @@ module Yaks
 
     def underscore(str)
       str.gsub(/::/, '/')
-         .gsub(/(?<!^)([A-Z])(?=[a-z$])|(?<=[a-z])([A-Z])/, '_\1\2')
-         .tr("-", "_")
-         .downcase!
+        .gsub(/(?<!^|\/)([A-Z])(?=[a-z$])|(?<=[a-z])([A-Z])/, '_\1\2')
+        .tr("-", "_")
+        .downcase
     end
 
     def camelize(str)
-      str.gsub(/\/(.?)/)      { "::#{ $1.upcase }" }
-         .gsub!(/(?:^|_)(.)/) { $1.upcase          }
+      str.gsub(/\/(.?)/)     { "::#{ $1.upcase }" }
+        .gsub!(/(?:^|_)(.)/) { $1.upcase          }
+    end
+
+    def List(*args)
+      Hamster.list(*args)
+    end
+
+    def Hash(*args)
+      Hamster.hash(*args)
+    end
+
+    def Set(*args)
+      Hamster.set(*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,
+    # this conversion function can be used to resolve the thing to a
+    # value.
+    #
+    # The proc can be evaluated (instance_evaled) in a certain context,
+    # or evaluated as a closure.
+    #
+    # @param [Object|Proc] maybe_proc
+    #   A proc or a plain value
+    # @param [Object] context
+    #   (optional) A context used to instance_eval the proc
+    def Resolve(maybe_proc, context = nil)
+      if maybe_proc.respond_to?(:to_proc)
+        if context
+          if maybe_proc.to_proc.arity > 0
+            context.instance_eval(&maybe_proc)
+          else
+            # In case it's a lambda with zero arity instance_eval fails
+            context.instance_exec(&maybe_proc)
+          end
+        else
+          maybe_proc.()
+        end
+      else
+        maybe_proc
+      end
+    end
+
+    def curry_method(name)
+      method(name).to_proc.curry
+    end
+    alias μ curry_method
+
+    def identity_function
+      ->(x) {x}
+    end
+    alias ι identity_function
+
+    def juxt(*procs)
+      ->(*args) { procs.map &σ(:call, *args) }
+    end
+
+    def curry_symbol(symbol, *args, &blk)
+      ->(obj) { obj.method(symbol).to_proc.curry.(*args, &blk) }
+    end
+    alias σ curry_symbol
+    alias send_with_args curry_symbol
+
+    def extract_options(args)
+      if args.last.is_a? Hash
+        [args.take(args.count-1), args.last]
+      else
+        [args, {}]
+      end
     end
 
   end

data/lib/yaks/version.rb

@@ -1,3 +1,3 @@
 module Yaks
-  VERSION = '0.0.0'
+  VERSION = '0.1.0'
 end

data/spec/integration/map_to_resource_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Mapping domain models to Resource objects' do
+  include_context 'fixtures'
+  include_context 'shorthands'
+
+  subject { mapper.to_resource }
+  let(:mapper) { FriendMapper.new(john) }
+
+
+  it { should be_a Yaks::Resource }
+  its(:attributes)   { should eq Yaks::Hash(id: 1, name: 'john') }
+  its(:links)        { should eq Yaks::List(
+      resource_link[:profile, 'friend'],
+      resource_link[:copyright, '/api/copyright/2024']
+  )}
+
+  its(:subresources) {
+    should eq Yaks::Hash(
+      "rel:src=friend&dest=pet_peeve" => resource[{id: 4, type: 'parsing with regexps'}, [resource_link[:profile, 'pet_peeve']]],
+      "rel:src=friend&dest=pets" => Yaks::CollectionResource.new(
+        [resource_link[:profile, 'pet']],
+        [
+          resource[{:id => 2, :species => "dog", :name => "boingboing"}, [resource_link[:profile, 'pet']]],
+          resource[{:id => 3, :species => "cat", :name => "wassup"}, [resource_link[:profile, 'pet']]]
+        ]
+      )
+    )
+  }
+end