snusnu-merb_resource_controller 0.1.0

data/lib/merb_resource_controller/resource_controller.rb

@@ -0,0 +1,160 @@
+module Merb
+  module ResourceController
+    
+    class ResourceControllerException < Exception; end
+    class WebMethodsNotAvailable < ResourceControllerException; end
+    class InvalidRoute < ResourceControllerException; end
+    
+    module Mixin
+  
+      module ClassMethods
+        
+        def controlling(name, options = {})
+          options = { :flash => true }.merge!(options)
+          @resource_proxy = Merb::ResourceController::ResourceProxy.new(name, options)
+          yield @resource_proxy if block_given?
+          class_inheritable_reader :resource_proxy
+          include InstanceMethods
+          include FlashSupport if options[:flash]
+          @resource_proxy.registered_actions.each do |a|
+            include Merb::ResourceController::Actions.const_get("#{a[:name].to_s.camel_case}")
+            show_action(a[:name])
+          end
+        end
+    
+      end
+  
+      module InstanceMethods
+        
+        protected
+    
+        def resource_proxy
+          self.class.resource_proxy
+        end
+        
+        
+        def singleton_controller?
+          resource_proxy.singleton_resource?
+        end
+        
+        def has_parent?
+          resource_proxy.has_parent? && has_parent_param?
+        end
+        
+        def has_parent_param?
+          !!parent_param
+        end
+        
+        
+        def parent
+          resource_proxy.path_to_resource(params)[-2].last
+        end
+        
+        # TODO refactor so that no additional queries are necessary
+        def parents
+          resource_proxy.parents.map do |parent|
+            parent[:class].get(params[parent[:key]])
+          end
+        end
+        
+        def parent_param
+          params[resource_proxy.parent_key]
+        end
+        
+        
+        def load_resource
+          path = resource_proxy.path_to_resource(params)
+          # puts "path_to_resource: #{path.inspect}"
+          path.each do |pc|
+            # puts "setting @#{pc[0]} to #{pc[1].inspect}" if pc[1]
+            instance_variable_set("@#{pc[0]}", pc[1]) if pc[1]
+          end
+        end
+        
+        def requested_resource
+          resource_proxy.path_to_resource(params).last.last
+        end
+        
+         
+        def set_collection(obj)
+          instance_variable_set("@#{collection_name}", obj)
+        end
+        
+        def set_member(obj)
+          instance_variable_set("@#{member_name}", obj)
+        end
+        
+        
+        def collection_name(resource = nil)
+          resource_proxy.collection_name(resource)
+        end
+        
+        def member_name(resource = nil)
+          resource_proxy.member_name(resource)
+        end
+        
+        
+        def collection
+          instance_variable_get("@#{collection_name}")
+        end
+        
+        def member
+          instance_variable_get("@#{member_name}")
+        end
+        
+        
+        def new_member(attributes = {})
+          resource_proxy.new_member(params, attributes)
+        end
+        
+        def member_params(attributes = {})
+          resource_proxy.member_params(params, attributes)
+        end
+        
+        def parent_params
+          resource_proxy.parent_params(params)
+        end
+        
+        
+        def flash_supported?
+          self.kind_of?(FlashSupport)
+        end
+    
+      end
+      
+      module FlashSupport
+        
+        protected
+        
+        def successful_create_messages
+          { :notice => "#{member.class.name} was successfully created" }
+        end
+                
+        def failed_create_messages
+          { :error => "Failed to create new #{member.class.name}" }
+        end
+        
+                
+        def successful_update_messages
+          { :notice => "#{member.class.name} was successfully updated" }
+        end
+                
+        def failed_update_messages
+          { :error => "Failed to update #{member.class.name}" }
+        end
+                
+                
+        def successful_destroy_messages
+          { :notice => "#{member.class.name} was successfully destroyed" }
+        end
+                
+        def failed_destroy_messages
+          { :error => "Failed to destroy #{member.class.name}" }
+        end
+        
+      end
+  
+    end
+  
+  end
+end

data/lib/merb_resource_controller/resource_proxy.rb

