para 0.11.4 → 0.12.0

data/lib/simple_form_extension/inputs/image_input.rb

@@ -0,0 +1,110 @@
+module SimpleFormExtension
+  module Inputs
+    class ImageInput < SimpleForm::Inputs::Base
+      include SimpleFormExtension::Translations
+      include SimpleFormExtension::FileConcern
+
+      delegate :content_tag, :image_tag, to: :template
+
+      def input(_wrapper_options = nil)
+        input_html_options[:class] << 'image-upload'
+        input_html_options[:accept] ||= SimpleFormExtension.default_image_input_accept
+
+        input_markup
+      end
+
+      private
+
+      def input_markup
+        content_tag(:div, class: 'fileinput fileinput-new', data: { provides: 'fileinput' }) do
+          content_tag(:div) do
+            content_tag(:div, class: 'btn btn-default btn-file') do
+              content_tag(:div, _translate('image.select'), class: 'fileinput-new') +
+                content_tag(:div, _translate('image.change'), class: 'fileinput-exists') +
+                @builder.file_field(attribute_name, input_html_options)
+            end +
+              content_tag(:button, class: 'btn btn-danger fileinput-exists', type: 'button',
+                                   data: { dismiss: 'fileinput' }) do
+                content_tag(:i, '', class: 'fa fa-times')
+              end
+          end +
+            existing_image_tag
+        end
+      end
+
+      def existing_image_tag
+        # If an existing paperclip image is found
+        if file_exists?
+          file_preview_and_remove_button
+        else
+          content_tag(:div, class: 'fileinput-preview thumbnail') do
+            content_tag(:div, '', class: 'empty-thumbnail')
+          end
+        end
+      end
+
+      def image
+        @image ||= object.try(attribute_name)
+      end
+
+      def file_preview_and_remove_button
+        return super unless displayable?(image)
+
+        container_style = 'position: relative; height: 100%; width: 100%; min-height: 50px;min-width: 58px; display: block;'
+
+        content_tag(:div, class: 'fileinput-preview thumbnail') do
+          content_tag(:div, style: container_style, data: { provides: 'existing-file' }) do
+            image_tag(
+              file_url,
+              style: 'height: 100%; width: 100%; display: block;', data: { toggle: 'existing-file' }
+            ) + remove_image_button
+          end
+        end
+      end
+
+      # Ensure the image is displayable and stored into the backend, otherwise we cannot
+      # generate a preview and/or URL for it.
+      #
+      def displayable?(image)
+        (image.variable? || image.previewable?) && image.persisted?
+      end
+
+      # Returns the paperclip or active_storage attachment url to show in the
+      # preview thumbnail
+      #
+      def file_url
+        if paperclip_attachment_attached?
+          object.send(attribute_name).url(image_style)
+        elsif activestorage_attachment_attached?
+          attachment = object.send(attribute_name)
+
+          if attachment.representable?
+            attachment.representation(resize: '400x150>')
+          else
+            attachment.service_url
+          end
+        end
+      end
+
+      def remove_image_button
+        return unless object.respond_to?(:"#{remove_attachment_method}=")
+
+        button_style = 'position: absolute; top: 10px; left: 10px;'
+
+        content_tag(:button, class: 'btn btn-danger', style: button_style, type: 'button',
+                             data: { dismiss: 'existing-file' }) do
+          content_tag(:i, '', class: 'fa fa-remove', data: { 'removed-class': 'fa fa-refresh' }) +
+            @builder.hidden_field(remove_attachment_method, class: 'remove-file-input', value: nil)
+        end
+      end
+
+      def image_style
+        styles = object.send(attribute_name).styles.map(&:first)
+        # Check if there's a :thumb or :thumbnail style in attachment definition
+        thumb = styles.find { |s| %w[thumb thumbnail].include?(s.to_s) }
+        # Return the potentially smallest size !
+        thumb || styles.first || :original
+      end
+    end
+  end
+end

data/lib/simple_form_extension/inputs/numeric_input.rb

@@ -0,0 +1,27 @@
+module SimpleFormExtension
+  module Inputs
+    class NumericInput < SimpleForm::Inputs::Base
+      def input(wrapper_options = nil)
+        input_html_options[:class] << "form-control spinbox-input"
+        if options.fetch(:spinner, true)
+          "<div class=\"input-group spinbox\">
+            #{@builder.text_field(attribute_name, input_html_options)}
+            <span class=\"input-group-btn\">
+              <span class=\"spinbox-buttons btn-group-vertical\">
+                <button class=\"btn btn-default spinbox-up\" type=\"button\" tabindex=\"-1\">
+                  <i class=\"fa fa-chevron-up\"></i>
+                </button>
+                <button class=\"btn btn-default spinbox-down\" type=\"button\" tabindex=\"-1\">
+                  <i class=\"fa fa-chevron-down\"></i>
+                </button>
+              </span>
+            </span>
+          </div> ".html_safe
+
+        else
+          @builder.number_field(attribute_name, input_html_options)
+        end
+      end
+    end
+  end
+end

