roar 0.12.9 → 1.0.0.beta1

data/lib/roar/{representer/json → json}/hal.rb

@@ -1,6 +1,6 @@
-require 'roar/representer/json'
+require 'roar/json'
 
-module Roar::Representer
+module Roar
   module JSON
     # Including the JSON::HAL module in your representer will render and parse documents
     # following the HAL specification: http://stateless.co/hal_specification.html
@@ -44,7 +44,7 @@ module Roar::Representer
     module HAL
       def self.included(base)
         base.class_eval do
-          include Roar::Representer::JSON
+          include Roar::JSON
           include Links       # overwrites #links_definition_options.
           extend ClassMethods # overwrites #links_definition_options, again.
           include Resources
@@ -60,13 +60,13 @@ module Roar::Representer
       module Resources
         # Write the property to the +_embedded+ hash when it's a resource.
         def compile_fragment(bin, doc)
-          embedded = ::Roar.representable_1_8? ? bin[:embedded] : bin.options[:embedded]
+          embedded = bin[:embedded]
           return super unless embedded
           super(bin, doc[:_embedded] ||= {})
         end
 
         def uncompile_fragment(bin, doc)
-          embedded = Roar.representable_1_8? ? bin[:embedded] : bin.options[:embedded]
+          embedded = bin[:embedded]
           return super unless embedded
           super(bin, doc["_embedded"] || {})
         end
@@ -74,11 +74,11 @@ module Roar::Representer
 
       module ClassMethods
         def links_definition_options
-          super.tap { |options| options[1].merge!(:as => :_links) }
+          super.merge(:as => :_links)
         end
       end
 
-      class LinkCollection < Feature::Hypermedia::LinkCollection
+      class LinkCollection < Hypermedia::LinkCollection
         def initialize(array_rels, *args)
           super(*args)
           @array_rels = array_rels.map(&:to_s)
@@ -106,11 +106,9 @@ module Roar::Representer
       # Note that the HAL::Links module alone doesn't prepend an underscore to +links+. Use the JSON::HAL module for that.
       module Links
         def self.included(base)
-          base.class_eval do
-            extend Links::ClassMethods  # ::links_definition_options
-            include Roar::Representer::Feature::Hypermedia
-            include InstanceMethods
-          end
+          base.extend ClassMethods  # ::links_definition_options
+          base.send :include, Hypermedia
+          base.send :include, InstanceMethods
         end
 
         module InstanceMethods
@@ -118,7 +116,7 @@ module Roar::Representer
           def prepare_link_for(href, options)
             return super(href, options) unless options[:array]  # TODO: remove :array and use special instan
 
-            list = href.collect { |opts| Feature::Hypermedia::Hyperlink.new(opts.merge!(:rel => options[:rel])) }
+            list = href.collect { |opts| Hypermedia::Hyperlink.new(opts.merge!(:rel => options[:rel])) }
             LinkArray.new(list, options[:rel])
           end
 
@@ -133,25 +131,29 @@ module Roar::Representer
         module LinkCollectionRepresenter
           include Representable::JSON::Hash
 
-          values :extend => lambda { |item, *| item.is_a?(Array) ? LinkArrayRepresenter : Roar::Representer::JSON::HyperlinkRepresenter },
-            :instance => lambda { |fragment, *| fragment.is_a?(LinkArray) ? fragment : Roar::Representer::Feature::Hypermedia::Hyperlink.new }
+          values :extend => lambda { |item, *|
+            item.is_a?(Array) ? LinkArrayRepresenter : Roar::JSON::HyperlinkRepresenter },
+            :instance => lambda { |fragment, *| fragment.is_a?(LinkArray) ? fragment : Roar::Hypermedia::Hyperlink.new
+          }
 
           def to_hash(options)
             super.tap do |hsh|  # TODO: cool: super(:exclude => [:rel]).
-              hsh.each { |k,v| v.delete(:rel) }
+              hsh.each { |k,v| v.delete("rel") }
             end
           end
 
 
-          def from_hash(hash, options={})
+          def from_hash(hash, *args)
             hash.each { |k,v| hash[k] = LinkArray.new(v, k) if is_array?(k) }
 
             hsh = super(hash) # this is where :class and :extend do the work.
 
-            hsh.each { |k, v| v.rel = k }
+            hsh.each { |k, v| v.merge!(:rel => k) }
+            hsh.values # links= expects [Hyperlink, Hyperlink]
           end
         end
 
+        # DISCUSS: we can probably get rid of this asset.
         class LinkArray < Array
           def initialize(elems, rel)
             super(elems)
@@ -160,8 +162,8 @@ module Roar::Representer
 
           attr_reader :rel
 
-          def rel=(rel)
-            each { |lnk| lnk.rel = rel }
+          def merge!(attrs)
+            each { |lnk| lnk.merge!(attrs) }
           end
         end
 
@@ -169,12 +171,12 @@ module Roar::Representer
         module LinkArrayRepresenter
           include Representable::JSON::Collection
 
