express_admin 1.7.5 → 1.7.7

data/vendor/gems/express_templates/lib/express_templates/components/capabilities/resourceful.rb

@@ -1,213 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Capabilities
-
-      module Resourceful
-
-        def self.included(base)
-          base.class_eval do
-            has_argument :id, "The name of the collection", type: :symbol, optional: false
-            has_option :collection, 'Provide an explicit collection as a resource.'
-            has_option :collection_path, 'Provide an explicit path for the collection resource.', type: [:string, :proc]
-            has_option :resource_class, 'Overrides namespaced resource_class for using resources from a different module or namespace.'
-            has_option :resource_path, 'Overides the resource path which is otherwise inferred from the class name.', type: [:string, :proc]
-            has_option :path_prefix, 'Rarely used.  Override inferred path_prefix for path helpers.'
-            # note there is some duplication here.
-            # resource_path can be specified as a proc which can specify a namespace
-            # TODO: investigate which approach is better and deprecate if desirable
-            has_option :namespace, 'Rarely used.  Overrides inferred namespace for resources.'
-          end
-        end
-
-        def namespace
-          config[:namespace] || infer_namespace
-        end
-
-        def path_prefix
-          config[:path_prefix] || infer_path_prefix
-        end
-
-        def resource_class
-          resource_class = config[:resource_class] || _namespaced_resource_class
-          resource_class.constantize
-        end
-
-        private
-
-        def _namespaced_resource_class
-          if namespace
-            "#{namespace}/#{resource_name}".classify
-          else
-            resource_name.to_s.classify
-          end
-        end
-
-        def template_virtual_path
-          begin
-            super
-          rescue
-            nil
-          end
-        end
-
-        def infer_namespace
-          if template_virtual_path
-            path_parts = template_virtual_path.split('/')
-
-            case
-            when path_parts.size == 4
-              path_parts.first
-            when path_parts.size == 3
-              mod = path_parts.first.classify.constantize
-              if mod.const_defined?(:Engine)
-                path_parts.first
-              else
-                nil
-              end
-            else
-              nil
-            end
-          else
-            nil
-          end
-        end
-
-        def infer_path_prefix
-          if template_virtual_path
-            path_parts = template_virtual_path.split('/')
-
-            case
-            when path_parts.size == 4
-              path_parts[1]
-            when path_parts.size == 3
-              mod = path_parts.first.classify.constantize
-              if mod.const_defined?(:Engine)
-                nil
-              else
-                path_parts.first
-              end
-            else
-              nil
-            end
-          else
-            nil
-          end
-        end
-
-        # TODO: this can now be inferred from the template.virtual_path
-        # if not supplied...
-        def resource_name
-          config[:id].to_s.singularize
-        end
-
-        def collection_member_name
-          resource_name
-        end
-
-        def collection_name
-          collection_member_name.pluralize
-        end
-
-        def collection_var
-          "@#{collection_name}".to_sym
-        end
-
-        def collection
-          if config[:collection]
-            if config[:collection].respond_to?(:call)
-              config[:collection].call()
-            else
-              config[:collection]
-            end
-          else
-            self.send(collection_name) # should be in view assigns
-          end
-        end
-
-        def collection_path
-          if config[:collection_path]
-            if config[:collection_path].respond_to?(:call)
-              config[:collection_path].call()
-            else
-              config[:collection_path]
-            end
-          else
-            if helpers.respond_to?(:collection_path)
-              helpers.collection_path
-            else
-              helpers.instance_eval collection_path_helper
-            end
-          end
-        end
-
-        def collection_path_helper
-          if path_namespace
-            "#{path_namespace}.#{collection_name_with_prefix}_path"
-          else
-            "#{collection_name_with_prefix}_path"
-          end
-        end
-
-        def collection_name_with_prefix
-          if path_prefix
-            "#{path_prefix}_#{collection_name}"
-          else
-            collection_name
-          end
-        end
-
-        def resource_path_helper
-          if path_namespace
-            "#{path_namespace}.#{resource_name_with_path_prefix}_path"
-          else
-            "#{resource_name_with_path_prefix}_path"
-          end
-        end
-
-        def path_namespace
-          resource_class_name = resource_class.to_s
-          resource_class_name.match(/::/) ?
-            resource_class_name.split("::").first.try(:underscore) : nil
-        end
-
-        def resource_path(object = nil)
-          if config[:resource_path]
-            if config[:resource_path].respond_to?(:call) && object.respond_to?(:to_param)
-              config[:resource_path].call(object)
-            else
-              config[:resource_path]
-            end
-          else
-            if helpers.respond_to?(:resource_path) &&
-               helpers.resource.to_param.present? # skip on nil resource
-              helpers.resource_path
-            else
-              if resource_path_helper.match(/\w+\.\w+/)
-                namespace, path_helper = resource_path_helper.split('.')
-                helpers.send(namespace).send(path_helper, object)
-              else
-                helpers.send(resource_path_helper, object)
-              end
-            end
-          end
-        end
-
-        def resource_name_with_path_prefix
-          if path_prefix
-            "#{path_prefix}_#{resource_name}"
-          else
-            resource_name
-          end
-        end
-
-        def resource_attributes
-          resource_class.columns
-        end
-
-        def resource
-          self.send(resource_name)
-        end
-      end
-    end
-  end
-end