data/lib/simple_form_extension/inputs/selectize_input.rb

@@ -0,0 +1,210 @@
+module SimpleFormExtension
+  module Inputs
+    class SelectizeInput < SimpleForm::Inputs::Base
+      include SimpleFormExtension::Translations
+      include SimpleFormExtension::ResourceNameHelper
+
+      # This field only allows local select options (serialized into JSON)
+      # Searching for remote ones will be implemented later.
+      #
+      # Data attributes that may be useful :
+      #
+      #   :'search-url' => search_url,
+      #   :'search-param' => search_param,
+      #   :'preload' => preload,
+      #
+      def input(_wrapper_options = {})
+        @attribute_name = foreign_key if relation?
+
+        input_html_options[:data] ||= {}
+
+        input_html_options[:data].merge!(
+          controller: 'selectize-field',
+          'selectize-field-input-value': Array.wrap(serialized_value),
+          'selectize-field-creatable-value': creatable?,
+          'selectize-field-multi-value': multi?,
+          'selectize-field-add-translation-value': _translate('selectize.add'),
+          'selectize-field-collection-value': collection,
+          'selectize-field-max-items-value': max_items,
+          'selectize-field-sort-field-value': sort_field,
+          'selectize-field-search-url-value': search_url,
+          'selectize-field-search-param-value': search_param,
+          'selectize-field-escape-value': escape.nil? ? true : escape
+        )
+
+        @builder.text_field attribute_name, input_html_options
+      end
+
+      def search_param
+        options[:search_param] ||= 'q'
+      end
+
+      def search_url
+        options[:search_url]
+      end
+
+      def creatable?
+        !!options[:creatable]
+      end
+
+      def escape
+        options[:escape]
+      end
+
+      def multi?
+        (options.key?(:multi) && !!options[:multi]) ||
+          enumerable?(value)
+      end
+
+      def max_items
+        options[:max_items]
+      end
+
+      def sort_field
+        if (sort_field = options[:sort_field]).present?
+          sort_field
+        elsif enum?
+          'position'
+        else
+          'text'
+        end
+      end
+
+      def collection
+        return if search_url
+
+        if (collection = options[:collection])
+          if enumerable?(collection)
+            collection.map(&method(:serialize_option))
+          else
+            (object.send(collection) || []).map(&method(:serialize_option))
+          end
+        elsif relation?
+          reflection.klass.all.map(&method(:serialize_option))
+        elsif enum?
+          enum_options
+        else
+          []
+        end
+      end
+
+      def serialized_value
+        return input_html_options[:data][:value] if input_html_options[:data][:value]
+
+        if multi?
+          if relation?
+            value.map do |item|
+              if (resource = relation.find { |r| r.id == item.to_i }) && (text = text_from(resource))
+                serialize_value(item, text)
+              else
+                serialize_value(item)
+              end
+            end
+          else
+            value.map(&method(:serialize_value))
+          end
+        elsif relation? && relation && (text = text_from(relation))
+          serialize_value(value, text)
+        else
+          serialize_value(value)
+        end
+      end
+
+      def value
+        @value ||= options_fetch(:value) { object.send(attribute_name) }
+      end
+
+      def serialize_value(value, text = nil)
+        { text: (text || value), value: value }
+      end
+
+      private
+
+      def serialize_option(option)
+        if option.is_a?(Hash) && option.key?(:text) && option.key?(:value)
+          option
+        elsif option.is_a?(ActiveRecord::Base)
+          { text: name_for(option), value: option.id }
+        elsif !option.is_a?(Hash)
+          { text: option.to_s, value: option }
+        else
+          raise ArgumentError, 'The individual collection items should ' \
+            'either be single items or a hash with :text and :value fields'
+        end
+      end
+
+      def options_fetch(key, &block)
+        [options, input_html_options].each do |hash|
+          return hash[key] if hash.key?(key)
+        end
+
+        # Return default block value or nil if no block was given
+        block ? block.call : nil
+      end
+
+      # Check if the given target object is enumerable. Used internally to
+      # check wether :collection or :value arguments are collections.
+      #
+      def enumerable?(target)
+        target.class.include?(Enumerable) || target.is_a?(ActiveRecord::Relation)
+      end
+
+      def name_for(option)
+        resource_name_for(option) || option.to_s
+      end
+
+      def relation
+        @relation ||= object.send(reflection.name) if relation?
+      end
+
+      def relation?
+        !!reflection
+      end
+
+      def reflection
+        @reflection ||= if object_class.respond_to?(:reflect_on_association)
+                          object_class.reflect_on_association(attribute_name)
+                        end
+      end
+
+      def enum?
+        object_class.respond_to?(:defined_enums) &&
+          object_class.defined_enums.key?(attribute_name.to_s)
+      end
+
+      def enum_options
+        object_class.defined_enums[attribute_name.to_s].map do |key, value|
+          path = [object.model_name.i18n_key, attribute_name, key].join('.')
+          translation = ::I18n.t("activerecord.enums.#{path}", default: '')
+
+          { text: translation.presence || key, value: key, position: value }
+        end
+      end
+
+      def foreign_key
+        @foreign_key ||= case reflection.macro
+                         when :belongs_to then reflection.foreign_key
+                         when :has_one then :"#{reflection.name}_id"
+                         when :has_many then :"#{reflection.name.to_s.singularize}_ids"
+                         end
+      end
+
+      def text_from(resource)
+        resource_name_for(resource)
+      end
+
+      # Retrieve actual model class even when the form object is a proxy like
+      # for Ransack::Search or ActiveRecord::Relation classes
+      #
+      def object_class
+        @object_class ||= if (object_class = object.class) < ActiveRecord::Base
+                            object_class
+                          elsif (klass = object.try(:klass))
+                            klass
+                          else
+                            object_class
+                          end
+      end
+    end
+  end
+end

