lucasefe-multi_helper 0.0.1

data/generators/full_scaffold/templates/controller.rb

@@ -0,0 +1,13 @@
+class <%= controller_class_name %>Controller < ResourceController::Base
+  index.wants.js {render :layout => false}
+private
+  def default_options_for(search)
+    { :per_page => 10, :order_as => "ASC" }.merge(search ||{})
+  end
+  def collection
+    @search = <%= model_name %>.new_search(default_options_for(params[:search]))
+    @search.per_page = 10
+    @<%= plural_name %>, @<%= plural_name %>_count = @search.all, @search.count
+    @<%= plural_name %>
+  end
+end

data/generators/full_scaffold/templates/helper.rb

@@ -0,0 +1,2 @@
+module <%= controller_class_name %>Helper
+end

data/generators/full_scaffold/templates/migration.rb

@@ -0,0 +1,15 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %>, :force => true do |t|
+<% for attribute in attributes -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/generators/full_scaffold/templates/model.rb

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/generators/full_scaffold/templates/rspec/unit_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../spec_helper')
+
+describe <%= class_name %> do
+  before(:each) do
+    @<%= file_name %> = <%= class_name %>.new
+  end
+
+  it "should be valid" do
+    @<%= file_name %>.should be_valid
+  end
+end

data/generators/full_scaffold/templates/view__collection.haml

@@ -0,0 +1,23 @@
+#resultados
+  %table.table
+    %tr
+  <% for attribute in attributes -%>
+    %th<%= (attribute == attributes.first) ? ".first" : "" %>= order_by_link :<%= attribute.column.name %>
+  <% end -%>
+    %th
+      %th
+      %th.last
+    - <%= plural_name %>.each do |<%= singular_name %>|
+      %tr
+      <%- for attribute in attributes %>
+        %td= h <%= singular_name %>.<%= attribute.name %>
+      <%- end -%>    
+        %td= link_to 'Show', object_url(<%= singular_name %>)
+        %td= link_to 'Edit', edit_object_url(<%= singular_name %>)
+        %td= link_to 'Destroy', object_url(<%= singular_name %>), :confirm => 'Are you sure?', :method => :delete
+  .actions-bar
+    .pagination
+      = page_links
+      = per_page_select
+    .clear
+      

data/generators/full_scaffold/templates/view__form.haml

@@ -0,0 +1,3 @@
+<%- for attribute in attributes -%>
+= f.<%= attribute.field_type %> :<%= attribute.name %>
+<% end -%>

data/generators/full_scaffold/templates/view__search.haml

@@ -0,0 +1,11 @@
+- next_form_for @search, :html=>{:id => 'search', :class => 'form'} do |fs|
+
+  - fs.fields_for @search.conditions do |s|
+    <%- for attribute in attributes -%>
+    .group
+      %label.title <%= attribute.name.humanize %>
+      = s.<%= attribute.field_type %> :<%= attribute.name %>
+    <%- end -%>
+
+    = fs.submit "Buscar"
+

data/generators/full_scaffold/templates/view_edit.haml

@@ -0,0 +1,9 @@
+- text_block :title => "Editing <%= singular_name %>" do
+  - next_form_for(:<%= singular_name %>, :url => object_url, :html => { :method => :put, :class => 'form' }) do |f|
+    = render :partial => "form", :locals => { :f => f }
+    - f.buttons do |b|
+      = b.save
+      = b.cancel :url => collection_path
+      
+- content_for :sidebar do
+  = sidebar_link 'Show', object_url

data/generators/full_scaffold/templates/view_index.haml

@@ -0,0 +1,8 @@
+- table_block :title => '<%= plural_name.humanize %>' do
+  = render :partial => '<%= plural_name %>', :object => @<%= plural_name %>
+
+- content_for :search do
+  = render :partial => 'search'
+  
+- content_for :sidebar do
+  = sidebar_link 'New <%= singular_name %>', new_object_url

data/generators/full_scaffold/templates/view_index.js.haml

@@ -0,0 +1 @@
+= render :partial => '<%= plural_name %>', :object => @<%= plural_name %>

data/generators/full_scaffold/templates/view_new.haml

@@ -0,0 +1,7 @@
+- text_block :title => "New <%= singular_name %>" do
+  - next_form_for(@<%= singular_name %>, :url => collection_path, :html => {:class => 'form'}) do |f|
+    = render :partial => "form", :locals => { :f => f }
+    - f.buttons do |b|
+      = b.save
+      = b.cancel :url => collection_path
+

