formtastic 1.2.4 → 3.1.5

data/lib/formtastic/namespaced_class_finder.rb

@@ -0,0 +1,99 @@
+module Formtastic
+  # This class implements class resolution in a namespace chain. It
+  # is used both by Formtastic::Helpers::InputHelper and
+  # Formtastic::Helpers::ActionHelper to look up action and input classes.
+  #
+  # @example Implementing own class finder
+  #   # You can implement own class finder that for example prefixes the class name or uses custom module.
+  #   class MyInputClassFinder < Formtastic::NamespacedClassFinder
+  #     def initialize(namespaces)
+  #       super [MyNamespace] + namespaces # first lookup in MyNamespace then the defaults
+  #     end
+  #
+  #     private
+  #
+  #     def class_name(as)
+  #       "My#{super}Input" # for example MyStringInput
+  #     end
+  #   end
+  #
+  #   # in config/initializers/formtastic.rb
+  #   Formtastic::FormBuilder.input_class_finder = MyInputClassFinder
+  #
+
+  class NamespacedClassFinder
+    attr_reader :namespaces # @private
+
+    # @private
+    class NotFoundError < NameError
+    end
+
+    def self.use_const_defined?
+      defined?(Rails) && ::Rails.application && ::Rails.application.config.respond_to?(:eager_load) && ::Rails.application.config.eager_load
+    end
+
+    # @param namespaces [Array<Module>]
+    def initialize(namespaces)
+      @namespaces = namespaces.flatten
+      @cache = {}
+    end
+
+    # Looks up the given reference in the configured namespaces.
+    #
+    # Two finder methods are provided, one for development tries to
+    # reference the constant directly, triggering Rails' autoloading
+    # const_missing machinery; the second one instead for production
+    # checks with .const_defined before referencing the constant.
+    #
+    def find(as)
+      @cache[as] ||= resolve(as)
+    end
+
+    def resolve(as)
+      class_name = class_name(as)
+
+      finder(class_name) or raise NotFoundError, "class #{class_name}"
+    end
+
+    # Converts symbol to class name
+    # Overridden in subclasses to create `StringInput` and `ButtonAction`
+    # @example
+    #   class_name(:string) == "String"
+
+    def class_name(as)
+      as.to_s.camelize
+    end
+
+    private
+
+    if use_const_defined?
+      def finder(class_name) # @private
+        find_with_const_defined(class_name)
+      end
+    else
+      def finder(class_name) # @private
+        find_by_trying(class_name)
+      end
+    end
+
+    # Looks up the given class name in the configured namespaces in order,
+    # returning the first one that has the class name constant defined.
+    def find_with_const_defined(class_name)
+      @namespaces.find do |namespace|
+        if namespace.const_defined?(class_name)
+          break namespace.const_get(class_name)
+        end
+      end
+    end
+
+    # Use auto-loading in development environment
+    def find_by_trying(class_name)
+      @namespaces.find do |namespace|
+        begin
+          break namespace.const_get(class_name)
+        rescue NameError
+        end
+      end
+    end
+  end
+end

data/lib/formtastic/util.rb

@@ -2,6 +2,7 @@
 
 # Adapted from the rails3 compatibility shim in Haml 2.2
 module Formtastic
+  # @private
   module Util
     extend self
     ## Rails XSS Safety
@@ -13,26 +14,44 @@ module Formtastic
     # @param text [String]
     # @return [String] `text`, marked as HTML-safe
     def html_safe(text)
-      return text if text.nil?
-      return text.html_safe if defined?(ActiveSupport::SafeBuffer)
-      return text.html_safe! if text.respond_to?(:html_safe!)
-      text
+      if text.respond_to?(:html_safe)
+        text.html_safe
+      else
+        text
+      end
     end
 
-    def rails_safe_buffer_class
-      # It's important that we check ActiveSupport first,
-      # because in Rails 2.3.6 ActionView::SafeBuffer exists
-      # but is a deprecated proxy object.
-      return ActiveSupport::SafeBuffer if defined?(ActiveSupport::SafeBuffer)
-      return ActionView::SafeBuffer
+    def rails3?
+      match?(rails_version, "~> 3.0")
     end
 
