dry_crud 0.6.0

data/rails_generators/dry_crud/templates/app/helpers/standard_helper.rb

@@ -0,0 +1,209 @@
+# A view helper to standartize often used functions like formatting, 
+# tables, forms or action links. This helper is ideally defined in the 
+# ApplicationController.
+module StandardHelper
+  
+  NO_LIST_ENTRIES_MESSAGE = "No entries available"
+  CONFIRM_DELETE_MESSAGE  = 'Do you really want to delete this entry?'
+  
+  FLOAT_FORMAT = "%.2f"
+  TIME_FORMAT  = "%H:%M"
+  EMPTY_STRING = " "   # non-breaking space asserts better css styling.
+  
+  ################  FORMATTING HELPERS  ##################################
+
+  # Define an array of associations symbols in your helper that should not get automatically linked.
+  #def no_assoc_links = [:city]
+  
+  # Formats a single value
+  def f(value)
+    case value
+      when Fixnum then number_with_delimiter(value)
+      when Float  then FLOAT_FORMAT % value
+			when Date	  then value.to_s
+      when Time   then value.strftime(TIME_FORMAT)   
+      when true   then 'yes'
+      when false  then 'no'
+      when nil    then EMPTY_STRING
+    else 
+      value.respond_to?(:label) ? h(value.label) : h(value.to_s)
+    end
+  end
+  
+  # Formats an arbitrary attribute of the given ActiveRecord object.
+  # If no specific format_{attr} method is found, formats the value as follows:
+  # If the value is an associated model, renders the label of this object.
+  # Otherwise, calls format_type.
+  def format_attr(obj, attr)
+    format_attr_method = :"format_#{attr.to_s}"
+    if respond_to?(format_attr_method)
+      send(format_attr_method, obj)
+    elsif assoc = belongs_to_association(obj, attr)
+      format_assoc(obj, assoc)
+    else
+      format_type(obj, attr)
+    end
+  end
+  
+  # Formats an active record association
+  def format_assoc(obj, assoc)
+    if assoc_val = obj.send(assoc.name)
+      link_to_unless(no_assoc_link?(assoc), h(assoc_val.label), assoc_val)
+    else
+			'(none)'
+    end
+  end
+  
+  # Returns true if no link should be created when formatting the given association.
+  def no_assoc_link?(assoc)
+    (respond_to?(:no_assoc_links) && no_assoc_links.to_a.include?(assoc.name.to_sym)) || 
+    !respond_to?("#{assoc.klass.name.underscore}_path".to_sym)
+  end
+  
+  # Formats an arbitrary attribute of the given object depending on its data type.
+  # For ActiveRecords, take the defined data type into account for special types
+  # that have no own object class.
+  def format_type(obj, attr)
+    val = obj.send(attr)
+    return EMPTY_STRING if val.nil?
+    case column_type(obj, attr)
+      when :time    then val.strftime(TIME_FORMAT)
+      when :date    then val.to_date.to_s
+      when :text    then simple_format(h(val))
+      when :decimal then f(val.to_s.to_f)
+    else f(val)
+    end
+  end
+  
+  # Returns the ActiveRecord column type or nil.
+  def column_type(obj, attr)
+    column_property(obj, attr, :type)
+  end
+  
+  # Returns an ActiveRecord column property for the passed attr or nil
+  def column_property(obj, attr, property)
+    if obj.respond_to?(:column_for_attribute)
+      column = obj.column_for_attribute(attr)
+      column.try(property)
+    end  
+  end
+  
+  # Returns the :belongs_to association for the given attribute or nil if there is none.
+  def belongs_to_association(obj, attr)
+    if assoc = association(obj, attr)
+      assoc if assoc.macro == :belongs_to
+    end
+  end
+  
+  # Returns the association proxy for the given attribute. The attr parameter
+  # may be the _id column or the association name. Returns nil if no association
+  # was found.
+  def association(obj, attr)
+    if obj.class.respond_to?(:reflect_on_association)
+      assoc = attr.to_s =~ /_id$/ ? attr.to_s[0..-4].to_sym : attr
+      obj.class.reflect_on_association(assoc)
+    end
+  end
+  
+  
+  ##############  STANDARD HTML SECTIONS  ############################
+  
+  
+  # Renders an arbitrary content with the given label. Used for uniform presentation.
+  # Without block, this may be used in the form <%= labeled(...) %>, with like <% labeled(..) do %>
+  def labeled(label, content = nil, &block)
+    content = capture(&block) if block_given?
+    html = render(:partial => 'shared/labeled', :locals => { :label => label, :content => content})
+    block_given? ? concat(html) : html  
+  end
+  
+  # Transform the given text into a form as used by labels or table headers.
+  def captionize(text, clazz = nil)
+    if clazz.respond_to?(:human_attribute_name)
+      clazz.human_attribute_name(text)
+    else
+      text.to_s.humanize.titleize      
+    end
+  end
+  
+  # Renders a list of attributes with label and value for a given object. 
+  # Optionally surrounded with a div.
+  def render_attrs(obj, attrs, div = true)
+    html = attrs.collect do |a| 
+      labeled(captionize(a, obj.class), format_attr(obj, a))
+    end.join
+    
+    div ? content_tag(:div, html, :class => 'attributes') : html
+  end
+  
+  # Renders a table for the given entries as defined by the following block.
+  # If entries are empty, an appropriate message is rendered.
+  def table(entries, &block)
+    if entries.present?
+      StandardTableBuilder.table(entries, self, &block)
+    else
+      content_tag(:div, NO_LIST_ENTRIES_MESSAGE, :class => 'list')
+    end
+  end
+  
+  # Renders a generic form for all given attributes using StandardFormBuilder.
+  # Before the input fields, the error messages are rendered, if present.
+  # The form is rendered with a basic save button.
+  # If a block is given, custom input fields may be rendered and attrs is ignored.
+  #
+  # The form is always directly printed into the erb, so the call must
+  # go within a normal <% form(...) %> section, not in a <%= output section
+  def standard_form(object, attrs = [], options = {})
+    form_for(object, {:builder => StandardFormBuilder}.merge(options)) do |form|
+      concat form.error_messages
+      
+      if block_given? 
+        yield(form)
+      else
+        concat form.labeled_input_fields(*attrs)
+      end
+      
+      concat labeled(EMPTY_STRING, form.submit("Save"))
+    end
+  end
+  
+  # Alternate table row
+  def tr_alt(&block)
+    content_tag(:tr, :class => cycle("even", "odd", :name => "row_class"), &block)
+  end
+ 
+  
+  ######## ACTION LINKS ###################################################### :nodoc:
+  
+  # Standard link action to the show page of a given record.
+  def link_action_show(record)
+    link_action 'Show', record
+  end
+  
+  # Standard link action to the edit page of a given record.
+  def link_action_edit(record)
+    link_action 'Edit', edit_polymorphic_path(record)
+  end
+  
+  # Standard link action to the destroy action of a given record.
+  def link_action_destroy(record)
+    link_action 'Delete', record, :confirm => CONFIRM_DELETE_MESSAGE, :method => :delete
+  end
+  
+  # Standard link action to the list page.
+  def link_action_index(url_options = {:action => 'index'})
+    link_action 'List', url_options
+  end
+  
+  # Standard link action to the new page.
+  def link_action_add(url_options = {:action => 'new'})
+    link_action 'Add', url_options
+  end
+  
+  # A generic helper method to create action links.
+  # These link may be styled to look like buttons, for example.
+  def link_action(label, options = {}, html_options = {})
+    link_to("[#{label}]", options, {:class => 'action'}.merge(html_options))
+  end
+  
+end