data/generators/full_scaffold/templates/view_show.haml

@@ -0,0 +1,10 @@
+- text_block :title => "<%= singular_name.humanize %>" do
+  <% for attribute in attributes %>
+  %p
+    %strong <%= attribute.column.human_name %>:
+    =h @<%= singular_name %>.<%= attribute.name %>
+  <% end -%>
+  
+- content_for :sidebar do
+  = sidebar_link 'Edit', edit_object_url
+  = sidebar_link 'Back', collection_url

data/lib/multi_helper.rb

@@ -0,0 +1,6 @@
+module MultiHelper
+end
+
+require "multi_helper/navigation"
+require "multi_helper/form"
+require "multi_helper/view"

data/lib/multi_helper/form.rb

@@ -0,0 +1,11 @@
+require 'multi_helper/vendor/validation_reflection'
+require 'multi_helper/form/helper'
+require 'multi_helper/form/builder'
+
+ActionView::Base.field_error_proc = Proc.new { |html_tag, instance| html_tag }
+ActionView::Base.send :include, MultiHelper::Form::Helper
+
+MultiHelper::Form::Builder.default_options.merge!({
+  :required_signifier => '*',
+  :label_suffix => '',
+})

data/lib/multi_helper/form/README.markdown

@@ -0,0 +1,119 @@
+AirBuddFormBuilder
+==================
+
+A form builder that generates semantic HTML as advocated by Andy Budd in [CSS Mastery][1].
+
+It generates [Wufoo-style][2] buttons and links for submitting the form, cancelling it, etc.  These buttons and links use several icons from the [FAMFAMFAM set][3].  You can choose not to use them if you don't want to.
+
+[1]: http://www.cssmastery.com
+[2]: http://particletree.com/features/rediscovering-the-button-element/
+[3]: http://famfamfam.com/lab/icons/silk/
+
+Please send feedback to boss@airbladesoftware.com.
+
+
+HAML
+====
+Thanks to [David Baldwin][4], this form builder can be used with HAML.
+
+[4]: http://www.baldwindigital.net
+
+
+ERB Example
+===========
+
+app/views/projects/new.html.erb:
+
+    <% next_form_for @project do |f| %>
+      <%= f.text_field :title, :required => true, :name => "Article's Title" %>
+      <% f.buttons do |b| %>
+        <%= b.save %>
+        <%= b.cancel :url => projects_path %>
+      <% end %>
+    <% end %>
+
+This renders:
+
+    <form ...> <!-- standard Rails form element -->
+      <p class="text">
+        <label for="article_title">Article's Title:
+          <em class="required">(required)</em>
+        </label>
+        <input id="article_title" name="article[title]" type="text" value=""/>
+      </p>
+      <div class="buttons">
+        <button type="submit" class="positive"><img src="/images/icons/tick.png" alt=""/> Save</button>
+        <a href="/projects"><img src="/images/icons.pencil.png" alt=""/> Cancel</a>
+      </div>
+    </form>
+
+And if the field's value is invalid:
+
+    <p class="error text">
+      <label for="article_title">Article's Title:
+        <em class="required">(required)</em>
+        <span class="feedback">can't be blank</span>
+      </label>
+      <input id="article_title" name="article[title]" type="text" value=""/>
+    </p>
+
+See Mr Budd's good book for discussion of the HTML and the CSS to go with it.
+
+
+Required fields
+===============
+
+Thanks to Bill, the form builder automatically detects required fields (by looking for :validates_presence_of in the model) and marks them up appropriately.
+
+
+Configuration
+=============
+
+Thanks to Dan Webb, whose [Enhanced Form Builder](http://svn.danwebb.net/external/rails/plugins/enhanced_form_builder/lib/enhanced_form_builder/form_builder.rb) configuration I borrowed.
+
+You can configure the form builder at three levels: app-wide, per-form, and per-field.  The per-field configuration differs slightly from the other two.
+
+* App-wide:
+
+config/initializers/form_builder.rb:
+
+    AirBlade::AirBudd::FormBuilder.default_options.merge!({
+      :required_signifier => '*',
+      :label_suffix => '',
+    })
+    
+* Per form:
+
+In your form:
+
+    - next_form_for @member do |f|
+      - f.required_signifier = '*'
+      = f.text_field :name
+
+* Per field:
+
+On a form field:
+
+    = f.text_field :name, :required => true, :suffix => ''
+
+See the comments in the form builder's code for the exact configuration options available.
+
+
+To Do
+=====
+
+* Fix `country_select` so it handles priority countries and options.  It's currently broken.
+* Wrapper for `options_group_from_collection_for_select`.
+* DRY way to show consistent form links, e.g. edit, outside a form.
+  - include `link_to_function`, `link_to_remote`, etc.
+  - Cf `AirBlade::AirBudd::FormHelper#link_to_form`.
+  - Do we need to wrap buttons/links in a div?  (Probably semantically good to do so?)
+* Two read-only field helpers: one for within a form, containing the value so it can be submitted, and one for the 'show' page, so we can use the same markup and CSS (c.f. http://tomayko.com/writings/administrative-debris)..
+* Example CSS:
+  - for Wufoo-style buttons and links.
+  - for CSS Mastery XHTML.
+* Summary error messages.
+* Consider how to handle multiple actions, e.g. 'save & create another', 'save & keep editing'.  See Brandon Keepers's [with_action plugin](http://opensoul.org/2007/7/16/handling-forms-with-multiple-buttons).
+
+
+Copyright (c) 2007 Andrew Stewart, released under the MIT license.

data/lib/multi_helper/form/builder.rb

@@ -0,0 +1,346 @@
+module MultiHelper
+  module Form
+
+    class Builder < ActionView::Helpers::FormBuilder
+      include Haml::Helpers if defined? Haml       # for compatibility
+      include ActionView::Helpers::TextHelper      # so we can use concat
+      include ActionView::Helpers::CaptureHelper   # so we can use capture
+      include ActionView::Helpers::TagHelper       # so we can use concat
+
+      # App-wide form configuration.
+      # E.g. in config/initializers/form_builder.rb:
+      #
+      #   AirBlade::AirBudd::FormBuilder.default_options[:required_signifier] = '*'
+      #
+      @@default_options = {
+        :required_signifier => '(required)',
+        :label_suffix => ':',
+        :capitalize_errors => true,
+      }
+      cattr_accessor :default_options
+
+      # Per-form configuration (overrides app-wide form configuration).
+      # E.g. in a form itself:
+      #
+      #   - airbudd_form_for @member do |f|
+      #     - f.required_signifier = '*'
+      #     = f.text_field :name
+      #     ...etc...
+      #
+      attr_writer *default_options.keys
+      default_options.keys.each do |field|
+        src = <<-END_SRC
+          def #{field}
+            @#{field} || default_options[:#{field}]
+          end
+        END_SRC
+        class_eval src, __FILE__, __LINE__
+      end
+
+      @@field_keys = [:hint, :required, :label, :addendum, :suffix]
+
+      alias_method :vanilla_hidden_field, :hidden_field
+
+      # Creates a glorified form field helper.  It takes a form helper's usual
+      # arguments with an optional options hash:
+      #
+      # <%= form.text_field 'title',
+      #                     :required => true,
+      #                     :label    => "Article's Title",
+      #                     :hint     => "Try not to use the letter 'e'." %>
+      #
+      # The code above generates the following HTML.  The :required entry in the hash
+      # triggers the <em/> element and the :label overwrites the default field label,
+      # 'title' in this case, with its value.  The stanza is wrapped in a <p/> element.
+      #
+      # <p class="text">
+      #   <label for="article_title">Article's Title:
+      #     <em class="required">(required)</em>
+      #   </label>
+      #   <input id="article_title" name="article[title]" type="text" value=""/>
+      #   <span class="hint">Try not to use the letter 'e'.</span>
+      # </p>
+      #
+      # If the field's value is invalid, the <p/> is marked so and a <span/> is added
+      # with the (in)validation message:
+      #
+      # <p class="error text">
+      #   <label for="article_title">Article's Title:
+      #     <em class="required">(required)</em>
+      #     <span class="feedback">can't be blank</span>
+      #   </label>
+      #   <input id="article_title" name="article[title]" type="text" value=""/>
+      #   <span class="hint">Try not to use the letter 'e'.</span>
+      # </p>
+      #
+      # You can also pass an :addendum option.  This generates a <span/> between the
+      # <input/> and the hint.  Typically you would use this to show a small icon
+      # for deleting the field.
+      def self.create_field_helper(field_helper)
+        src = <<-END
+          def #{field_helper}(method, options = {}, html_options = {})
+            attribs = attributes_for(method, '#{field_helper}')
+            attribs[:class] << " group"
+            @template.content_tag('div',
+                                  label_element(method, options, html_options) +
+                                    super(method, options.except(*@@field_keys)) +
+                                    addendum_element(options) +
+                                    hint_element(options),
+                                  attribs
+            )
+          end
+        END
+        class_eval src, __FILE__, __LINE__
+      end
+
+      def self.create_short_field_helper(field_helper)
+        src = <<-END
+          def #{field_helper}(method, options = {}, html_options = {})
+            attribs = attributes_for(method, '#{field_helper}')
+            attribs[:class] << " group"
+            @template.content_tag('p',
+                                  super(method, options.except(*@@field_keys)) +
+                                    label_element(method, options, html_options) +
+                                    hint_element(options), attribs
+            )
+          end
+        END
+        class_eval src, __FILE__, __LINE__
+      end
+
+      # Creates a hidden input field and a simple <span/> using the same
+      # pattern as other form fields.
+      def read_only_text_field(method_for_text_field, method_for_hidden_field = nil, options = {}, html_options = {})
+        method_for_hidden_field ||= method_for_text_field
+        @template.content_tag('p',
+                              label_element(method_for_text_field, options, html_options) +
+                                vanilla_hidden_field(method_for_hidden_field, options) +
+                                @template.content_tag('span', object.send(method_for_text_field)) +
+                                addendum_element(options) +
+                                hint_element(options),
+                              attributes_for(method_for_text_field, 'text_field')
+        )
+      end
+
+      # TODO: DRY this with self.create_field_helper above.
+      def self.create_collection_field_helper(field_helper)
+        src = <<-END
+          def #{field_helper}(method, choices, options = {}, html_options = {})
+            @template.content_tag('p',
+                                  label_element(method, options, html_options) +
+                                    super(method, choices, options.except(*@@field_keys)) +
+                                    addendum_element(options) +
+                                    hint_element(options),
+                                  attributes_for(method, '#{field_helper}')
+            )
+          end
+        END
+        class_eval src, __FILE__, __LINE__
+      end
+
+      def attributes_for(method, field_helper)
+        # FIXME: there must be a neater way than below.  This is Ruby, after all.
+        ary = []
+        ary << 'error' if errors_for?(method)
+        ary << input_type_for(field_helper) unless input_type_for(field_helper).blank?
+        attrs = {}
+        attrs[:class] = ary.reject{ |x| x.blank? }.join(' ') unless ary.empty?
+        attrs
+      end
+
+      def input_type_for(field_helper)
+        case field_helper
+        when 'text_field';     'text'
+        when 'text_area';      'text'
+        when 'password_field'; 'password'
+        when 'file_field';     'file'
+        when 'hidden_field';   'hidden'
+        when 'check_box';      'checkbox'
+        when 'radio_button';   'radio'
+        when 'select';         'select'
+        when 'date_select';    'select'
+        when 'time_select';    'select'
+        when 'country_select'; 'select'
+        else ''
+        end
+      end
+
+
+      # Beefs up the appropriate field helpers.
+      %w( text_field text_area password_field file_field
+          date_select time_select country_select ).each do |name|
+        create_field_helper name
+      end
+
+      # Beefs up the appropriate field helpers.
+      %w( check_box radio_button ).each do |name|
+        create_short_field_helper name
+      end
+
+      # Beefs up the appropriate field helpers.
+      %w( select ).each do |name|
+        create_collection_field_helper name
+      end
+
+
+      # Within the form's block you can get good buttons with:
+      #
+      #   <% f.buttons do |b| %>
+      #     <%= b.save %>
+      #     <%= b.cancel %>
+      #   <% end %>
+      #
+      # You can have save, cancel, edit and delete buttons.
+      # Each one takes an optional label.  For example:
+      #
+      #     <%= b.save :label => 'Update' %>
+      #
+      # See the documentation for the +button+ method for the
+      # options you can use.
+      #
+      # You could call the button method directly, e.g. <%= f.button %>,
+      # but then your button would not be wrapped with a div of class
+      # 'buttons'.  The div is needed for the CSS.
+      def buttons(&block)
+        concat '<div class="buttons">'
+        yield self
+        concat '</div>'
+      end
+
+      # Buttons and links for REST actions.  Actions that change
+      # state, i.e. save and delete, have buttons.  Other actions
+      # have links.
+      #
+      # For visual feedback with colours and icons, save is seen
+      # as a positive action; delete is negative.
+      #
+      # type = :new|:save|:cancel|:edit|:delete
+      # TODO :all ?
+      #
+      # Options you can use are:
+      #   :label - The label for the button or text for the link.
+      #            Optional; defaults to capitalised purpose.
+      #   :icon  - Whether or not to show an icon to the left of the label.
+      #            Optional; icon will be shown unless :icon set to false.
+      #   :url   - The URL to link to (only used in links).
+      #            Optional; defaults to ''.
+      def button(purpose = :save, options = {}, html_options = {})
+        # TODO: DRY the :a and :button.
+        element, icon, nature = case purpose
+                                when :new    then [:a,      'add',        'positive']
+                                when :save   then [:button, 'tick',       'positive']
+                                when :cancel then [:a,      'arrow_undo', nil       ]
+                                when :edit   then [:a,      'pencil',     nil       ]
+                                when :delete then [:button, 'cross',      'negative']
+                                end
+        legend = ( (options[:icon] == false || options[:icon] == 'false') ?
+                   '' :
+                   "<img src='/images/icons/#{icon}.png' alt=''/> " ) +
+                 (options[:label] || purpose.to_s.capitalize)
+
+        html_options.merge!(:class => nature)
+        if element == :button
+          html_options.merge!(:type => 'submit')
+        else
+          html_options.merge!(:href => (options[:url] || ''))
+        end
+
+        # TODO: separate button and link construction and use
+        # link_to to gain its functionality, e.g. :back?
+        @template.content_tag(element.to_s,
+                              legend,
+                              html_options)
+      end
+
+      def method_missing(*args, &block)
+        # Button method
+        if args.first.to_s =~ /^(new|save|cancel|edit|delete)$/
+          button args.shift, *args, &block
+        else
+          super
+        end
+      end
+
+      private
+
+      # Writes out a <label/> element for the given field.
+      # Options:
+      #  - :required: text to indicate that field is required.  Optional: if not given,
+      #  field is not required.  If set to true instead of a string, default indicator
+      #  text is '(required)'.
+      #  - :label: text wrapped by the <label/>.  Optional (default is field's name).
+      #  - :suffix: appended to the label.  Optional (default is ':').
+      #  - :capitalize: false if any error message should not be capitalised,
+      #    true otherwise.  Optional (default is true).
+      def label_element(field, options = {}, html_options = {})
+        return '' if options.has_key?(:label) && options[:label].nil?
+        text = options.delete(:label) || (@object.nil? ? field.to_s.humanize : @object.class.human_attribute_name(field.to_s))
+        suffix = options.delete(:suffix) || label_suffix
+        value = text + suffix
+        html_options[:class] ||= []
+        html_options[:class] << " title"
+        if (required = mandatory?(field, options.delete(:required)))
+          required = required_signifier if required == true
+          value += " <em class='required'>#{required}</em>"
+        end
+
+        html_options.stringify_keys!
+        html_options['for'] ||= "#{@object_name}_#{field}"
+
+        if errors_for? field
+          error_msg = @object.errors[field].to_a.to_sentence
+          option_capitalize = options.delete(:capitalize) || capitalize_errors
+          error_msg = error_msg.capitalize unless option_capitalize == 'false' or option_capitalize == false
+          value += %Q( <span class="feedback">#{error_msg}.</span>)
+        end
+
+        @template.content_tag :label, value, html_options
+      end
+
+      def mandatory?(method, override = nil)
+        return override unless override.nil?
+        # Leverage vendor/validation_reflection.rb
+        if @object.class.respond_to? :reflect_on_validations_for
+          @object.class.reflect_on_validations_for(method).any? { |v| v.macro == :validates_presence_of }
+        end
+      end
+
+      # Writes out a <span/> element with a hint for how to fill in a field.
+      # Options:
+      #  - :hint: text for the hint.  Optional.
+      def hint_element(options = {})
+        hint = options.delete :hint
+        if hint
+          @template.content_tag :span, hint, :class => 'hint'
+        else
+          ''
+        end
+      end
+
+      # Writes out a <span/> element with something that follows a field.
+      # Options:
+      #  - :hint: text for the hint.  Optional.
+      def addendum_element(options = {})
+        addendum = options.delete :addendum
+        if addendum
+          @template.content_tag :span, addendum, :class => 'addendum'
+        else
+          ''
+        end
+      end
+
+      def errors_for?(method)
+        @object && @object.respond_to?(:errors) && @object.errors[method]
+      end
+
+      def output_buffer
+        @template.output_buffer
+      end
+
+      def output_buffer=(buffer)
+        @template.output_buffer = buffer
+      end
+
+    end
+  end
+end