roar 0.12.9 → 1.0.0.beta1

data/gemfiles/Gemfile.representable-1.7

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-
-gemspec path: '../'
-
-gem 'representable', '~> 1.7.0'
-gem "sinatra-contrib", :git => "git@github.com:apotonick/sinatra-contrib.git", :branch => "runner"

data/gemfiles/Gemfile.representable-1.8

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-
-gemspec path: '../'
-
-gem 'representable', '~> 1.8.0'
-gem "sinatra-contrib", :git => "git@github.com:apotonick/sinatra-contrib.git", :branch => "runner"

data/lib/roar/representer/feature/client.rb

@@ -1,39 +0,0 @@
-require "roar/representer/feature/http_verbs"
-
-module Roar
-  # Automatically add accessors for properties and collections. Also mixes in HttpVerbs.
-  module Representer
-    module Feature
-      module Client
-        include HttpVerbs
-
-        def self.extended(base)
-          base.instance_eval do
-            representable_attrs.each do |attr|
-              next unless attr.instance_of? Representable::Definition # ignore hyperlinks etc for now.
-              name = attr.name
-
-              # TODO: could anyone please make this better?
-              instance_eval %Q{
-                def #{name}=(v)
-                  @#{name} = v
-                end
-
-                def #{name}
-                  @#{name}
-                end
-              }
-            end
-          end
-        end
-
-        # DISCUSS: should we just override #serialize here? otherwise if you later include Hypermedia, it'll run before that method.
-        def before_serialize(options={})
-          options[:links] ||= false
-
-          super(options)
-        end
-      end
-    end
-  end
-end

data/lib/roar/representer/feature/http_verbs.rb

@@ -1,95 +0,0 @@
-require 'roar/representer/transport/net_http'
-
-module Roar
-  # Gives HTTP-power to representers. They can serialize, send, process and deserialize HTTP-requests.
-  module Representer
-    module Feature
-      module HttpVerbs
-
-        class << self
-          attr_accessor :transport_engine
-
-          def included(base)
-            base.extend ClassMethods
-          end
-        end
-        self.transport_engine = ::Roar::Representer::Transport::NetHTTP
-
-
-        module ClassMethods
-          # GETs +url+ with +format+ and returns deserialized represented object.
-          def get(*args)
-            new.get(*args)
-          end
-        end
-
-
-        attr_writer :transport_engine
-        def transport_engine
-          @transport_engine || HttpVerbs.transport_engine
-        end
-
-        # Serializes the object, POSTs it to +url+ with +format+, deserializes the returned document
-        # and updates properties accordingly.
-        def post(*args, &block)
-          options  = handle_deprecated_args(serialize, *args)
-          response = http.post_uri(options, &block)
-          handle_response(response)
-        end
-
-        # GETs +url+ with +format+, deserializes the returned document and updates properties accordingly.
-        def get(*args, &block)
-          response = http.get_uri(*args, &block)
-          handle_response(response)
-        end
-
-        # Serializes the object, PUTs it to +url+ with +format+, deserializes the returned document
-        # and updates properties accordingly.
-        def put(*args, &block)
-          options  = handle_deprecated_args(serialize, *args)
-          response = http.put_uri(options, &block)
-          handle_response(response)
-          self
-        end
-
-        def patch(*args, &block)
-          options  = handle_deprecated_args(serialize, *args)
-          response = http.patch_uri(options, &block)
-          handle_response(response)
-          self
-        end
-
-        def delete(*args, &block)
-          http.delete_uri(*args, &block)
-          self
-        end
-
-      private
-        def handle_response(response)
-          document = response.body
-          deserialize(document)
-        end
-
-        def http
-          transport_engine.new
-        end
-
-        def handle_deprecated_args(body, *args) # TODO: remove in 1.0.
-          options = args.first
-
-          if args.size > 1
-            warn %{DEPRECATION WARNING: #get, #post, #put, #delete and #patch no longer accept positional arguments. Please call them as follows:
-     get(uri: "http://localhost/songs", as: "application/json")
-    post(uri: "http://localhost/songs", as: "application/json")
-Thank you and have a beautiful day.}
-            options = {:uri => args[0], :as => args[1]} if args.size == 2
-            options = {:uri => args[0], :as => args[2]}
-          end
-
-          options[:body] = body
-          options
-        end
-      end
-    end
-  end
-end

