intermodal 0.0.1 → 0.4.0

data/lib/intermodal/mapping/presenter.rb

@@ -5,23 +5,29 @@ module Intermodal
       self._mapping_strategy = INCLUDE_NILS
 
       class << self
-        alias exclude_from_presentation exclude_properties 
+        alias exclude_from_presentation exclude_properties
 
         # Convenience alias for maps
         # Examples:
         #
         #  presents :name
-        #  presents :name, :as => lambda { |o| o.name.camelize }
-        #  presents :name, :as => [ :first_name, :last_name, :suffix, :prefix ]
-        #  
+        #  presents :name, :with => lambda { |o| o.name.camelize }
+        #  presents :name, :with => [ :first_name, :last_name, :suffix, :prefix ]
+
         alias presents maps
 
         def model_name(resource)
           resource.class.name.demodulize.underscore
         end
 
-        def call(resource)
-          { model_name(resource) => map_attributes(resource) }
+        def call(resource, options = {})
+          _scope = options[:scope] || :default
+
+          if options[:root] || options[:always_nest_collections]
+            { (options[:root].is_a?(TrueClass) || options[:root].nil? ? model_name(resource) : options[:root]) => map_attributes(resource, _scope) }
+          else
+            map_attributes(resource, _scope)
+          end
         end
       end
     end

data/lib/intermodal/proxies/linking_resources.rb

@@ -0,0 +1,58 @@
+module Intermodal
+  module Proxies
+    # This class is necessary to create the correct output for linked resources. 
+    # Example:
+    #
+    #   books n-to-n authors
+    #   Book #1 has 3 authors, Author #1, #2, and #3
+    #
+    #   Expected output:
+    #
+    #   { "books": { "author_ids": [ 1, 2, 3 ] } }
+    #
+    #   <books>
+    #     <author_ids>
+    #       <author_id>1</author_id>
+    #       <author_id>2</author_id>
+    #       <author_id>3</author_id>
+    #     </author_ids>
+    #   </books>
+    #
+    class LinkingResources
+      attr_accessor :parent_resource_name, :linked_resource_name, :collection, :parent_id
+      delegate :to_a, :to => :collection
+
+      # USAGE:
+      #   Intermodal::Proxies::LinkingResources.new(:parent, :to => :linked_resources, :with => collection)
+      def initialize(parent_resource_name, options = {})
+        @parent_resource_name = parent_resource_name
+        @collection = options[:with]
+        @linked_resource_name = options[:to]
+        @parent_id = (options[:parent_id] ? options[:parent_id].to_i : nil ) # nil should be nil, not 0
+      end
+
+      def to_json(options = {})
+        as_json(options).to_json
+      end
+
+      def as_json(options = {})
+        root = options[:root] || parent_resource_name
+        (root ? { root => presentation } : presentation)
+      end
+
+      def to_xml(options = {})
+        root = options[:root] || parent_resource_name
+        presentation.to_xml(:root => root)
+      end
+
+      def presentation
+        { linked_resource_element_name => collection.to_a, :id => parent_id }
+      end
+
+      def linked_resource_element_name
+        "#{linked_resource_name.to_s.singularize}_ids"
+      end
+
+    end
+  end
+end

data/lib/intermodal/proxies/will_paginate.rb