-    def rails3?
-      version=
-        if defined?(ActionPack::VERSION::MAJOR)
-          ActionPack::VERSION::MAJOR
-        end
-      !version.blank? && version >= 3
+    def rails4?
+      match?(rails_version, "~> 4.0")
+    end
+
+    def rails4_0?
+      match?(rails_version, "~> 4.0.0")
+    end
+
+    def rails4_1?
+      match?(rails_version, "~> 4.1.0")
+    end
+
+    def deprecated_version_of_rails?
+      match?(rails_version, "< #{minimum_version_of_rails}")
     end
+
+    def minimum_version_of_rails
+      "4.1.0"
+    end
+
+    def rails_version
+      ::Rails::VERSION::STRING
+    end
+
+    def match?(version, dependency)
+      Gem::Dependency.new("formtastic", dependency).match?("formtastic", version)
+    end
+
   end
 end

data/lib/formtastic/version.rb

@@ -0,0 +1,3 @@
+module Formtastic
+  VERSION = "3.1.5"
+end

data/lib/generators/formtastic/form/form_generator.rb

@@ -1,54 +1,59 @@
 # encoding: utf-8
 module Formtastic
+  # Generates a Formtastic form partial based on an existing model. It will not overwrite existing
+  # files without confirmation.
+  #
+  # @example
+  # !!!shell
+  #   $ rails generate formtastic:form Post
+  # @example Copy the partial code to the pasteboard rather than generating a partial
+  # !!!shell
+  #   $ rails generate formtastic:form Post --copy
+  # @example Return HAML or Slim output instead of default ERB
+  # !!!shell
+  #   $ rails generate formtastic:form Post --template-engine haml
+  #   $ rails generate formtastic:form Post --template-engine slim
+  # @example Generate a form for specific model attributes
+  # !!!shell
+  #   $ rails generate formtastic:form Post title:string body:text
+  # @example Generate a form for a specific controller
+  # !!!shell
+  #   $ rails generate formtastic:form Post --controller admin/posts
   class FormGenerator < Rails::Generators::NamedBase
-    desc "Generates formtastic form code based on an existing model. By default the " <<
-         "generated code will be printed out directly in the terminal, and also copied " <<
-         "to clipboard. Can optionally be saved into partial directly."
+    desc "Generates a Formtastic form partial based on an existing model."
 
-    argument :name, :type => :string, :required => true, :banner => 'ExistingModelName'
-    argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+    argument :name, :type => :string, :required => true, :banner => 'MODEL_NAME'
+    argument :attributes, :type => :array, :default => [], :banner => 'attribute attribute'
 
-    class_option :haml, :type => :boolean, :default => false, :group => :formtastic,
-                 :desc => "Generate HAML instead of ERB"
+    source_root File.expand_path('../../../templates', __FILE__)
 
-    class_option :partial, :type => :boolean, :default => false, :group => :formtastic,
-                 :desc => 'Generate a form partial in the model views path, i.e. "_form.html.erb" or "_form.html.haml"'
+    class_option :template_engine
 
-    class_option :controller, :type => :string, :default => false, :group => :formtastic,
-                 :desc => 'Generate for custom controller/view path - in case model and controller namespace is different, i.e. "admin/posts"'
+    class_option :copy, :type => :boolean, :default => false, :group => :formtastic,
+    :desc => 'Copy the generated code the clipboard instead of generating a partial file."'
 
-    source_root File.expand_path('../../../templates', __FILE__)
+    class_option :controller, :type => :string, :default => false, :group => :formtastic,
+    :desc => 'Generate for custom controller/view path - in case model and controller namespace is different, i.e. "admin/posts"'
 
     def create_or_show
-      @attributes = self.columns if @attributes.empty?
+      @attributes = reflected_attributes if @attributes.empty?
 
