easy_admin_ui 0.4.0 → 0.5.0

data/vendor/plugins/make_resourceful/lib/resourceful/default/urls.rb

@@ -0,0 +1,137 @@
+module Resourceful
+  module Default
+    # This file contains various methods to make URL helpers less painful.
+    # They provide methods analogous to the standard foo_url and foo_path helpers.
+    # However, they use make_resourceful's knowledge of the structure of the controller
+    # to allow you to avoid figuring out which method to call and which parent objects it should be passed.
+    module URLs
+      # This returns the path for the given object,
+      # by default current_object[link:classes/Resourceful/Default/Accessors.html#M000012].
+      # For example, in HatsController the following are equivalent:
+      #
+      #   object_path    #=> "/hats/12"
+      #   hat_path(@hat) #=> "/hats/12"
+      # 
+      def object_path(object = current_object); object_route(object, 'path'); end
+      # Same as object_path, but with the protocol and hostname.
+      def object_url (object = current_object); object_route(object, 'url');  end
+
+      # This is the same as object_path,
+      # unless a parent exists.
+      # Then it returns the nested path for the object.
+      # For example, in HatsController where Person has_many :hats and <tt>params[:person_id] == 42</tt>,
+      # the following are equivalent:
+      #
+      #   nested_object_path             #=> "/person/42/hats/12"
+      #   person_hat_path(@person, @hat) #=> "/person/42/hats/12"
+      # 
+      def nested_object_path(object = current_object); nested_object_route(object, 'path'); end
+      # Same as nested_object_path, but with the protocol and hostname.
+      def nested_object_url (object = current_object); nested_object_route(object, 'url');  end
+
+      # This returns the path for the edit action for the given object,
+      # by default current_object[link:classes/Resourceful/Default/Accessors.html#M000012].
+      # For example, in HatsController the following are equivalent:
+      #
+      #   edit_object_path                    #=> "/hats/12/edit"
+      #   edit_person_hat_path(@person, @hat) #=> "/hats/12/edit"
+      # 
+      def edit_object_path(object = current_object); edit_object_route(object, 'path'); end
+      # Same as edit_object_path, but with the protocol and hostname.
+      def edit_object_url (object = current_object); edit_object_route(object, 'url');  end
+
+      # This returns the path for the collection of the current controller.
+      # For example, in HatsController where Person has_many :hats and <tt>params[:person_id] == 42</tt>,
+      # the following are equivalent:
+      #
+      #   objects_path              #=> "/people/42/hats"
+      #   person_hats_path(@person) #=> "/people/42/hats"
+      # 
+      def objects_path; objects_route('path'); end
+      # Same as objects_path, but with the protocol and hostname.
+      def objects_url ; objects_route('url');  end
+
+      # This returns the path for the new action for the current controller.
+      # For example, in HatsController where Person has_many :hats and <tt>params[:person_id] == 42</tt>,
+      # the following are equivalent:
+      #
+      #   new_object_path              #=> "/people/42/hats/new"
+      #   new_person_hat_path(@person) #=> "/people/42/hats/new"
+      # 
+      def new_object_path; new_object_route('path'); end
+      # Same as new_object_path, but with the protocol and hostname.
+      def new_object_url ; new_object_route('url');  end
+
+      # This returns the path for the parent object.
+      # 
+      def parent_path(object = parent_object)
+        instance_route(parent_class_name.underscore, object, 'path')
+      end
+      # Same as parent_path, but with the protocol and hostname.
+      def parent_url(object = parent_object)
+        instance_route(parent_class_name.underscore, object, 'url')
+      end
+
+      # This prefix is added to the Rails URL helper names
+      # before they're called.
+      # By default, it's the underscored list of namespaces of the current controller,
+      # or nil if there are no namespaces defined.
+      # However, it can be overridden if another prefix is needed.
+      # Note that if this is overridden,
+      # the new method should return a string ending in an underscore.
+      #
+      # For example, in Admin::Content::PagesController:
+      #
+      #   url_helper_prefix #=> "admin_content_"
+      #
+      # Then object_path is the same as <tt>admin_content_page_path(current_object)</tt>.
+      def url_helper_prefix
+        namespaces.empty? ? nil : "#{namespaces.join('_')}_"
+      end
+
+      # This prefix is added to the Rails URL helper names
+      # for the make_resourceful collection URL helpers,
+      # objects_path and new_object_path.
+      # It's only added if url_helper_prefix returns nil.
+      # By default, it's the parent name followed by an underscore if a parent is given,
+      # and the empty string otherwise.
+      #
+      # See also url_helper_prefix.
+      def collection_url_prefix
+        parent? ? "#{parent_class_name.underscore}_" : ''
+      end
+
+      private
+
+      def object_route(object, type)
+        instance_route(current_model_name.underscore, object, type)
+      end
+
+      def nested_object_route(object, type)
+        return object_route(object, type) unless parent?
+        send("#{url_helper_prefix}#{parent_class_name.underscore}_#{current_model_name.underscore}_#{type}", parent_object, object)
+      end
+
+      def edit_object_route(object, type)
+        instance_route(current_model_name.underscore, object, type, "edit")
+      end
+
+      def objects_route(type)
+        collection_route(current_model_name.pluralize.underscore, type)
+      end
+
+      def new_object_route(type)
+        collection_route(current_model_name.underscore, type, "new")
+      end
+
+      def instance_route(name, object, type, action = nil)
+        send("#{action ? action + '_' : ''}#{url_helper_prefix}#{collection_url_prefix}#{name}_#{type}", *(parent? ? [parent_object, object] : [object]))
+      end
+
+      def collection_route(name, type, action = nil)
+        send("#{action ? action + '_' : ''}#{url_helper_prefix}#{collection_url_prefix}#{name}_#{type}",
+             *(parent? ? [parent_object] : []))
+      end
+    end
+  end
+end