@@ -0,0 +1,85 @@
+module Intermodal
+  module Proxies
+    module WillPaginate
+      module Collection
+
+        def pagination_info
+          { :page => self.current_page.to_i,
+            :per_page => self.per_page.to_i,
+            :total_pages => self.total_pages,
+            :total_entries => self.total_entries }
+        end
+
+        # TODO: This needs its own spec
+        def as_json(*args)
+          options = args.extract_options!
+          _root = options.delete(:root)
+          _collection_name = _root || :collection
+
+          # Scrub out everything else
+          presenter_options = {
+            :root => (options[:always_nest_collections] && _root ? _collection_name.to_s.singularize : nil),
+            :always_nest_collections => options[:always_nest_collections],
+            :scope => options[:scope],
+            :presenter => options[:presenter] }
+          pagination_info.merge({ _collection_name => self.to_a.as_json(presenter_options)})
+        end
+
+        # TODO: This needs its own spec
+        # TODO: Should be refactored to have clearer code
+        def to_xml(*args)
+          options = args.extract_options!
+          _collection = self
+
+          # For a paginated collection of say, books, we want the following output:
+          #
+          # <books>
+          #   <collection>
+          #     <book>
+          #       <title> ... </title>
+          # ...
+          #
+          # Since Rails 3.0 magically assumes that a hash
+          # 
+          #   { :collection => [ {:title => ' ... ' } ] } 
+          #
+          # outputs to
+          #
+          #   <collection>
+          #     <collection>
+          #       <title> ... </title>
+          #
+          # We need to use a custom builder. We use very kludgy code, by calling #to_xml
+          # again, but override builder so it will nest things properly.
+          #
+          # Actually, it is also depending on some magic. Presenter/API options are saved
+          # in the builder class, so it uses that. Which means this isn't side-effect-free
+          # code. Ugh.
+          #
+          # Ultimately, this needs to be more modular so that API writers can specify their
+          # own builder. For now, we'll dictate the auto-generated XML and wait until someone
+          # complains about it in the Github Issues tracker.
+          collection_builder = proc do |opts, key|
+            _builder = opts[:builder]
+
+            _builder.collection do
+              _collection.to_a.map do |r| 
+                r.presentation(options.except(:root)).
+                  to_xml(
+                    :root => r.class.name.demodulize.underscore,
+                    :builder => opts[:builder],
+                    :skip_instruct => true )
+              end
+            end
+          end
+
+          # Merge information such as current page, total pages, total entries, etc.
+          pagination_info.
+            merge({ :collection => collection_builder }).
+            to_xml(options)
+        end
+      end
+    end
+  end
+end
+

data/lib/intermodal/rack/auth.rb

@@ -0,0 +1,29 @@
+module Intermodal
+  module Rack
+    class Auth
+      UNAUTHORIZED = [401, {}, []]
+      IDENTITY='HTTP_X_AUTH_IDENTITY'
+      KEY='HTTP_X_AUTH_KEY'
+
+      class << self
+        def valid?(env)
+          env[IDENTITY] && env[KEY]
+        end
+
+        # USAGE:
+        #
+        # (1) Define ::AccessCredential.authenticate!(identity, key) and returns an account object
+        # (2) Define ::AccessToken.generate!(account) and inserts token for authentication
+        #     You can inherit from Intermodal::Auth::AccessToken
+        # (3) Add to routes:
+        #     match '/auth', :to => Intermodal::Rack::Auth
+
+        def call(env)
+          return UNAUTHORIZED unless valid?(env) && ( account = ::AccessCredential.authenticate!(env[IDENTITY], env[KEY]))
+          access_token = ::AccessToken.generate!(account)
+          [ 204, { 'X-Auth-Token' => access_token.to_s }, []]
+        end
+      end
+    end
+  end
+end

data/lib/intermodal/rack/dummy_store.rb

@@ -0,0 +1,24 @@
+require 'action_dispatch/middleware/session/abstract_store'
+
+module Intermodal
+  module Rack
+    # A dummy store that does nothing, but satisfies Warden's session store requirement
+    # This allows us to use the x_auth_token strategy
+    class DummyStore < ::ActionDispatch::Session::AbstractStore
+
+      def get_session(env, sid)
+        [nil, nil]
+      end
+
+      # Set a session in the cache.
+      def set_session(env, sid, session, options)
+        nil
+      end
+
+      # Remove a session from the cache.
+      def destroy_session(env, sid, options)
+        nil
+      end
+    end
+  end
+end

data/lib/intermodal/rack/rescue.rb

