mega-safe-tool 0.0.1

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    module ActionHelper
+      # Renders an action for the form (such as a subit/reset button, or a cancel link).
+      #
+      # Each action is wrapped in an `<li class="action">` tag with other classes added based on the
+      # type of action being rendered, and is intended to be rendered inside a {#buttons}
+      # block which wraps the button in a `fieldset` and `ol`.
+      #
+      # The textual value of the label can be changed from the default through the `:label`
+      # argument or through i18n.
+      #
+      # If using i18n, you'll need to provide the following translations:
+      #
+      #   en:
+      #     formtastic:
+      #       actions:
+      #         create: "Create new %{model}"
+      #         update: "Save %{model}"
+      #         cancel: "Cancel"
+      #         reset: "Reset form"
+      #         submit: "Submit"
+      #
+      # For forms with an object present, the `update` key will be used if calling `persisted?` on
+      # the object returns true (saving changes to a record), otherwise the `create` key will be
+      # used. The `submit` key is used as a fallback when there is no object or we cannot determine
+      # if `create` or `update` is appropriate.
+      #
+      # @example Basic usage
+      #   # form
+      #   <%= semantic_form_for @post do |f| %>
+      #     ...
+      #     <%= f.actions do %>
+      #       <%= f.action :submit %>
+      #       <%= f.action :reset %>
+      #       <%= f.action :cancel %>
+      #     <% end %>
+      #   <% end %>
+      #
+      #   # output
+      #   <form ...>
+      #     ...
+      #     <fieldset class="buttons">
+      #       <ol>
+      #         <li class="action input_action">
+      #           <input name="commit" type="submit" value="Create Post">
+      #         </li>
+      #         <li class="action input_action">
+      #           <input name="commit" type="reset" value="Reset Post">
+      #         </li>
+      #         <li class="action link_action">
+      #           <a href="/posts">Cancel Post</a>
+      #         </li>
+      #       </ol>
+      #     </fieldset>
+      #   </form>
+      #
+      # @example Set the value through the `:label` option
+      #   <%= f.action :submit, :label => "Go" %>
+      #
+      # @example Pass HTML attributes down to the tag inside the wrapper
+      #   <%= f.action :submit, :button_html => { :class => 'pretty', :accesskey => 'g', :disable_with => "Wait..." } %>
+      #
+      # @example Pass HTML attributes down to the `<li>` wrapper
+      #   <%= f.action :submit, :wrapper_html => { :class => 'special', :id => 'whatever' } %>
+      #
+      # @option *args :label [String, Symbol]
+      #   Override the label text with a String or a symbold for an i18n translation key
+      #
+      # @option *args :button_html [Hash]
+      #   Override or add to the HTML attributes to be passed down to the `<input>` tag
+      #
+      # @option *args :wrapper_html [Hash]
+      #   Override or add to the HTML attributes to be passed down to the wrapping `<li>` tag
+      #
+      # @todo document i18n keys
+      def action(method, options = {})
+        options = options.dup # Allow options to be shared without being tainted by Formtastic
+        options[:as] ||= default_action_type(method, options)
+
+        klass = namespaced_action_class(options[:as])
+
+        klass.new(self, template, @object, @object_name, method, options).to_html
+      end
+
+      protected
+
+      def default_action_type(method, options = {}) # @private
+        case method
+          when :submit then :input
+          when :reset  then :input
+          when :cancel then :link
+          else method
+        end
+      end
+
+      # Takes the `:as` option and attempts to return the corresponding action
+      # class. In the case of `:as => :awesome` it will first attempt to find a
+      # top level `AwesomeAction` class (to allow the application to subclass
+      # and modify to suit), falling back to `Formtastic::Actions::AwesomeAction`.
+      #
+      # Custom action namespaces to look into can be configured via the
+      # {Formtastic::FormBuilder.action_namespaces} configuration setting.
+      # @see Helpers::InputHelper#namespaced_input_class
+      # @see Formtastic::ActionClassFinder
+      def namespaced_action_class(as)
+        @action_class_finder ||= action_class_finder.new(self)
+        @action_class_finder.find(as)
+      rescue Formtastic::ActionClassFinder::NotFoundError => e
+        raise Formtastic::UnknownActionError, "Unable to find action #{e.message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    # ActionsHelper encapsulates the responsibilities of the {#actions} DSL for acting on 
+    # (submitting, cancelling, resetting) forms.
+    #
+    # {#actions} is a block helper used to wrap the form's actions (buttons, links) in a 
+    # `<fieldset>` and `<ol>`, with each item in the list containing the markup representing a 
+    # single action.
+    #
+    #     <%= semantic_form_for @post do |f| %>
+    #       ...
+    #       <%= f.actions do %>
+    #         <%= f.action :submit
+    #         <%= f.action :cancel
+    #       <% end %>
+    #     <% end %>
+    #
+    # The HTML output will be something like:
+    #
+    #     <form class="formtastic" method="post" action="...">
+    #       ...
+    #       <fieldset class="actions">
+    #         <ol>
+    #           <li class="action input_action">
+    #             <input type="submit" name="commit" value="Create Post">
+    #           </li>
+    #           <li class="action input_action">
+    #             <a href="/posts">Cancel Post</a>
+    #           </li>
+    #         </ol>
+    #       </fieldset>
+    #     </form>
+    #
+    # It's important to note that the `semantic_form_for` and {#actions} blocks wrap the
+    # standard Rails `form_for` helper and form builder, 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 to create your own buttons, links and actions:
+    #
+    #     <%= semantic_form_for @post do |f| %>
+    #       ...
+    #       <%= f.actions do %>
+    #         <li class="save">
+    #           <%= f.submit "Save" %>
+    #         <li>
+    #         <li class="cancel-link">
+    #           Or <%= link_to "Cancel", posts_url %>
+    #         <li>
+    #       <% end %>
+    #     <% end %>
+    #
+    # There are many other syntax variations and arguments to customize your form. See the
+    # full documentation of {#actions} and {#action} for details.
+    module ActionsHelper
+
+      include Formtastic::Helpers::FieldsetWrapper
+      
+      # Creates a fieldset and ol tag wrapping for use around a set of buttons. 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 named actions. These two examples are functionally equivalent:
+      #
+      #     # With a block:
+      #     <% semantic_form_for @post do |f| %>
+      #       ...
+      #       <% f.actions do %>
+      #         <%= f.action :submit %>
+      #         <%= f.action :cancel %>
+      #       <% end %>
+      #     <% end %>
+      #
+      #     # With a list of fields:
+      #     <% semantic_form_for @post do |f| %>
+      #       <%= f.actions :submit, :cancel %>
+      #     <% end %>
+      #
+      #     # Output:
+      #     <form ...>
+      #       <fieldset class="buttons">
+      #         <ol>
+      #           <li class="action input_action">
+      #             <input type="submit" ...>
+      #           </li>
+      #           <li class="action link_action">
+      #             <a href="...">...</a>
+      #           </li>
+      #         </ol>
+      #       </fieldset>
+      #     </form>
+      #
+      # All options except `:name` and `:title` are passed down to the fieldset as HTML
+      # attributes (`id`, `class`, `style`...). If provided, the `:name` or `:title` option is
+      # passed into a `<legend>` inside the `<fieldset>` to name the set of buttons.
+      #
+      # @example Quickly add button(s) to the form, accepting all default values, options and behaviors
+      #     <% semantic_form_for @post do |f| %>
+      #       ...
+      #       <%= f.actions %>
+      #     <% end %>
+      #
+      # @example Specify which named buttons you want, accepting all default values, options and behaviors
+      #     <% semantic_form_for @post do |f| %>
+      #       ...
+      #       <%= f.actions :commit %>
+      #     <% end %>
+      #
+      # @example Specify which named buttons you want, and name the fieldset
+      #     <% semantic_form_for @post do |f| %>
+      #       ...
+      #       <%= f.actions :commit, :name => "Actions" %>
+      #       or
+      #       <%= f.actions :commit, :label => "Actions" %>
+      #     <% end %>
+      #
+      # @example Get full control over the action options
+      #     <% semantic_form_for @post do |f| %>
+      #       ...
+      #       <%= f.actions do %>
+      #         <%= f.action :label => "Go", :button_html => { :class => "pretty" :disable_with => "Wait..." }, :wrapper_html => { ... }
+      #       <% end %>
+      #     <% end %>
+      #
+      # @example Make your own actions with standard Rails helpers or HTML
+      #     <% semantic_form_for @post do |f| %>
+      #       <%= f.actions do %>
+      #         <li>
+      #           ...
+      #         </li>
+      #       <% end %>
+      #     <% end %>
+      #
+      # @example Add HTML attributes to the fieldset
+      #     <% semantic_form_for @post do |f| %>
+      #       ...
+      #       <%= f.actions :commit, :style => "border:1px;" %>
+      #       or
+      #       <%= f.actions :style => "border:1px;" do %>
+      #         ...
+      #       <% end %>
+      #     <% end %>
+      #
+      # @option *args :label [String, Symbol]
+      #   Optionally specify text for the legend of the fieldset
+      #
+      # @option *args :name [String, Symbol]
+      #   Optionally specify text for the legend of the fieldset (alias for `:label`)
+      #
+      # @todo document i18n keys
+      def actions(*args, &block)
+        html_options = args.extract_options!
+        html_options[:class] ||= "actions"
+
+        if block_given?
+          field_set_and_list_wrapping(html_options, &block)
+        else
+          args = default_actions if args.empty?
+          contents = args.map { |action_name| action(action_name) }
+          field_set_and_list_wrapping(html_options, contents)
+        end
+      end
+
+      protected
+      
+      def default_actions
+        [:submit]
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    # @private
+    module Enum
+      # Returns the enum (if defined) for the given method
+      def enum_for(method) # @private
+        if @object.respond_to?(:defined_enums)
+          @object.defined_enums[method.to_s]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    module ErrorsHelper
+      include Formtastic::Helpers::FileColumnDetection
+      include Formtastic::Helpers::Reflection
+      include Formtastic::LocalizedString
+
+      INLINE_ERROR_TYPES = [:sentence, :list, :first]
+
+      # Generates an unordered list of error messages on the base object and optionally for a given
+      # set of named attribute. This is idea for rendering a block of error messages at the top of
+      # the form for hidden/special/virtual attributes (the Paperclip Rails plugin does this), or
+      # errors on the base model.
+      #
+      # A hash can be used as the last set of arguments to pass HTML attributes to the `<ul>`
+      # wrapper.
+      #
+      # # in config/initializers/formtastic.rb
+      # Setting `Formtastic::FormBuilder.semantic_errors_link_to_inputs = true`
+      # will render attribute errors as links to the corresponding errored inputs.
+      #
+      # @example A list of errors on the base model
+      #   <%= semantic_form_for ... %>
+      #     <%= f.semantic_errors %>
+      #     ...
+      #   <% end %>
+      #
+      # @example A list of errors on the base and named attributes
+      #   <%= semantic_form_for ... %>
+      #     <%= f.semantic_errors :something_special %>
+      #     ...
+      #   <% end %>
+      #
+      # @example A list of errors on the base model, with custom HTML attributes
+      #   <%= semantic_form_for ... %>
+      #     <%= f.semantic_errors :class => "awesome" %>
+      #     ...
+      #   <% end %>
+      #
+      # @example A list of errors on the base model and named attributes, with custom HTML attributes
+      #   <%= semantic_form_for ... %>
+      #     <%= f.semantic_errors :something_special, :something_else, :class => "awesome", :onclick => "Awesome();" %>
+      #     ...
+      #   <% end %>
+      def semantic_errors(*args)
+        html_options = args.extract_options!
+        html_options[:class] ||= "errors"
+
+        if Formtastic::FormBuilder.semantic_errors_link_to_inputs
+          attribute_error_hash = semantic_error_hash_from_attributes(args)
+          return nil if @object.errors[:base].blank? && attribute_error_hash.blank?
+
+          template.content_tag(:ul, html_options) do
+            (
+              @object.errors[:base].map { |base_error| template.content_tag(:li, base_error) } <<
+              attribute_error_hash.map { |attribute, error_message|
+                template.content_tag(:li) do
+                  template.content_tag(:a, href: "##{object_name}_#{attribute}") do
+                    error_message
+                  end
+                end
+              }
+            ).join.html_safe
+          end
+        else
+          full_errors = @object.errors[:base]
+          full_errors += semantic_error_list_from_attributes(args)
+          return nil if full_errors.blank?
+
+          template.content_tag(:ul, html_options) do
+            full_errors.map { |error| template.content_tag(:li, error) }.join.html_safe
+          end
+        end
+      end
+
+      protected
+
+      def error_keys(method, options)
+        @methods_for_error ||= {}
+        @methods_for_error[method] ||= begin
+          methods_for_error = [method.to_sym]
+          methods_for_error << file_metadata_suffixes.map{|suffix| "#{method}_#{suffix}".to_sym} if is_file?(method, options)
+          methods_for_error << [association_primary_key_for_method(method)] if [:belongs_to, :has_many].include? association_macro_for_method(method)
+          methods_for_error.flatten.compact.uniq
+        end
+      end
+
+      def has_errors?(method, options)
+        methods_for_error = error_keys(method,options)
+        @object && @object.respond_to?(:errors) && methods_for_error.any?{|error| !@object.errors[error].blank?}
+      end
+
+      def render_inline_errors?
+        @object && @object.respond_to?(:errors) && Formtastic::FormBuilder::INLINE_ERROR_TYPES.include?(inline_errors)
+      end
+
+      def semantic_error_list_from_attributes(*args)
+        attribute_errors = []
+        args = args.flatten
+        args.each do |attribute|
+          next if attribute == :base
+
+          full_message = error_message_for_attribute(attribute)
+
+          attribute_errors << full_message unless full_message.blank?
+        end
+
+        attribute_errors
+      end
+
+      # returns { 'attribute': 'error_message_for_attribute' }
+      def semantic_error_hash_from_attributes(*args)
+        attribute_error_hash = {}
+        args = args.flatten
+        args.each do |attribute|
+          next if attribute == :base
+
+          full_message = error_message_for_attribute(attribute)
+
+          attribute_error_hash[attribute] = full_message unless full_message.blank?
+        end
+
+        attribute_error_hash
+      end
+
+      # Returns "Attribute error_message_sentence" localized, humanized
+      def error_message_for_attribute(attribute)
+        attribute_string = localized_string(attribute, attribute.to_sym, :label) || humanized_attribute_name(attribute)
+        error_message = @object.errors[attribute.to_sym]&.to_sentence
+
+        return nil if error_message.blank?
+
+        full_message = [attribute_string, error_message].join(" ")
+        full_message
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    # @private
+    module FieldsetWrapper
+
+      protected
+
+      # Generates a fieldset and wraps the content in an ordered list. When working
+      # with nested attributes, it allows %i as interpolation option in :name. So you can do:
+      #
+      #   f.inputs :name => 'Task #%i', :for => :tasks
+      #
+      # or the shorter equivalent:
+      #
+      #   f.inputs 'Task #%i', :for => :tasks
+      #
+      # And it will generate a fieldset for each task with legend 'Task #1', 'Task #2',
+      # 'Task #3' and so on.
+      #
+      # Note: Special case for the inline inputs (non-block):
+      #   f.inputs "My little legend", :title, :body, :author   # Explicit legend string => "My little legend"
+      #   f.inputs :my_little_legend, :title, :body, :author    # Localized (118n) legend with I18n key => I18n.t(:my_little_legend, ...)
+      #   f.inputs :title, :body, :author                       # First argument is a column => (no legend)
+      def field_set_and_list_wrapping(*args, &block) # @private
+        contents = args[-1].is_a?(::Hash) ? '' : args.pop.flatten
+        html_options = args.extract_options!
+
+        if block_given?
+          contents = if template.respond_to?(:is_haml?) && template.is_haml?
+            template.capture_haml(&block)
+          else
+            template.capture(&block)
+          end
+        end
+
+        # Work-around for empty contents block
+        contents ||= ""
+
+        # Ruby 1.9: String#to_s behavior changed, need to make an explicit join.
+        contents = contents.join if contents.respond_to?(:join)
+
+        legend = field_set_legend(html_options)
+        fieldset = template.content_tag(:fieldset,
+          legend.html_safe << template.content_tag(:ol, contents.html_safe),
+          html_options.except(:builder, :parent, :name)
+        )
+
+        fieldset
+      end
+
+      def field_set_legend(html_options)
+        legend  = (html_options[:name] || '').to_s
+       	# only applying if String includes '%i' avoids argument error when $DEBUG is true
+        legend %= parent_child_index(html_options[:parent]) if html_options[:parent] && legend.include?('%i')
+        legend  = template.content_tag(:legend, template.content_tag(:span, legend.html_safe)) unless legend.blank?
+        legend
+      end
+
+      # Gets the nested_child_index value from the parent builder. It returns a hash with each
+      # association that the parent builds.
+      def parent_child_index(parent) # @private
+        # Could be {"post[authors_attributes]"=>0} or { :authors => 0 }
+        duck = parent[:builder].instance_variable_get('@nested_child_index')
+
+        # Could be symbol for the association, or a model (or an array of either, I think? TODO)
+        child = parent[:for]
+        # Pull a symbol or model out of Array (TODO: check if there's an Array)
+        child = child.first if child.respond_to?(:first)
+        # If it's an object, get a symbol from the class name
+        child = child.class.name.underscore.to_sym unless child.is_a?(Symbol)
+
+        key = "#{parent[:builder].object_name}[#{child}_attributes]"
+
+        # TODO: One of the tests produces a scenario where duck is "0" and the test looks for a "1"
+        # in the legend, so if we have a number, return it with a +1 until we can verify this scenario.
+        return duck + 1 if duck.is_a?(Integer)
+
+        # First try to extract key from duck Hash, then try child
+        (duck[key] || duck[child]).to_i + 1
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Formtastic
+  module Helpers
+    # @private
+    module FileColumnDetection
+
+      def is_file?(method, options = {})
+        @files ||= {}
+        @files[method] ||= (options[:as].present? && options[:as] == :file) || begin
+          file = @object.send(method) if @object && @object.respond_to?(method)
+          file && file_methods.any?{|m| file.respond_to?(m)}
+        end
+      end
+
+    end
+  end
+end