mega-safe-tool 0.0.1

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Choices
+
+        def choices_wrapping(&block)
+          template.content_tag(:fieldset,
+            template.capture(&block),
+            choices_wrapping_html_options
+          )
+        end
+
+        def choices_wrapping_html_options
+          { :class => "choices" }
+        end
+
+        def choices_group_wrapping(&block)
+          template.content_tag(:ol,
+            template.capture(&block),
+            choices_group_wrapping_html_options
+          )
+        end
+
+        def choices_group_wrapping_html_options
+          { :class => "choices-group" }
+        end
+
+        def choice_wrapping(html_options, &block)
+          template.content_tag(:li,
+            template.capture(&block),
+            html_options
+          )
+        end
+
+        def choice_wrapping_html_options(choice)
+          classes = ['choice']
+          classes << "#{sanitized_method_name.singularize}_#{choice_html_safe_value(choice)}" if value_as_class?
+
+          { :class => classes.join(" ") }
+        end
+
+        def choice_html(choice)
+          raise "choice_html() needs to be implemented when including Formtastic::Inputs::Base::Choices"
+        end
+
+        def choice_label(choice)
+          if choice.is_a?(Array)
+            choice.first
+          else
+            choice
+          end.to_s
+        end
+
+        def choice_value(choice)
+          choice.is_a?(Array) ? choice[1] : choice
+        end
+
+        def choice_html_options(choice)
+          custom_choice_html_options(choice).merge(default_choice_html_options(choice))
+        end
+
+        def default_choice_html_options(choice)
+          { :id => choice_input_dom_id(choice) }
+        end
+
+        def custom_choice_html_options(choice)
+          (choice.is_a?(Array) && choice.size > 2) ? choice[-1] : {}
+        end
+
+        def choice_html_safe_value(choice)
+          choice_value(choice).to_s.gsub(/\s/, '_').gsub(/[^\w-]/, '').downcase
+        end
+
+        def choice_input_dom_id(choice)
+          [
+            builder.dom_id_namespace,
+            sanitized_object_name,
+            builder.options[:index],
+            association_primary_key || method,
+            choice_html_safe_value(choice)
+          ].compact.reject { |i| i.blank? }.join("_")
+        end
+
+        def value_as_class?
+          options[:value_as_class]
+        end
+
+        def legend_html
+          if render_label?
+            template.content_tag(:legend,
+              template.content_tag(:label, label_text),
+              label_html_options.merge(:class => "label")
+            )
+          else
+            +"".html_safe
+          end
+        end
+
+        # Override to remove the for attribute since this isn't associated with any element, as it's
+        # nested inside the legend.
+        def label_html_options
+          super.merge(:for => nil)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Collections
+
+        def label_method
+          @label_method ||= (label_method_from_options || label_and_value_method.first)
+        end
+
+        def label_method_from_options
+          options[:member_label]
+        end
+
+        def value_method
+          @value_method ||= (value_method_from_options || label_and_value_method[-1])
+        end
+
+        def value_method_from_options
+          options[:member_value]
+        end
+
+        def label_and_value_method
+          @label_and_value_method ||= label_and_value_method_from_collection(raw_collection)
+        end
+
+        def label_and_value_method_from_collection(_collection)
+          sample = _collection.first || _collection[-1]
+
+          case sample
+          when Array
+            label, value = :first, :last
+          when Integer
+            label, value = :to_s, :to_i
+          when Symbol, String, NilClass
+            label, value = :to_s, :to_s
+          end
+
+          # Order of preference: user supplied method, class defaults, auto-detect
+          label ||= builder.collection_label_methods.find { |m| sample.respond_to?(m) }
+          value ||= builder.collection_value_methods.find { |m| sample.respond_to?(m) }
+
+          [label, value]
+        end
+
+        def raw_collection
+          @raw_collection ||= (collection_from_options || collection_from_enum || collection_from_association || collection_for_boolean)
+        end
+
+        def collection
+          # Return if we have a plain string
+          return raw_collection if raw_collection.is_a?(String)
+
+          # Return if we have an Array of strings, integers or arrays
+          return raw_collection if (raw_collection.instance_of?(Array) || raw_collection.instance_of?(Range)) &&
+                               ([Array, String, Symbol].include?(raw_collection.first.class) || raw_collection.first.is_a?(Integer)) &&
+                               !(options.include?(:member_label) || options.include?(:member_value))
+
+          raw_collection.map { |o| [send_or_call(label_method, o), send_or_call(value_method, o)] }
+        end
+
+        def collection_from_options
+          items = options[:collection]
+          case items
+          when Hash
+            items.to_a
+          when Range
+            items.to_a.collect{ |c| [c.to_s, c] }
+          else
+            items
+          end
+        end
+
+        def collection_from_association
+          if reflection
+            if reflection.respond_to?(:options)
+              raise PolymorphicInputWithoutCollectionError.new(
+                        "A collection must be supplied for #{method} input. Collections cannot be guessed for polymorphic associations."
+                    ) if reflection.options[:polymorphic] == true
+            end
+
+            return reflection.klass.merge(reflection.scope) if reflection.scope
+
+            conditions_from_reflection = (reflection.respond_to?(:options) && reflection.options[:conditions]) || {}
+            conditions_from_reflection = conditions_from_reflection.call if conditions_from_reflection.is_a?(Proc)
+
+            scope_conditions = conditions_from_reflection.empty? ? nil : {:conditions => conditions_from_reflection}
+            where_conditions = (scope_conditions && scope_conditions[:conditions]) || {}
+
+            reflection.klass.where(where_conditions)
+          end
+        end
+
+        # Assuming the following model:
+        #
+        # class Post < ActiveRecord::Base
+        #   enum :status => [ :active, :archived ]
+        # end
+        #
+        # We would end up with a collection like this:
+        #
+        # [["Active", "active"], ["Archived", "archived"]
+        #
+        # The first element in each array uses String#humanize, but I18n
+        # translations are available too. Set them with the following structure.
+        #
+        # en:
+        #   activerecord:
+        #     attributes:
+        #       post:
+        #         statuses:
+        #           active: Custom Active Label Here
+        #           archived: Custom Archived Label Here
+        def collection_from_enum
+          if collection_from_enum?
+            method_name = method.to_s
+
+            enum_options_hash = object.defined_enums[method_name]
+            enum_options_hash.map do |name, value|
+              key = "activerecord.attributes.#{object.model_name.i18n_key}.#{method_name.pluralize}.#{name}"
+              label = ::I18n.translate(key, :default => name.humanize)
+              [label, name]
+            end
+          end
+        end
+
+        def collection_from_enum?
+          object.respond_to?(:defined_enums) && object.defined_enums.has_key?(method.to_s)
+        end
+
+        def collection_for_boolean
+          true_text = options[:true] || Formtastic::I18n.t(:yes)
+          false_text = options[:false] || Formtastic::I18n.t(:no)
+
+          # TODO options[:value_as_class] = true unless options.key?(:value_as_class)
+
+          [ [true_text, true], [false_text, false] ]
+        end
+
+        def send_or_call(duck, object)
+          if duck.respond_to?(:call)
+            duck.call(object)
+          elsif object.respond_to? duck.to_sym
+            object.send(duck)
+          end
+        end
+
+        # Avoids an issue where `send_or_call` can be a String and duck can be something simple like
+        # `:first`, which obviously String responds to.
+        def send_or_call_or_object(duck, object)
+          return object if object.is_a?(String) || object.is_a?(Integer) || object.is_a?(Symbol) # TODO what about other classes etc?
+          send_or_call(duck, object)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Database
+
+        def column
+          if object.respond_to?(:column_for_attribute)
+            object.column_for_attribute(method)
+          end
+        end
+
+        def column?
+          !column.nil?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module DatetimePickerish
+        include Base::Placeholder
+      
+        def html_input_type
+          raise NotImplementedError
+        end
+      
+        def default_size
+          raise NotImplementedError
+        end
+        
+        def value
+          raise NotImplementedError
+        end
+      
+        def input_html_options
+          super.merge(extra_input_html_options)
+        end
+      
+        def extra_input_html_options
+          {
+            :type => html_input_type, 
+            :size => size, 
+            :maxlength => maxlength, 
+            :step => step,
+            :value => value
+          }
+        end
+      
+        def size
+          return options[:size] if options.key?(:size)
+          return options[:input_html][:size] if options[:input_html] && options[:input_html].key?(:size)
+          default_size
+        end
+      
+        def step
+          return step_from_macro(options[:input_html][:step]) if options[:input_html] && options[:input_html][:step] && options[:input_html][:step].is_a?(Symbol)
+          return options[:input_html][:step] if options[:input_html] && options[:input_html].key?(:step)
+          default_step
+        end
+      
+        def maxlength
+          return options[:maxlength] if options.key?(:maxlength)
+          return options[:input_html][:maxlength] if options[:input_html] && options[:input_html].key?(:maxlength)
+          default_size
+        end
+      
+        def default_maxlength
+          default_size
+        end
+      
+        def default_step
+          1
+        end
+        
+        protected
+        
+        def step_from_macro(sym)
+          case sym
+
+            # date
+            when :day then "1"
+            when :seven_days, :week then "7"
+            when :two_weeks, :fortnight then "14"
+            when :four_weeks then "28"
+            when :thirty_days then "30"
+
+            # time
+            when :second then "1"
+            when :minute then "60"
+            when :fifteen_minutes, :quarter_hour then "900"
+            when :thirty_minutes, :half_hour then "1800"
+            when :sixty_minutes, :hour then "3600"            
+
+            else sym
+          end
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Errors
+        
+        def error_html
+          errors? ? send(:"error_#{builder.inline_errors}_html") : +""
+        end
+        
+        def error_sentence_html
+          error_class = builder.default_inline_error_class
+          template.content_tag(:p, errors.to_sentence, id: "#{method}_error", :class => error_class)
+        end
+                
+        def error_list_html
+          error_class = builder.default_error_list_class
+          list_elements = []
+          errors.each do |error|
+            list_elements << template.content_tag(:li, error.html_safe)
+          end
+          template.content_tag(:ul, list_elements.join("\n").html_safe, :class => error_class)
+        end
+        
+        def error_first_html
+          error_class = builder.default_inline_error_class
+          template.content_tag(:p, errors.first.untaint.html_safe, :class => error_class)
+        end
+        
+        def error_none_html
+          +""
+        end
+        
+        def errors?
+          !errors.blank?
+        end
+        
+        def errors
+          errors = []
+          if object && object.respond_to?(:errors)
+            error_keys.each do |key| 
+              errors << object.errors[key] unless object.errors[key].blank?
+            end
+          end
+          errors.flatten.compact.uniq
+        end
+        
+        def error_keys
+          keys = [method.to_sym]
+          keys << builder.file_metadata_suffixes.map{|suffix| "#{method}_#{suffix}".to_sym} if file?
+          keys << association_primary_key if belongs_to? || has_many?
+          keys.flatten.compact.uniq
+        end
+        
+      end
+    end
+  end
+end
+        

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Fileish
+      
+        def file?
+          @file ||= begin
+            # TODO return true if self.is_a?(Formtastic::Inputs::FileInput::Woo)
+            object && object.respond_to?(method) && builder.file_methods.any? { |m| object.send(method).respond_to?(m) }
+          end
+        end
+      
+      end
+    end
+  end
+end
+
+
+
+        
+
+
+

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Hints
+        
+        def hint_html
+          if hint?
+            template.content_tag(
+              :p, 
+              hint_text.html_safe, 
+              :class => builder.default_hint_class
+            )
+          end
+        end
+        
+        def hint?
+          !hint_text.blank? && !hint_text.kind_of?(Hash)
+        end
+
+        def hint_text
+          localized_string(method, options[:hint], :hint)
+        end
+        
+        def hint_text_from_options
+          options[:hint]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Html
+
+        # Defines how the instance of an input should be rendered to a HTML string.
+        #
+        # @abstract Implement this method in your input class to describe how the input should render itself.
+        #
+        # @example A basic label and text field input inside a standard wrapping might look like this:
+        #     def to_html
+        #       input_wrapping do
+        #         label_html <<
+        #         builder.text_field(method, input_html_options)
+        #       end
+        #     end
+        def to_html
+          raise NotImplementedError
+        end
+
+        def input_html_options
+          {
+            :id => dom_id,
+            :required => required_attribute?,
+            :autofocus => autofocus?,
+            :readonly => readonly?
+          }.merge(options[:input_html] || {}).merge(error_aria_attributes)
+        end
+
+        def dom_id
+          [
+            builder.dom_id_namespace,
+            sanitized_object_name,
+            dom_index,
+            association_primary_key || sanitized_method_name
+          ].reject { |x| x.blank? }.join('_')
+        end
+
+        def dom_index
+          if builder.options.has_key?(:index)
+            builder.options[:index]
+          elsif !builder.auto_index.blank?
+            # TODO there's no coverage for this case, not sure how to create a scenario for it
+            builder.auto_index
+          else
+            +""
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Labelling
+        
+        include Formtastic::LocalizedString
+        
+        def label_html
+          render_label? ? builder.label(input_name, label_text, label_html_options) : +"".html_safe
+        end
+        
+        def label_html_options
+          {
+            :for => input_html_options[:id],
+            :class => ['label'],
+          }.merge(options[:label_html] || {})
+        end
+        
+        def label_text
+          ((localized_label || humanized_method_name) + requirement_text).html_safe
+        end
+        
+        # TODO: why does this need to be memoized in order to make the inputs_spec tests pass? 
+        def requirement_text_or_proc
+          @requirement_text_or_proc ||= required? ? builder.required_string : builder.optional_string
+        end
+        
+        def requirement_text
+          if requirement_text_or_proc.respond_to?(:call)
+            requirement_text_or_proc.call
+          else
+            requirement_text_or_proc
+          end
+        end
+
+        def label_from_options
+          options[:label]
+        end
+
+        def localized_label
+          localized_string(method, label_from_options || method, :label)
+        end
+        
+        def render_label?
+          return false if options[:label] == false
+          true
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Naming
+
+        def as
+          self.class.name.split("::")[-1].underscore.gsub(/_input$/, '')
+        end
+
+        def sanitized_object_name
+          object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+        end
+
+        def sanitized_method_name
+          @sanitized_method_name ||= method.to_s.gsub(/[\?\/\-]$/, '')
+        end
+
+        def attributized_method_name
+          method.to_s.gsub(/_id$/, '').to_sym
+        end
+
+        def humanized_method_name
+          if builder.label_str_method != :humanize
+            # Special case where label_str_method should trump the human_attribute_name
+            # TODO: is this actually a desired bheavior, or should we ditch label_str_method and
+            # rely purely on :human_attribute_name.
+            method.to_s.send(builder.label_str_method)
+          elsif object && object.class.respond_to?(:human_attribute_name)
+            object.class.human_attribute_name(method.to_s)
+          else
+            method.to_s.send(builder.label_str_method)
+          end
+        end
+
+        def input_name
+          association_primary_key
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    module Base
+      module Numeric
+        def input_html_options
+          defaults = super
+
+          # override rails default size - does not apply to numeric inputs
+          #@todo document/spec
+          defaults[:size] = nil
+          
+          if in_option
+            defaults[:min] = in_option.to_a.min
+            defaults[:max] = in_option.to_a.max
+          else
+            defaults[:min]  ||= min_option
+            defaults[:max]  ||= max_option
+          end
+          defaults[:step] ||= step_option
+          defaults
+        end
+        
+        def step_option
+          return options[:step] if options.key?(:step)
+          validation_step
+        end
+        
+        def min_option
+          return options[:min] if options.key?(:min)
+          validation_min
+        end
+        
+        def max_option
+          return options[:max] if options.key?(:max)
+          validation_max
+        end
+        
+        def in_option
+          options[:in]
+        end
+        
+        def wrapper_html_options
+          new_class = [super[:class], "numeric", "stringish"].compact.join(" ")
+          super.merge(:class => new_class)
+        end
+        
+      end
+    end
+  end
+end