flexa_lib 0.1.21 → 0.2.0

data/Gemfile

@@ -2,3 +2,5 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in menu_builder.gemspec
 gemspec
+
+gem 'formtastic'

data/flexa_lib.gemspec

@@ -7,7 +7,7 @@ require 'flexa_lib/version'
 Gem::Specification.new do |s|
   s.name        = 'flexa_lib'
 #  s.version     = FlexaLib::VERSION
-  s.version     = '0.1.21'
+  s.version     = '0.2.0'
   s.platform    = Gem::Platform::RUBY
 
   s.authors     = ['Allan Freitas','Marcio Sfalsin']
@@ -18,6 +18,10 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "flexa_lib"
 
+#  s.extra_rdoc_files = [
+#    "LICENSE.txt",
+#    "README.md"
+#  ]
   s.files          =  Dir["vendor/**/*.{scss,js,png,css,jpg,gif}"] + Dir.glob('lib/**/*.{rb,erb}')+ %w(LICENSE README.txt init.rb flexa_lib.gemspec Gemfile Rakefile) + Dir["docs/**/*.*"]
 #  s.files         = 'git ls-files'.split("\n")
 #  s.test_files    = 'git ls-files -- {test,spec,features}/*'.split("\n")
@@ -30,9 +34,8 @@ Gem::Specification.new do |s|
   #s.add_development_dependency("devise", ">= 1.5.3")
   #s.add_dependency 'thor',  '~> 0.14'
   s.add_dependency 'formtastic', '>=2.0.2'
-  s.add_dependency 'formtastic-bootstrap', '>=1.2.0'
   s.add_dependency 'table_for_collection', '>=1.0.6'
   s.add_dependency 'will_paginate', '>=3.0.2'
   s.add_dependency 'will_paginate_twitter_bootstrap', '>=1.0.0'
   
-end
+end

data/lib/action_view/helpers/text_field_date_helper.rb

