roar 1.0.4 → 1.1.0

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
-

data/test/json_api_test.rb

@@ -1,451 +0,0 @@
-require 'test_helper'
-require 'roar/json/json_api'
-require 'json'
-
-require "representable/version"
-if Gem::Version.new(Representable::VERSION) >= Gem::Version.new("2.1.4") # TODO: remove check once we bump representable dependency.
-  class JSONAPITest < MiniTest::Spec
-    let(:song) {
-      s = OpenStruct.new(
-        bla: "halo",
-        id: "1",
-        title: 'Computadores Fazem Arte',
-        album: OpenStruct.new(id: 9, title: "Hackers"),
-        :album_id => "9",
-        :musician_ids => ["1","2"],
-        :composer_id => "10",
-        :listener_ids => ["8"],
-        musicians: [OpenStruct.new(id: 1, name: "Eddie Van Halen"), OpenStruct.new(id: 2, name: "Greg Howe")]
-      )
-
-    }
-
-    # minimal resource, singular
-    module MinimalSingular
-      include Roar::JSON::JSONAPI
-      type :songs
-
-      property :id
-    end
-
-    class MinimalSingularDecorator < Roar::Decorator
-      include Roar::JSON::JSONAPI
-      type :songs
-
-      property :id
-    end
-
-    [MinimalSingular, MinimalSingularDecorator].each do |representer|
-      describe "minimal singular with #{representer}" do
-        subject { representer.prepare(song) }
-
-        it { subject.to_json.must_equal "{\"songs\":{\"id\":\"1\"}}" }
-        it { subject.from_json("{\"songs\":{\"id\":\"2\"}}").id.must_equal "2"  }
-      end
-    end
-
-    module Singular
-      include Roar::JSON::JSONAPI
-      type :songs
-
-      property :id
-      property :title, if: lambda { |args| args[:omit_title] != true }
-
-      # local per-model "id" links
-      links do
-        property :album_id, :as => :album
-        collection :musician_ids, :as => :musicians
-      end
-      has_one :composer
-      has_many :listeners
-
-
-      # global document links.
-      link "songs.album" do
-        {
-          type: "album",
-          href: "http://example.com/albums/{songs.album}"
-        }
-      end
-
-      compound do
-        property :album do
-          property :title
-        end
-
-        collection :musicians do
-          property :name
-        end
-      end
-    end
-
-    class SingularDecorator < Roar::Decorator
-      include Roar::JSON::JSONAPI
-      type :songs
-
-      property :id
-      property :title, if: lambda { |args| args[:omit_title] != true }
-
-      # NOTE: it is important to call has_one, then links, then has_many to assert that they all write
-      #to the same _links property and do NOT override things.
-      has_one :composer
-      # local per-model "id" links
-      links do
-        property :album_id, :as => :album
-        collection :musician_ids, :as => :musicians
-      end
-      has_many :listeners
-
-
-      # global document links.
-      link "songs.album" do
-        {
-          type: "album",
-          href: "http://example.com/albums/{songs.album}"
-        }
-      end
-
-      compound do
-        property :album do
-          property :title
-        end
-
-        collection :musicians do
-          property :name
-        end
-      end
-    end
-
-    [Singular, SingularDecorator].each do |representer|
-      describe "singular with #{representer}" do
-        subject { song.extend(Singular) }
-
-        let (:document) do
-          {
-            "songs" => {
-              "id" => "1",
-              "title" => "Computadores Fazem Arte",
-              "links" => {
-                "album" => "9",
-                "musicians" => [ "1", "2" ],
-                "composer"=>"10",
-                "listeners"=>["8"]
-              }
-            },
-            "links" => {
-              "songs.album"=> {
-                "href"=>"http://example.com/albums/{songs.album}", "type"=>"album"
-              }
-            },
-            "linked" => {
-              "album"=> [{"title"=>"Hackers"}],
-              "musicians"=> [
-                {"name"=>"Eddie Van Halen"},
-                {"name"=>"Greg Howe"}
-              ]
-            }
-          }
-        end
-
-        # to_hash
-        it do
-          subject.to_hash.must_equal document
-        end
-
-        # to_hash(options)
-        it do
-          subject.to_hash(omit_title: true)['songs'].wont_include('title')
-        end
-
-        # #to_json
-        it do
-          subject.to_json.must_equal JSON.generate(document)
-        end
-
-        # #from_json
-        it do
-          song = OpenStruct.new.extend(Singular)
-          song.from_json(
-            JSON.generate(
-              {
-                "songs" => {
-                  "id" => "1",
-                  "title" => "Computadores Fazem Arte",
-                  "links" => {
-                    "album" => "9",
-                    "musicians" => [ "1", "2" ],
-                    "composer"=>"10",
-                    "listeners"=>["8"]
-                  }
-                },
-                "links" => {
-                  "songs.album"=> {
-                    "href"=>"http://example.com/albums/{songs.album}", "type"=>"album"
-                  }
-                }
-              }
-            )
-          )
-
-          song.id.must_equal "1"
-          song.title.must_equal "Computadores Fazem Arte"
-          song.album_id.must_equal "9"
-          song.musician_ids.must_equal ["1", "2"]
-          song.composer_id.must_equal "10"
-          song.listener_ids.must_equal ["8"]
-        end
-      end
-    end
-
-
-    # collection with links
-    [Singular, SingularDecorator].each do |representer|
-      describe "collection with links and compound with #{representer}" do
-        subject { representer.for_collection.prepare([song, song]) }
-
-        let (:document) do
-          {
-            "songs" => [
-              {
-                "id" => "1",
-                "title" => "Computadores Fazem Arte",
-                "links" => {
-                  "composer"=>"10",
-                  "album" => "9",
-                  "musicians" => [ "1", "2" ],
-                  "listeners"=>["8"]
-                }
-              }, {
-                "id" => "1",
-                "title" => "Computadores Fazem Arte",
-                "links" => {
-                  "composer"=>"10",
-                  "album" => "9",
-                  "musicians" => [ "1", "2" ],
-                  "listeners"=>["8"]
-                }
-              }
-            ],
-            "links" => {
-              "songs.album" => {
-                "href" => "http://example.com/albums/{songs.album}",
-                "type" => "album" # DISCUSS: does that have to be albums ?
-              },
-            },
-            "linked"=>{
-              "album"    =>[{"title"=>"Hackers"}], # only once!
-              "musicians"=>[{"name"=>"Eddie Van Halen"}, {"name"=>"Greg Howe"}]
-            }
-          }
-        end
-
-        # to_hash
-        it do
-          subject.to_hash.must_equal document
-        end
-
-        # to_hash(options)
-        it do
-          subject.to_hash(omit_title: true)['songs'].each do |song|
-            song.wont_include('title')
-          end
-        end
-
-        # #to_json
-        it { subject.to_json.must_match /linked/ } # hash ordering changes, and i don't care why.
-      end
-
-
-      # from_json
-      it do
-        song1, song2 = Singular.for_collection.prepare([OpenStruct.new, OpenStruct.new]).from_json(
-          JSON.generate(
-            {
-              "songs" => [
-                {
-                  "id" => "1",
-                  "title" => "Computadores Fazem Arte",
-                  "links" => {
-                    "album" => "9",
-                    "musicians" => [ "1", "2" ],
-                    "composer"=>"10",
-                    "listeners"=>["8"]
-                  },
-                },
-                {
-                  "id" => "2",
-                  "title" => "Talking To Remind Me",
-                  "links" => {
-                    "album" => "1",
-                    "musicians" => [ "3", "4" ],
-                    "composer"=>"2",
-                    "listeners"=>["6"]
-                  }
-                },
-              ],
-              "links" => {
-                "songs.album"=> {
-                  "href"=>"http://example.com/albums/{songs.album}", "type"=>"album"
-                }
-              }
-            }
-          )
-        )
-
-        song1.id.must_equal "1"
-        song1.title.must_equal "Computadores Fazem Arte"
-        song1.album_id.must_equal "9"
-        song1.musician_ids.must_equal ["1", "2"]
-        song1.composer_id.must_equal "10"
-        song1.listener_ids.must_equal ["8"]
-
-        song2.id.must_equal "2"
-        song2.title.must_equal "Talking To Remind Me"
-        song2.album_id.must_equal "1"
-        song2.musician_ids.must_equal ["3", "4"]
-        song2.composer_id.must_equal "2"
-        song2.listener_ids.must_equal ["6"]
-      end
-    end
-
-
-    class CollectionWithoutCompound <  self
-      module Representer
-        include Roar::JSON::JSONAPI
-        type :songs
-
-        property :id
-        property :title
-
-        # local per-model "id" links
-        links do
-          property :album_id, :as => :album
-          collection :musician_ids, :as => :musicians
-        end
-        has_one :composer
-        has_many :listeners
-
-
-        # global document links.
-        link "songs.album" do
-          {
-            type: "album",
-            href: "http://example.com/albums/{songs.album}"
-          }
-        end
-      end
-
-      subject { [song, song].extend(Singular.for_collection) }
-
-      # to_json
-      it do
-        subject.extend(Representer.for_collection).to_hash.must_equal(
-          {
-            "songs"=>[{"id"=>"1", "title"=>"Computadores Fazem Arte", "links"=>{"album"=>"9", "musicians"=>["1", "2"], "composer"=>"10", "listeners"=>["8"]}}, {"id"=>"1", "title"=>"Computadores Fazem Arte", "links"=>{"album"=>"9", "musicians"=>["1", "2"], "composer"=>"10", "listeners"=>["8"]}}],
-            "links"=>{"songs.album"=>{"href"=>"http://example.com/albums/{songs.album}", "type"=>"album"}
-            }
-          }
-        )
-      end
-    end
-
-    class CompoundCollectionUsingExtend < self
-      module SongRepresenter
-        include Roar::JSON::JSONAPI
-
-        type :songs
-        property :id
-        property :title
-      end
-
-      module AlbumRepresenter
-        include Roar::JSON::JSONAPI
-
-        type :albums
-        property :id
-        compound do
-          collection :songs, extend: SongRepresenter
-        end
-      end
-
-      let(:songs) do
-        struct = Struct.new(:id, :title)
-        [struct.new(1, 'Stand Up'), struct.new(2, 'Audition Mantra')]
-      end
-
-      let(:album) { Struct.new(:id, :songs).new(1, songs) }
-
-      subject { album.extend(AlbumRepresenter) }
-
-      # to_hash
-      it do
-        subject.to_hash.must_equal({
-          'albums' => { 'id' => 1 },
-          'linked' => {
-            'songs' => [
-              {'id' => 1, 'title' => 'Stand Up'},
-              {'id' => 2, 'title' => 'Audition Mantra'}
-            ]
-          }
-        })
-      end
-    end
-
-    class ExplicitMeta < self
-      module Representer
-        include Roar::JSON::JSONAPI
-
-        type :songs
-        property :id
-
-        meta do
-          property :page
-        end
-      end
-
-      module Page
-        def page
-          2
-        end
-      end
-
-      let (:song) { Struct.new(:id).new(1) }
-
-      subject { [song, song].extend(Representer.for_collection).extend(Page) }
-
-      # to_json
-      it do
-        subject.to_hash.must_equal(
-          {
-            "songs"=>[{"id"=>1}, {"id"=>1}],
-            "meta" =>{"page"=>2}
-          }
-        )
-      end
-    end
-
-
-    class ImplicitMeta < self
-      module Representer
-        include Roar::JSON::JSONAPI
-
-        type :songs
-        property :id
-      end
-
-      let (:song) { Struct.new(:id).new(1) }
-
-      subject { [song, song].extend(Representer.for_collection) }
-
-      # to_json
-      it do
-        subject.to_hash("meta" => {"page" => 2}).must_equal(
-          {
-            "songs"=>[{"id"=>1}, {"id"=>1}],
-            "meta" =>{"page"=>2}
-          }
-        )
-      end
-    end
-  end
-end