data/vendor/plugins/make_resourceful/lib/resourceful/maker.rb

@@ -0,0 +1,84 @@
+require 'resourceful/builder'
+require 'resourceful/base'
+
+module Resourceful
+  # This module is extended by the ActionController::Base class object.
+  # It provides the actual +make_resourceful+ method
+  # and sets up the controller so that everything will work.
+  module Maker
+    # Called automatically on ActionController::Base.
+    # Initializes various inheritable attributes.
+    def self.extended(base)
+      base.write_inheritable_attribute :resourceful_callbacks, {}
+      base.write_inheritable_attribute :resourceful_responses, {}
+      base.write_inheritable_attribute :parents,               []
+      base.write_inheritable_attribute :made_resourceful,      false
+    end
+
+    # :call-seq:
+    #   make_resourceful(options = {}) { ... }
+    #
+    # This is the central method, and namesake, of make_resourceful.
+    # It takes a block and evaluates it in the context of a Builder,
+    # allowing the controller to be customized extensively.
+    #
+    # See Resourceful::Builder for documentation on the methods available
+    # in the context of the block.
+    #
+    # The only option currently available is <tt>:include</tt>.
+    # It takes an object that responds to to_proc
+    # (or an array of such objects)
+    # and evaluates that proc in the same context as the block.
+    # For example:
+    #
+    #   make_resourceful :include => proc { actions :all } do
+    #     before :show do
+    #       current_object.current_user = current_user
+    #     end
+    #   end
+    #
+    # This is the same as:
+    #
+    #   make_resourceful do
+    #     actions :all
+    #     before :show do
+    #       current_object.current_user = current_user
+    #     end
+    #   end
+    # 
+    def make_resourceful(options = {}, &block)
+      # :stopdoc:
+      include Resourceful::Base
+      # :startdoc:
+
+      builder = Resourceful::Builder.new(self)
+      unless builder.inherited?
+        Resourceful::Base.made_resourceful.each { |proc| builder.instance_eval(&proc) }
+      end
+      Array(options[:include]).each { |proc| builder.instance_eval(&proc) }
+      builder.instance_eval(&block)
+
+      builder.apply
+
+      add_helpers
+    end
+
+    # Returns whether or not make_resourceful has been called
+    # on this controller or any controllers it inherits from.
+    def made_resourceful?
+      read_inheritable_attribute(:made_resourceful)
+    end
+
+    private
+
+    def add_helpers
+      helper_method(:object_path, :objects_path, :new_object_path, :edit_object_path,
+                    :object_url, :objects_url, :new_object_url, :edit_object_url,
+                    :parent_path, :parent_url,
+                    :nested_object_path, :nested_object_url,
+                    :current_objects, :current_object, :current_model, :current_model_name,
+                    :namespaces, :instance_variable_name, :parent_names, :parent_name,
+                    :parent?, :parent_model, :parent_object, :save_succeeded?)
+    end
+  end
+end