-      if options[:partial]
-        empty_directory "app/views/#{controller_path}"
-        template "_form.html.#{template_type}", "app/views/#{controller_path}/_form.html.#{template_type}"
-      else
-        template = File.read("#{self.class.source_root}/_form.html.#{template_type}")
+      engine = options[:template_engine]
+
+      if options[:copy]
+        template = File.read("#{self.class.source_root}/_form.html.#{engine}")
         erb = ERB.new(template, nil, '-')
         generated_code = erb.result(binding).strip rescue nil
-
-        puts "# ---------------------------------------------------------"
-        puts "#  GENERATED FORMTASTIC CODE"
-        puts "# ---------------------------------------------------------"
-        puts
-        puts generated_code || "Nothing could be generated - model exists?"
-        puts
-        puts "# ---------------------------------------------------------"
-        puts "Copied to clipboard - just paste it!" if save_to_clipboard(generated_code)
+        puts "The following code has been copied to the clipboard, just paste it in your views:" if save_to_clipboard(generated_code)
+        puts generated_code || "Error: Nothing generated. Does the model exist?"
+      else
+        empty_directory "app/views/#{controller_path}"
+        template "_form.html.#{engine}", "app/views/#{controller_path}/_form.html.#{engine}"
       end
     end
 
     protected
 
-    IGNORED_COLUMNS = [:updated_at, :created_at].freeze
-
-    def template_type
-      @template_type ||= options[:haml] ? :haml : :erb
-    end
-
     def controller_path
       @controller_path ||= if options[:controller]
         options[:controller].underscore
@@ -57,8 +62,29 @@ module Formtastic
       end
     end
 
-    def columns
-      @columns ||= self.name.camelize.constantize.content_columns.reject { |column| IGNORED_COLUMNS.include?(column.name.to_sym) }
+    def reflected_attributes
+      columns = content_columns
+      columns += association_columns
+    end
+
+    def model
+      @model ||= name.camelize.constantize
+    end
+
+    # Collects content columns (non-relation columns) for the current class.
+    # Skips Active Record Timestamps.
+    def content_columns
+      model.content_columns.select do |column|
+        !Formtastic::FormBuilder.skipped_columns.include? column.name.to_sym
+      end
+    end
+
+    # Collects association columns (relation columns) for the current class. Skips polymorphic
+    # associations because we can't guess which class to use for an automatically generated input.
+    def association_columns
+      model.reflect_on_all_associations(:belongs_to).select do |association_reflection|
+        association_reflection.options[:polymorphic] != true
+      end
     end
 
     def save_to_clipboard(data)
@@ -75,10 +101,11 @@ module Formtastic
           `echo "#{data}" | xsel --clipboard` || `echo "#{data}" | xclip`
         end
       rescue LoadError
-        false
+          false
       else
-        true
+          true
       end
     end
+
   end
 end

data/lib/generators/formtastic/input/input_generator.rb

@@ -0,0 +1,46 @@
+module Formtastic
+
+  # Modify existing inputs, subclass them, or create your own from scratch.
+  # @example
+  # !!!shell
+  #   $ rails generate formtastic:input HatSize
+
+  # @example Define input name using underscore convention
+  # !!!shell
+  #   $ rails generate formtastic:input hat_size
+
+  # @example Override an existing input behavior
+  # !!!shell
+  #   $ rails generate formtastic:input string --extend
+
+  # @example Extend an existing input behavior
+  # !!!shell
+  #   $ rails generate formtastic:input FlexibleText --extend string
+  class InputGenerator < Rails::Generators::NamedBase
+
+    argument :name, :type => :string, :required => true, :banner => 'FILE_NAME'
+
+    source_root File.expand_path('../../../templates', __FILE__)
+
+    class_option :extend
+
+    def create
+      normalize_file_name
+      define_extension_sentence
+      template "input.rb", "app/inputs/#{name.underscore}_input.rb"
+    end
+
+    protected
+
+    def normalize_file_name
+      name.chomp!("Input")  if name.ends_with?("Input")
+      name.chomp!("_input") if name.ends_with?("_input")
+      name.chomp!("input")  if name.ends_with?("input")
+    end
+
+    def define_extension_sentence
+      @extension_sentence = "< Formtastic::Inputs::#{name.camelize}Input" if options[:extend] == "extend"
+      @extension_sentence ||= "< Formtastic::Inputs::#{options[:extend].camelize}Input" if options[:extend]
+    end
+  end
+end