data/lib/roar/representer/feature/hypermedia.rb

@@ -1,175 +0,0 @@
-module Roar
-  module Representer
-    module Feature
-      # Define hypermedia links in your representations.
-      #
-      # Example:
-      #
-      #   class Order
-      #     include Roar::Representer::JSON
-      #
-      #     property :id
-      #
-      #     link :self do
-      #       "http://orders/#{id}"
-      #     end
-      #
-      # If you want more attributes, just pass a hash to #link.
-      #
-      #     link :rel => :next, :title => "Next, please!" do
-      #       "http://orders/#{id}"
-      #     end
-      #
-      # If you need dynamic attributes, the block can return a hash.
-      #
-      #     link :preview do
-      #       {:href => image.url, :title => image.name}
-      #     end
-      #
-      # Sometimes you need values from outside when the representation links are rendered. Just pass them
-      # to the render method, they will be available as block parameters.
-      #
-      #   link :self do |opts|
-      #     "http://orders/#{opts[:id]}"
-      #   end
-      #
-      #   model.to_json(:id => 1)
-      module Hypermedia
-        def self.included(base)
-          base.extend ClassMethods
-          base.extend InheritableArray
-        end
-
-        def before_serialize(options={})
-          super(options) # Representer::Base
-          prepare_links!(options) unless options[:links] == false  # DISCUSS: doesn't work when links are already setup (e.g. from #deserialize).
-        end
-
-        attr_writer :links
-
-        def links
-          @links ||= LinkCollection.new
-        end
-
-        def links_array
-          links.values  # FIXME: move to LinkCollection#to_a.
-        end
-
-        def links_array=(ary)
-          # FIXME: move to LinkCollection
-          self.links= LinkCollection.new
-          ary.each { |lnk| links.add(lnk) }
-        end
-
-        module LinkConfigsMethod
-          def link_configs
-            representable_attrs.inheritable_array(:links)
-          end
-        end
-
-        include LinkConfigsMethod
-
-      private
-        def links_definition_options
-          # TODO: this method is never called.
-          [:links_array, {:as => :link, :class => Feature::Hypermedia::Hyperlink, :collection => true,
-            :decorator_scope => true}] # TODO: merge with JSON.
-        end
-
-        # Setup hypermedia links by invoking their blocks. Usually called by #serialize.
-        def prepare_links!(*args)
-          # TODO: move this method to _links or something so it doesn't need to be called in #serialize.
-          compile_links_for(link_configs, *args).each do |lnk|
-            links.add(lnk)  # TODO: move to LinkCollection.new.
-          end
-        end
-
-        def compile_links_for(configs, *args)
-          configs.collect do |config|
-            options, block  = config.first, config.last
-            href            = run_link_block(block, *args) or next
-
-            prepare_link_for(href, options)
-          end.compact # FIXME: make this less ugly.
-        end
-
-        def prepare_link_for(href, options)
-          options = options.merge(href.is_a?(Hash) ? href : {:href => href})
-          Hyperlink.new(options)
-        end
-
-        def run_link_block(block, *args)
-          instance_exec(*args, &block)
-        end
-
-
-        class LinkCollection < Hash
-          # DISCUSS: make Link#rel return string always.
-          def [](rel)
-            self.fetch(rel.to_s, nil)
-          end
-
-          def add(link)
-            self[link.rel.to_s] = link
-          end
-        end
-
-
-        module ClassMethods
-          # Declares a hypermedia link in the document.
-          #
-          # Example:
-          #
-          #   link :self do
-          #     "http://orders/#{id}"
-          #   end
-          #
-          # The block is executed in instance context, so you may call properties or other accessors.
-          # Note that you're free to put decider logic into #link blocks, too.
-          def link(options, &block)
-            options = {:rel => options} unless options.is_a?(Hash)
-            create_links_definition # this assures the links are rendered at the right position.
-            link_configs << [options, block]
-          end
-
-          include LinkConfigsMethod
-
-        private
-          def create_links_definition
-            return if representable_attrs.find { |d| d.is_a?(LinksDefinition) }
-
-            options = links_definition_options # TODO: remove in 1.0.
-            if Roar.representable_1_8?
-              opt = options.last
-              opt[:exec_context] = :decorator
-              opt.delete(:decorator_scope)
-            end
-
-            representable_attrs << LinksDefinition.new(*options)
-          end
-        end
-
-        class LinksDefinition < Representable::Definition
-        end
-
-
-        require "ostruct"
-        # An abstract hypermedia link with arbitrary attributes.
-        class Hyperlink < OpenStruct
-          include Enumerable
-
-          def each(*args, &block)
-            marshal_dump.each(*args, &block)
-          end
-
-          # FIXME: do we need this method any longer?
-          def replace(hash)
-            # #marshal_load requires symbol keys: http://apidock.com/ruby/v1_9_3_125/OpenStruct/marshal_load
-            marshal_load(hash.inject({}) { |h, (k,v)| h[k.to_sym] = v; h })
-            self
-          end
-        end
-      end
-    end
-  end
-end