@@ -0,0 +1,166 @@
+require 'action_view/helpers/form_tag_helper'
+
+module ActionView
+  module Helpers
+
+    module TextFieldDateHelper
+
+      # These two handle an object with a method that returns a Date or Time object.
+      def date_text_field(object_name, method, options = {}, html_options = {})
+        InstanceTag.new(object_name, method, self, options.delete(:object)).to_date_text_field_tag(options, html_options)
+      end
+
+      def time_text_field(object_name, method, options = {}, html_options = {})
+        InstanceTag.new(object_name, method, self, options.delete(:object)).to_time_text_field_tag(options, html_options)
+      end
+
+      # These two handle Date and Time objects.
+      def text_field_date(date = Date.current, options = {}, html_options = {})
+        DateTimeSelector.new(date, options, html_options).text_field_date
+      end
+
+      def text_field_time(time = Time.current, options = {}, html_options = {})
+        DateTimeSelector.new(time, options, html_options).text_field_time
+      end
+    end
+
+    class DateTimeSelector
+
+      include ActionView::Helpers::FormTagHelper
+
+      def text_field_date
+        order = date_order.dup
+
+        @options[:discard_hour]     = true
+        @options[:discard_minute]   = true
+        @options[:discard_second]   = true
+
+        @options[:discard_year]   ||= true unless order.include?(:year)
+        @options[:discard_month]  ||= true unless order.include?(:month)
+        @options[:discard_day]    ||= true if @options[:discard_month] || !order.include?(:day)
+
+        # Save this so we can restore it.
+        original_datetime_separator_separator = @options[:datetime_separator] 
+        original_date_separator = @options[:date_separator] 
+
+        @options[:datetime_separator] = ""
+        @options[:date_separator] = " "
+
+        # If the day is hidden and the month is visible, the day should be set to the 1st so all month choices are
+        # valid (otherwise it could be 31 and February wouldn't be a valid date)
+        if @datetime && @options[:discard_day] && !@options[:discard_month]
+          @datetime = @datetime.change(:day => 1)
+        end
+
+        [:day, :month, :year].each { |o| order.unshift(o) unless order.include?(o) }
+
+        build_text_field_from_types(order).tap do
+          # Restore.
+          @options[:datetime_separator] = original_datetime_separator_separator
+          @options[:date_separator] = original_date_separator
+        end
+      end
+
+      def text_field_time
+        order = []
+
+        @options[:discard_month]    = true
+        @options[:discard_year]     = true
+        @options[:discard_day]      = true
+        @options[:discard_second] ||= true unless @options[:include_seconds]
+
+        # Save this so we can restore it.
+        original_datetime_separator = @options[:datetime_separator]
+        original_time_separator = @options[:time_separator] 
+        original_date_separator = @options[:date_separator] 
+
+        @options[:datetime_separator] = ''
+        @options[:time_separator] = ':'
+        @options[:date_separator] = " "
+
+        order += [:year, :month, :day] unless @options[:ignore_date]
+
+        order += [:hour, :minute]
+        order << :second if @options[:include_seconds]
+
+        build_text_field_from_types(order).tap do
+          # Restore.
+          @options[:datetime_separator] = original_datetime_separator 
+          @options[:date_separator] = original_date_separator
+          @options[:time_separator] = original_time_separator
+        end
+      end
+
+      def text_field_second
+        unless @options[:use_hidden] || @options[:discard_second]
+          build_text(:second, sec)
+        end
+      end
+
+      def text_field_minute
+        unless @options[:use_hidden] || @options[:discard_minute]
+          build_text(:minute, min)
+        end
+      end
+
+      def text_field_hour
+        unless @options[:use_hidden] || @options[:discard_hour]
+          build_text(:hour, hour, :ampm => @options[:ampm])
+        end
+      end
+
+      def text_field_day
+        unless @options[:use_hidden] || @options[:discard_day]
+          build_text(:day, day, :leading_zeros => false)
+        end
+      end
+
+      def text_field_month
+        unless @options[:use_hidden] || @options[:discard_month]
+          build_text(:month, month.nil? ? "" : month_name(month), :leading_zeros => false)
+        end
+      end
+
+      def text_field_year
+        unless @options[:use_hidden] || @options[:discard_year]
+          build_text(:year, year, :leading_zeros => false)
+        end
+      end
+
+      def build_text_field_from_types(order)
+        input = ''
+        order.reverse.each do |type|
+          separator = separator(type) unless type == order.first # don't add on last field
+          input.insert(0, separator.to_s + send("text_field_#{type}").to_s) 
+        end
+        text_field_tag("", input.html_safe, @html_options).html_safe
+      end
+
+      def build_text(selected, value, options = {})
+        unless value.nil?
+          options.reverse_merge!({:leading_zeros => true, :ampm => false})
+          leading_zeros = options.delete(:leading_zeros)
+          value = leading_zeros ? sprintf("%02d", value) : value
+          text = options[:ampm] ? AMPM_TRANSLATION[value] : value
+        else
+          ""
+        end
+      end
+
+    end
+
+    class InstanceTag #:nodoc:
+      def to_date_text_field_tag(options = {}, html_options = {})
+       datetime_selector(options, html_options).text_field_date.html_safe
+      end
+
+      def to_time_text_field_tag(options = {}, html_options = {})
+       datetime_selector(options, html_options).text_field_time.html_safe
+      end
+    end
+
+    autoload :TextFieldDateHelper
+    include TextFieldDateHelper
+
+  end
+end

data/lib/flexa_formtastic_bootstrap/engine.rb

@@ -0,0 +1,4 @@
+module FlexaFormtasticBootstrap
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/flexa_formtastic_bootstrap/form_builder.rb

@@ -0,0 +1,38 @@
+module FlexaFormtasticBootstrap
+  
+  class FormBuilder < Formtastic::FormBuilder
+
+    configure :default_inline_error_class, 'help-inline'
+    configure :default_block_error_class,  'help-block'
+    configure :default_inline_hint_class,  'help-inline'
+    configure :default_block_hint_class,   'help-block'
+
+    def self.default_error_class
+      # self.default_inline_error_class
+      raise
+    end
+    
+    def self.default_error_class=(error_class)
+      # self.default_inline_error_class = error_class
+      # self.default_block_error_class = error_class
+      raise
+    end
+    
+    def self.default_hint_class
+      # self.default_inline_hint_class
+      raise
+    end
+    
+    def self.default_hint_class=(hint_class)
+      # self.default_inline_hint_class = hint_class
+      # self.default_block_hint_class = hint_class
+      raise
+    end
+
+    include FlexaFormtasticBootstrap::Helpers::InputHelper
+    include FlexaFormtasticBootstrap::Helpers::InputsHelper
+    include FlexaFormtasticBootstrap::Helpers::ButtonsHelper
+
+  end
+
+end

