e9_rails 0.0.10 → 0.0.11

data/lib/e9_rails/active_record/inheritable_options.rb

@@ -7,6 +7,11 @@ module E9Rails::ActiveRecord
     extend ActiveSupport::Concern
 
     included do
+      #
+      # NOTE 
+      #
+      attribute_method_suffix "_with_inheritable_options"
+
       class_inheritable_accessor :options_column
       self.options_column = :options
 
@@ -16,16 +21,17 @@ module E9Rails::ActiveRecord
       class_inheritable_accessor :options_class
       self.options_class = Options
 
+      class_inheritable_accessor :delegate_options_methods
+      self.delegate_options_methods = false
+
       self.options_class.lookup_ancestors = lookup_ancestors
     end
 
     def options=(hash={})
-      _serialize_inheritable_options_column unless _inheritable_options_column_serialized?
       write_attribute(options_column, hash.stringify_keys)
     end
 
     def options
-      _serialize_inheritable_options_column unless _inheritable_options_column_serialized?
       opts = read_attribute(options_column) || {}
       opts.reverse_merge! Hash[options_parameters.map(&:to_s).zip([nil])]
       options_class.new(opts, self)
@@ -33,18 +39,32 @@ module E9Rails::ActiveRecord
 
     protected
 
-      def _serialize_inheritable_options_column
-        self.class.serialized_attributes[options_column.to_s] = Hash
+    module ClassMethods
+      def define_method_attribute_with_inheritable_options(attr_name)
+        initialize_inheritable_options
+      end
+
+      def inheritable_options_initialized?
+        serialized_attributes[self.options_column.to_s].present?
       end
 
-      def _inheritable_options_column_serialized?
-        self.class.serialized_attributes[options_column.to_s].present?
+      def initialize_inheritable_options
+        return if inheritable_options_initialized?
+        serialized_attributes[self.options_column.to_s] = Hash
+
+        if self.delegate_options_methods
+          self.options_parameters.each do |param|
+            delegate param, "#{param}=", :to => :options
+          end
+        end
       end
+    end
 
     class Options < HashWithIndifferentAccess
       extend ActiveModel::Naming
       extend ActiveModel::Translation
 
+      # implementation of lookup_ancestors for AM & i18n
       class_inheritable_accessor :lookup_ancestors
 
       attr_reader :base

data/lib/e9_rails/active_record/initialization.rb

@@ -0,0 +1,20 @@
+module E9Rails::ActiveRecord
+  module Initialization
+    extend ActiveSupport::Concern
+
+    included do
+      alias :initialize_without_defaults :initialize
+
+      def initialize(attributes = nil, &block)
+        initialize_without_defaults(attributes) do
+          self.send(:_assign_initialization_defaults)
+          yield self if block_given?
+        end
+      end
+    end
+
+    def _assign_initialization_defaults; end
+
+    protected :_assign_initialization_defaults
+  end
+end

data/lib/e9_rails/controllers/orderable.rb

@@ -6,51 +6,80 @@ module E9Rails::Controllers
   module Orderable
     extend ActiveSupport::Concern
 
-    def default_ordered_on; 'created_at' end
-
-    def default_ordered_dir; 'DESC' end
+    included do
+      helper HelperMethods
 
-    def ordered_if; params[:action] == 'index' end
+      helper_method :default_ordered_dir
 