data/lib/roar/representer/json.rb

@@ -1,67 +0,0 @@
-require 'roar/representer'
-require 'roar/representer/feature/hypermedia'
-require 'representable/json'
-
-module Roar
-  require 'representable/version'
-  def self.representable_1_8? # TODO: remove me in 1.0.
-    Representable::VERSION =~ /^1.8/
-  end
-
-  module Representer
-    module JSON
-      def self.included(base)
-        base.class_eval do
-          include Representer
-          include Representable::JSON
-
-          extend ClassMethods
-          include InstanceMethods # otherwise Representable overrides our #to_json.
-        end
-      end
-
-      module InstanceMethods
-        def to_hash(*args)
-          before_serialize(*args)
-          super
-        end
-
-        def from_json(document, options={})
-          document = '{}' if document.nil? or document.empty?
-
-          super
-        end
-
-        # Generic entry-point for rendering.
-        def serialize(*args)
-          to_json(*args)
-        end
-
-        def deserialize(*args)
-          from_json(*args)
-        end
-      end
-
-
-      module ClassMethods
-        def deserialize(*args)
-          from_json(*args)
-        end
-
-        # TODO: move to instance method, or remove?
-        def links_definition_options
-          # FIXME: this doesn't belong into the generic JSON representer.
-          [:links_array, {:as => :links, :class => Feature::Hypermedia::Hyperlink, :extend => HyperlinkRepresenter, :collection => true,
-            :decorator_scope => true}]
-        end
-      end
-
-
-      require "representable/json/hash"
-      # Represents a hyperlink in standard roar+json hash representation.
-      module HyperlinkRepresenter
-        include Representable::JSON::Hash
-      end
-    end
-  end
-end

data/lib/roar/representer/transport/faraday.rb

@@ -1,50 +0,0 @@
-require 'faraday'
-
-module Roar
-  module Representer
-    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(uri, as, *args)
-          build_connection(uri, as).get
-        end
-
-        def post_uri(uri, body, as, *args)
-          build_connection(uri, as).post(nil, body)
-        end
-
-        def put_uri(uri, body, as, *args)
-          build_connection(uri, as).put(nil, body)
-        end
-
-        def patch_uri(uri, body, as, *args)
-          build_connection(uri, as).patch(nil, body)
-        end
-
-        def delete_uri(uri, as, *args)
-          build_connection(uri, 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
-end