data/rails_generators/dry_crud/templates/app/views/crud/_attrs.html.erb

@@ -0,0 +1 @@
+<%= render_attrs @entry, default_attrs %>

data/rails_generators/dry_crud/templates/app/views/crud/_form.html.erb

@@ -0,0 +1 @@
+<% crud_form %>

data/rails_generators/dry_crud/templates/app/views/crud/_list.html.erb

@@ -0,0 +1 @@
+<%= crud_table %>

data/rails_generators/dry_crud/templates/app/views/crud/edit.html.erb

@@ -0,0 +1,8 @@
+<% @title = "Edit #{full_entry_label}" -%>
+
+<%= render_inheritable :partial => 'form' %>
+
+<br/>
+
+<%= link_action_show @entry %>
+<%= link_action_destroy @entry %>

data/rails_generators/dry_crud/templates/app/views/crud/index.html.erb

@@ -0,0 +1,14 @@
+<% @title = "Listing #{models_label}" -%>
+
+<%= render_inheritable :partial => 'list' %>
+
+<br/>
+
+<%= link_action_add %>
+
+
+
+
+
+
+

data/rails_generators/dry_crud/templates/app/views/crud/new.html.erb

@@ -0,0 +1,7 @@
+<% @title = "New #{models_label.singularize}" -%>
+
+<%= render_inheritable :partial => 'form' %>
+
+<br/>
+
+<%= link_action_index %>