data/lib/flexa_formtastic_bootstrap/helpers/buttons_helper.rb

@@ -0,0 +1,52 @@
+module FlexaFormtasticBootstrap
+  module Helpers
+    module ButtonsHelper
+
+      include Formtastic::Helpers::ButtonsHelper
+
+      def buttons(*args, &block)
+
+        html_options = args.extract_options!
+        html_options[:class] ||= "actions"
+  
+        if html_options.has_key?(:name)
+          ActiveSupport::Deprecation.warn('The :name option is not supported')
+        end
+
+        if block_given?
+          template.content_tag(:div, html_options) do
+            yield
+          end          
+        else
+          args = [:commit] if args.empty?
+          contents = args.map { |button_name| send(:"#{button_name}_button") }
+          template.content_tag(:div, html_options.except(:builder, :parent, :name)) do
+            Formtastic::Util.html_safe(contents.join)
+          end
+        end
+
+      end
+
+      def commit_button(*args)
+        options = args.extract_options!
+        text = options.delete(:label) || args.shift
+      
+        text = (localized_string(commit_button_i18n_key, text, :action, :model => commit_button_object_name) ||
+                Formtastic::I18n.t(commit_button_i18n_key, :model => commit_button_object_name)) unless text.is_a?(::String)
+      
+        button_html = options.delete(:button_html) || {}
+        button_html.merge!(:class => [button_html[:class], "btn commit", commit_button_i18n_key].compact.join(' '))
+      
+        # TODO We don't have a wrapper. Add deprecation message.
+        # wrapper_html = options.delete(:wrapper_html) || {}
+        # wrapper_html[:class] = (commit_button_wrapper_html_class << wrapper_html[:class]).flatten.compact.join(' ')
+      
+        accesskey = (options.delete(:accesskey) || default_commit_button_accesskey) unless button_html.has_key?(:accesskey)
+        button_html = button_html.merge(:accesskey => accesskey) if accesskey
+        
+        Formtastic::Util.html_safe(submit(text, button_html))
+      end
+
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/helpers/fieldset_wrapper.rb

@@ -0,0 +1,37 @@
+module FlexaFormtasticBootstrap
+  module Helpers
+    module FieldsetWrapper
+
+      include Formtastic::Helpers::FieldsetWrapper
+      
+      protected
+
+      def field_set_and_list_wrapping(*args, &block) #:nodoc:
+        contents = args.last.is_a?(::Hash) ? '' : args.pop.flatten
+        html_options = args.extract_options!
+
+        legend  = (html_options[:name] || '').to_s
+        legend %= parent_child_index(html_options[:parent]) if html_options[:parent]
+        legend  = template.content_tag(:legend, Formtastic::Util.html_safe(legend)) unless legend.blank?
+
+        if block_given?
+          contents = if template.respond_to?(:is_haml?) && template.is_haml?
+            template.capture_haml(&block)
+          else
+            template.capture(&block)
+          end
+        end
+
+        # Ruby 1.9: String#to_s behavior changed, need to make an explicit join.
+        contents = contents.join if contents.respond_to?(:join)
+        fieldset = template.content_tag(:fieldset,
+          Formtastic::Util.html_safe(legend) << Formtastic::Util.html_safe(contents),
+          html_options.except(:builder, :parent, :name)
+        )
+
+        fieldset
+      end
+
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/helpers/input_helper.rb

