mega-safe-tool 0.0.1

data/formtastic-6.0.0/lib/formtastic/helpers/inputs_helper.rb

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+
+    # {#inputs} is used to wrap a series of form items in a `<fieldset>` and `<ol>`, with each item
+    # in the list containing the markup representing a single {#input}.
+    #
+    # {#inputs} is usually called with a block containing a series of {#input} methods:
+    #
+    #     <%= semantic_form_for @post do |f| %>
+    #       <%= f.inputs do %>
+    #         <%= f.input :title %>
+    #         <%= f.input :body %>
+    #       <% end %>
+    #     <% end %>
+    #
+    # The HTML output will be something like:
+    #
+    #     <form class="formtastic" method="post" action="...">
+    #       <fieldset>
+    #         <ol>
+    #           <li class="string required" id="post_title_input">
+    #             ...
+    #           </li>
+    #           <li class="text required" id="post_body_input">
+    #             ...
+    #           </li>
+    #         </ol>
+    #       </fieldset>
+    #     </form>
+    #
+    # It's important to note that the `semantic_form_for` and {#inputs} blocks wrap the
+    # standard Rails `form_for` helper and FormBuilder, so you have full access to every standard
+    # Rails form helper, with any HTML markup and ERB syntax, allowing you to "break free" from
+    # Formtastic when it doesn't suit:
+    #
+    #     <%= semantic_form_for @post do |f| %>
+    #       <%= f.inputs do %>
+    #         <%= f.input :title %>
+    #         <li>
+    #           <%= f.text_area :body %>
+    #         <li>
+    #       <% end %>
+    #     <% end %>
+    #
+    # @see Formtastic::Helpers::InputHelper#input
+    module InputsHelper
+      include Formtastic::Helpers::FieldsetWrapper
+      include Formtastic::LocalizedString
+
+      # {#inputs} creates an input fieldset and ol tag wrapping for use around a set of inputs.  It can be
+      # called either with a block (in which you can do the usual Rails form stuff, HTML, ERB, etc),
+      # or with a list of fields (accepting all default arguments and options). These two examples
+      # are functionally equivalent:
+      #
+      #     # With a block:
+      #     <% semantic_form_for @post do |form| %>
+      #       <% f.inputs do %>
+      #         <%= f.input :title %>
+      #         <%= f.input :body %>
+      #       <% end %>
+      #     <% end %>
+      #
+      #     # With a list of fields (short hand syntax):
+      #     <% semantic_form_for @post do |form| %>
+      #       <%= f.inputs :title, :body %>
+      #     <% end %>
+      #
+      #     # Output:
+      #     <form ...>
+      #       <fieldset class="inputs">
+      #         <ol>
+      #           <li class="string">...</li>
+      #           <li class="text">...</li>
+      #         </ol>
+      #       </fieldset>
+      #     </form>
+      #
+      # **Quick Forms**
+      #
+      # Quick, scaffolding-style forms can be easily rendered for rapid early development if called
+      # without a block or a field list. In the case an input is rendered for **most** columns in
+      # the model's database table (like Rails' scaffolding) plus inputs for some model associations.
+      #
+      # In this case, all inputs are rendered with default options and arguments. You'll want more
+      # control than this in a production application, but it's a great way to get started, then
+      # come back later to customise the form with a field list or a block of inputs.  Example:
+      #
+      #     <% semantic_form_for @post do |form| %>
+      #       <%= f.inputs %>
+      #     <% end %>
+      #
+      # **Nested Attributes**
+      #
+      # One of the most complicated parts of Rails forms comes when nesting the inputs for
+      # attrinbutes on associated models. Formtastic can take the pain away for many (but not all)
+      # situations.
+      #
+      # Given the following models:
+      #
+      #     # Models
+      #     class User < ActiveRecord::Base
+      #       has_one :profile
+      #       accepts_nested_attributes_for :profile
+      #     end
+      #     class Profile < ActiveRecord::Base
+      #       belongs_to :user
+      #     end
+      #
+      # Formtastic provides a helper called `semantic_fields_for`, which wraps around Rails' built-in
+      # `fields_for` helper for backwards compatibility with previous versions of Formtastic, and for
+      # a consistent method naming API. The following examples are functionally equivalent:
+      #
+      #     <% semantic_form_for @user do |form| %>
+      #       <%= f.inputs :name, :email %>
+      #
+      #       <% f.semantic_fields_for :profile do |profile| %>
+      #         <% profile.inputs do %>
+      #           <%= profile.input :biography %>
+      #           <%= profile.input :twitter_name %>
+      #         <% end %>
+      #       <% end %>
+      #     <% end %>
+      #
+      #     <% semantic_form_for @user do |form| %>
+      #       <%= f.inputs :name, :email %>
+      #
+      #       <% f.fields_for :profile do |profile| %>
+      #         <% profile.inputs do %>
+      #           <%= profile.input :biography %>
+      #           <%= profile.input :twitter_name %>
+      #         <% end %>
+      #       <% end %>
+      #     <% end %>
+      #
+      # {#inputs} also provides a DSL similar to `fields_for` / `semantic_fields_for` to reduce the
+      # lines of code a little:
+      #
+      #     <% semantic_form_for @user do |f| %>
+      #       <%= f.inputs :name, :email %>
+      #
+      #       <% f.inputs :for => :profile do %>
+      #         <%= profile.input :biography %>
+      #         <%= profile.input :twitter_name %>
+      #         <%= profile.input :shoe_size %>
+      #       <% end %>
+      #     <% end %>
+      #
+      # The `:for` option also works with short hand syntax:
+      #
+      #     <% semantic_form_for @post do |form| %>
+      #       <%= f.inputs :name, :email %>
+      #       <%= f.inputs :biography, :twitter_name, :shoe_size, :for => :profile %>
+      #     <% end %>
+      #
+      # {#inputs} will always create a new `<fieldset>` wrapping, so only use it when it makes sense
+      # in the document structure and semantics (using `semantic_fields_for` otherwise).
+      #
+      # All options except `:name`, `:title` and `:for` will be passed down to the fieldset as HTML
+      # attributes (id, class, style, etc).
+      #
+      # When nesting `inputs()` inside another `inputs()` block, the nested content will
+      # automatically be wrapped in an `<li>` tag to preserve the HTML validity (a `<fieldset>`
+      # cannot be a direct descendant of an `<ol>`.
+      #
+      #
+      # @option *args :for [Symbol, ActiveModel, Array]
+      #   The contents of this option is passed down to Rails' fields_for() helper, so it accepts the same values.
+      #
+      # @option *args :name [String]
+      #   The optional name passed into the `<legend>` tag within the fieldset (alias of `:title`)
+      #
+      # @option *args :title [String]
+      #   The optional name passed into the `<legend>` tag within the fieldset (alias of `:name`)
+      #
+      #
+      # @example Quick form: Render a scaffold-like set of inputs for automatically guessed attributes and simple associations on the model, with all default arguments and options
+      #   <% semantic_form_for @post do |form| %>
+      #     <%= f.inputs %>
+      #   <% end %>
+      #
+      # @example Quick form: Skip one or more fields
+      #   <%= f.inputs :except => [:featured, :something_for_admin_only] %>
+      #   <%= f.inputs :except => :featured %>
+      #
+      # @example Short hand: Render inputs for a named set of attributes and simple associations on the model, with all default arguments and options
+      #   <% semantic_form_for @post do |form| %>
+      #     <%= f.inputs :title, :body, :user, :categories %>
+      #   <% end %>
+      #
+      # @example Block: Render inputs for attributes and simple associations with full control over arguments and options
+      #   <% semantic_form_for @post do |form| %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :title ... %>
+      #       <%= f.input :body ... %>
+      #       <%= f.input :user ... %>
+      #       <%= f.input :categories ... %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # @example Multiple blocks: Render inputs in multiple fieldsets
+      #   <% semantic_form_for @post do |form| %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :title ... %>
+      #       <%= f.input :body ... %>
+      #     <% end %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :user ... %>
+      #       <%= f.input :categories ... %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # @example Provide text for the `<legend>` to name a fieldset (with a block)
+      #   <% semantic_form_for @post do |form| %>
+      #     <%= f.inputs :name => 'Write something:' do %>
+      #       <%= f.input :title ... %>
+      #       <%= f.input :body ... %>
+      #     <% end %>
+      #     <%= f.inputs :name => 'Advanced options:' do %>
+      #       <%= f.input :user ... %>
+      #       <%= f.input :categories ... %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # @example Provide text for the `<legend>` to name a fieldset (with short hand)
+      #   <% semantic_form_for @post do |form| %>
+      #     <%= f.inputs :title, :body, :name => 'Write something:'%>
+      #     <%= f.inputs :user, :cateogies, :name => 'Advanced options:' %>
+      #   <% end %>
+      #
+      # @example Inputs for nested attributes (don't forget `accepts_nested_attributes_for` in your model, see Rails' `fields_for` documentation)
+      #   <% semantic_form_for @user do |form| %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :name ... %>
+      #       <%= f.input :email ... %>
+      #     <% end %>
+      #     <%= f.inputs :for => :profile do |profile| %>
+      #       <%= profile.input :user ... %>
+      #       <%= profile.input :categories ... %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # @example Inputs for nested record (don't forget `accepts_nested_attributes_for` in your model, see Rails' `fields_for` documentation)
+      #   <% semantic_form_for @user do |form| %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :name ... %>
+      #       <%= f.input :email ... %>
+      #     <% end %>
+      #     <%= f.inputs :for => @user.profile do |profile| %>
+      #       <%= profile.input :user ... %>
+      #       <%= profile.input :categories ... %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # @example Inputs for nested record with a different name (don't forget `accepts_nested_attributes_for` in your model, see Rails' `fields_for` documentation)
+      #   <% semantic_form_for @user do |form| %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :name ... %>
+      #       <%= f.input :email ... %>
+      #     <% end %>
+      #     <%= f.inputs :for => [:user_profile, @user.profile] do |profile| %>
+      #       <%= profile.input :user ... %>
+      #       <%= profile.input :categories ... %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # @example Nesting {#inputs} blocks requires an extra `<li>` tag for valid markup
+      #   <% semantic_form_for @user do |form| %>
+      #     <%= f.inputs do %>
+      #       <%= f.input :name ... %>
+      #       <%= f.input :email ... %>
+      #       <li>
+      #         <%= f.inputs :for => [:user_profile, @user.profile] do |profile| %>
+      #           <%= profile.input :user ... %>
+      #           <%= profile.input :categories ... %>
+      #         <% end %>
+      #       </li>
+      #     <% end %>
+      #   <% end %>
+      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
+        skipped_args = Array.wrap html_options.delete(:except)
+
+        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 - skipped_args 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 = wrap_it
+        out
+      end
+
+      protected
+
+      def default_columns_for_object
+        cols  = association_columns(:belongs_to)
+        cols += content_columns
+        cols -= skipped_columns
+        cols.compact
+      end
+
+      def fieldset_contents_from_column_list(columns)
+        columns.collect do |method|
+          if @object
+            if @object.class.respond_to?(:reflect_on_association)
+              if (@object.class.reflect_on_association(method.to_sym) && @object.class.reflect_on_association(method.to_sym).options[:polymorphic] == true)
+                raise PolymorphicInputWithoutCollectionError.new("Please provide a collection for :#{method} input (you'll need to use block form syntax). Inputs for polymorphic associations can only be used when an explicit :collection is provided.")
+              end
+            elsif @object.class.respond_to?(:associations)
+              if (@object.class.associations[method.to_sym] && @object.class.associations[method.to_sym].options[:polymorphic] == true)
+                raise PolymorphicInputWithoutCollectionError.new("Please provide a collection for :#{method} input (you'll need to use block form syntax). Inputs for polymorphic associations can only be used when an explicit :collection is provided.")
+              end
+            end
+          end
+          input(method.to_sym)
+        end
+      end
+
+      # Collects association columns (relation columns) for the current form object class. Skips
+      # polymorphic associations because we can't guess which class to use for an automatically
+      # generated input.
+      def association_columns(*by_associations) # @private
+        if @object.present? && @object.class.respond_to?(:reflections)
+          @object.class.reflections.collect do |name, association_reflection|
+            if by_associations.present?
+              if by_associations.include?(association_reflection.macro) && association_reflection.options[:polymorphic] != true
+                name
+              end
+            else
+              name
+            end
+          end.compact
+        else
+          []
+        end
+      end
+
+      # Collects all foreign key columns
+      def foreign_key_columns # @private
+        if @object.present? && @object.class.respond_to?(:reflect_on_all_associations)
+          @object.class.reflect_on_all_associations(:belongs_to).map{ |reflection| reflection.foreign_key.to_sym }
+        else
+          []
+        end
+      end
+
+      # Collects content columns (non-relation columns) for the current form object class.
+      def content_columns # @private
+        # TODO: NameError is raised by Inflector.constantize. Consider checking if it exists instead.
+        begin klass = model_name.constantize; rescue NameError; return [] end
+        return [] unless klass.respond_to?(:content_columns)
+        klass.content_columns.collect { |c| c.name.to_sym }.compact - foreign_key_columns
+      end
+
+      # Deals with :for option when it's supplied to inputs methods. Additional
+      # options to be passed down to :for should be supplied using :for_options
+      # key.
+      #
+      # It should raise an error if a block with arity zero is given.
+      def inputs_for_nested_attributes(*args, &block) # @private
+        options = args.extract_options!
+        args << options.merge!(:parent => { :builder => self, :for => options[:for] })
+
+        fields_for_block = if block_given?
+          raise ArgumentError, 'You gave :for option with a block to inputs method, ' +
+                               'but the block does not accept any argument.' if block.arity <= 0
+          lambda do |f|
+            contents = f.inputs(*args) do
+              if block.arity == 1  # for backwards compatibility with REE & Ruby 1.8.x
+                yield(f)
+              else
+                index = parent_child_index(options[:parent]) if options[:parent]
+                yield(f, index)
+              end
+            end
+            template.concat(contents)
+          end
+        else
+          lambda do |f|
+            contents = f.inputs(*args)
+            template.concat(contents)
+          end
+        end
+
+        fields_for_args = [options.delete(:for), options.delete(:for_options) || {}].flatten(1)
+        fields_for(*fields_for_args, &fields_for_block)
+      end
+
+      def field_set_title_from_args(*args) # @private
+        options = args.extract_options!
+        options[:name] ||= options.delete(:title)
+        title = options[:name]
+
+        if title.blank?
+          valid_name_classes = [::String, ::Symbol]
+          valid_name_classes.delete(::Symbol) if !block_given? && (args.first.is_a?(::Symbol) && content_columns.include?(args.first))
+          title = args.shift if valid_name_classes.any? { |valid_name_class| args.first.is_a?(valid_name_class) }
+        end
+        title = localized_string(title, title, :title) if title.is_a?(::Symbol)
+        title
+      end
+
+    end
+  end
+end