data/vendor/gems/express_templates/lib/express_templates/components/configurable.rb

@@ -1,181 +0,0 @@
-module ExpressTemplates
-  module Components
-    # Configurable components support configuration options supplied to the
-    # builder method.  Supported options must be declared.  All other options
-    # are passed along and converted to html attributes.
-    #
-    # Example:
-    #
-    # ```ruby
-    #
-    # class Pane < ExpressTemplates::Components::Configurable
-    #   has_option :title, "Displayed in the title area", required: true
-    #   has_option :status, "Displayed in the status area"
-    # end
-    #
-    # # Usage:
-    #
-    # pane(title: "People", status: "#{people.count} people")
-    #
-    # ```ruby
-    #
-    # Options specified as required must be supplied.
-    #
-    # Default values may be supplied for options with a default: keyword.
-    #
-    # Options may be passed as html attributes with attribute: true
-    #
-    class Configurable < Base
-
-      abstract_component
-
-      class_attribute :supported_options
-      self.supported_options = {}
-
-      class_attribute :supported_arguments
-      self.supported_arguments = {}
-
-      def self.emits(*args, &block)
-        warn ".emits is deprecrated"
-        self.contains(*args, &block)
-      end
-
-      def build(*args, &block)
-        _process_builder_args!(args)
-        super(*args, &block)
-      end
-
-      def config
-        @config ||= {}
-      end
-
-      def self.has_option(name, description, type: :string, required: nil, default: nil, attribute: nil, values: nil)
-        raise "name must be a symbol" unless name.kind_of?(Symbol)
-        option_definition = {description: description}
-        option_definition.merge!(type: type, required: required, default: default, attribute: attribute, values: values)
-        self.supported_options =
-          self.supported_options.merge(name => option_definition)
-      end
-
-      def required_options
-        supported_options.select {|k,v| v[:required] unless v[:default] }
-      end
-
-      def self.has_argument(name, description, as: nil, type: :string, default: nil, optional: false)
-        raise "name must be a symbol" unless name.kind_of?(Symbol)
-        argument_definition = {description: description, as: as, type: type, default: default, optional: optional}
-        self.supported_arguments =
-          self.supported_arguments.merge(name => argument_definition)
-      end
-
-      has_argument :id, "The id of the component.", type: :symbol, optional: true
-
-      protected
-
-        def _default_options
-          supported_options.select {|k,v| v[:default] }
-        end
-
-        def _check_required_options(supplied)
-          missing = required_options.keys - supplied.keys
-          if missing.any?
-            raise "#{self.class} missing required option(s): #{missing}"
-          end
-        end
-
-        def _set_defaults
-          _default_options.each do |key, value|
-            if !!value[:attribute]
-              set_attribute key, value[:default]
-            else
-              if config[key].nil?
-                config[key] = value[:default]
-              end
-            end
-          end
-        end
-
-        def _valid_types(definition)
-          valid_type_names = if definition[:type].kind_of?(Symbol)
-              [definition[:type]]
-            elsif definition[:type].respond_to?(:keys)
-              definition[:type].keys
-            else
-              definition[:type] || []
-            end
-          valid_type_names.map do |type_name|
-            if type_name.eql?(:boolean)
-              type_name
-            else
-              type_name.to_s.classify.constantize
-            end
-          end
-        end
-
-        def _is_valid?(value, definition)
-          valid_types = _valid_types(definition)
-          if valid_types.empty? && value.kind_of?(String)
-            true
-          elsif valid_types.include?(value.class)
-            true
-          elsif valid_types.include?(:boolean) &&
-                [1, 0, true, false].include?(value)
-            true
-          else
-            false
-          end
-        end
-
-        def _optional_argument?(definition)
-          definition[:default] || definition[:optional]
-        end
-
-        def _required_argument?(definition)
-          !_optional_argument?(definition)
-        end
-
-        def _extract_supported_arguments!(args)
-          supported_arguments.each do |key, definition|
-            value = args.shift
-            if value.nil? && _required_argument?(definition)
-              raise "argument for #{key} not supplied"
-            end
-            unless _is_valid?(value, definition)
-              if _required_argument?(definition)
-                raise "argument for #{key} invalid (#{value.class}) '#{value.to_s}'; Allowable: #{_valid_types(definition).inspect}"
-              else
-                args.unshift value
-                next
-              end
-            end
-            config_key = definition[:as] || key
-            config[config_key] = value || definition[:default]
-          end
-        end
-
-        def _set_id_attribute
-          attributes[:id] = config[:id]
-        end
-
-        def _extract_supported_options!(builder_options)
-          builder_options.each do |key, value|
-            if supported_options.keys.include?(key)
-              unless supported_options[key][:attribute]
-                config[key] = builder_options.delete(key)
-              end
-            end
-          end
-        end
-
-        def _process_builder_args!(args)
-          _extract_supported_arguments!(args)
-          builder_options = args.last.try(:kind_of?, Hash) ? args.last : {}
-          _check_required_options(builder_options)
-          _extract_supported_options!(builder_options)
-          _set_defaults
-          _set_id_attribute
-        end
-
-    end
-  end
-end