data/lib/generators/formtastic/install/install_generator.rb

@@ -1,15 +1,23 @@
 # encoding: utf-8
+
 module Formtastic
+  # Copies a config initializer to config/initializers/formtastic.rb
+  #
+  # @example
+  # !!!shell
+  #   $ rails generate formtastic:install
   class InstallGenerator < Rails::Generators::Base
-    desc "Copies formtastic.css and formtastic_changes.css to public/stylesheets/ and a config initializer to config/initializers/formtastic_config.rb"
-
     source_root File.expand_path('../../../templates', __FILE__)
+    class_option :template_engine
 
+    desc "Copies a config initializer to config/initializers/formtastic.rb"
     def copy_files
-      template        'formtastic.rb', 'config/initializers/formtastic.rb'
+      copy_file 'formtastic.rb', 'config/initializers/formtastic.rb'
+    end
 
-      template        'formtastic.css',         'public/stylesheets/formtastic.css'
-      template        'formtastic_changes.css', 'public/stylesheets/formtastic_changes.css'
+    def copy_scaffold_template
+      engine = options[:template_engine]
+      copy_file "_form.html.#{engine}", "lib/templates/#{engine}/scaffold/_form.html.#{engine}"
     end
   end
 end

data/lib/generators/templates/_form.html.erb

@@ -1,5 +1,11 @@
-<%%= f.inputs do %>
-<% attributes.each do |attribute| -%>
-  <%%= f.input :<%= attribute.name %> %>
-<% end -%>
+<%%= semantic_form_for @<%= singular_name %> do |f| %>
+  <%%= f.inputs do %>
+  <%- attributes.each do |attribute| -%>
+    <%%= f.input :<%= attribute.name %> %>
+  <%- end -%>
+  <%% end %>
+
+  <%%= f.actions do %>
+    <%%= f.action :submit, :as => :input %>
+  <%% end %>
 <%% end %>

data/lib/generators/templates/_form.html.haml

@@ -1,4 +1,8 @@
-= f.inputs do
-<% attributes.each do |attribute| -%>
-  = f.input :<%= attribute.name %>
-<% end -%>
+= semantic_form_for @<%= singular_name %> do |f|
+  = f.inputs do
+  <%- attributes.each do |attribute| -%>
+    = f.input :<%= attribute.name %>
+  <%- end -%>
+
+  = f.actions do
+    = f.action :submit, :as => :input

data/lib/generators/templates/_form.html.slim

@@ -0,0 +1,8 @@
+= semantic_form_for @<%= singular_name %> do |f|
+  = f.inputs do
+  <%- attributes.each do |attribute| -%>
+    = f.input :<%= attribute.name %>
+  <%- end -%>
+
+  = f.actions do
+    = f.action :submit, as: :input

data/lib/generators/templates/formtastic.rb

@@ -1,80 +1,113 @@
 # encoding: utf-8
 
-# --------------------------------------------------------------------------------------------------
-# Please note: If you're subclassing Formtastic::SemanticFormBuilder in a Rails 3 project, 
-# Formtastic uses class_attribute for these configuration attributes instead of the deprecated 
-# class_inheritable_attribute. The behaviour is slightly different with subclasses (especially 
-# around attributes with Hash or Array) values, so make sure you understand what's happening. 
-# See the documentation for class_attribute in ActiveSupport for more information.
-# --------------------------------------------------------------------------------------------------
-
 # Set the default text field size when input is a string. Default is nil.
-# Formtastic::SemanticFormBuilder.default_text_field_size = 50
+# Formtastic::FormBuilder.default_text_field_size = 50
 
 # Set the default text area height when input is a text. Default is 20.
-# Formtastic::SemanticFormBuilder.default_text_area_height = 5
+# Formtastic::FormBuilder.default_text_area_height = 5
 
 # Set the default text area width when input is a text. Default is nil.