data/formtastic-6.0.0/lib/formtastic/helpers/reflection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    # @private
+    module Reflection
+      # If an association method is passed in (f.input :author) try to find the
+      # reflection object.
+      def reflection_for(method) # @private
+        if @object.class.respond_to?(:reflect_on_association)
+          @object.class.reflect_on_association(method)
+        elsif @object.class.respond_to?(:associations) # MongoMapper uses the 'associations(method)' instead
+          @object.class.associations[method]
+        end
+      end
+
+      def association_macro_for_method(method) # @private
+        reflection = reflection_for(method)
+        reflection.macro if reflection
+      end
+
+      def association_primary_key_for_method(method) # @private
+        reflection = reflection_for(method)
+        if reflection
+          case association_macro_for_method(method)
+          when :has_and_belongs_to_many, :has_many, :references_and_referenced_in_many, :references_many
+            :"#{method.to_s.singularize}_ids"
+          else
+            return reflection.foreign_key.to_sym if reflection.respond_to?(:foreign_key)
+            return reflection.options[:foreign_key].to_sym unless reflection.options[:foreign_key].blank?
+            :"#{method}_id"
+          end
+        else
+          method.to_sym
+        end
+      end
+    end
+  end
+end

data/formtastic-6.0.0/lib/formtastic/helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    autoload :ActionHelper, 'formtastic/helpers/action_helper'
+    autoload :ActionsHelper, 'formtastic/helpers/actions_helper'
+    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 :Reflection, 'formtastic/helpers/reflection'
+    autoload :Enum, 'formtastic/helpers/enum'
+  end
+end
+