data/vendor/gems/express_templates/lib/express_templates/components/container.rb

@@ -1,45 +0,0 @@
-module ExpressTemplates
-  module Components
-    class Container < Configurable
-
-      abstract_component
-
-      class_attribute :prepended_blocks
-      self.prepended_blocks = []
-
-      class_attribute :appended_blocks
-      self.appended_blocks = []
-
-      contains -> (&block) {
-        prepended
-        block.call(self) if block
-        appended
-      }
-
-      def prepended
-        prepended_blocks.each do |block_to_prepend|
-          call_block(block_to_prepend)
-        end
-      end
-
-      def appended
-        appended_blocks.each do |block_to_append|
-          call_block(block_to_append)
-        end
-      end
-
-      def call_block(block)
-        instance_exec &block
-      end
-
-      def self.prepends(proc = nil, &block)
-        self.prepended_blocks += [proc || block]
-      end
-
-      def self.appends(proc = nil, &block)
-        self.appended_blocks += [proc || block]
-      end
-
-    end
-  end
-end

data/vendor/gems/express_templates/lib/express_templates/components/forms/basic_fields.rb

@@ -1,52 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Forms
-      module BasicFields
-        ALL = %w(email phone text password color date datetime
-                datetime_local number range
-                search telephone time url week)
-
-        ALL.each do |type|
-          class_definition = <<-RUBY
-            class #{type.classify} < FormComponent
-              contains {
-                label_tag(label_name, label_text)
-                #{type}_field_tag field_name_attribute, field_value, field_helper_options
-              }
-            end
-RUBY
-
-          eval(class_definition)
-
-        end
-      end
-
-      # class Email < FormComponent
-      #   contains {
-      #      label_tag label_name, label_text
-      #      email_field  field_name_attribute, field_value, field_helper_options
-      #   }
-      # end
-
-      class File < FormComponent
-        contains {
-          label_tag(label_name, label_text)
-          file_field_tag field_name_attribute, field_helper_options
-        }
-      end
-
-      class Textarea < FormComponent
-        contains {
-          label_tag(label_name, label_text)
-          text_area_tag field_name_attribute, field_value, field_helper_options
-        }
-      end
-
-      class Hidden < FormComponent
-        contains {
-          hidden_field_tag field_name_attribute, field_value, field_helper_options
-        }
-      end
-    end
-  end
-end

data/vendor/gems/express_templates/lib/express_templates/components/forms/checkbox.rb

@@ -1,37 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Forms
-      class Checkbox < FormComponent
-
-        has_option :label_after, 'Positions the option label after the checkbox.', default: false
-
-        contains {
-          label_tag(label_name, label_text) if label_before?
-          check_box(resource_name, field_name.to_sym, field_options, checked_value, unchecked_value)
-          label_tag(label_name, label_text) if label_after?
-        }
-
-        def label_before?
-          !label_after?
-        end
-
-        def label_after?
-          !!config[:label_after]
-        end
-
-        def field_options
-          {}
-        end
-
-        def checked_value
-          "1"
-        end
-
-        def unchecked_value
-          "0"
-        end
-
-      end
-    end
-  end
-end

