express_admin 1.3.2 → 1.4.0

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

@@ -3,6 +3,18 @@ module ExpressTemplates
     module Capabilities
 
       module Resourceful
+
+        def self.included(base)
+          base.class_eval do
+            has_option :collection, 'Provide an explicit collection as a resource.'
+            has_option :collection_path, 'Provide an explicit path for the collection resource.'
+            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.'
+            has_option :path_prefix, 'Rarely used.  Override inferred path_prefix for path helpers.'
+            has_option :namespace, 'Rarely used.  Overrides inferred namespace for resources.'
+          end
+        end
+
         def namespace
           config[:namespace] || infer_namespace
         end

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

@@ -1,41 +1,168 @@
 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
 
-      def self.emits(proc = nil, &block)
-        define_method(:markup, &(proc || block))
+      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_args!(args)
-        if method(:markup).arity > 0
-          markup(block)
-        else
-          markup(&block)
-        end
+        _process_builder_args!(args)
+        super(*args, &block)
       end
 
       def config
         @config ||= {}
       end
 
-      alias :my :config
+      def self.has_option(name, description, type: :text, required: nil, default: nil, attribute: 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)
+        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 _process_args!(args)
-          if args.first.kind_of?(Symbol)
-            config.merge!(id: args.shift)
-            attributes[:id] = config[:id]
+        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
-          args.each do |arg|
-            if arg.kind_of?(Hash)
-              config.merge!(arg)
+        end
+
+        def _set_defaults
+          _default_options.each do |key, value|
+            if !!value[:attribute]
+              set_attribute key, value[:default]
+            else
+              config[key] ||= value[:default]
             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(&:to_s).map(&:classify).map(&:constantize)
+        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
+          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/forms/basic_fields.rb

@@ -9,11 +9,9 @@ module ExpressTemplates
         ALL.each do |type|
           class_definition = <<-RUBY
             class #{type.classify} < FormComponent