-          items :extend => Roar::Representer::JSON::HyperlinkRepresenter,
-            :class => Roar::Representer::Feature::Hypermedia::Hyperlink
+          items :extend => Roar::JSON::HyperlinkRepresenter,
+            :class => Roar::Hypermedia::Hyperlink
 
           def to_hash(*)
             super.tap do |ary|
-              ary.each { |lnk| rel = lnk.delete(:rel) }
+              ary.each { |lnk| rel = lnk.delete("rel") }
             end
           end
         end
@@ -182,13 +184,13 @@ module Roar::Representer
 
         module ClassMethods
           def links_definition_options
-            [:links,
-              {
-                :extend   => HAL::Links::LinkCollectionRepresenter,
-                :instance => lambda { |*| LinkCollection.new(link_array_rels) }, # defined in InstanceMethods as this is executed in represented context.
-                :decorator_scope => true
-              }
-            ]
+            # property :links_array,
+            {
+              :as       => :links,
+              :extend   => HAL::Links::LinkCollectionRepresenter,
+              :instance => lambda { |*| LinkCollection.new(link_array_rels) }, # defined in InstanceMethods as this is executed in represented context.
+              :exec_context => :decorator,
+            }
           end
 
           # Use this to define link arrays. It accepts the shared rel attribute and an array of options per link object.
@@ -199,7 +201,7 @@ module Roar::Representer
           #   end
           def links(options, &block)
             options = {:rel => options} if options.is_a?(Symbol)
-            options[:array] = true  # FIXME: we need to save this information somewhere.
+            options[:array] = true
             link(options, &block)
           end
 

data/lib/roar/json/hash.rb

@@ -0,0 +1,3 @@
+require "representable/json/hash"
+
+Roar::JSON::Hash = Representable::JSON::Hash

data/lib/roar/json/json_api.rb

@@ -0,0 +1,208 @@
+require 'roar/json'
+require 'roar/decorator'
+
+module Roar
+  module JSON
+    module JSONAPI
+      def self.included(base)
+        base.class_eval do
+          include Representable::JSON
+          include Roar::JSON::JSONAPI::Singular
+          include Roar::JSON::JSONAPI::Resource
+          include Roar::JSON::JSONAPI::Document
+
+          extend ForCollection
+
+          representable_attrs[:resource_representer] = Class.new(Resource::Representer)
+        end
+      end
+
+      module ForCollection
+        def for_collection # same API as representable. TODO: we could use ::collection_representer! here.
+          singular = self # e.g. Song::Representer
+
+          # this basically does Module.new { include Hash::Collection .. }
+          build_inline(nil, [Document::Collection, Representable::Hash::Collection, Roar::JSON], "", {}) do
+            items extend: singular, :parse_strategy => :sync
+
+            representable_attrs[:resource_representer] = singular.representable_attrs[:resource_representer]
+            representable_attrs[:_wrap] = singular.representable_attrs[:_wrap]
+          end
+        end
+      end
+
+
+      module Singular
+        def to_hash(options={})
+          # per resource:
+          super(:exclude => [:links]).tap do |hash|
+            hash["links"] = hash.delete("_links") if hash["_links"]
+          end
+        end
+
+        def from_hash(hash, options={})
+          hash["_links"] = hash["links"]
+          super
+        end
+      end
+
+
+      module Resource
+        # ::link is delegated to Representer which handles the hypermedia (rendering
+        # and parsing links).
+        class Representer < Roar::Decorator
+          include Roar::JSON
+          include Roar::Hypermedia
+
+          def self.links_definition_options
+            {
+              :extend       => LinkCollectionRepresenter,
+              :exec_context => :decorator
+            }
+          end
+        end
+
+        def self.included(base)
+          base.extend Declarative # inject our ::link.
+        end
+
+        # New API for JSON-API representers.
+        module Declarative
+          def type(name=nil)
+            return super unless name # original name.
+            representable_attrs[:_wrap] = name.to_s
+          end
+
+          # Define global document links for the links: directive.
+          def link(*args, &block)
+            representable_attrs[:resource_representer].link(*args, &block)
+          end
+
+          # Per-model links.
+          def links(&block)
+            nested(:_links, &block)
+          end
+
+          # TODO: always create _links.
+          def has_one(name)
+            property :_links, :inherit => true, :use_decorator => true do # simply extend the Decorator _links.
+              property "#{name}_id", :as => name
+            end
+          end
+
+          def has_many(name)
+            property :_links, :inherit => true, :use_decorator => true do # simply extend the Decorator _links.
+              collection "#{name.to_s.sub(/s$/, "")}_ids", :as => name
+            end
+          end
+
+          def compound(&block)
+            nested(:linked, &block)
+          end
+        end
+      end
+
+
+      # TODO: don't use Document for singular+wrap AND singular in collection (this way, we can get rid of the only_body)
+      module Document
+        def to_hash(options={})
+          # per resource:
+          res = super # render single resource or collection.
+          return res if options[:only_body]
+          # this is the only "dirty" part: this module is always included in the Singular document representer, when used in collection, we don't want it to do the extra work. this mechanism here might be changed soon.
+
+          to_document(res)
+        end
+
+        def from_hash(hash, options={})
+
+          return super(hash, options) if options[:only_body] # singular
+
+          super(from_document(hash)) # singular
+        end
+
+      private
+        def to_document(res)
+          links    = representable_attrs[:resource_representer].new(represented).to_hash # creates links: section.
+          # FIXME: provide two different #to_document
+
+          if res.is_a?(Array)
+            compound = collection_compound!(res, {})
+          else
+            compound = compile_compound!(res.delete("linked"), {})
+          end
+
+          {representable_attrs[:_wrap] => res}.tap do |doc|
+            doc.merge!(links)
+            doc.merge!("linked" => compound) if compound && compound.size > 0
+          end
+        end
+
+        def from_document(hash)
+          hash[representable_attrs[:_wrap]]
+        end
+
+        # Compiles the linked: section for compound objects in the document.
+        def collection_compound!(collection, compound)
+          collection.each { |res|
+            kv = res.delete("linked") or next
+
+            compile_compound!(kv, compound)
+          }
+
+          compound
+        end
+
+        # Go through {"album"=>{"title"=>"Hackers"}, "musicians"=>[{"name"=>"Eddie Van Halen"}, ..]} from linked:
+        # and wrap every item in an array.
+        def compile_compound!(linked, compound)
+          return unless linked
+
+          linked.each { |k,v| # {"album"=>{"title"=>"Hackers"}, "musicians"=>[{"name"=>"Eddie Van Halen"}, {"name"=>"Greg Howe"}]}
+            compound[k] ||= []
+
+            if v.is_a?(::Hash) # {"title"=>"Hackers"}
+              compound[k] << v
+            else
+              compound[k].push(*v) # [{"name"=>"Eddie Van Halen"}, {"name"=>"Greg Howe"}]
+            end
+
+            compound[k] = compound[k].uniq
+          }
+
+          compound
+        end
+
+
+        module Collection
+          include Document
+
+          def to_hash(options={})
+            res = super(options.merge(:only_body => true))
+            to_document(res)
+          end
+
+          def from_hash(hash, options={})
+            hash = from_document(hash)
+            super(hash, options.merge(:only_body => true))
+          end
+        end
+      end
+
+
+      module LinkRepresenter
+        include Roar::JSON
+
+        property :href
+        property :type
+      end
+
+      require 'representable/json/hash'
+      module LinkCollectionRepresenter
+        include Representable::JSON::Hash
+
+        values :extend => LinkRepresenter # TODO: parsing.
+      end
+    end
+  end
+end

