simple_form_awesome 2.2.0

data/lib/simple_form/inputs/text_area_input.rb

@@ -0,0 +1,12 @@
+module SimpleForm
+  module Inputs
+    class TextAreaInput < TextInput
+      def input
+        input_html_classes.unshift(:textarea).delete(:text_area)
+        input_html_options[:style] ||= ""
+        input_html_options[:style] += ";height: 61px; width: 251px;"
+        super
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/text_input.rb

@@ -0,0 +1,11 @@
+module SimpleForm
+  module Inputs
+    class TextInput < Base
+      enable :placeholder, :maxlength
+
+      def input
+        @builder.text_area(attribute_name, input_html_options)
+      end
+    end
+  end
+end

data/lib/simple_form/inputs.rb

@@ -0,0 +1,23 @@
+module SimpleForm
+  module Inputs
+    autoload :Base,                         'simple_form/inputs/base'
+    autoload :BlockInput,                   'simple_form/inputs/block_input'
+    autoload :BooleanInput,                 'simple_form/inputs/boolean_input'
+    autoload :CollectionCheckBoxesInput,    'simple_form/inputs/collection_check_boxes_input'
+    autoload :CollectionInput,              'simple_form/inputs/collection_input'
+    autoload :CollectionRadioButtonsInput,  'simple_form/inputs/collection_radio_buttons_input'
+    autoload :CollectionSelectInput,        'simple_form/inputs/collection_select_input'
+    autoload :DateTimeInput,                'simple_form/inputs/date_time_input'
+    autoload :FileInput,                    'simple_form/inputs/file_input'
+    autoload :GroupedCollectionSelectInput, 'simple_form/inputs/grouped_collection_select_input'
+    autoload :HiddenInput,                  'simple_form/inputs/hidden_input'
+    autoload :NumericInput,                 'simple_form/inputs/numeric_input'
+    autoload :PasswordInput,                'simple_form/inputs/password_input'
+    autoload :PriorityInput,                'simple_form/inputs/priority_input'
+    autoload :RangeInput,                   'simple_form/inputs/range_input'
+    autoload :StringInput,                  'simple_form/inputs/string_input'
+    autoload :TextInput,                    'simple_form/inputs/text_input'
+    autoload :TextAreaInput,                'simple_form/inputs/text_area_input'
+    autoload :AuiStringInput,               'simple_form/inputs/aui_string_input'
+  end
+end

data/lib/simple_form/map_type.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/class/attribute'
+
+module SimpleForm
+  module MapType
+    def self.extended(base)
+      base.class_attribute :mappings
+      base.mappings = {}
+    end
+
+    def map_type(*types)
+      map_to = types.extract_options![:to]
+      raise ArgumentError, "You need to give :to as option to map_type" unless map_to
+      self.mappings = mappings.merge types.each_with_object({}) { |t, m| m[t] = map_to }
+    end
+  end
+end

data/lib/simple_form/version.rb

@@ -0,0 +1,3 @@
+module SimpleForm
+  VERSION = "2.2.0".freeze
+end

data/lib/simple_form/wrappers/builder.rb