-# Formtastic::SemanticFormBuilder.default_text_area_width = 50
+# Formtastic::FormBuilder.default_text_area_width = 50
 
 # Should all fields be considered "required" by default?
-# Rails 2 only, ignored by Rails 3 because it will never fall back to this default.
 # Defaults to true.
-# Formtastic::SemanticFormBuilder.all_fields_required_by_default = true
+# Formtastic::FormBuilder.all_fields_required_by_default = true
 
 # Should select fields have a blank option/prompt by default?
 # Defaults to true.
-# Formtastic::SemanticFormBuilder.include_blank_for_select_by_default = true
+# Formtastic::FormBuilder.include_blank_for_select_by_default = true
 
-# Set the string that will be appended to the labels/fieldsets which are required
+# Set the string that will be appended to the labels/fieldsets which are required.
 # It accepts string or procs and the default is a localized version of
 # '<abbr title="required">*</abbr>'. In other words, if you configure formtastic.required
 # in your locale, it will replace the abbr title properly. But if you don't want to use
-# abbr tag, you can simply give a string as below
-# Formtastic::SemanticFormBuilder.required_string = "(required)"
+# abbr tag, you can simply give a string as below.
+# Formtastic::FormBuilder.required_string = "(required)"
 
-# Set the string that will be appended to the labels/fieldsets which are optional
-# Defaults to an empty string ("") and also accepts procs (see required_string above)
-# Formtastic::SemanticFormBuilder.optional_string = "(optional)"
+# Set the string that will be appended to the labels/fieldsets which are optional.
+# Defaults to an empty string ("") and also accepts procs (see required_string above).
+# Formtastic::FormBuilder.optional_string = "(optional)"
 
 # Set the way inline errors will be displayed.
 # Defaults to :sentence, valid options are :sentence, :list, :first and :none
-# Formtastic::SemanticFormBuilder.inline_errors = :sentence
+# Formtastic::FormBuilder.inline_errors = :sentence
 # Formtastic uses the following classes as default for hints, inline_errors and error list
 
-# If you override the class here, please ensure to override it in your formtastic_changes.css stylesheet as well
-# Formtastic::SemanticFormBuilder.default_hint_class = "inline-hints"
-# Formtastic::SemanticFormBuilder.default_inline_error_class = "inline-errors"
-# Formtastic::SemanticFormBuilder.default_error_list_class = "errors"
+# If you override the class here, please ensure to override it in your stylesheets as well.
+# Formtastic::FormBuilder.default_hint_class = "inline-hints"
+# Formtastic::FormBuilder.default_inline_error_class = "inline-errors"
+# Formtastic::FormBuilder.default_error_list_class = "errors"
 
 # Set the method to call on label text to transform or format it for human-friendly
 # reading when formtastic is used without object. Defaults to :humanize.
-# Formtastic::SemanticFormBuilder.label_str_method = :humanize
+# Formtastic::FormBuilder.label_str_method = :humanize
 
 # Set the array of methods to try calling on parent objects in :select and :radio inputs
 # for the text inside each @<option>@ tag or alongside each radio @<input>@. The first method
 # that is found on the object will be used.
 # Defaults to ["to_label", "display_name", "full_name", "name", "title", "username", "login", "value", "to_s"]
-# Formtastic::SemanticFormBuilder.collection_label_methods = [
+# Formtastic::FormBuilder.collection_label_methods = [
 #   "to_label", "display_name", "full_name", "name", "title", "username", "login", "value", "to_s"]
 
-# Formtastic by default renders inside li tags the input, hints and then
-# errors messages. Sometimes you want the hints to be rendered first than
-# the input, in the following order: hints, input and errors. You can
-# customize it doing just as below:
-# Formtastic::SemanticFormBuilder.inline_order = [:input, :hints, :errors]
-
-# Additionally, you can customize the order for specific types of inputs.
-# This is configured on a type basis and if a type is not found it will
-# fall back to the default order as defined by #inline_order
-# Formtastic::SemanticFormBuilder.custom_inline_order[:checkbox] = [:errors, :hints, :input]
-# Formtastic::SemanticFormBuilder.custom_inline_order[:select] = [:hints, :input, :errors]
-
 # Specifies if labels/hints for input fields automatically be looked up using I18n.