data/formtastic-6.0.0/lib/formtastic/html_attributes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Formtastic
+  # @private
+  module HtmlAttributes
+    # Returns a namespace passed by option or inherited from parent builders / class configuration
+    def dom_id_namespace
+      namespace = options[:custom_namespace]
+      parent = options[:parent_builder]
+
+      case
+        when namespace then namespace
+        when parent && parent != self then parent.dom_id_namespace
+        else custom_namespace
+      end
+    end
+
+    protected
+
+    def humanized_attribute_name(method)
+      if @object && @object.class.respond_to?(:human_attribute_name)
+        humanized_name = @object.class.human_attribute_name(method.to_s)
+        if humanized_name == method.to_s.send(:humanize)
+          method.to_s.send(label_str_method)
+        else
+          humanized_name
+        end
+      else
+        method.to_s.send(label_str_method)
+      end
+    end
+
+  end
+end

data/formtastic-6.0.0/lib/formtastic/i18n.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Formtastic
+  # @private
+  module I18n
+
+    DEFAULT_SCOPE = [:formtastic].freeze
+    DEFAULT_VALUES = YAML.load_file(File.expand_path("../../locale/en.yml", __FILE__))["en"]["formtastic"].freeze
+    SCOPES = [
+        '%{model}.%{nested_model}.%{action}.%{attribute}',
+        '%{model}.%{nested_model}.%{attribute}',
+        '%{nested_model}.%{action}.%{attribute}',
+        '%{nested_model}.%{attribute}',
+        '%{model}.%{action}.%{attribute}',
+        '%{model}.%{attribute}',
+        '%{attribute}'
+      ]
+
+    class << self
+
+      def translate(*args)
+        key = args.shift.to_sym
+        options = args.extract_options!
+        options.reverse_merge!(:default => DEFAULT_VALUES[key])
+        options[:scope] = [DEFAULT_SCOPE, options[:scope]].flatten.compact
+        ::I18n.translate(key, *args, **options)
+      end
+      alias :t :translate
+
+    end
+
+  end
+end