data/rails_generators/dry_crud/templates/app/views/crud/show.html.erb

@@ -0,0 +1,9 @@
+<% @title = full_entry_label -%>
+
+<%= render_inheritable :partial => 'attrs' %>
+
+<br/>
+
+<%= link_action_index %>
+<%= link_action_edit(@entry) %>
+<%= link_action_destroy	(@entry) %>

data/rails_generators/dry_crud/templates/app/views/layouts/crud.html.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
+  <title><%= @title %></title>
+  <%= stylesheet_link_tag 'crud' %>
+  <%= javascript_include_tag :all %>
+</head>
+<body>
+
+<h1><%= @title %></h1>
+
+<p id="flash_notice"><%= flash[:notice] %></p>
+
+<%= yield %>
+
+</body>
+</html>

data/rails_generators/dry_crud/templates/app/views/shared/_labeled.html.erb

@@ -0,0 +1,5 @@
+<div class="labeled">
+	<%-# presence is Rails 2.3.8 for label.present? ? label : StandardHelper::EMPTY_STRING -%>
+	<div class="caption"><%= label.presence || StandardHelper::EMPTY_STRING %></div>
+	<div class="value"><%= content.presence || StandardHelper::EMPTY_STRING %></div>
+</div>

data/rails_generators/dry_crud/templates/lib/crud_callbacks.rb

@@ -0,0 +1,55 @@
+# Defines before and after callback hooks for render, create, update, save and destroy.
+# When to execute the callbacks is in the responsibility of the clients of this module.
+#
+# The following callbacks may be defined:
+# * before_create
+# * after_create
+# * before_update
+# * after_update
+# * before_save
+# * after_save
+# * before_destroy
+# * after_destroy
+# * before_render_index
+# * before_render_show
+# * before_render_new
+# * before_render_edit
+#
+module CrudCallbacks
+  
+  def self.included(base)
+    base.send :include, ActiveSupport::Callbacks
+    
+    base.define_callbacks :before_create,  :after_create, 
+      						        :before_update,  :after_update, 
+      						        :before_save,    :after_save, 
+      						        :before_destroy, :after_destroy,
+                          :before_render_index,
+                          :before_render_show,
+                          :before_render_new,
+                          :before_render_edit
+  end
+  
+  protected
+  
+  # Helper method the run the given block in between the before and after
+  # callbacks of the given kind.
+  def with_callbacks(kind)
+    return false if callbacks("before_#{kind}".to_sym) == false        
+    if result = yield
+      callbacks("after_#{kind}".to_sym)
+    end
+    result
+  end
+  
+  def render_callbacks(action)
+    run_callbacks("before_render_#{action}".to_sym) do |result, object| 
+      result == false || object.performed?
+    end
+  end
+  
+  def callbacks(kind)
+    run_callbacks(kind) { |result, object| false == result }
+  end
+  
+end

data/rails_generators/dry_crud/templates/lib/render_inheritable.rb