data/lib/simple_form_extension/inputs/slider_input.rb

@@ -0,0 +1,30 @@
+module SimpleFormExtension
+  module Inputs
+    class SliderInput < SimpleForm::Inputs::Base
+      def input(wrapper_options = nil)
+        input_html_options[:class] << 'form-control'
+
+        input_html_options[:data] ||= {}
+        input_html_options[:data][:'simple-form-slider'] = true
+
+        [:min, :max, :step, :orientation, :range, :value].each do |key|
+          if options.key?(key)
+            input_html_options[:data][:"slider-#{ key }"] = options[key]
+          end
+        end
+
+        input_html_options[:data][:'slider-value'] ||= object.send(attribute_name)
+
+        if options[:disabled]
+          input_html_options[:data][:'slider-enabled'] = false
+        end
+
+        if options[:ticks]
+          input_html_options[:data][:ticks] = options[:ticks].to_json
+        end
+
+        @builder.hidden_field(attribute_name, input_html_options)
+      end
+    end
+  end
+end

data/lib/simple_form_extension/inputs.rb

@@ -0,0 +1,16 @@
+module SimpleFormExtension
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :DateTimeInput
+    autoload :BooleanInput
+    autoload :NumericInput
+    autoload :CollectionCheckBoxesInput
+    autoload :CollectionRadioButtonsInput
+    autoload :ColorInput
+    autoload :FileInput
+    autoload :ImageInput
+    autoload :SelectizeInput
+    autoload :SliderInput
+  end
+end

data/lib/simple_form_extension/railtie.rb

@@ -0,0 +1,21 @@
+module SimpleFormExtension
+  class Railtie < Rails::Railtie
+    initializer 'add vendor path to assets pipeline' do |app|
+      %w(javascripts stylesheets images).each do |folder|
+        app.config.assets.paths << vendor_asset_path_for(folder)
+      end
+    end
+
+    initializer 'add images to precompile hook' do |app|
+      Dir[vendor_asset_path_for('images/**/*.*')].each do |image_path|
+        app.config.assets.precompile << image_path.split('/images/').pop
+      end
+    end
+
+    private
+
+    def vendor_asset_path_for(sub_path)
+      File.expand_path("../../../vendor/assets/#{ sub_path }", __FILE__)
+    end
+  end
+end

data/lib/simple_form_extension/resource_name_helper.rb

@@ -0,0 +1,9 @@
+module SimpleFormExtension
+  module ResourceNameHelper
+    def resource_name_for(resource)
+      SimpleFormExtension.resource_name_methods.each do |method_name|
+        if (value = resource.try(method_name)) then return value end
+      end
+    end
+  end
+end

data/lib/simple_form_extension/translations.rb

@@ -0,0 +1,7 @@
+module SimpleFormExtension
+  module Translations
+    def _translate(key, options = {})
+      I18n.translate(['simple_form.extension', key].join('.'))
+    end
+  end
+end

data/lib/simple_form_extension/version.rb

@@ -0,0 +1,3 @@
+module SimpleFormExtension
+  VERSION = '1.5.1'
+end

data/lib/simple_form_extension.rb

@@ -0,0 +1,30 @@
+require 'simple_form_extension/version'
+require 'simple_form'
+
+module SimpleFormExtension
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :Translations
+    autoload :ResourceNameHelper
+    autoload :FileConcern
+    autoload :Components
+    autoload :Inputs
+  end
+
+  # Allows overriding which methods are used by the fields that try to fetch
+  # the name of a resource to display it instead of calling #to_s
+  #
+  mattr_accessor :resource_name_methods
+  @@resource_name_methods = %i[name title]
+
+  mattr_accessor :default_image_input_accept
+  @@default_image_input_accept = 'image/jpeg,image/png,image/gif'
+end
+
+SimpleForm::Inputs::Base.include SimpleFormExtension::Components::Icons
+SimpleForm::Inputs::Base.include SimpleFormExtension::Components::Popovers
+
+SimpleForm.custom_inputs_namespaces << 'SimpleFormExtension::Inputs'
+
+require 'simple_form_extension/railtie' if defined?(Rails)