data/vendor/gems/express_templates/lib/express_templates/components/forms/express_form.rb

@@ -1,48 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Forms
-      class ExpressForm < Container
-        include ExpressTemplates::Components::Capabilities::Resourceful
-
-        tag :form
-
-        has_option :method, 'The form method', default: 'POST', attribute: true #, options: ['PUT', 'POST', 'GET', 'DELETE']
-        has_option :action, 'The form action containing the resource path or url.'
-        has_option :on_success, 'Pass a form value indicating where to go on a successful submission.'
-        has_option :on_failure, 'Pass a form value indicating where to go on a failed submission.'
-        has_option :enctype, 'The enctype attribute specifies how the form-data should be encoded when submitting it to the server.'
-
-        prepends -> {
-          div(style: 'display:none') {
-            add_child helpers.utf8_enforcer_tag
-            add_child helpers.send(:method_tag, resource.persisted? ? :put : :post)
-            add_child helpers.send(:token_tag)
-            hidden_field_tag :on_success, config[:on_success] if config[:on_success]
-            hidden_field_tag :on_failure, config[:on_failure] if config[:on_failure]
-          }
-        }
-
-        before_build -> {
-          set_attribute(:id, form_id)
-          set_attribute(:action, form_action)
-          set_attribute(:enctype, form_enctype) if form_enctype
-          add_class(config[:id])
-        }
-
-        def form_id
-          [config[:id], resource.try(:id)].compact.join('_')
-        end
-
-        def form_action
-          config[:action] || (resource.try(:persisted?) ? resource_path(resource) : collection_path)
-        end
-
-        def form_enctype
-          config[:enctype]
-        end
-
-      end
-    end
-  end
-end
-

data/vendor/gems/express_templates/lib/express_templates/components/forms/form_component.rb

@@ -1,88 +0,0 @@
-module ExpressTemplates
-  module Components
-    module Forms
-      class FormComponent < Configurable
-
-        attr :input_attributes
-
-        before_build -> {
-          set_attribute(:id, "#{resource_name}_#{field_name}_wrapper")
-          add_class(config[:wrapper_class])
-          add_class('error') if resource.respond_to?(:errors) &&
-                                resource.errors.include?(field_name.to_sym)
-        }
-
-        has_option :wrapper_class, 'Override the class of the wrapping div of a form component', default: 'field-wrapper'
-        has_option :label, 'Override the inferred label of a form component'
-
-        def resource
-          self.send(resource_name)
-        end
-
-        # Lookup the resource_name from the parent ExpressForm.
-        def resource_name
-          raise "FormComponent must have a parent form" unless parent_form
-          parent_form.config[:id].to_s
-        end
-
-        def resource_class
-          parent_form.resource_class
-        end
-
-        # Return the name attribute for the label
-        def label_name
-          "#{resource_name.singularize}_#{field_name}"
-        end
-
-        # Return the text content for the label
-        def label_text
-          config[:label] || field_name.titleize
-        end
-
-        # Return the field_name as a string.  This taken from the first argument
-        # to the component macro in the template or fragment.
-        def field_name
-          (config[:id] || (@args.first.is_a?(String) && @args.first)).to_s
-        end
-
-        def field_value
-          resource.send(field_name)
-        end
-
-        # Return the field name attribute.  Currently handles only simple attributes
-        # on the resource.  Does not handle attributes for associated resources.
-        def field_name_attribute
-          "#{resource_name.singularize}[#{field_name}]"
-        end
-
-        def field_id_attribute
-          "#{resource_name.singularize}_#{field_name}"
-        end
-
-        def field_helper_options
-          {id: field_id_attribute}.merge(input_attributes||nil)
-        end
-
-        # Search the parent graph until we find an ExpressForm.  Returns nil if none found.
-        def parent_form
-          @my_form ||= parent
-          until @my_form.nil? || @my_form.kind_of?(ExpressForm)
-            @my_form = @my_form.parent
-          end
-          return @my_form
-        end
-
-        protected
-
-          # saving attributes for passing to the input field
-          def _process_builder_args!(args)
-            super(args)
-            @input_attributes = args.last if args.last.kind_of?(Hash)
-            @input_attributes ||= {}
-            args.clear
-          end
-
-      end
-    end
-  end
-end