@@ -0,0 +1,12 @@
+module FlexaFormtasticBootstrap
+  module Helpers
+    module InputHelper
+      include Formtastic::Helpers::InputHelper
+      
+      def standard_input_class_name(as)
+        "FlexaFormtasticBootstrap::Inputs::#{as.to_s.camelize}Input"
+      end
+      
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/helpers/inputs_helper.rb

@@ -0,0 +1,36 @@
+module FlexaFormtasticBootstrap
+  module Helpers
+    module InputsHelper
+      include FlexaFormtasticBootstrap::Helpers::FieldsetWrapper
+
+        def inputs(*args, &block)
+          wrap_it = @already_in_an_inputs_block ? true : false
+          @already_in_an_inputs_block = true
+        
+          title = field_set_title_from_args(*args)
+          html_options = args.extract_options!
+          html_options[:class] ||= "inputs"
+          html_options[:name] = title
+
+          out = begin
+            if html_options[:for] # Nested form
+              inputs_for_nested_attributes(*(args << html_options), &block)
+            elsif block_given?
+              field_set_and_list_wrapping(*(args << html_options), &block)
+            else
+              legend = args.shift if args.first.is_a?(::String)
+              args = default_columns_for_object if @object && args.empty?
+              contents = fieldset_contents_from_column_list(args)
+              args.unshift(legend) if legend.present?
+              field_set_and_list_wrapping(*((args << html_options) << contents))
+            end
+          end
+        
+          # out = template.content_tag(:li, out, :class => "input") if wrap_it
+          @already_in_an_inputs_block = false
+          out
+        end
+
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/helpers.rb

@@ -0,0 +1,19 @@
+require "flexa_formtastic_bootstrap/helpers/buttons_helper"
+require "flexa_formtastic_bootstrap/helpers/fieldset_wrapper"
+require "flexa_formtastic_bootstrap/helpers/input_helper"
+require "flexa_formtastic_bootstrap/helpers/inputs_helper"
+
+module FlexaFormtasticBootstrap
+  module Helpers
+    # autoload :ErrorsHelper, 'formtastic/helpers/errors_helper'
+    # autoload :FieldsetWrapper, 'formtastic/helpers/fieldset_wrapper'
+    # autoload :FileColumnDetection, 'formtastic/helpers/file_column_detection'
+    # autoload :FormHelper, 'formtastic/helpers/form_helper'
+    # autoload :InputHelper, 'formtastic/helpers/input_helper'
+    # autoload :InputsHelper, 'formtastic/helpers/inputs_helper'
+    # autoload :LabelHelper, 'formtastic/helpers/label_helper' 
+    # autoload :SemanticFormHelper, 'formtastic/helpers/semantic_form_helper'
+    # autoload :Reflection, 'formtastic/helpers/reflection'
+  end
+end
+

data/lib/flexa_formtastic_bootstrap/inputs/base/choices.rb

@@ -0,0 +1,49 @@
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Choices
+
+        def input_div_wrapping(&block)
+          template.content_tag(:div, choices_wrapping_html_options) do
+            [yield, error_html(:block), hint_html(:block)].join("\n").html_safe  
+          end
+        end
+
+        def choices_wrapping_html_options
+          # TODO Call the Formtastic one explicity and append?
+          { :class => "choices input" }
+        end
+
+        def choices_group_wrapping(&block)
+          template.content_tag(:ul,
+            template.capture(&block),
+            choices_group_wrapping_html_options
+          )
+        end
+
+        def choices_group_wrapping_html_options
+          { :class => "choices-group inputs-list" }
+        end
+
+        def choice_label(choice)
+          "\n".html_safe + template.content_tag(:span) do
+            # (choice.is_a?(Array) ? choice.first : choice).to_s
+            (choice.is_a?(Array) ? choice.first : choice).to_s
+          end
+        end
+
+        # This is actually a label in Bootstrap.
+        def legend_html
+          template.content_tag(:label, label_html_options) do
+            render_label? ? label_text : "".html_safe
+          end
+        end
+
+        def label_html_options
+          super.merge(:for => nil)
+        end
+
+      end
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/inputs/base/errors.rb

