mega-safe-tool 0.0.1

data/formtastic-6.0.0/lib/formtastic/inputs/url_input.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+
+    # Outputs a simple `<label>` with a HTML5 `<input type="url">` wrapped in the standard
+    # `<li>` wrapper. This is the default input choice for all attributes matching
+    # `/^url$|^website$|_url$/`, but can be applied to any text-like input with `:as => :url`.
+    #
+    # @example Full form context and output
+    #
+    #   <%= semantic_form_for(@user) do |f| %>
+    #     <%= f.inputs do %>
+    #       <%= f.input :home_page, :as => :url %>
+    #     <% end %>
+    #   <% end %>
+    #
+    #   <form...>
+    #     <fieldset>
+    #       <ol>
+    #         <li class="url">
+    #           <label for="user_home_page">Home page</label>
+    #           <input type="number" id="user_home_page" name="user[home_page]">
+    #         </li>
+    #       </ol>
+    #     </fieldset>
+    #   </form>
+    #
+    # @see Formtastic::Helpers::InputsHelper#input InputsHelper#input for full documentation of all possible options.
+    class UrlInput 
+      include Base
+      include Base::Stringish
+      include Base::Placeholder
+      
+      def to_html
+        input_wrapping do
+          label_html <<
+          builder.url_field(method, input_html_options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Formtastic
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Basic
+    autoload :Timeish
+
+    eager_autoload do
+      autoload :BooleanInput
+      autoload :CheckBoxesInput
+      autoload :ColorInput
+      autoload :CountryInput
+      autoload :DatalistInput
+      autoload :DateInput
+      autoload :DatePickerInput
+      autoload :DatetimePickerInput
+      autoload :DateSelectInput
+      autoload :DatetimeInput
+      autoload :DatetimeSelectInput
+      autoload :EmailInput
+      autoload :FileInput
+      autoload :HiddenInput
+      autoload :NumberInput
+      autoload :NumericInput
+      autoload :PasswordInput
+      autoload :PhoneInput
+      autoload :RadioInput
+      autoload :RangeInput
+      autoload :SearchInput
+      autoload :SelectInput
+      autoload :StringInput
+      autoload :TextInput
+      autoload :TimeInput
+      autoload :TimePickerInput
+      autoload :TimeSelectInput
+      autoload :TimeZoneInput
+      autoload :UrlInput
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Formtastic
+  module LocalizedString
+
+    def model_name
+      @object.present? ? @object.class.name : @object_name.to_s.classify
+    end
+
+    protected
+
+    def localized_string(key, value, type, options = {}) # @private
+      current_builder = respond_to?(:builder) ? builder : self
+      localizer = Formtastic::FormBuilder.i18n_localizer.new(current_builder)
+      localizer.localize(key, value, type, options)
+    end
+
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+module Formtastic
+  # Implementation for looking up localized values within Formtastic using I18n, if no
+  # explicit value (like the `:label` option) is set and I18n-lookups are enabled in the
+  # configuration.
+  #
+  # You can subclass this to implement your own Localizer, and configure Formtastic to use this
+  # localizer with:
+  #
+  #   Formtastic::FormBuilder.i18n_localizer
+  #
+  # Enabled/disable i18n lookups completely with:
+  #
+  #   Formtastic::FormBuilder.i18n_lookups_by_default = true/false
+  #
+  # Lookup priority:
+  #
+  #   'formtastic.%{type}.%{model}.%{action}.%{attribute}'
+  #   'formtastic.%{type}.%{model}.%{attribute}'
+  #   'formtastic.%{type}.%{attribute}'
+  #
+  # Example:
+  #
+  #   'formtastic.labels.post.edit.title'
+  #   'formtastic.labels.post.title'
+  #   'formtastic.labels.title'
+  class Localizer
+    class Cache
+      def get(key)
+        cache[key]
+      end
+
+      def has_key?(key)
+        cache.has_key?(key)
+      end
+
+      def set(key, result)
+        cache[key] = result
+      end
+
+      def cache
+        @cache ||= {}
+      end
+
+      def clear!
+        cache.clear
+      end
+    end
+
+    attr_accessor :builder
+
+    def self.cache
+      @cache ||= Cache.new
+    end
+
+    def initialize(current_builder)
+      self.builder = current_builder
+    end
+
+    def localize(key, value, type, options = {}) # @private
+      key = value if value.is_a?(::Symbol)
+
+      if value.is_a?(::String)
+        escape_html_entities(value)
+      else
+        use_i18n = value.nil? ? i18n_lookups_by_default : (value != false)
+        use_cache = i18n_cache_lookups
+        cache = self.class.cache
+
+        if use_i18n
+          model_name, nested_model_name  = normalize_model_name(builder.model_name.underscore)
+
+          action_name = builder.template.params[:action].to_s rescue ''
+          attribute_name = key.to_s
+
+          # look in the cache first
+          if use_cache
+            cache_key = [::I18n.locale, action_name, model_name, nested_model_name, attribute_name, key, value, type, options]
+            return cache.get(cache_key) if cache.has_key?(cache_key)
+          end
+
+          defaults = Formtastic::I18n::SCOPES.reject do |i18n_scope|
+            nested_model_name.nil? && i18n_scope.match(/nested_model/)
+          end.collect do |i18n_scope|
+            i18n_path = i18n_scope.dup
+            i18n_path.gsub!('%{action}', action_name)
+            i18n_path.gsub!('%{model}', model_name)
+            i18n_path.gsub!('%{nested_model}', nested_model_name) unless nested_model_name.nil?
+            i18n_path.gsub!('%{attribute}', attribute_name)
+            i18n_path.tr!('..', '.')
+            i18n_path.to_sym
+          end
+          defaults << ''
+
+          defaults.uniq!
+
+          default_key = defaults.shift
+          i18n_value = Formtastic::I18n.t(default_key,
+            options.merge(:default => defaults, :scope => type.to_s.pluralize.to_sym))
+          i18n_value = i18n_value.is_a?(::String) ? i18n_value : nil
+          if i18n_value.blank? && type == :label
+            # This is effectively what Rails label helper does for i18n lookup
+            options[:scope] = [:helpers, type]
+            options[:default] = defaults
+            i18n_value = ::I18n.t(default_key, **options)
+          end
+
+          # save the result to the cache
+          result = (i18n_value.is_a?(::String) && i18n_value.present?) ? escape_html_entities(i18n_value) : nil
+          cache.set(cache_key, result) if use_cache
+          result
+        end
+      end
+    end
+
+    protected
+
+    def normalize_model_name(name)
+      if name =~ /(.+)\[(.+)\]/
+        # Nested builder case with :post rather than @post
+        # TODO: check if this is no longer required with a minimum of Rails 4.1
+        [$1, $2]
+      elsif builder.respond_to?(:options) && builder.options.key?(:as)
+        [builder.options[:as].to_s]
+      elsif builder.respond_to?(:options) && builder.options.key?(:parent_builder)
+        # Rails 3.0+ nested builder work-around case, where :parent_builder is provided by f.semantic_form_for
+        [builder.options[:parent_builder].object_name.to_s, name]
+      else
+        # Non-nested case
+        [name]
+      end
+    end
+
+    def escape_html_entities(string) # @private
+      if (builder.escape_html_entities_in_hints_and_labels) ||
+         (self.respond_to?(:escape_html_entities_in_hints_and_labels) && escape_html_entities_in_hints_and_labels)
+        string = builder.template.escape_once(string) unless string.respond_to?(:html_safe?) && string.html_safe? == true # Accept html_safe flag as indicator to skip escaping
+      end
+      string
+    end
+
+    def i18n_lookups_by_default
+      builder.i18n_lookups_by_default
+    end
+
+    def i18n_cache_lookups
+      builder.i18n_cache_lookups
+    end
+
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+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
+
+    def self.finder_method
+      @finder_method ||= use_const_defined? ? :find_with_const_defined : :find_by_trying
+    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
+
+    def finder(class_name) # @private
+      send(self.class.finder_method, class_name)
+    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/formtastic-6.0.0/lib/formtastic/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Formtastic
+  VERSION = "6.0.0"
+end

data/formtastic-6.0.0/lib/formtastic.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Formtastic
+  extend ActiveSupport::Autoload
+
+  autoload :Helpers
+  autoload :HtmlAttributes
+  autoload :LocalizedString
+  autoload :Localizer
+  autoload :NamespacedClassFinder
+  autoload :InputClassFinder
+  autoload :ActionClassFinder
+  autoload :Deprecation
+
+  eager_autoload do
+    autoload :I18n
+    autoload :FormBuilder
+    autoload :Inputs
+    autoload :Actions
+  end
+
+  # @public
+  class UnknownInputError < NameError
+  end
+
+  # @private
+  class UnknownActionError < NameError
+  end
+
+  # @private
+  class PolymorphicInputWithoutCollectionError < ArgumentError
+  end
+
+  # @private
+  class UnsupportedMethodForAction < ArgumentError
+  end
+
+  # @private
+  class UnsupportedEnumCollection < NameError
+  end
+
+end
+
+if defined?(::Rails)
+  ActiveSupport.on_load(:action_view) do
+    include Formtastic::Helpers::FormHelper
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+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 a Formtastic form partial based on an existing model."
+
+    argument :name, :type => :string, :required => true, :banner => 'MODEL_NAME'
+    argument :attributes, :type => :array, :default => [], :banner => 'attribute attribute'
+
+    source_root File.expand_path('../../../templates', __FILE__)
+
+    class_option :template_engine
+
+    class_option :copy, :type => :boolean, :default => false, :group => :formtastic,
+    :desc => 'Copy the generated code the clipboard instead of generating a partial file."'
+
+    class_option :controller, :type => :string, :default => nil, :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 = reflected_attributes if @attributes.empty?
+
+      engine = options[:template_engine]
+
+      if options[:copy]
+        template = File.read("#{self.class.source_root}/_form.html.#{engine}")
+        erb = ERB.new(template, trim_mode: '-')
+        generated_code = erb.result(binding).strip rescue nil
+        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
+
+    def controller_path
+      @controller_path ||= if options[:controller]
+        options[:controller].underscore
+      else
+        name.underscore.pluralize
+      end
+    end
+
+    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)
+      return unless data
+
+      begin
+        case RUBY_PLATFORM
+        when /win32/
+          require 'win32/clipboard'
+          ::Win32::Clipboard.data = data
+        when /darwin/ # mac
+          `echo "#{data}" | pbcopy`
+        else # linux/unix
+          `echo "#{data}" | xsel --clipboard` || `echo "#{data}" | xclip`
+        end
+      rescue LoadError
+          false
+      else
+          true
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+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/formtastic-6.0.0/lib/generators/formtastic/install/install_generator.rb

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

data/formtastic-6.0.0/lib/generators/formtastic/stylesheets/stylesheets_generator.rb

@@ -0,0 +1,15 @@
+module Formtastic
+  # Copies a stylesheet into to app/assets/stylesheets/formtastic.css
+  #
+  # @example
+  # !!!shell
+  #   $ rails generate formtastic:stylesheets
+  class StylesheetsGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../../templates", __FILE__)
+
+    desc "Copies Formtastic example stylesheet into your app"
+    def copy_files
+      copy_file "formtastic.css", "app/assets/stylesheets/formtastic.css"
+    end
+  end
+end

data/formtastic-6.0.0/lib/generators/templates/_form.html.erb

@@ -0,0 +1,11 @@
+<%%= 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/formtastic-6.0.0/lib/generators/templates/_form.html.haml

@@ -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/formtastic-6.0.0/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