@@ -0,0 +1,317 @@
+module Merb
+  module ResourceController
+    
+    class ResourceProxy
+      
+      DEFAULT_NESTING_OPTIONS = {
+        :singleton => false, 
+        :fully_qualified => false
+      }
+            
+      DEFAULT_OPTIONS = DEFAULT_NESTING_OPTIONS.merge({
+        :defaults => true,
+        :use => :all
+      })
+      
+      attr_reader :resource, :parents, :registered_methods
+      
+      def initialize(resource, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+        @resource, @singleton = load_resource(resource), !!options[:singleton]
+        @fully_qualified = !!options[:fully_qualified]
+        @actions, @registered_methods, @parents = [], [], []
+        @specific_methods_registered = options[:use] != :all
+        register_default_actions! if options[:defaults]
+        register_methods!(options[:use])
+      end
+      
+      def action(name, options = {})
+        @actions << { :name => name.to_sym }.merge(options)
+      end
+            
+      def actions(*names)
+        names.each { |n| @actions << n.is_a?(Hash) ? n : { :name => n.to_sym } }
+      end
+      
+      def registered_actions
+        @actions
+      end
+      
+      # ----------------------------------------------------------------------------------------
+      # # one level nestings
+      # ----------------------------------------------------------------------------------------
+      # r.belongs_to :article               # assumes  :key => :article_id
+      # r.belongs_to :article, :key => :foo # override :key => :foo
+      # ----------------------------------------------------------------------------------------
+      # # multi level nestings (array item ordering reflects nesting strategy)
+      # ----------------------------------------------------------------------------------------
+      # r.belongs_to [ :article, :post ]    # assumes  :key => :article_id and :key => :post_id 
+      # r.belongs_to [ [ :article, :key => :foo ], :post ]
+      # r.belongs_to [ [ :article, :key => :foo ], [ :post, :key => :bar ] ] ]
+      # ----------------------------------------------------------------------------------------
+      
+      def belongs_to(parent, options = {})
+        case parent
+        when Symbol, String then
+          options = DEFAULT_NESTING_OPTIONS.merge(:key => key_name(parent)).merge(options)
+          @parents << { :name => parent, :class => load_resource(parent) }.merge(options)
+        when Array  then
+          parent.each do |p|
+            case p
+            when Symbol, String then
+              options = DEFAULT_NESTING_OPTIONS.merge(:key => key_name(p))
+              @parents << { :name => p, :class => load_resource(p) }.merge(options)
+            when Array  then
+              if (p[0].is_a?(Symbol) || p[0].is_a?(String)) && p[1].is_a?(Hash)
+                options = DEFAULT_NESTING_OPTIONS.merge(:key => key_name(p[0])).merge(p[1])
+                @parents << { :name => p[0], :class => load_resource(p[0]) }.merge(options)
+              else
+                raise ArgumentError, "use [ Symbol|String, Hash ] to denote one of multiple parents"
+              end
+            else
+              raise ArgumentError, "parent must be Symbol, String or Array but was #{p.class}"
+            end
+          end
+        else
+          raise ArgumentError, "parent must be Symbol, String or Array but was #{parent.class}"
+        end
+      end
+      
+      def belongs_to?(parent)
+        @parents.any? { |h| h[:name] == parent }
+      end
+      
+      def has_parent?
+        !@parents.empty?
+      end
+      
+      def has_parents?
+        @parents.size > 1
+      end
+      
+      def fully_qualified?
+        @fully_qualified
+      end
+      
+      def singleton_resource?
+        @singleton
+      end
+      
+      
+      def path_to_resource(params)
+        nesting_strategy_instance(nesting_strategy_template(params)).map do |i|
+          [ i[3] ? member_name(i[0], i[2]) : i[1] ? member_name(i[0], i[2]) : collection_name(i[0], i[2]), i[4] ]
+        end
+      end
+
+      def nesting_strategy_instance(nst, idx = 0)
+        if nst[idx]
+          if idx == 0
+            if nst[idx][3]
+              if nst[idx][1]
+                raise "Toplevel singleton resources are not supported"
+              else
+                nst[idx] = nst[idx] + [ nst[idx][0].get(nst[idx][3]), nra(nst[idx][0], nst) ]
+                nesting_strategy_instance(nst, idx + 1)
+              end
+            else
+              nst[idx] = nst[idx] + [ nst[idx][0].all, nra(nst[idx][0], nst) ]
+              nesting_strategy_instance(nst, idx + 1)
+            end
+          else
+            if nst[idx][3]
+              if nst[idx][1]
+                nst[idx] = nst[idx] + [ nst[idx - 1][4].send(nst[idx - 1][5]), nra(nst[idx][0], nst) ]
+                nesting_strategy_instance(nst, idx + 1)
+              else
+                nst[idx] = nst[idx] + [ nst[idx - 1][4].send(nst[idx - 1][5]).get(nst[idx][3]), nra(nst[idx][0], nst) ]
+                nesting_strategy_instance(nst, idx + 1)
+              end
+            else
+              nst[idx] = nst[idx] + [ nst[idx - 1][4].send(nst[idx - 1][5]), nra(nst[idx][0], nst) ]
+              nesting_strategy_instance(nst, idx + 1)
+            end
+          end
+        else
+          nst
+        end
+      end
+
+      # nested_resource_accessor
+      def nra(member, nst)
+        member = member.is_a?(Class) ? member : member.class
+        return nil unless idx = nst.map { |el| el[0] }.index(member)
+        if child = nst[idx + 1]
+          model, singleton, fully_qualified, id = child[0], child[1], child[2], child[3]
+          if id
+            collection_name(model, fully_qualified)
+          else
+            singleton ? member_name(model, fully_qualified) : collection_name(model, fully_qualified)
+          end
+        else
+          nil
+        end
+      end
+      
+      
+      def nesting_strategy_template(params)
+        idx = -1
+        nesting_strategy_params(params).map do |nsp|
+          nesting_strategy[idx += 1] << nsp
+        end
+      end
+      
+      def nesting_strategy_params(params)
+        parent_param_values(params) << params["id"]
+      end
+      
+      def nesting_strategy
+        parent_resources << [ @resource, @singleton, fully_qualified? ]
+      end
+      
+      def nesting_level
+        nesting_strategy.size
+      end
+      
+      
+      # all parent parameters
+      def parent_param_values(params)
+        parent_keys.map { |k| params[k] }
+      end
+      
+      # the immediate parent parameter    
+      def parent_param_value(params)
+        parent_param_values(params).last
+      end
+      
+      
+      def new_member(params, attributes = {})
+        resource.new(member_params(params, attributes))
+      end
+      
+      def member_params(params, attributes = {})
+        if attrs = params[member_name]
+          has_parent? ? parent_params(params).merge!(attrs).merge!(attributes) : attrs.merge!(attributes)
+        else
+          has_parent? ? parent_params(params).merge!(attributes) : attributes
+        end
+      end
+      
+      def parent_params(params)
+        parent_keys.inject({}) do |hash, key|
+          key = key.to_sym
+          hash[key] = params[key] if resource.properties.map { |p| p.name }.include?(key.to_sym)
+          hash
+        end
+      end
+      
+      
+      # all parent resources
+      def parent_resources
+        @parents.map { |h| [ h[:class], h[:singleton], h[:fully_qualified] ] }
+      end
+      
+      # the immediate parent resource
+      def parent_resource
+        parent_resources.last
+      end
+      
+      
+      # all parent resource keys
+      def parent_keys
+        @parents.map { |h| h[:key] }
+      end
+      
+      # the immediate parent resource key
+      def parent_key
+        @parents.last ? @parents.last[:key] : nil
+      end
+      
+      
+      def collection_name(resource = nil, fully_qualified = false)
+        if fully_qualified
+          Extlib::Inflection.tableize((resource || @resource).name).to_sym
+        else  
+          Extlib::Inflection.demodulize((resource || @resource).name).pluralize.snake_case.to_sym
+        end
+      end
+      
+      def member_name(resource = nil, fully_qualified = false)
+        collection_name(resource, fully_qualified).to_s.singularize.to_sym
+      end
+      
+      def key_name(resource = nil)
+        Extlib::Inflection.foreign_key(resource || @resource)
+      end
+      
+      
+      def specific_methods_registered?
+        @specific_methods_registered && !@registered_methods.empty?
+      end
+  
+      def method_registered?(name)
+        specific_methods_registered? ? registered_methods.map { |m| m[:name] }.include?(name.to_sym) : true
+      end
+      
+      
+      def method_missing(name, *args, &block)
+        return super unless method_registered?(name)
+        @resource.send(name, *args, &block)
+      end
+      
+      
+      private
+      
+      def load_resource(r)
+        case r
+        when Symbol
+          Module.find_const(r.to_s.singular.camel_case)
+        when String
+          Module.find_const(r.include?('::') ? r : r.singular.camel_case)
+        when Class
+          r
+        else
+          raise "resource must be either a Symbol, a String or a Class"
+        end
+      end
+      
+      def register_default_actions!
+        action :index unless @singleton
+        [ :show, :new, :edit, :create, :update, :destroy ].each do |a|
+          action(a)
+        end
+      end
+      
+      
+      # KEEP THESE for later
+      
+      def register_methods!(methods)
+        @registered_methods = case methods
+          when :all         then []
+          when :web_methods then @resource.web_methods
+          when Array        then methods
+          else raise
+        end
+      end
+      
+      # def raise_if_invalid_options!(options)
+      #   if options[:use] == :web_methods && !@resource.respond_to?(:web_methods)
+      #     raise WebMethodsNotAvailable, "require 'dm-is-online' if you want to use web_methods"
+      #   end
+      #   meth = options[:to]        
+      #   if options[:use] == :all
+      #     msg = "merb_resource_controller: #{@resource}.public_methods.include?(:#{meth}) == false"
+      #     raise InvalidRoute, msg unless @resource.public_methods.include?(meth)
+      #   elsif options[:use] == :web_methods
+      #     msg = "merb_resource_controller: #{@resource}.web_methods.include?(:#{meth}) == false"
+      #     raise InvalidRoute, msg unless @resource.web_methods.include?(meth)
+      #   else
+      #     msg = "merb_resource_controller: Invalid option[:use] = #{options[:use]}, using :all instead"
+      #     Merb::Logger.warn(msg)
+      #   end
+      # end
+  
+    end
+  
+  end
+end

data/lib/merb_resource_controller.rb

@@ -0,0 +1,29 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+
+  # Merb gave me a Merb::Plugins.config hash
+  # i felt free to put my stuff in my piece of it
+  Merb::Plugins.config[:merb_resource_controller] = {
+    :identity_map => true,
+    :action_timeout => true
+  }
+  
+  Merb::BootLoader.before_app_loads do
+    # require code that must be loaded before the application
+    mrc = File.join(File.dirname(__FILE__), 'merb_resource_controller')
+    require mrc / 'resource_proxy'
+    require mrc / 'actions'
+    require mrc / 'resource_controller'
+    if Merb::Plugins.config[:merb_resource_controller][:identity_map]
+      require mrc / 'identity_map_support'
+    end
+    if Merb::Plugins.config[:merb_resource_controller][:action_timeout]
+      require mrc / 'action_timeout_support'
+    end
+  end
+  
+  Merb::BootLoader.after_app_loads do
+    # code that can be required after the application loads
+  end
+  
+end

data/spec/mrc_test_app/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake/rdoctask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+include FileUtils
+
+# Load the basic runtime dependencies; this will include 
+# any plugins and therefore plugin rake tasks.
+init_env = ENV['MERB_ENV'] || 'rake'
+Merb.load_dependencies(:environment => init_env)
+     
+# Get Merb plugins and dependencies
+Merb::Plugins.rakefiles.each { |r| require r } 
+
+# Load any app level custom rakefile extensions from lib/tasks
+tasks_path = File.join(File.dirname(__FILE__), "lib", "tasks")
+rake_files = Dir["#{tasks_path}/*.rake"]
+rake_files.each{|rake_file| load rake_file }
+
+desc "Start runner environment"
+task :merb_env do
+  Merb.start_environment(:environment => init_env, :adapter => 'runner')
+end
+
+require 'spec/rake/spectask'
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+  
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+  
+end
+
+desc 'Default: run spec examples'
+task :default => 'spec'
+
+##############################################################################
+# ADD YOUR CUSTOM TASKS IN /lib/tasks
+# NAME YOUR RAKE FILES file_name.rake
+##############################################################################

data/spec/mrc_test_app/app/controllers/application.rb

@@ -0,0 +1,6 @@
+class Application < Merb::Controller
+  include Merb::ResourceController::DM::IdentityMapSupport
+  extend Merb::ResourceController::Mixin::ClassMethods
+  extend Merb::ResourceController::ActionTimeout
+  set_action_timeout 1
+end

data/spec/mrc_test_app/app/controllers/articles.rb

@@ -0,0 +1,3 @@
+class Articles < Application
+  controlling :articles
+end

data/spec/mrc_test_app/app/controllers/community/comments.rb

@@ -0,0 +1,9 @@
+module Community
+
+  class Comments < Application
+    controlling "Community::Comment" do |c|
+      c.belongs_to :article
+    end
+  end
+
+end

data/spec/mrc_test_app/app/controllers/community/ratings.rb

@@ -0,0 +1,9 @@
+module Community
+
+  class Ratings < Application
+    controlling "Community::Rating" do |r|
+      r.belongs_to [ :article, "Community::Comment" ]
+    end
+  end
+
+end

data/spec/mrc_test_app/app/controllers/editors.rb

@@ -0,0 +1,7 @@
+class Editors < Application
+  
+  controlling :editor, :singleton => true do |e|
+    e.belongs_to :article
+  end
+  
+end

data/spec/mrc_test_app/app/models/article.rb

@@ -0,0 +1,19 @@
+class Article
+  
+  include DataMapper::Resource
+  
+  property :id,      Serial
+  property :title,   String, :nullable => false, :length => (3..80)
+  property :body,    String
+  
+  property :editor_id, Integer
+  
+  belongs_to :editor
+  
+  has n, :comments, :class_name => "Community::Comment"
+  
+  def editor_name
+    editor ? editor.name : "Anonymous"
+  end
+  
+end

data/spec/mrc_test_app/app/models/editor.rb

@@ -0,0 +1,11 @@
+class Editor
+  
+  include DataMapper::Resource
+  
+  property :id, Serial
+  
+  property :name, String, :nullable => false, :length => (3..40)
+  
+  has n, :articles
+  
+end

data/spec/mrc_test_app/app/views/articles/edit.html.erb

@@ -0,0 +1,13 @@
+<h2>Edit Article</h2>
+
+<%= form_for(@article, :action => resource(@article), :method => :put) do %>
+
+  <p><%= text_field :title, :label => "Title"  %></p>
+  <p><%= text_field :body,  :label => "Body"  %></p>
+  <p><%= submit "Update" %></p>
+
+<% end =%>
+
+<%= link_to 'Show Editor', resource(@article, :editor) %> | 
+<%= link_to 'Show Article', resource(@article) %> | 
+<%= link_to 'All Articles', resource(:articles) %>

data/spec/mrc_test_app/app/views/articles/index.html.erb

@@ -0,0 +1,25 @@
+<h1>Listing Articles</h1>
+ 
+<table>
+  <tr>
+    <th>Title</th>
+    <th>Editor</th>
+    <th>Body</th>
+ 
+    <th colspan="3">Actions</th>
+  </tr>
+ 
+<% @articles.each do |article| %>
+  <tr>
+    <td><%=h article.title %></td>
+    <td><%=h article.editor_name %></td>
+    <td><%=h article.body %></td>
+ 
+    <td><%= link_to 'Show', resource(article) %></td>
+    <td><%= link_to 'Edit', resource(article, :edit) %></td>
+    <td><%= delete_button(article, "Delete #{article.title}") %></td>
+  </tr>
+<% end %>
+</table>
+ 
+<%= link_to 'New Article', resource(:articles, :new) %>

data/spec/mrc_test_app/app/views/articles/new.html.erb

@@ -0,0 +1,12 @@
+<h2>New Article</h2>
+ 
+<%= form_for(@article, :action => resource(:articles)) do %>
+ 
+  <p><%= text_field :title, :label => "Title" %></p>
+  <p><%= text_area :body, :label => "Body" %></p>
+  
+  <p><%= submit "Create" %></p>
+  
+<% end =%>
+
+<%= link_to 'All Articles', resource(:articles) %>

data/spec/mrc_test_app/app/views/articles/show.html.erb

@@ -0,0 +1,8 @@
+<h2>Show Article</h2>
+ 
+<h3><%=h @article.title %></h3>
+<p><%=h @article.body %></p>
+ 
+<%= link_to 'Edit Article', resource(@article, :edit) %>
+<%= link_to 'All Articles', resource(:articles) %>
+