-# Default value: false. Overridden for specific fields by setting value to true,
+# Default value: true. Overridden for specific fields by setting value to true,
 # i.e. :label => true, or :hint => true (or opposite depending on initialized value)
-# Formtastic::SemanticFormBuilder.i18n_lookups_by_default = false
+# Formtastic::FormBuilder.i18n_lookups_by_default = false
 
-# You can add custom inputs or override parts of Formtastic by subclassing SemanticFormBuilder and
-# specifying that class here.  Defaults to SemanticFormBuilder.
-# Formtastic::SemanticFormHelper.builder = MyCustomBuilder
+# Specifies if I18n lookups of the default I18n Localizer should be cached to improve performance.
+# Defaults to true.
+# Formtastic::FormBuilder.i18n_cache_lookups = false
+
+# Specifies the class to use for localization lookups. You can create your own
+# class and use it instead by subclassing Formtastic::Localizer (which is the default).
+# Formtastic::FormBuilder.i18n_localizer = MyOwnLocalizer
+
+# You can add custom inputs or override parts of Formtastic by subclassing Formtastic::FormBuilder and
+# specifying that class here.  Defaults to Formtastic::FormBuilder.
+# Formtastic::Helpers::FormHelper.builder = MyCustomBuilder
+
+# All formtastic forms have a class that indicates that they are just that. You
+# can change it to any class you want.
+# Formtastic::Helpers::FormHelper.default_form_class = 'formtastic'
+
+# Formtastic will infer a class name from the model, array, string or symbol you pass to the
+# form builder. You can customize the way that class is presented by overriding
+# this proc.
+# Formtastic::Helpers::FormHelper.default_form_model_class_proc = proc { |model_class_name| model_class_name }
+
+# Allows to set a custom field_error_proc wrapper. By default this wrapper
+# is disabled since `formtastic` already adds an error class to the LI tag
+# containing the input.
+# Formtastic::Helpers::FormHelper.formtastic_field_error_proc = proc { |html_tag, instance_tag| html_tag }
+
+# You can opt-in to Formtastic's use of the HTML5 `required` attribute on `<input>`, `<select>`
+# and `<textarea>` tags by setting this to true (defaults to false).
+# Formtastic::FormBuilder.use_required_attribute = false
+
+# You can opt-in to new HTML5 browser validations (for things like email and url inputs) by setting
+# this to true. Doing so will omit the `novalidate` attribute from the `<form>` tag.
+# See http://diveintohtml5.org/forms.html#validation for more info.
+# Formtastic::FormBuilder.perform_browser_validations = true
+
+# By creating custom input class finder, you can change how input classes  are looked up.
+# For example you can make it to search for TextInputFilter instead of TextInput.
+# See # TODO: add link # for more information
+# NOTE: this behavior will be default from Formtastic 4.0
+Formtastic::FormBuilder.input_class_finder = Formtastic::InputClassFinder
+
+# Define custom namespaces in which to look up your Input classes. Default is
+# to look up in the global scope and in Formtastic::Inputs.
+# Formtastic::FormBuilder.input_namespaces = [ ::Object, ::MyInputsModule, ::Formtastic::Inputs ]
+
+# By creating custom action class finder, you can change how action classes are looked up.
+# For example you can make it to search for MyButtonAction instead of ButtonAction.
+# See # TODO: add link # for more information
+# NOTE: this behavior will be default from Formtastic 4.0
+Formtastic::FormBuilder.action_class_finder = Formtastic::ActionClassFinder
+
+# Define custom namespaces in which to look up your Action classes. Default is
+# to look up in the global scope and in Formtastic::Actions.
+# Formtastic::FormBuilder.action_namespaces = [ ::Object, ::MyActionsModule, ::Formtastic::Actions ]
+
+# Which columns to skip when automatically rendering a form without any fields specified.
+# Formtastic::FormBuilder.skipped_columns = [:created_at, :updated_at, :created_on, :updated_on, :lock_version, :version]