@@ -0,0 +1,48 @@
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Errors
+
+        include Formtastic::Inputs::Base::Errors
+
+        def error_html(inline_or_block = :inline)
+          errors? ? send(:"error_#{builder.inline_errors}_html", inline_or_block) : ""
+        end
+
+        def error_sentence_html(inline_or_block)
+          error_class = if inline_or_block == :inline
+            options[:error_class] || builder.default_inline_error_class
+          else
+            options[:error_class] || builder.default_block_error_class
+          end
+          template.content_tag(:span, Formtastic::Util.html_safe(errors.to_sentence.html_safe), :class => error_class)
+        end
+
+        def error_list_html(ignore)
+          super()
+          # error_class = options[:error_class] || builder.default_error_list_class
+          # list_elements = []
+          # errors.each do |error|
+          #   list_elements << template.content_tag(:li, Formtastic::Util.html_safe(error.html_safe))
+          # end
+          # template.content_tag(:ul, Formtastic::Util.html_safe(list_elements.join("\n")), :class => error_class)
+        end
+        
+        def error_first_html(inline_or_block = :inline)
+          error_class = if inline_or_block == :inline
+            options[:error_class] || builder.default_inline_error_class
+          else
+            options[:error_class] || builder.default_block_error_class
+          end
+          template.content_tag(:span, Formtastic::Util.html_safe(errors.first.untaint), :class => error_class)
+        end
+
+        def error_none_html(ignore)
+          # super
+          ""
+        end
+
+      end
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/inputs/base/hints.rb

@@ -0,0 +1,27 @@
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Hints
+        
+        include Formtastic::Inputs::Base::Hints
+
+        def hint_html(inline_or_block = :inline)
+          if hint?
+            hint_class = if inline_or_block == :inline
+              options[:hint_class] || builder.default_inline_hint_class
+            else
+              options[:hint_class] || builder.default_block_hint_class
+            end
+            template.content_tag(
+              :span, 
+              Formtastic::Util.html_safe(hint_text), 
+              :class => hint_class
+            )
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/flexa_formtastic_bootstrap/inputs/base/html.rb

@@ -0,0 +1,21 @@
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Html
+
+        include Formtastic::Inputs::Base::Html
+
+        def input_html_options
+          if errors?
+            { 
+              :class => "error"
+            }.merge(super)
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/inputs/base/labelling.rb

@@ -0,0 +1,18 @@
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Labelling
+
+        include Formtastic::Inputs::Base::Labelling
+
+        def label_html_options
+          {}.tap do |opts|
+            opts[:for] ||= input_html_options[:id]
+            opts[:class] = [opts[:class]]
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/inputs/base/stringish.rb

@@ -0,0 +1,18 @@
+# Alas, I need to duplicate code from Formtastic::Inputs::Base::Stringish because
+# there's no way to re-import that module.
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Stringish
+        
+        include Formtastic::Inputs::Base::Stringish
+
+        def wrapper_html_options
+          new_class = [super[:class], "stringish"].compact.join(" ")
+          super.merge(:class => new_class)
+        end
+        
+      end
+    end
+  end
+end

data/lib/flexa_formtastic_bootstrap/inputs/base/timeish.rb

@@ -0,0 +1,35 @@
+module FlexaFormtasticBootstrap
+  module Inputs
+    module Base
+      module Timeish
+
+        def label_html
+          # TODO Supress the "for" field?
+          template.content_tag(:label, label_html_options) do
+            render_label? ? label_text : "".html_safe
+          end
+        end
+
+        def date_input_html
+          fragment_input_html(:date, "small")
+        end
+
+        def time_input_html
+          fragment_input_html(:time, "mini")
+        end
+        
+        def fragment_id(fragment)
+          # TODO is this right?
+          # "#{input_html_options[:id]}_#{position(fragment)}i"
+          "#{input_html_options[:id]}[#{fragment}]"
+        end
+        
+        def fragment_input_html(fragment, klass)
+          opts = input_options.merge(:prefix => object_name, :field_name => fragment_name(fragment), :default => value, :include_blank => include_blank?)
+          template.send(:"text_field_#{fragment}", value, opts, input_html_options.merge(:id => fragment_id(fragment), :class => klass))
+        end
+     
+      end
+    end
+  end
+end