-              emits -> {
-                div(class: field_wrapper_class) {
-                  label_tag(label_name, label_text)
-                  #{type}_field resource_var, field_name.to_sym, html_options
-                }
+              contains {
+                label_tag(label_name, label_text)
+                #{type}_field resource_var, field_name.to_sym, input_attributes
               }
             end
 RUBY
@@ -24,25 +22,22 @@ RUBY
       end
 
       # class Email < FormComponent
-      #   emits -> {
-      #     div(class: field_wrapper_class) {
-      #       email_field resource_var, field_name.to_sym
-      #     }
+      #   contains {
+      #      label_tag label_name, label_text
+      #      email_field resource_var, field_name.to_sym, input_attributes
       #   }
       # end
 
       class Textarea < FormComponent
-        emits -> {
-          div(class: field_wrapper_class) {
-            label_tag(label_name, label_text)
-            text_area resource_var, field_name.to_sym, html_options
-          }
+        contains {
+          label_tag(label_name, label_text)
+          text_area resource_var, field_name.to_sym, input_attributes
         }
       end
 
       class Hidden < FormComponent
-        emits -> {
-          hidden_field resource_var, field_name.to_sym, html_options
+        contains {
+          hidden_field resource_var, field_name.to_sym, input_attributes
         }
       end
     end

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

@@ -3,12 +3,12 @@ module ExpressTemplates
     module Forms
       class Checkbox < FormComponent
 
-        emits -> {
-          div(class: field_wrapper_class) {
-            label_tag(label_name, label_text) if label_before?
-            check_box(resource_var, field_name.to_sym, field_options, checked_value, unchecked_value)
-            label_tag(label_name, label_text) if label_after?
-          }
+        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_var, field_name.to_sym, field_options, checked_value, unchecked_value)
+          label_tag(label_name, label_text) if label_after?
         }
 
         def label_before?

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

@@ -4,42 +4,34 @@ module ExpressTemplates
       class ExpressForm < Configurable
         include ExpressTemplates::Components::Capabilities::Resourceful
 
-        emits -> (block) {
-          form(form_tag_options ) {
-            form_rails_support form_method
-            block.call(self) if block
+        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.'
+
+        contains -> (&block) {
+          div(style: 'display:none') {
+            add_child helpers.utf8_enforcer_tag
+            add_child helpers.send(:method_tag, resource.persisted? ? :put : :post)
+            helpers.send(:token_tag)
           }
+          block.call(self) if block
         }
 
-        def form_id
-          "#{resource_name}_#{resource.id}"
-        end
+        before_build -> {
+          set_attribute(:id, form_id)
+          set_attribute(:action, form_action)
+          add_class(config[:id])
+        }
 
-        def form_method
-          config[:method].to_s.upcase || 'POST'
+        def form_id
+          [config[:id], resource.try(:id)].compact.join('_')
         end
 
         def form_action
           config[:action] || (resource.try(:persisted?) ? resource_path(ivar: true) : collection_path)
         end
 
-        def form_tag_options
-          args = {id: form_id, action: form_action}.merge!(config).merge!(method: 'POST')
-
-          if html_options = args.delete(:html_options)
-            args.merge!(html_options)
-          end
-          args
-        end
-
-        def resource_name_for_path
-          config[:id].to_s
-        end
-
-        def resource_name
-          (config[:resource_name] || config[:id]).to_s
-        end
-
       end
     end
   end

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

@@ -3,10 +3,20 @@ module ExpressTemplates
     module Forms
       class FormComponent < Configurable
 
+        attr :input_attributes
+
+        before_build -> {
+          set_attribute(:id, "#{resource_name}_#{field_name}_wrapper")
+          add_class(config[:class])
+        }
+
+        has_option :class, 'Override the class of the wrapping div of a form component', default: 'field-wrapper', attribute: true
+        has_option :label, 'Override the inferred label of a form component'
+
         # Lookup the resource_name from the parent ExpressForm.
         def resource_name
           raise "FormComponent must have a parent form" unless parent_form
-          parent_form.resource_name
+          parent_form.config[:id].to_s
         end
 
         def resource_var
@@ -17,7 +27,7 @@ module ExpressTemplates
           parent_form.resource_class
         end
 
-        # Return the name attribute for the lable
+        # Return the name attribute for the label
         def label_name
           "#{resource_name.singularize}_#{field_name}"
         end
@@ -39,10 +49,6 @@ module ExpressTemplates
           "#{resource_name.singularize}[#{field_name}]"
         end
 
-        def field_wrapper_class
-          config[:wrapper_class] || 'field-wrapper'
-        end
-
         # Search the parent graph until we find an ExpressForm.  Returns nil if none found.
         def parent_form
           @my_form ||= parent
@@ -52,19 +58,14 @@ module ExpressTemplates
           return @my_form
         end
 
-        def default_html_options
-          (config || {}).reject {|k,v| k.eql?(:id)}
-        end
-
-        def html_options
-          default_html_options.merge(config[:html_options] || {})
-        end
-
         protected
 
-          def _process_args!(args)
-            @args = args
+          # 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

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

@@ -4,21 +4,22 @@ module ExpressTemplates
       class Radio < FormComponent
         include OptionSupport
 
-        emits -> {
-          div(class: field_wrapper_class) {
-            label_tag(label_name, label_text)
-            if option_values_specified?
-              generate_options_from_specified_values
-            else
-              use_options_from_collection_radio_buttons_helper
-            end
-          }
+        has_option :options, 'Supplies a list of options for the radio tag'
+        has_option :label_wrapper_class, 'Specify a class for labels which wrap each radio option.'
+
+        contains -> {
+          label_tag(label_name, label_text)
+          if option_values_specified?
+            generate_options_from_specified_values
+          else
+            use_options_from_collection_radio_buttons_helper
+          end
         }
 
         def use_options_from_collection_radio_buttons_helper
           collection_radio_buttons(resource_var, field_name.to_sym, collection_from_association,
                                    option_value_method, option_name_method,
-                                   field_options, html_options) do |b|
+                                   input_attributes) do |b|
             b.label(class: "radio") {
               b.radio_button + b.text
             }
@@ -30,25 +31,21 @@ module ExpressTemplates
         end
 
         def option_collection
-          @args.first
-        end
-
-        def wrapper_class
-          config[:wrapper_class] || 'wrapper-class'
+          config[:options]
         end
 
         def generate_options_from_specified_values
           case
           when option_collection.kind_of?(Array)
             option_collection.each_with_index do |option, index|
-              label(class: wrapper_class) {
+              label(class: config[:label_wrapper_class]) {
                 radio_button(resource_var, field_name.to_sym, option, class: 'radio')
                 current_arbre_element.add_child option
               }
             end
           when option_collection.kind_of?(Hash)
             option_collection.each_pair do |key, value|
-              label(class: wrapper_class) {
+              label(class: config[:label_wrapper_class]) {
                 radio_button(resource_var, field_name.to_sym, key, class: 'radio')
                 current_arbre_element.add_child  value
               }
@@ -62,21 +59,6 @@ module ExpressTemplates
           related_collection or raise "No association collection for: #{resource_name}.#{field_name}"
         end
 
-        def field_options
-          # If field_otions is omitted the Expander will be
-          # in last or 3rd position and we don't want that
-          if @args[1] && @args[1].is_a?(Hash)
-            @args[1]
-          else
-            {}
-          end
-        end
-
-        # TODO: implement
-        def html_options
-          {}
-        end
-
       end
     end
   end