resource_mapper 0.0.1

data/lib/resource_mapper.rb

@@ -0,0 +1,31 @@
+require 'sinatra/base'
+require 'active_support'
+require 'mongo_mapper'
+
+module ResourceMapper
+  ACTIONS           = [:index, :show, :create, :update, :destroy]
+  SINGLETON_ACTIONS = (ACTIONS - [:index]).freeze
+  FAILABLE_ACTIONS  = (ACTIONS - [:index]).freeze
+  NAME_ACCESSORS    = [:model_name, :route_name, :object_name]
+  
+  autoload :Accessors,              'resource_mapper/accessors'
+  autoload :ActionOptions,          'resource_mapper/action_options'
+  autoload :Actions,                'resource_mapper/actions'
+  autoload :ClassMethods,           'resource_mapper/class_methods'
+  autoload :Controller,             'resource_mapper/controller'
+  autoload :FailableActionOptions,  'resource_mapper/failable_action_options'
+  autoload :ResponseCollector,      'resource_mapper/response_collector'
+
+  module Helpers
+    autoload :Internal,       'resource_mapper/helpers/internal'
+    autoload :Nested,         'resource_mapper/helpers/nested'
+    autoload :CurrentObjects, 'resource_mapper/helpers/current_objects'
+
+    include ResourceMapper::Helpers::Internal
+    include ResourceMapper::Helpers::Nested
+    include ResourceMapper::Helpers::CurrentObjects
+  end
+
+end
+
+require 'sinatra/resource'

data/lib/resource_mapper/accessors.rb