@@ -0,0 +1,103 @@
+module SimpleForm
+  module Wrappers
+    # Provides the builder syntax for components. The builder provides
+    # three methods `use`, `optional` and `wrapper` and they allow the following invocations:
+    #
+    #     config.wrappers do |b|
+    #       # Use a single component
+    #       b.use :html5
+    #
+    #       # Use the component, but do not automatically lookup. It will only be triggered when
+    #       # :placeholder is explicitly set.
+    #       b.optional :placeholder
+    #
+    #       # Use a component with specific wrapper options
+    #       b.use :error, :wrap_with => { :tag => "span", :class => "error" }
+    #
+    #       # Use a set of components by wrapping them in a tag+class.
+    #       b.wrapper :tag => "div", :class => "another" do |ba|
+    #         ba.use :label
+    #         ba.use :input
+    #       end
+    #
+    #       # Use a set of components by wrapping them in a tag+class.
+    #       # This wrapper is identified by :label_input, which means it can
+    #       # be turned off on demand with `f.input :name, :label_input => false`
+    #       b.wrapper :label_input, :tag => "div", :class => "another" do |ba|
+    #         ba.use :label
+    #         ba.use :input
+    #       end
+    #     end
+    #
+    # The builder also accepts default options at the root level. This is usually
+    # used if you want a component to be disabled by default:
+    #
+    #     config.wrappers :hint => false do |b|
+    #       b.use :hint
+    #       b.use :label_input
+    #     end
+    #
+    # In the example above, hint defaults to false, which means it won't automatically
+    # do the lookup anymore. It will only be triggered when :hint is explicitly set.
+    class Builder
+      def initialize(options)
+        @options    = options
+        @components = []
+      end
+
+      def use(name, options=nil, &block)
+        if block_given?
+          ActiveSupport::Deprecation.warn "Passing a block to use is deprecated. " \
+            "Please use wrapper instead of use."
+          return wrapper(name, options, &block)
+        end
+
+        if options && options.keys != [:wrap_with]
+          ActiveSupport::Deprecation.warn "Passing :tag, :class and others to use is deprecated. " \
+            "Please invoke b.use #{name.inspect}, :wrap_with => #{options.inspect} instead."
+          options = { :wrap_with => options }
+        end
+
+        if options && wrapper = options[:wrap_with]
+          @components << Single.new(name, wrapper)
+        else
+          @components << name
+        end
+      end
+
+      def optional(name, options=nil, &block)
+        if block_given?
+          ActiveSupport::Deprecation.warn "Passing a block to optional is deprecated. " \
+            "Please use wrapper instead of optional."
+          return wrapper(name, options, &block)
+        end
+
+        if options && options.keys != [:wrap_with]
+          ActiveSupport::Deprecation.warn "Passing :tag, :class and others to optional is deprecated. " \
+            "Please invoke b.optional #{name.inspect}, :wrap_with => #{options.inspect} instead."
+          options = { :wrap_with => options }
+        end
+
+        @options[name] = false
+        use(name, options, &block)
+      end
+
+      def wrapper(name, options=nil)
+        if block_given?
+          name, options = nil, name if name.is_a?(Hash)
+          builder = self.class.new(@options)
+          options ||= {}
+          options[:tag] = :div if options[:tag].nil?
+          yield builder
+          @components << Many.new(name, builder.to_a, options)
+        else
+          raise ArgumentError, "A block is required as argument to wrapper"
+        end
+      end
+
+      def to_a
+        @components
+      end
+    end
+  end
+end

data/lib/simple_form/wrappers/many.rb

@@ -0,0 +1,73 @@
+module SimpleForm
+  module Wrappers
+    # A wrapper is an object that holds several components and render them.
+    # A component may either be a symbol or any object that responds to `render`.
+    # This API allows inputs/components to be easily wrapped, removing the
+    # need to modify the code only to wrap input in an extra tag.
+    #
+    # `Many` represents a wrapper around several components at the same time.
+    # It may optionally receive a namespace, allowing it to be configured
+    # on demand on input generation.
+    class Many
+      attr_reader :namespace, :defaults, :components
+      alias :to_sym :namespace
+
+      def initialize(namespace, components, defaults={})
+        @namespace  = namespace
+        @components = components
+        @defaults   = defaults
+        @defaults[:tag]   = :div unless @defaults.key?(:tag)
+        @defaults[:class] = Array.wrap(@defaults[:class])
+      end
+
+      def render(input)
+        content = "".html_safe
+        options = input.options
+
+        components.each do |component|
+          next if options[component] == false
+          rendered = component.respond_to?(:render) ? component.render(input) : input.send(component)
+          content.safe_concat rendered.to_s if rendered
+        end
+
+        wrap(input, options, content)
+      end
+
+      def find(name)
+        return self if namespace == name
+
+        @components.each do |c|
+          if c.is_a?(Symbol)
+            return nil if c == namespace
+          elsif value = c.find(name)
+            return value
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      def wrap(input, options, content)
+        return content if options[namespace] == false
+
+        tag = (namespace && options[:"#{namespace}_tag"]) || @defaults[:tag]
+        return content unless tag
+
+        klass = html_classes(input, options)
+        opts  = html_options(options)
+        opts[:class] = (klass << opts[:class]).join(' ').strip unless klass.empty?
+        input.template.content_tag(tag, content, opts)
+      end
+
+      def html_options(options)
+        options[:"#{namespace}_html"] || {}
+      end
+
+      def html_classes(input, options)
+        @defaults[:class].dup
+      end
+    end
+  end
+end

data/lib/simple_form/wrappers/root.rb

@@ -0,0 +1,36 @@
+module SimpleForm
+  module Wrappers
+    # `Root` is the root wrapper for all components. It is special cased to
+    # always have a namespace and to add special html classes.
+    class Root < Many
+      attr_reader :options
+
+      def initialize(*args)
+        super(:wrapper, *args)
+        @options = @defaults.except(:tag, :class, :error_class, :hint_class)
+      end
+
+      def render(input)
+        input.options.reverse_merge!(@options)
+        super
+      end
+
+      # Provide a fallback if name cannot be found.
+      def find(name)
+        super || SimpleForm::Wrappers::Many.new(name, [name])
+      end
+
+      private
+
+      def html_classes(input, options)
+        css = options[:wrapper_class] ? Array.wrap(options[:wrapper_class]) : @defaults[:class]
+        css += SimpleForm.additional_classes_for(:wrapper) do
+          input.additional_classes + [input.input_class]
+        end
+        css << (options[:wrapper_error_class] || @defaults[:error_class]) if input.has_errors?
+        css << (options[:wrapper_hint_class] || @defaults[:hint_class]) if input.has_hint?
+        css.compact
+      end
+    end
+  end
+end