@@ -0,0 +1,118 @@
+# Allows one to render inheritable views and partials.
+# If no view file is found for the current controller, the corresponding file
+# is looked up in its superclass hierarchy. This module must only be
+# included in the root controller of the desired lookup hierarchy.
+# 
+# By default, this module only supports direct inheritance over one level. By overriding
+# the method lookup_path, you may define a custom lookup path. By providing an object
+# for the 'with' parameter, this path may even be dynamic.
+module RenderInheritable
+  
+  protected
+  
+  # Add inheritable_root_path method to includer
+  def self.included(controller_class)
+    controller_class.send(:extend, ClassMethods)
+    
+    controller_class.send(:class_variable_set, :@@inheritable_root_controller, controller_class)
+    controller_class.cattr_reader :inheritable_root_controller
+    
+    controller_class.helper ViewHelper
+    controller_class.helper_method :inheritable_partial_options
+  end    
+  
+  # Method from ActionController::Base overriden, so render_inheritable will be 
+  # called if the action does not call render explicitly.   
+  def default_render
+    render_inheritable :action => action_name
+  end
+  
+  # Renders an action or a partial considering the lookup path. Templates
+  # specified in the :action or :partial options are looked up and the most 
+  # specific one found will get rendered. The options are directly passed to 
+  # the original render method.
+  def render_inheritable(options)         
+    if options[:action]
+      inheritable_template_options(options)
+    elsif options[:partial]
+      inheritable_partial_options(options)
+    end
+    render options
+  end
+  
+  # Replaces the :template option with the file found in the lookup.
+  def inheritable_template_options(options)
+    file = options.delete(:action)
+    inheritable_file_options(options, :template, file)
+  end
+  
+  # Replaces the :partial option with the file found in the lookup.
+  def inheritable_partial_options(options)
+    inheritable_file_options(options, :partial, options[:partial])
+  end
+  
+  def inheritable_file_options(options, key, file) #:nodoc:
+    with = options.delete(:with)
+    filename = (key == :partial) ? "_#{file}" : file
+    folder = self.class.find_inheritable_file(filename, default_template_format, with)        
+    options[key] = folder.present? ? "#{folder}/#{file}" : file
+  end
+  
+  module ClassMethods
+    # Performs a lookup for the given filename and returns the most specific
+    # folder that contains the file.
+    def find_inheritable_file(filename, format = :html, with = nil)  
+      inheritable_cache[format.to_sym][filename][with] ||= find_inheritable_artifact(with) do |folder|
+        view_paths.find_template("#{folder}/#{filename}", format).present? rescue false
+      end
+    end
+    
+    # Performs a lookup for a controller and returns the name of the most specific one found.
+    # This method is primarly usefull when given a 'with' argument, that is used
+    # in a custom lookup_path. 
+    def inheritable_controller(with = nil)
+      c = find_inheritable_artifact(with) do |folder|
+        ActionController::Routing.possible_controllers.any? { |c| c == folder }
+      end
+      c || inheritable_root_controller.controller_path
+    end
+    
+    # Runs through the lookup path and yields each folder to the passed block.
+    # If the block returns true, this folder is returned and no further lookup
+    # happens. If no folder is found, the nil is returned.
+    def find_inheritable_artifact(with = nil)
+      lookup_path(with).each { |folder| return folder if yield(folder) }
+      nil
+    end
+    
+    # An array of controller names / folders, ordered from most specific to most general.
+    # May be dynamic dependening on the passed 'with' argument. 
+    # You may override this method in an own controller to customize the lookup path.
+    def lookup_path(with = nil)
+      inheritance_lookup_path
+    end
+    
+    # The inheritance path of controllers that is used as default lookup path.
+    def inheritance_lookup_path
+      path = [self]
+      until path.last == inheritable_root_controller
+        path << path.last.superclass
+      end
+      path.collect(&:controller_path)
+    end
+    
+    def inheritable_cache #:nodoc:
+      @inheritable_cache ||= Hash.new {|h, k| h[k] = Hash.new {|h, k| h[k] = Hash.new } }
+    end
+  end
+  
+  module ViewHelper
+    # Because ActionView has a different :render method than ActionController, 
+    # this method provides an entry point to use render_inheritable from views.
+    def render_inheritable(options)                
+      inheritable_partial_options(options) if options[:partial]  
+      render options
+    end   
+  end
+  
+end

data/rails_generators/dry_crud/templates/lib/standard_form_builder.rb