@@ -0,0 +1,77 @@
+module ResourceMapper # :nodoc:
+  module Accessors # :nodoc:
+    private
+      def block_accessor(*accessors)
+        accessors.each do |block_accessor|
+          class_eval <<-"end_eval", __FILE__, __LINE__
+
+            def #{block_accessor}(*args, &block)
+              unless args.empty? && block.nil?
+                args.push block if block_given?
+                @#{block_accessor} = [args].flatten
+              end
+              
+              @#{block_accessor}
+            end
+
+          end_eval
+        end
+      end
+      
+      def scoping_reader(*accessor_names)
+        accessor_names.each do |accessor_name|        
+          class_eval <<-"end_eval", __FILE__, __LINE__
+            def #{accessor_name}(&block)
+              @#{accessor_name}.instance_eval &block if block_given?
+              @#{accessor_name}
+            end
+          end_eval
+        end
+      end
+      
+      def class_scoping_reader(accessor_name, start_value)
+        write_inheritable_attribute accessor_name, start_value
+        
+        class_eval <<-"end_eval", __FILE__, __LINE__
+          def self.#{accessor_name}(&block)
+            read_inheritable_attribute(:#{accessor_name}).instance_eval(&block) if block_given?
+            read_inheritable_attribute(:#{accessor_name})
+          end
+        end_eval
+      end
+      
+      def reader_writer(accessor_name)
+        class_eval <<-"end_eval", __FILE__, __LINE__
+          def #{accessor_name}(*args, &block)
+            args << block unless block.nil?
+            @#{accessor_name} = args.first unless args.empty?
+            @#{accessor_name}
+          end
+        end_eval
+      end
+      
+      def class_reader_writer(*accessor_names)
+        accessor_names.each do |accessor_name|
+          class_eval <<-"end_eval", __FILE__, __LINE__
+            def self.#{accessor_name}(*args)
+              unless args.empty?
+                write_inheritable_attribute :#{accessor_name}, args.first if args.length == 1
+                write_inheritable_attribute :#{accessor_name}, args if args.length > 1
+              end
+            
+              read_inheritable_attribute :#{accessor_name}
+            end
+          
+            def #{accessor_name}(*args)
+              unless args.empty?
+                self.class.write_inheritable_attribute :#{accessor_name}, args.first if args.length == 1
+                self.class.write_inheritable_attribute :#{accessor_name}, args if args.length > 1
+              end
+            
+              self.class.read_inheritable_attribute :#{accessor_name}
+            end
+          end_eval
+        end
+      end
+  end
+end

data/lib/resource_mapper/action_options.rb

@@ -0,0 +1,35 @@
+module ResourceMapper
+  class ActionOptions
+    extend ResourceMapper::Accessors
+    
+    block_accessor :after, :before
+    
+    def initialize
+      @collector = ResourceMapper::ResponseCollector.new
+    end
+    
+    def response(*args, &block)
+      if !args.empty? || block_given?
+        @collector.clear
+        args.flatten.each { |symbol| @collector.send(symbol) }
+        block.call(@collector) if block_given?
+      end
+      
+      @collector.responses
+    end
+    alias_method :respond_to,  :response
+    alias_method :responds_to, :response
+    
+    def wants
+      @collector
+    end
+    
+    def dup
+      returning self.class.new do |duplicate|
+        duplicate.instance_variable_set(:@collector, wants.dup)
+        duplicate.instance_variable_set(:@before, before.dup)       unless before.nil?
+        duplicate.instance_variable_set(:@after, after.dup)         unless after.nil?
+      end
+    end
+  end
+end

data/lib/resource_mapper/actions.rb

@@ -0,0 +1,56 @@
+module ResourceMapper
+  module Actions
+    
+    def index
+      load_collection
+      before :index
+      response_for :index
+    end
+    
+    def show
+      load_object
+      before :show
+      response_for :show
+    rescue #ActiveRecord::RecordNotFound
+      response_for :show_fails
+    end
+
+    def create
+      build_object
+      load_object
+      before :create
+      if object.save
+        after :create
+        response_for :create
+      else
+        after :create_fails
+        response_for :create_fails
+      end
+    end
+
+    def update
+      load_object
+      before :update
+      if object.update_attributes object_params
+        after :update
+        response_for :update
+      else
+        after :update_fails
+        response_for :update_fails
+      end
+    end
+
+    def destroy
+      load_object
+      before :destroy
+      if object.destroy
+        after :destroy
+        response_for :destroy
+      else
+        after :destroy_fails
+        response_for :destroy_fails
+      end
+    end
+    
+  end
+end

data/lib/resource_mapper/class_methods.rb

@@ -0,0 +1,65 @@
+module ResourceMapper
+  module ClassMethods
+
+    # Use this method in your controller to specify which actions you'd like it to respond to.
+    #
+    #   class PostsController < ResourceController::Base
+    #     actions :all, :except => :create
+    #   end
+    def actions(*opts)
+      config = {}
+      config.merge!(opts.pop) if opts.last.is_a?(Hash)
+
+      all_actions = (singleton? ? ResourceMapper::SINGLETON_ACTIONS : ResourceMapper::ACTIONS)
+
+      actions_to_remove = []
+      actions_to_remove += all_actions - opts unless opts.first == :all                
+      actions_to_remove += [*config[:except]] if config[:except]
+      actions_to_remove.uniq!
+
+      actions_to_remove.each { |action| undef_method(action) if method_defined?(action) }
+    end
+
+    def key(sym)
+      class_eval <<-"end_eval", __FILE__, __LINE__
+        def key
+          :#{sym}
+        end
+      end_eval
+    end
+
+    def before(*args, &block)
+      raise "Need to specify a block for a before set." unless block_given?
+
+      args.flatten.each do |arg|
+        self.method(arg).call.before &block
+      end
+    end
+
+    # TODO: After fail after success
+    def after(*args, &block)
+      raise "Need to specify a block for an after set." unless block_given?
+
+      args.flatten.each do |arg|
+        self.method(arg).call.after &block
+      end
+    end
+
+    def read_params(*args)
+      class_eval <<-"end_eval", __FILE__, __LINE__
+        def read_params
+          {:only => #{args}}
+        end
+      end_eval
+    end
+
+    def write_params(*args)
+      class_eval <<-"end_eval", __FILE__, __LINE__
+        def write_params
+          #{args}
+        end
+      end_eval
+    end
+    
+  end
+end

data/lib/resource_mapper/controller.rb

@@ -0,0 +1,56 @@
+module ResourceMapper
+  module Controller
+    def self.included(subclass)
+      subclass.class_eval do
+        include ResourceMapper::Helpers
+        include ResourceMapper::Actions
+        extend  ResourceMapper::Accessors
+        extend  ResourceMapper::ClassMethods
+      
+        class_reader_writer :belongs_to, *NAME_ACCESSORS
+        NAME_ACCESSORS.each { |accessor| send(accessor, controller_name.singularize.underscore) }
+
+        ACTIONS.each do |action|
+          class_scoping_reader action, FAILABLE_ACTIONS.include?(action) ? ResourceMapper::FailableActionOptions.new : ResourceMapper::ActionOptions.new
+        end
+      end
+
+      init_default_actions(subclass)
+    end
+
+    private
+      def self.init_default_actions(klass)
+        klass.class_eval do
+          index.wants.json { collection.to_json(read_params) }
+          
+          show do
+            wants.json { object.to_json(read_params) }
+            failure.wants.json {
+              throw(:halt, [404, 'Not found.'])
+            }
+          end
+
+          create do
+            wants.json { object.to_json(read_params) }
+            failure.wants.json { "BOOOM!!!" }
+          end
+
+          update do
+            wants.json { object.to_json(read_params) }
+            failure.wants.json { "BOOOM!!!" }
+          end
+
+          destroy do
+            wants.json { "" }
+            failure.wants.json { "BOOM!!!" }
+          end
+          
+          class << self
+            def singleton?
+              false
+            end
+          end
+        end
+      end
+  end
+end

data/lib/resource_mapper/failable_action_options.rb

@@ -0,0 +1,25 @@
+module ResourceMapper
+  class FailableActionOptions
+    extend ResourceMapper::Accessors
+    
+    scoping_reader :success, :fails
+    alias_method :failure, :fails
+    
+    block_accessor :before
+    
+    def initialize
+      @success = ActionOptions.new
+      @fails   = ActionOptions.new
+    end
+    
+    delegate :after, :response, :wants, :to => :success
+    
+    def dup
+      returning self.class.new do |duplicate|
+        duplicate.instance_variable_set(:@success, success.dup)
+        duplicate.instance_variable_set(:@fails,   fails.dup)
+        duplicate.instance_variable_set(:@before,  before.dup) unless before.nil?
+      end
+    end
+  end
+end

data/lib/resource_mapper/helpers/current_objects.rb

@@ -0,0 +1,82 @@
+module ResourceMapper
+  module Helpers
+    module CurrentObjects
+      protected
+        # Used internally to return the model for your resource.  
+        #
+        def model
+          model_name.to_s.camelize.constantize
+        end
+
+  
+        # Used to fetch the collection for the index method
+        #
+        # In order to customize the way the collection is fetched, to add something like pagination, for example, override this method.
+        #
+        def collection
+          end_of_association_chain.all
+        end
+    
+        # Returns the current param for key.
+        # 
+        # Override this method if you'd like to use an alternate param name.
+        #
+        def param
+          params[:id]
+        end
+        
+        # Returns the key used for finding.
+        def key
+          :id
+        end
+  
+        # Used to fetch the current member object in all of the singular methods that operate on an existing member.
+        #
+        # Override this method if you'd like to fetch your objects in some alternate way, like using a permalink.
+        #
+        # class PostsController < ResourceController::Base
+        #   private
+        #     def object
+        #       @object ||= end_of_association_chain.find_by_permalink(param)
+        #     end
+        #   end
+        #
+        def object
+          @object ||= end_of_association_chain.first({key => param}) unless param.nil?
+          @object
+        end
+    
+        # Used internally to load the member object in to an instance variable @#{model_name} (i.e. @post)
+        #
+        def load_object
+          instance_variable_set "@#{parent_type}", parent_object if parent?
+          instance_variable_set "@#{object_name}", object
+        end
+    
+        # Used internally to load the collection in to an instance variable @#{model_name.pluralize} (i.e. @posts)
+        #
+        def load_collection
+          instance_variable_set "@#{parent_type}", parent_object if parent?
+          instance_variable_set "@#{object_name.to_s.pluralize}", collection
+        end
+  
+        # Returns the form params.  Defaults to params[model_name] (i.e. params["post"])
+        #
+        def object_params
+          ret = params["#{object_name}"]
+          ret.delete_if { |k, v| write_params.index(k.to_sym).nil? } unless write_params.nil?
+          ret
+        end
+    
+        # Builds the object, but doesn't save it, during the new, and create action.
+        #
+        def build_object
+          @object = end_of_association_chain.send parent? ? :build : :new, object_params
+        end
+
+        def read_params ; nil end
+        def write_params ; nil end
+        
+    end
+  end
+end

data/lib/resource_mapper/helpers/internal.rb

@@ -0,0 +1,58 @@
+# Internal action lifecycle management.
+# 
+# All of these methods are used internally to execute the options, set by the user in ActionOptions and FailableActionOptions
+#
+module ResourceMapper
+  module Helpers
+    module Internal
+      protected
+        # Used to actually pass the responses along to the controller's respond_to method.
+        #
+        def response_for(action)
+          respond_to do |wants|
+            options_for(action).response.each do |method, block|
+              if block.nil?
+                wants.send(method)
+              else
+                wants.send(method) { instance_eval(&block) }
+              end
+            end
+          end
+        end
+
+        # Calls the after callbacks for the action, if one is present.
+        #
+        def after(action)
+          invoke_callbacks *options_for(action).after
+        end
+
+        # Calls the before block for the action, if one is present.
+        #
+        def before(action)
+          invoke_callbacks *self.class.send(action).before
+        end
+
+        # Returns the options for an action, which is a symbol.
+        #
+        # Manages splitting things like :create_fails.
+        #
+        def options_for(action)
+          action = "#{action}".split('_').map(&:to_sym)
+          options = self.class.send(action.first)
+          options = options.send(action.last == :fails ? :fails : :success) if ResourceMapper::FAILABLE_ACTIONS.include? action.first
+  
+          options
+        end
+  
+        def invoke_callbacks(*callbacks)
+          unless callbacks.empty?
+            callbacks.select { |callback| callback.is_a? Symbol }.each { |symbol| send(symbol) }
+    
+            block = callbacks.detect { |callback| callback.is_a? Proc }
+            instance_eval &block unless block.nil?
+          end
+        end 
+
+    end
+  end
+end