data/vendor/plugins/make_resourceful/lib/resourceful/response.rb

@@ -0,0 +1,33 @@
+module Resourceful
+  # This is the class of the object passed to the Builder#response_for method.
+  # It shouldn't be used by users.
+  #
+  # The Response collects format procs
+  # and returns them with the format method,
+  # in the order they were given.
+  # For example:
+  #
+  #   response.html { redirect_to '/' }
+  #   response.xml { render :xml => current_object.to_xml }
+  #   response.js
+  #   response.formats #=> [[:html, #<Proc>], [:xml, #<Proc>], [:js, #<Proc>]]
+  #
+  # Note that the <tt>:js</tt> response is the empty proc -
+  # the same as <tt>proc {}</tt>.
+  class Response # :nodoc:
+    # Returns a list of pairs of formats and procs
+    # representing the formats passed to the response object.
+    # See class description.
+    attr :formats
+
+    # Returns a new Response with no format data.
+    def initialize
+      @formats = []
+    end
+
+    # Used to dispatch the individual format methods.
+    def method_missing(name, &block)
+      @formats.push([name, block || proc {}]) unless @formats.any? {|n,b| n == name}
+    end
+  end
+end

data/vendor/plugins/make_resourceful/lib/resourceful/serialize.rb

@@ -0,0 +1,185 @@
+require 'resourceful/builder'
+
+module Resourceful
+  # This module contains mixin modules
+  # used to implement the object serialization
+  # used for the Builder#publish method.
+  # They can also be used to get serialized representations of objects
+  # in other contexts.
+  #
+  # Serialization makes use of duck typing.
+  # Each class that can be serialized
+  # (just Array and ActiveRecord::Base by default)
+  # implements the +serialize+ and +to_serializable+ methods.
+  # These methods are implemented differently by the different classes,
+  # but the semantics of the implementations are consistent,
+  # so they can be used consistently.
+  #
+  # +to_serializable+ returns an object that can be directly serialized
+  # with a call to +to_xml+, +to_yaml+, or +to_json+.
+  # This object is either a hash or an array,
+  # and all the elements are either values, like strings and integers,
+  # or other serializable objects.
+  # This is useful for getting a model into a simple data structure format.
+  # The +attributes+ argument uses the same semantics
+  # as the <tt>:attributes</tt> option for Builder#publish.
+  # For example:
+  #
+  #   c = Cake.new(:flavor => 'chocolate', :text => 'Happy birthday, Chris!')
+  #   c.recipient = User.new(:name => 'Chris', :password => 'not very secure')
+  #   c.to_serializable [
+  #       :flavor, :text,
+  #       :recipient => :name
+  #     ]
+  #
+  # This would return the Ruby hash
+  #
+  #   { :flavor => 'chocolate', :text => 'Happy birthday, Chris!',
+  #     :user => {:name => 'Chris'} }
+  #
+  # +serialize+ takes a format (<tt>:xml</tt>, <tt>:yaml</tt>, or <tt>:json</tt> - see New Formats below)
+  # and a hash of options.
+  # The only option currently recognized is <tt>:attributes</tt>,
+  # which has the same semantics
+  # as the <tt>:attributes</tt> option for Builder#publish.
+  # +serialize+ returns a string containing the target
+  # serialized in the given format.
+  # For example:
+  #
+  #   c = CandyBag.new(:title => 'jellybag')
+  #   c.candies << Candy.new(:type => 'jellybean', :flavor => 'root beer')
+  #   c.candies << Candy.new(:type => 'jellybean', :flavor => 'pear')
+  #   c.candies << Candy.new(:type => 'licorice',  :flavor => 'anisey')
+  #   c.serialize :xml, :attributes => [:title, {:candies => [:type, :flavor]}]
+  #
+  # This would return a Ruby string containing
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <candy-bag>
+  #     <title>jellybag</title>
+  #     <candies>
+  #       <candy>
+  #         <type>jellybean</type>
+  #         <flavor>root beer</flavor>
+  #       </candy>
+  #       <candy>
+  #         <type>jellybean</type>
+  #         <flavor>pear</flavor>
+  #       </candy>
+  #       <candy>
+  #         <type>licorice</type>
+  #         <flavor>anisey</flavor>
+  #       </candy>
+  #     </candies>
+  #   </candy-bag>
+  # 
+  module Serialize
+
+    # Takes an attributes option in the form passed to Builder#publish
+    # and returns a hash (or nil, if attributes is nil)
+    # containing the same data,
+    # but in a more consistent format.
+    # All keys are converted to symbols,
+    # and all lists are converted to hashes.
+    # For example:
+    #
+    #   Resourceful::Serialize.normalize_attributes([:foo, :bar, {"baz" => ["boom"]}])
+    #     #=> {"baz"=>["boom"], :foo=>nil, :bar=>nil}
+    # 
+    def self.normalize_attributes(attributes) # :nodoc:
+      return nil if attributes.nil?
+      return {attributes.to_sym => nil} if String === attributes
+      return {attributes => nil} if !attributes.respond_to?(:inject)
+
+      attributes.inject({}) do |hash, attr|
+        if Array === attr
+          hash[attr[0]] = attr[1]
+          hash
+        else
+          hash.merge normalize_attributes(attr)
+        end
+      end
+    end
+
+    # This module contains the definitions of +serialize+ and +to_serializable+
+    # that are included in ActiveRecord::Base.
+    module Model
+      # :call-seq:
+      #   serialize format, options = {}, :attributes => [ ... ]
+      #
+      # See the module documentation for Serialize for details.
+      def serialize(format, options)
+        raise "Must specify :attributes option" unless options[:attributes]
+        hash = self.to_serializable(options[:attributes])
+        root = self.class.to_s.underscore
+        if format == :xml
+          hash.send("to_#{format}", :root => root)
+        else
+          {root => hash}.send("to_#{format}")
+        end
+      end
+
+      # See the module documentation for Serialize for details.
+      def to_serializable(attributes)
+        raise "Must specify attributes for #{self.inspect}.to_serializable" if attributes.nil?
+
+        Serialize.normalize_attributes(attributes).inject({}) do |hash, (key, value)|
+          hash[key.to_s] = attr_hash_value(self.send(key), value)
+          hash
+        end
+      end
+
+      private
+
+      # Given an attribute value
+      # and a normalized (see above) attribute hash,
+      # returns the serializable form of that attribute.
+      def attr_hash_value(attr, sub_attributes)
+        if attr.respond_to?(:to_serializable)
+          attr.to_serializable(sub_attributes)
+        else
+          attr
+        end
+      end
+    end
+
+    # This module contains the definitions of +serialize+ and +to_serializable+
+    # that are included in ActiveRecord::Base.
+    module Array
+      # :call-seq:
+      #   serialize format, options = {}, :attributes => [ ... ]
+      #
+      # See the module documentation for Serialize for details.      
+      def serialize(format, options)
+        raise "Not all elements respond to to_serializable" unless all? { |e| e.respond_to? :to_serializable }
+        raise "Must specify :attributes option" unless options[:attributes]
+
+        serialized = map { |e| e.to_serializable(options[:attributes]) }
+        root = first.class.to_s.pluralize.underscore
+
+        if format == :xml
+          serialized.send("to_#{format}", :root => root)
+        else
+          {root => serialized}.send("to_#{format}")
+        end
+      end
+
+      # See the module documentation for Serialize for details.
+      def to_serializable(attributes)
+        if first.respond_to?(:to_serializable)
+          attributes = Serialize.normalize_attributes(attributes)
+          map { |e| e.to_serializable(attributes) }
+        else
+          self
+        end
+      end
+    end
+  end
+end
+
+if defined? ActiveModel
+  class ActiveModel::Base; include Resourceful::Serialize::Model; end
+else
+  class ActiveRecord::Base; include Resourceful::Serialize::Model; end
+end
+class Array; include Resourceful::Serialize::Array; end