-    included do
-      if respond_to?(:resource_class)
-        has_scope :ordered_on, :if => :ordered_if, :default => lambda {|c| c.send(:default_ordered_on) } do |controller, scope, val|
-          begin
-            # determine the dir from params or controller default
-            dir = case controller.params[:dir]
-                  when /^desc$/i then 'DESC'
-                  when /^asc$/i  then 'ASC'
-                  else controller.send(:default_ordered_dir) rescue ''
-                  end
-
-            # split the ordered_param on commas and periods, the idea being that 
-            # it can take multiple columns, and on assocation columns
-            val = val.split(',').map {|v| v.split('.') }
-
-            val = val.map {|v| 
-              # if val split on '.', try to constantize the parsed class
-              if v.length > 1
-                klass = v.first.classify.constantize rescue nil
-                # and if it succeeds
-                if klass
-                  # apply the join to the scope.
-                  # NOTE there's no checking whatsoever here as to:
-                  #      A.) is this class an association?
-                  #      B.) does this class have the passed column?
-                  scope = scope.joins(v.first.underscore.to_sym)
-                  "#{klass.table_name}.#{v.last} #{dir}"
+      has_scope :order, :if => :ordered_if, :default => lambda {|c| c.send(:default_ordered_on) } do |controller, scope, columns|
+        begin
+          # determine the dir from params or controller default
+          dir = case controller.params[:sort]
+                when /^desc$/i then 'DESC'
+                when /^asc$/i  then 'ASC'
+                else controller.try(:default_ordered_dir) || ''
                 end
-              else
-                # else we're assuming the column is on the table
-                "#{resource_class.table_name}.#{v.last} #{dir}"
+
+          # split the ordered_param on commas and periods, the idea being that 
+          # it can take multiple columns, and on assocation columns
+          columns = columns.split(',').map {|n| n.split('.') }
+
+          columns = columns.map {|v| 
+            # if column split on '.', try to constantize the parsed class
+            if v.length > 1
+              klass = v.first.classify.constantize rescue nil
+
+              # and if it succeeds
+              if klass
+                # apply the join to the scope.
+                # NOTE there's no checking whatsoever here as to:
+                #      A.) is this class an association?
+                #      B.) does this class have the passed column?
+                scope = scope.includes(v.first.underscore.to_sym)
+                "#{klass.table_name}.#{v.last} #{dir}"
               end
-            }.compact.join(', ')
+            else
+              # else we're assuming the column is on the table
+              "#{controller.send(:resource_class).table_name}.#{v.last} #{dir}"
+            end
+          }.compact.join(', ')
+
+          scope.order(columns)
+        rescue => e
+          Rails.logger.error("Orderable ordered_on scope : #{e.message}")
+          scope
+        end
+      end
+    end
+
+    def default_ordered_on 
+      'created_at' 
+    end
+
+    def default_ordered_dir 
+      'DESC' 
+    end
+
+    def ordered_if 
+      params[:action] == 'index' 
+    end
+
+    module HelperMethods
+      def orderable_column_link(column, override_name = nil)
+        link_text = resource_class.human_attribute_name(override_name || column)
+
+        column = column.join(',') if column.is_a?(Array)
+
+        co, lo = if params[:order] == column.to_s
+          params[:sort] =~ /^desc$/i ? %w(DESC ASC) : %w(ASC DESC)
+        else
+          [nil, default_ordered_dir.presence || 'DESC']
+        end
+
+        css_classes = ["order-gfx", co, "h-#{lo}"].compact.join(' ').downcase
 
-            scope.order(val)
-          rescue => e
-            Rails.logger.error("Orderable ordered_on scope : #{e.message}")
-            scope
-          end
+        content_tag(:div, :class => 'ordered-column') do
+          link_to(link_text, :order => column, :sort => lo).safe_concat tag(:span, :class => css_classes)
         end
       end
     end

data/lib/e9_rails/controllers/sortable.rb

@@ -12,10 +12,26 @@ module E9Rails::Controllers
   module Sortable
     extend ActiveSupport::Concern
 
+    included do
+      class_inheritable_accessor :sortable_column
+      self.sortable_column = :position
+
+      class_inheritable_accessor :sortable_scope_proc
+      self.sortable_scope_proc = lambda {|_, scope, _| scope.order(sortable_column) }
+
+      #
+      # NOTE whatever the sortable column value, the proc will override the default.
+      #      the 'default' is only specified here to ensure that the scope is always called
+      #
+      has_scope :sortable_order, :only => :index, :default => sortable_column.to_s do |controller, scope, value|
+        sortable_scope_proc.call(controller, scope, value)
+      end
+    end
+
     def update_order(options = {}, &block)
       if params[:ids].is_a?(Array)
         pos = 0
-        params[:ids].each {|id| pos += 1; _do_position_update(id, :position => pos) }
+        params[:ids].each {|id| pos += 1; _do_position_update(id, sortable_column => pos) }
         flash[:notice] = I18n.t(:notice, :scope => :"flash.actions.update_order")
       else
         flash[:alert]  = I18n.t(:alert,  :scope => :"flash.actions.update_order")

data/lib/e9_rails/helpers/resource_error_messages.rb

@@ -23,11 +23,11 @@ module E9Rails::Helpers
           return ''
         end
 
+        errors = object.errors.map {|attribute, msg| msg }.flatten.map {|m| "<li>#{m}</li>"}.join("\n")
+
         <<-HTML.html_safe
           <div id="errorExplanation">
-            <ul>
-              #{ object.errors.map {|attribute, msg| "<li>#{msg}</li>" }.join }
-            </ul>
+            <ul>#{errors}</ul>
           </div>
         HTML
       rescue => e

data/lib/e9_rails/helpers/resource_links.rb