@@ -0,0 +1,82 @@
+#require 'action_dispatch/http/mime_type'
+
+module Intermodal
+  module Rack
+    class Rescue
+      include ActionController::Rescue
+
+      def self.watch(x)
+        ap x if defined? ap
+      end
+
+      def watch(x)
+        self.class.watch(x)
+      end
+
+      rescue_from Exception do |exception|
+        if defined? Rails and Rails.env == 'production'
+          [500, {}, [ "Unexpected error. Please contact support." ] ]
+        else
+          [500, {}, [ "Exception: #{exception.message}", "\n\n", exception.backtrace ].tap(&method(:watch)) ]
+        end
+      end
+
+      rescue_from Intermodal::BadRequest do |exception|
+        [400, {}, [ 'Bad Request' ] ]
+      end
+
+      rescue_from ActiveRecord::RecordNotFound do |exception|
+        [404, {}, [ 'Not Found' ] ]
+      end
+
+      rescue_from ActionController::RoutingError do |exception|
+        if defined? Rails and Rails.env == 'production'
+          [404, {}, ['Not Found'] ]
+        else
+          [500, {}, [ "Exception: #{exception.message}", "\n", caller.join("\n"), "\n", exception.backtrace ].tap(&method(:watch)) ]
+        end
+      end
+
+      # TODO: Hack. Untested.
+      if defined? ActiveResource::ResourceNotFound
+        rescue_from ActiveResource::ResourceNotFound do |exception|
+          [404, {}, [ 'Not Found' ] ]
+        end
+      end
+
+      rescue_from ActionDispatch::ParamsParser::ParseError do |exception|
+        [400, { 'Content-Type' => content_type(:json) }, { :parse_error => exception.message }.to_json]
+      end
+
+      rescue_from MultiJson::DecodeError do |exception|
+        [400, { 'Content-Type' => content_type(:json) }, { :parse_error => exception.message }.to_json]
+      end
+
+      rescue_from 'REXML::ParseException' do |exception|
+        [400, { 'Content-Type' => content_type(:xml) }, { :parse_error => exception.message }.to_xml]
+      end
+
+      def content_type(format)
+        "#{Mime::Type.lookup_by_extension(format)}; charset=utf-8"
+      end
+
+      def initialize(app, &block)
+        @app = app
+        self.class.instance_eval(&block) if block_given?
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Exception => exception
+        rescue_with_handler(exception) || raise(exception)
+      end
+
+      # Overrides ActiveSuppor::Rescuable#rescue_with_handler
+      # All handlers *MUST* respond with a valid Rack response
+      def rescue_with_handler(exception)
+        return unless handler = handler_for_rescue(exception)
+        handler.arity != 0 ? handler.call(exception) : handler.call
+      end
+    end
+  end
+end

data/lib/intermodal/responders/linking_resource_responder.rb

@@ -0,0 +1,21 @@
+require 'action_controller/responder'
+
+module Intermodal
+  class LinkingResourceResponder < ResourceResponder
+
+    # This is the common behavior for "API" requests, like :xml and :json.
+    def respond
+      if get?
+        display resource, :root => presentation_root
+      elsif has_errors?
+        display resource.errors, :status => :unprocessable_entity
+      elsif post?
+        display resource, :status => :created
+          #:location => api_location # Taken out because it requires some additional URL definitions
+      else
+        head :ok
+      end
+    end
+
+  end
+end

data/lib/intermodal/responders/resource_responder.rb