data/lib/roar/representer.rb

@@ -1,44 +1,11 @@
 require 'representable'
 
 module Roar
+  # generic features can be included here and will be available in all format-specific representers.
   module Representer
-    # TODO: move to separate module
-    # DISCUSS: experimental. this will soon be moved to a separate gem
-    module InheritableArray
-      def representable_attrs
-        super.extend(ConfigExtensions)
-      end
-
-      module ConfigExtensions
-        def inheritable_array(name)
-          inheritable_arrays[name] ||= []
-        end
-        def inheritable_arrays
-          @inheritable_arrays ||= {}
-        end
-
-        def inherit(parent)
-          super
-
-          parent.inheritable_arrays.keys.each do |k|
-            inheritable_array(k).push *parent.inheritable_array(k).clone
-          end
-        end
-      end
-    end
-
     def self.included(base)
-      base.class_eval do
-        include Representable
-        extend InheritableArray # this adds InheritableArray::representable_attrs to the module, e.g. when a representer includes a  representer, we don't work with the instance method, yet.
-      end
-    end
-
-    include InheritableArray
-
-
-  private
-    def before_serialize(*)
+      super
+      base.send(:include, Representable)
     end
   end
 end

data/lib/roar/transport/faraday.rb

@@ -0,0 +1,49 @@
+gem 'faraday'
+require 'faraday'
+
+module Roar
+  module Transport
+    # Advanced implementation of the HTTP verbs with the Faraday HTTP library
+    # (which can, in turn, use adapters based on Net::HTTP or libcurl)
+    #
+    # Depending on how the Faraday middleware stack is configured, this
+    # Transport can support features such as HTTP error code handling,
+    # redirects, etc.
+    #
+    # @see http://rubydoc.info/gems/faraday/file/README.md Faraday README
+    class Faraday
+
+      def get_uri(options)
+        build_connection(options[:uri], options[:as]).get
+      end
+
+      def post_uri(options)
+        build_connection(options[:uri], options[:as]).post(nil, options[:body])
+      end
+
+      def put_uri(options)
+        build_connection(options[:uri], options[:as]).put(nil, options[:body])
+      end
+
+      def patch_uri(options)
+        build_connection(options[:uri], options[:as]).patch(nil, options[:body])
+      end
+
+      def delete_uri(options)
+        build_connection(options[:uri], options[:as]).delete
+      end
+
+      private
+
+      def build_connection(uri, as)
+        ::Faraday::Connection.new(
+          :url => uri,
+          :headers => { :accept => as, :content_type => as }
+        ) do |builder|
+          builder.use ::Faraday::Response::RaiseError
+          builder.adapter ::Faraday.default_adapter
+        end
+      end
+    end
+  end
+end