@@ -0,0 +1,161 @@
+# A form builder that automatically selects the corresponding input field
+# for ActiveRecord column types. Convenience methods for each column type allow
+# one to customize the different fields. 
+# All field methods may be prefixed with 'labeled_' in order to render
+# a standard label with them.
+class StandardFormBuilder < ActionView::Helpers::FormBuilder
+  
+  BLANK_SELECT_LABEL = 'Please select'
+  
+  attr_reader :template 
+  
+  delegate :association, :belongs_to_association, :column_type, :column_property, :captionize, 
+           :to => :template
+  
+  # Render multiple input fields together with a label for the given attributes.
+  def labeled_input_fields(*attrs)
+    attrs.collect {|a| labeled_input_field(a) }.join("\n")
+  end
+  
+  # Render a standartized label.
+  def label(attr, text = nil, options = {})
+    if attr.is_a?(Symbol) && text.nil? && options.blank?
+      super(attr, captionize(attr, @object.class))
+    else
+      super(attr, text, options)
+    end
+  end
+  
+  # Render a corresponding input field for the given attribute.
+  # The input field is chosen based on the ActiveRecord column type.
+  # Use additional html_options for the input element.
+  def input_field(attr, html_options = {})
+    type = column_type(@object, attr)
+    if type == :text
+      text_area(attr, html_options)
+    elsif belongs_to_association?(attr, type)
+      belongs_to_field(attr, html_options)
+    else
+      custom_field_method = :"#{type}_field"
+      if respond_to?(custom_field_method)
+        send(custom_field_method, attr, html_options)
+      else
+        text_field(attr, html_options)
+      end
+    end
+  end
+  
+  # Render a standard text field.
+  def text_field(attr, html_options = {})
+    super(attr, {:size => 30}.merge(html_options))
+  end
+  
+  # Render a standard text area.
+  def text_area(attr, html_options = {})
+    super(attr, {:rows => 5, :cols => 30}.merge(html_options))
+  end
+  
+  # Render a standard string field with column contraints.
+  def string_field(attr, html_options = {})
+    limit = column_property(@object, attr, :limit)
+    html_options = {:maxlength => limit}.merge(html_options) if limit
+    text_field(attr, html_options)
+  end
+  
+  # Render a standard number field.
+  def number_field(attr, html_options = {})
+    text_field(attr, {:size => 15}.merge(html_options))
+  end
+  
+  # Render an integer field.
+  def integer_field(attr, html_options = {})
+    number_field(attr, html_options)
+  end
+  
+  # Render a float field.
+  def float_field(attr, html_options = {})
+    number_field(attr, html_options)
+  end 
+  
+  # Render a decimal field.
+  def decimal_field(attr, html_options = {})
+    number_field(attr, html_options)
+  end
+  
+  # Render a boolean field.
+  def boolean_field(attr, html_options = {})
+    check_box(attr, html_options)
+  end
+  
+  # Render a field to select a date. You might want to customize this.
+  def date_field(attr, html_options = {})
+    date_select(attr, {}, html_options)
+  end
+  
+  # Render a select element for a :belongs_to association defined by attr.
+  # Use additional html_options for the select element.
+  # To pass a custom element list, specify the list with the :list key or
+  # define an instance variable with the pluralized name of the association.
+  def belongs_to_field(attr, html_options = {})
+    list = association_entries(attr, html_options)
+    if list.present?
+      collection_select(attr, list, :id, :label, { :prompt => BLANK_SELECT_LABEL }, html_options)
+    else
+      '(none available)'
+    end
+  end
+  
+  # Render a label for the given attribute with the passed field html section.
+  def labeled(attr, field_html = nil, &block)
+    template.labeled(label(attr), field_html, &block)
+  end
+  
+  # Dispatch methods starting with 'labeled_' to render a label and the corresponding 
+  # input field. E.g. labeled_boolean_field(:checked, {:class => 'bold'})
+  def method_missing(name, *args)
+    if field_method = labeled_field_method?(name)
+      labeled(args.first, send(field_method, *args))
+    else     
+      super(name, *args)
+    end
+  end
+  
+  def respond_to?(name)
+    labeled_field_method?(name).present? || super(name)
+  end
+  
+  protected
+  
+  def labeled_field_method?(name)
+    prefix = 'labeled_'
+    if name.to_s.start_with?(prefix)
+      field_method = name.to_s[prefix.size..-1]
+      field_method if respond_to?(field_method)
+    end
+  end
+  
+  def belongs_to_association?(attr, type)
+    if type == :integer || type == nil
+      assoc = belongs_to_association(@object, attr)
+      assoc.present? && assoc.options[:polymorphic].nil?
+    else
+      false
+    end
+  end
+  
+  # Returns the list of association entries, either from options[:list],
+  # the instance variable with the pluralized association name or all
+  # entries of the association klass.
+  def association_entries(attr, options)
+    list = options.delete(:list) 
+    unless list
+      assoc = association(@object, attr)
+      list = @template.send(:instance_variable_get, :"@#{assoc.name.to_s.pluralize}")
+      unless list
+        list = assoc.klass.find(:all, :conditions => assoc.options[:conditions],
+                               :order => assoc.options[:order])
+      end
+    end
+    list
+  end
+end