roar 1.0.2 → 1.1.1

data/lib/roar/json/json_api.rb

@@ -1,233 +0,0 @@
-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)
-
-          private
-            def create_representation_with(doc, options, format)
-              super(doc, options.merge(:only_body => true), format)
-            end
-        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, [Representable::Hash::Collection, Document::Collection, Roar::JSON], "", {}) do
-            items extend: singular, :parse_strategy => :sync
-
-            representable_attrs[:resource_representer] = singular.representable_attrs[:resource_representer]
-            representable_attrs[:meta_representer]     = singular.representable_attrs[:meta_representer] # DISCUSS: do we need that?
-            representable_attrs[:_wrap] = singular.representable_attrs[:_wrap]
-          end
-        end
-      end
-
-
-      module Singular
-        def to_hash(options={})
-          # per resource:
-          super(options.merge(: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, :inherit => true, &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
-
-          def meta(&block)
-            representable_attrs[:meta_representer] = Class.new(Roar::Decorator, &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, options)
-        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, options)
-          links = render_links
-          meta  = render_meta(options)
-          # 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!(meta)
-            doc.merge!("linked" => compound) if compound && compound.size > 0 # FIXME: make that like the above line.
-          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
-
-        def render_links
-          representable_attrs[:resource_representer].new(represented).to_hash # creates links: section.
-        end
-
-        def render_meta(options)
-          # TODO: this will call collection.page etc, directly on the collection. we could allow using a "meta"
-          # object to hold this data.
-          # `meta call_meta: true` or something
-          return {"meta" => options["meta"]} if options["meta"]
-          return {} unless representer = representable_attrs[:meta_representer]
-          {"meta" => representer.new(represented).extend(Representable::Hash).to_hash}
-        end
-
-
-        module Collection
-          include Document
-
-          def to_hash(options={})
-            res = super(options.merge(:only_body => true))
-            to_document(res, options)
-          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/test/collection_json_test.rb

@@ -1,132 +0,0 @@
-require 'test_helper'
-require 'roar/json/collection_json'
-
-if RUBY_ENGINE != "rbx"
-  class CollectionJsonTest < MiniTest::Spec
-    let(:song) { OpenStruct.new(:title => "scarifice", :length => 43) }
-
-    representer_for([Roar::JSON::CollectionJSON]) do
-      version "1.0"
-      href { "//songs/" }
-
-      link(:feed) { "//songs/feed" }
-
-      items(:class => Song) do
-        href { "//songs/scarifice" }
-
-        property :title, :prompt => "Song title"
-        property :length, :prompt => "Song length"
-
-        link(:download) { "//songs/scarifice.mp3" }
-        link(:stats) { "//songs/scarifice/stats" }
-      end
-
-      template do
-        property :title, :prompt => "Song title"
-        property :length, :prompt => "Song length"
-      end
-
-      queries do
-        link :search do
-          {:href => "//search", :data => [{:name => "q", :value => ""}]}
-        end
-      end
-    end
-
-    describe "#to_json" do
-      it "renders document" do
-        [song].extend(rpr).to_hash.must_equal(
-        {
-          "collection"=>{
-            "version"=>"1.0",
-            "href"=>"//songs/",
-
-            "template"=>{
-              :data=>[
-                {:name=>"title", :value=>nil},
-                {:name=>"length", :value=>nil}
-              ]
-            },
-
-            "queries"=>[
-              {"rel"=>"search", "href"=>"//search",
-                "data"=>[
-                  {:name=>"q", :value=>""}
-                ]
-              }
-            ],
-
-            "items"=>[
-              {
-                "links"=>[
-                  {"rel"=>"download", "href"=>"//songs/scarifice.mp3"},
-                  {"rel"=>"stats",    "href"=>"//songs/scarifice/stats"}
-                ],
-                "href"=>"//songs/scarifice",
-                :data=>[
-                  {:name=>"title", :value=>"scarifice"},
-                  {:name=>"length", :value=>43}
-                ]
-              }
-            ],
-
-            "links"=>[
-              {"rel"=>"feed", "href"=>"//songs/feed"}
-            ]
-          }
-        })# %{{"collection":{"version":"1.0","href":"//songs/","items":[{"href":"//songs/scarifice","links":[{"rel":"download","href":"//songs/scarifice.mp3"},{"rel":"stats","href":"//songs/scarifice/stats"}],"data":[{"name":"title","value":"scarifice"},{"name":"length","value":43}]}],"template":{"data":[{"name":"title","value":null},{"name":"length","value":null}]},"queries":[{"rel":"search","href":"//search","data":[{"name":"q","value":""}]}],"links":[{"rel":"feed","href":"//songs/feed"}]}}}
-      end
-    end
-
-    describe "#from_json" do
-      subject { [].extend(rpr).from_json [song].extend(rpr).to_json }
-
-      it "provides #version" do
-        subject.version.must_equal "1.0"
-      end
-
-      it "provides #href" do
-        subject.href.must_equal link(:href => "//songs/")
-      end
-
-      it "provides #template" do
-        # DISCUSS: this might return a Template instance, soon.
-        subject.template.must_equal([
-          {"name"=>"title", "value"=>nil},
-          {"name"=>"length", "value"=>nil}])
-      end
-
-      it "provides #queries" do
-        # DISCUSS: this might return CollectionJSON::Hyperlink instances that support some kind of substitution operation for the :data attribute.
-        # FIXME: this is currently _not_ parsed!
-        subject.queries.must_equal([link(:rel => :search, :href=>"//search", :data=>[{:name=>"q", :value=>""}])])
-      end
-
-      it "provides #items" do
-        subject.items.must_equal([Song.new(:title => "scarifice", :length => "43")])
-        song = subject.items.first
-        song.title.must_equal "scarifice"
-        song.length.must_equal 43
-        song.links.must_equal("download" => link({:rel=>"download", :href=>"//songs/scarifice.mp3"}), "stats" => link({:rel=>"stats", :href=>"//songs/scarifice/stats"}))
-        song.href.must_equal link(:href => "//songs/scarifice")
-      end
-
-      it "provides #links" do
-        subject.links.must_equal({"feed" => link(:rel => "feed", :href => "//songs/feed")})
-      end
-    end
-
-    describe "template_representer#from_json" do
-      it "parses object" do
-        song = OpenStruct.new.extend(rpr.template_representer).from_hash(
-          "template"=>{
-            "data"=>[
-              {"name"=>"title",  "value"=>"Black Star"},
-              {"name"=>"length", "value"=>"4.53"}
-            ]
-          })
-        song.title.must_equal "Black Star"
-      end
-    end
-  end
-end

data/test/hal_links_test.rb

@@ -1,31 +0,0 @@
-require 'ostruct'
-require 'test_helper'
-require 'roar/json/hal'
-
-
-class HalLinkTest < MiniTest::Spec
-  let(:rpr) do
-    Module.new do
-      include Roar::JSON
-      include Roar::JSON::HAL::Links
-      link :self do
-        "//songs"
-      end
-    end
-  end
-
-  subject { Object.new.extend(rpr) }
-
-  describe "#to_json" do
-    it "uses 'links' key" do
-      subject.to_json.must_equal "{\"links\":{\"self\":{\"href\":\"//songs\"}}}"
-    end
-  end
-
-  describe "#from_json" do
-    it "uses 'links' key" do
-      subject.from_json("{\"links\":{\"self\":{\"href\":\"//lifer\"}}}").links.values.must_equal [link("href" => "//lifer", "rel" => "self")]
-    end
-  end
-end
-