data/formtastic-6.0.0/lib/formtastic/input_class_finder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Formtastic
+
+  # Uses the {Formtastic::NamespacedClassFinder} to look up input class names.
+  #
+  # See {Formtastic::FormBuilder#namespaced_input_class} for details.
+  #
+  class InputClassFinder < NamespacedClassFinder
+
+    # @param builder [FormBuilder]
+    def initialize(builder)
+      super builder.input_namespaces
+    end
+
+    def class_name(as)
+      "#{super}Input"
+    end
+  end
+end

data/formtastic-6.0.0/lib/formtastic/inputs/base/aria.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Aria
+
+        def error_aria_attributes
+          return {} unless builder.semantic_errors_link_to_inputs
+          return {} unless errors?
+
+          {
+            'aria-describedby': describedby,
+            'aria-invalid': options.dig(:input_html, :'aria-invalid') || 'true'
+          }
+        end
+
+        def describedby
+          describedby = options.dig(:input_html, :'aria-describedby') || ''
+          describedby += ' ' unless describedby.empty?
+          describedby += "#{method}_error"
+        end
+
+      end
+    end
+  end
+end

data/formtastic-6.0.0/lib/formtastic/inputs/base/associations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Associations
+        include Formtastic::Helpers::Reflection
+
+        # :belongs_to, etc
+        def association
+          @association ||= association_macro_for_method(method)
+        end
+
+        def reflection
+          @reflection ||= reflection_for(method)
+        end
+
+        def belongs_to?
+          association == :belongs_to
+        end
+
+        def has_many?
+          association == :has_many
+        end
+
+        def association_primary_key
+          association_primary_key_for_method(method)
+        end
+
+      end
+    end
+  end
+end