data/lib/simple_form/wrappers/single.rb

@@ -0,0 +1,24 @@
+module SimpleForm
+  module Wrappers
+    # `Single` is an optimization for a wrapper that has only one component.
+    class Single < Many
+      def initialize(name, options={})
+        super(name, [name], options)
+      end
+
+      def render(input)
+        options = input.options
+        if options[namespace] != false
+          content = input.send(namespace)
+          wrap(input, options, content) if content
+        end
+      end
+
+      private
+
+      def html_options(options)
+        [:label, :input].include?(namespace) ? {} : super
+      end
+    end
+  end
+end

data/lib/simple_form/wrappers.rb

@@ -0,0 +1,8 @@
+module SimpleForm
+  module Wrappers
+    autoload :Builder, 'simple_form/wrappers/builder'
+    autoload :Many,    'simple_form/wrappers/many'
+    autoload :Root,    'simple_form/wrappers/root'
+    autoload :Single,  'simple_form/wrappers/single'
+  end
+end

data/lib/simple_form.rb

@@ -0,0 +1,221 @@
+require 'action_view'
+require 'simple_form/action_view_extensions/form_helper'
+require 'simple_form/action_view_extensions/builder'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/reverse_merge'
+
+module SimpleForm
+  autoload :Components,        'simple_form/components'
+  autoload :ErrorNotification, 'simple_form/error_notification'
+  autoload :FormBuilder,       'simple_form/form_builder'
+  autoload :Helpers,           'simple_form/helpers'
+  autoload :I18nCache,         'simple_form/i18n_cache'
+  autoload :Inputs,            'simple_form/inputs'
+  autoload :MapType,           'simple_form/map_type'
+  autoload :Wrappers,          'simple_form/wrappers'
+
+  ## CONFIGURATION OPTIONS
+
+  # Method used to tidy up errors.
+  mattr_accessor :error_method
+  @@error_method = :first
+
+  # Default tag used for error notification helper.
+  mattr_accessor :error_notification_tag
+  @@error_notification_tag = :p
+
+  # CSS class to add for error notification helper.
+  mattr_accessor :error_notification_class
+  @@error_notification_class = :error_notification
+
+  # Series of attemps to detect a default label method for collection.
+  mattr_accessor :collection_label_methods
+  @@collection_label_methods = [ :to_label, :name, :title, :to_s ]
+
+  # Series of attemps to detect a default value method for collection.
+  mattr_accessor :collection_value_methods
+  @@collection_value_methods = [ :id, :to_s ]
+
+  # You can wrap a collection of radio/check boxes in a pre-defined tag, defaulting to none.
+  mattr_accessor :collection_wrapper_tag
+  @@collection_wrapper_tag = nil
+
+  # You can define the class to use on all collection wrappers, defaulting to none.
+  mattr_accessor :collection_wrapper_class
+  @@collection_wrapper_class = nil
+
+  # You can wrap each item in a collection of radio/check boxes with a tag,
+  # defaulting to none. Please note that when using :boolean_style = :nested,
+  # SimpleForm will force this option to be a :label.
+  mattr_accessor :item_wrapper_tag
+  @@item_wrapper_tag = :span
+
+  # You can define the class to use on all item wrappers, defaulting to none.
+  mattr_accessor :item_wrapper_class
+  @@item_wrapper_class = nil
+
+  # How the label text should be generated altogether with the required text.
+  mattr_accessor :label_text
+  @@label_text = lambda { |label, required| "#{required} #{label}" }
+
+  # You can define the class to use on all labels. Default is nil.
+  mattr_accessor :label_class
+  @@label_class = nil
+
+  # Define the way to render check boxes / radio buttons with labels.
+  #   :inline => input + label (default)
+  #   :nested => label > input
+  mattr_accessor :boolean_style
+  @@boolean_style = :inline
+
+  # You can define the class to use on all forms. Default is simple_form.
+  mattr_accessor :form_class
+  @@form_class = :simple_form
+
+  # You can define which elements should obtain additional classes
+  mattr_accessor :generate_additional_classes_for
+  @@generate_additional_classes_for = [:wrapper, :label, :input]
+
+  # Whether attributes are required by default (or not).
+  mattr_accessor :required_by_default
+  @@required_by_default = true
+
+  # Tell browsers whether to use default HTML5 validations (novalidate option).
+  mattr_accessor :browser_validations
+  @@browser_validations = true
+
+  # Collection of methods to detect if a file type was given.
+  mattr_accessor :file_methods
+  @@file_methods = [ :mounted_as, :file?, :public_filename ]
+
+  # Custom mappings for input types. This should be a hash containing a regexp
+  # to match as key, and the input type that will be used when the field name
+  # matches the regexp as value, such as { /count/ => :integer }.
+  mattr_accessor :input_mappings
+  @@input_mappings = nil
+
+  # Custom wrappers for input types. This should be a hash containing an input
+  # type as key and the wrapper that will be used for all inputs with specified type.
+  # e.g { :string => :string_wrapper, :boolean => :boolean_wrapper }
+  mattr_accessor :wrapper_mappings
+  @@wrapper_mappings = nil
+
+  # Default priority for time_zone inputs.
+  mattr_accessor :time_zone_priority
+  @@time_zone_priority = nil
+
+  # Default priority for country inputs.
+  mattr_accessor :country_priority
+  @@country_priority = nil
+
+  # Maximum size allowed for inputs.
+  mattr_accessor :default_input_size
+  @@default_input_size = 50
+
+  # When off, do not use translations in labels. Disabling translation in
+  # hints and placeholders can be done manually in the wrapper API.
+  mattr_accessor :translate_labels
+  @@translate_labels = true
+
+  # Automatically discover new inputs in Rails' autoload path.
+  mattr_accessor :inputs_discovery
+  @@inputs_discovery = true
+
+  # Cache SimpleForm inputs discovery
+  mattr_accessor :cache_discovery
+  @@cache_discovery = defined?(Rails) && !Rails.env.development?
+
+  # Adds a class to each generated button, mostly for compatiblity
+  mattr_accessor :button_class
+  @@button_class = 'button'
+
+  ## WRAPPER CONFIGURATION
+  # The default wrapper to be used by the FormBuilder.
+  mattr_accessor :default_wrapper
+  @@default_wrapper = :default
+  @@wrappers = {}
+
+  # Retrieves a given wrapper
+  def self.wrapper(name)
+    @@wrappers[name.to_sym] or raise WrapperNotFound, "Couldn't find wrapper with name #{name}"
+  end
+
+  # Raised when fails to find a given wrapper name
+  class WrapperNotFound < StandardError
+  end
+
+  # Define a new wrapper using SimpleForm::Wrappers::Builder
+  # and store it in the given name.
+  def self.wrappers(*args, &block)
+    if block_given?
+      options                 = args.extract_options!
+      name                    = args.first || :default
+      @@wrappers[name.to_sym] = build(options, &block)
+    else
+      @@wrappers
+    end
+  end
+
+  # Builds a new wrapper using SimpleForm::Wrappers::Builder.
+  def self.build(options={})
+    options[:tag] = :div if options[:tag].nil?
+    builder = SimpleForm::Wrappers::Builder.new(options)
+    yield builder
+    SimpleForm::Wrappers::Root.new(builder.to_a, options)
+  end
+
+  wrappers :class => :input, :hint_class => :field_with_hint, :error_class => :field_with_errors do |b|
+    b.use :html5
+
+    b.use :min_max
+    b.use :maxlength
+    b.use :placeholder
+    b.optional :pattern
+    b.optional :readonly
+
+    b.use :label_input
+    b.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
+    b.use :error, :wrap_with => { :tag => :span, :class => :error }
+  end
+
+  ## SETUP
+
+  DEPRECATED = %w(hint_tag hint_class error_tag error_class error_notification_id wrapper_tag wrapper_class wrapper_error_class components html5)
+  @@deprecated = []
+
+  DEPRECATED.each do |method|
+    class_eval "def self.#{method}=(*); @@deprecated << :#{method}=; end"
+    class_eval "def self.#{method}; deprecation_warn 'SimpleForm.#{method} is deprecated and has no effect'; end"
+  end
+
+  def self.translate=(value)
+    deprecation_warn "SimpleForm.translate= is disabled in favor of translate_labels="
+    self.translate_labels = value
+  end
+
+  def self.translate
+    deprecation_warn "SimpleForm.translate is disabled in favor of translate_labels"
+    self.translate_labels
+  end
+
+  def self.deprecation_warn(message)
+    ActiveSupport::Deprecation.warn "[SIMPLE_FORM] #{message}", caller
+  end
+
+  def self.additional_classes_for(component)
+    generate_additional_classes_for.include?(component) ? yield : []
+  end
+
+  # Default way to setup SimpleForm. Run rails generate simple_form:install
+  # to create a fresh initializer with all configuration values.
+  def self.setup
+    yield self
+
+    unless @@deprecated.empty?
+      raise "[SIMPLE FORM] Your SimpleForm initializer file is using the following methods: #{@@deprecated.to_sentence}. " <<
+        "Those methods are part of the outdated configuration API. Updating to the new API is easy and fast. " <<
+        "Check for more info here: https://github.com/plataformatec/simple_form/wiki/Upgrading-to-Simple-Form-2.0"
+    end
+  end
+end