@@ -0,0 +1,64 @@
+require 'action_controller/responder'
+
+
+module Intermodal
+  class ResourceResponder < ActionController::Responder
+    include Intermodal::Let
+
+    attr_accessor :options
+
+    let(:presenter) { options[:presenter] || controller.send(:presenter) }
+
+    let(:presentation_root)       { options[:presentation_root]  || controller_send(:presentation_root)  }
+    let(:presentation_scope)      { options[:presentation_scope] || controller_send(:presentation_scope) }
+    let(:always_nest_collections) { options[:always_nest_collections] || controller_send(:always_nest_collections) || false }
+
+    def initialize(controller, resources, options={})
+      super(controller, resources, options)
+      @options = options
+    end
+
+    # This is the common behavior for "API" requests, like :xml and :json.
+    def respond
+      return head :status => 404 unless resource
+      if get?
+        display resource,
+          root: presentation_root,
+          presenter: presenter,
+          scope: presentation_scope,
+          always_nest_collections: always_nest_collections
+
+      elsif has_errors?
+        display resource.errors,
+          root: presentation_root,
+          status: :unprocessable_entity,
+          presenter: presenter,
+          scope: presentation_scope,
+          always_nest_collections: always_nest_collections
+      elsif put?
+        display resource,
+          root: presentation_root,
+          presenter: presenter,
+          scope: presentation_scope,
+          always_nest_collections: always_nest_collections
+      elsif post?
+        display resource,
+          root: presentation_root,
+          status: :created,
+          presenter: presenter,
+          scope: presentation_scope,
+          always_nest_collections: always_nest_collections
+          #:location => api_location # Taken out because it requires some additional URL definitions
+      else
+        head status: 204
+      end
+    end
+
+    protected
+
+    def controller_send(_method)
+      controller.respond_to?(_method, true) ? controller.send(_method) : nil
+    end
+
+  end
+end

data/lib/intermodal/rspec/acceptors.rb

@@ -0,0 +1,79 @@
+module Intermodal
+  module RSpec
+    module Acceptors
+      extend ActiveSupport::Concern
+      included do
+        extend ::Intermodal::RSpec::Macros::Acceptors
+
+        let(:resource_name) { subject.name.underscore }
+        let(:acceptor) { api.acceptors[resource_name.to_sym] }
+        let(:random_field_data) { "Accepted Field #{rand(100000)}" }
+
+        def acceptance_for(input)
+          acceptor.call(input.with_indifferent_access)
+        end
+
+        def expects_acceptance(input, expectation)
+          acceptance_for(input).should eql(expectation)
+        end
+
+        def expects_rejection(input, expectation)
+          acceptance_for(input).should_not eql(expectation)
+        end
+      end
+    end
+
+    module Macros
+      module Acceptors
+        def concerned_with_acceptance(_model, &blk)
+          describe _model do
+            context "when concerned with acceptance" do
+              subject { _model }
+              instance_eval(&blk) if blk
+            end
+          end
+        end
+
+        def imposes(*fields)
+          fields.each do |field|
+            it "should accept #{field}" do
+              expects_acceptance({ field => random_field_data }, { field.to_sym => random_field_data })
+            end
+          end
+        end
+
+        def rejects(*fields)
+          fields.each do |field|
+            it "should reject #{field}" do
+              expects_rejection({ field => random_field_data }, { field.to_sym => random_field_data })
+            end
+          end
+        end
+
+        def imposes_named_resource
+          context 'when exposing named resource fields' do
+            imposes 'name'
+          end
+        end
+
+        def imposes_linked_resources(linked_resources_name, options = {})
+          _linked_resource_name, _linking_association = linked_resources_name.to_s.singularize, options[:with]
+          pending "when exposing linked resources, #{_linked_resource_name}" do
+            let(:linked_resource_ids_name) { :"#{_linked_resource_name}_ids" }
+            let(:linking_association) { :"#{_linking_association}" }
+            let(:linked_resource_ids) { subject.send(linking_association).send("to_#{linked_resource_ids_name}") }
+
+            it { should accept "#{_linked_resource_name}_ids" }
+            it "should accept \"#{_linked_resource_name}_ids\" as a collection of ids" do
+              resource
+              (presenter[linked_resource_ids_name].to_a & linked_resource_ids.to_a).should be_empty
+            end
+
+            pending "should only accept \"#{_linked_resource_name}_ids\" scoped to account"
+          end
+        end
+
+      end
+    end
+  end
+end