@@ -0,0 +1,84 @@
+module E9Rails::Helpers
+  module ResourceLinks
+    extend ActiveSupport::Concern
+
+    included do
+      helper HelperMethods
+
+      unless self._helper_methods.member?(:parent)
+        def parent; end
+        protected :parent
+        helper_method :parent
+      end
+    end
+
+    module HelperMethods
+      def link_to_resource(resource, options = {})
+        options.symbolize_keys!
+
+        path_options = options.slice!(:scope, :action, :method, :remote, :confirm, :class)
+
+        klass   = resource.is_a?(Class) ? resource : resource.class
+
+        action  = options.delete(:action)
+        action  = klass == resource ? :new : (action || :show).to_sym
+
+        scopes  = [*(options[:scope] || @route_scope), parent].compact
+        path    = case action
+                  when :new;  new_polymorphic_path(scopes << klass, path_options)
+                  when :edit; edit_polymorphic_path(scopes << resource, path_options)
+                  else        polymorphic_path(scopes << resource, path_options)
+                  end
+
+        mn = klass.model_name
+
+        translation_options = {
+          :model      => mn.human,
+          :models     => mn.human.pluralize,
+          :collection => mn.collection,
+          :element    => mn.element
+        }
+        
+        if action == :destroy
+          defaults = klass.lookup_ancestors.map {|k|
+            :"#{klass.i18n_scope}.links.#{k.model_name.underscore}.confirm_destroy"
+          } << :"#{klass.i18n_scope}.links.confirm_destroy"
+
+          options[:method] = :delete
+          options.reverse_merge!({
+            :remote  => true, 
+            :confirm => I18n.t(defaults.shift, translation_options.merge(:default => defaults))
+          })
+        end
+
+        #
+        # Mimic ActiveModel's lookup chain for attributes
+        #
+        defaults = klass.lookup_ancestors.map do |k|
+          :"#{klass.i18n_scope}.links.#{k.model_name.underscore}.#{action}"
+        end
+
+        defaults << :"#{klass.i18n_scope}.links.#{action}"
+        defaults << action.to_s.humanize
+
+        link_to I18n.t(defaults.shift, translation_options.merge(:default => defaults)), path, options
+      end
+
+      def link_to_show_resource(resource, options = {})
+        link_to_resource(resource, options.merge(:action => :show))
+      end
+
+      def link_to_edit_resource(resource, options = {})
+        link_to_resource(resource, options.merge(:action => :edit))
+      end
+
+      def link_to_new_resource(resource, options = {})
+        link_to_resource(resource, options.merge(:action => :new))
+      end
+
+      def link_to_destroy_resource(resource, options = {})
+        link_to_resource(resource, options.merge(:action => :destroy))
+      end
+    end
+  end
+end

data/lib/e9_rails/version.rb

@@ -1,3 +1,3 @@
 module E9Rails
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/lib/e9_rails.rb

@@ -4,9 +4,10 @@ module E9Rails
   autoload :Version, 'e9_rails/version'
 
   module ActiveRecord
-    autoload :STI,                   'e9_rails/active_record/sti'
     autoload :AttributeSearchable,   'e9_rails/active_record/attribute_searchable'
     autoload :InheritableOptions,    'e9_rails/active_record/inheritable_options'
+    autoload :Initialization,        'e9_rails/active_record/initialization'
+    autoload :STI,                   'e9_rails/active_record/sti'
   end
 
   module Controllers
@@ -15,9 +16,10 @@ module E9Rails
   end
 
   module Helpers
-    autoload :Translation,           'e9_rails/helpers/translation'
+    autoload :Pagination,            'e9_rails/helpers/pagination'
     autoload :ResourceErrorMessages, 'e9_rails/helpers/resource_error_messages'
+    autoload :ResourceLinks,         'e9_rails/helpers/resource_links'
     autoload :Title,                 'e9_rails/helpers/title'
-    autoload :Pagination,            'e9_rails/helpers/pagination'
+    autoload :Translation,           'e9_rails/helpers/translation'
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: e9_rails
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors: 
 - Travis Cox
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-02 00:00:00 -04:00
+date: 2011-05-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,11 +53,13 @@ files:
 - lib/e9_rails.rb
 - lib/e9_rails/active_record/attribute_searchable.rb
 - lib/e9_rails/active_record/inheritable_options.rb
+- lib/e9_rails/active_record/initialization.rb
 - lib/e9_rails/active_record/sti.rb
 - lib/e9_rails/controllers/orderable.rb
 - lib/e9_rails/controllers/sortable.rb
 - lib/e9_rails/helpers/pagination.rb
 - lib/e9_rails/helpers/resource_error_messages.rb
+- lib/e9_rails/helpers/resource_links.rb
 - lib/e9_rails/helpers/title.rb
 - lib/e9_rails/helpers/translation.rb
 - lib/e9_rails/version.rb