express_admin 1.3.2 → 1.4.0

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

@@ -2,13 +2,11 @@ module ExpressTemplates
   module Components
     module Forms
       # Provides a form Select component based on the Rails *select_tag* helper.
-      # Parameters:
-      # field_name, select_options, helper_options
       #
-      # Select options may be specified as an Array or Hash which will be
+      # The :options may be specified as an Array or Hash which will be
       # supplied to the *options_for_select* helper.
       #
-      # If the select_options are omitted, the component attempts to check
+      # If the :options are omitted, the component attempts to check
       # whether the field is an association.  If an association exists,
       # the options will be generated using *options_from_collection_for_select*
       # with the assumption that :id and :name are the value and name fields
@@ -18,24 +16,26 @@ module ExpressTemplates
       class Select < FormComponent
         include OptionSupport
 
-        emits -> {
-          div(class: field_wrapper_class) {
-            label_tag(label_name, label_text)
-            select_tag(*select_tag_args)
-          }
+        has_option :options, 'Select options. Can be Array, Hash, or Proc.'
+        has_option :selected, 'The currently selected value; Used when options are supplied. Otherwise the value is taken from the resource.'
+        has_option :include_blank, 'Whether or not to include a blank option.', default: true
+        has_option :select2, 'Use select2 enhanced select box.', default: true
+
+        contains -> {
+          label_tag(label_name, label_text)
+          select_tag(*select_tag_args)
         }
 
         def select_tag_args
-          args = [field_name_attribute, select_options, select_helper_options]
-          args
+          [field_name_attribute, select_options, select_helper_options]
         end
 
         def select_options_supplied?
-          [Array, Hash, Proc].include?(supplied_component_options[:options].class)
+          [Array, Hash, Proc].include?(config[:options].class)
         end
 
         def use_supplied_options
-          opts = supplied_component_options[:options]
+          opts = config[:options]
           if opts.respond_to?(:call) # can be a proc
             opts.call(resource)
           else
@@ -55,7 +55,7 @@ module ExpressTemplates
         end
 
         def selected_value
-          field_options[:selected]||resource.send(field_name)
+          config[:selected]||resource.send(field_name)
         end
 
         def options_from_supplied_or_field_values
@@ -104,33 +104,16 @@ module ExpressTemplates
           end
         end
 
-        def field_options
-          # If field_otions is omitted the Expander will be
-          # in last or 3rd position and we don't want that
-          defaults = {include_blank: true}
-          defaults.merge(supplied_component_options)
-        end
-
         def select_helper_options
-          component_option_names = [:select2, :options, :selected]
-          add_select2_class( field_options.reject {|k,v| component_option_names.include?(k)})
+          add_select2_class( input_attributes.merge(include_blank: !!config[:include_blank]) )
         end
 
         protected
 
           def add_select2_class(helper_options)
-            add_class(helper_options[:class]) if helper_options[:class]
-            add_class('select2') if supplied_component_options[:select2] === true
-            helper_options[:class] = (class_list - ["select"]).to_s
-            helper_options
-          end
-
-          def supplied_component_options
-            if @args.last && @args.last.is_a?(Hash)
-              @args.last
-            else
-              {}
-            end
+            classes = (helper_options[:class]||'').split(' ')
+            classes << 'select2' if config[:select2] === true
+            helper_options.merge(:class => classes.join(' '))
           end
 
       end

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

@@ -1,24 +1,18 @@
 module ExpressTemplates
   module Components
     module Forms
-      # Provides a form Select component based on the Rails *select_tag* helper.
-      # Parameters:
-      # field_name, select_options, helper_options
-      #
-      # Select options may be specified as an Array or Hash which will be
-      # supplied to the *options_for_select* helper.
-      #
+      # Provides a form Select component based on the Rails *collection_select* helper.
       class SelectCollection < Select
 
-        emits -> {
-          div(class: field_wrapper_class) {
-            label_tag(label_name, label_text)
+        has_option :multiple, "Allow multiple selections.", default: true
 
-            # need this because the collection_select helper does not provide
-            # the hidden_field_tag trick (see rails api docs for select)
-            hidden_field_tag(multi_field_name, '')
-            collection_select(*collection_select_tag_args)
-          }
+        contains -> {
+          label_tag(label_name, label_text)
+
+          # need this because the collection_select helper does not provide
+          # the hidden_field_tag trick (see rails api docs for select)
+          hidden_field_tag(multi_field_name, '')
+          collection_select(*collection_select_tag_args)
         }
 
         def collection_select_tag_args
@@ -30,11 +24,11 @@ module ExpressTemplates
         end
 
         def field_options
-          super.merge(include_blank: false)
+          {include_blank: !!input_attributes.delete(:include_blank)}
         end
 
         def html_options
-          (super||{}).merge(multiple: true)
+          input_attributes.reject {|k,v| k.eql?(:include_blank)}.merge(multiple: config[:multiple])
         end
 
         def multi_field_name

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

@@ -3,22 +3,26 @@ module ExpressTemplates
     module Forms
       class Submit < FormComponent
 
-        def build(*args)
-          div(class: field_wrapper_class) {
-            if args.first.is_a?(String) or args.empty?
-              submit_tag(args.first || 'Save', (args[1]||{}))
-            else
-              submit_tag 'Save', (args.first || {})
-            end
-          }
-        end
+        has_option :button_class, 'The css class of the input button.'
+        has_option :value, 'The value of the submit tag.  Text show in button.',
+                           default: 'Save'
 
-        def value
-          if @args.first.is_a?(String)
-            @args.first
-          else
-            'Save'
+        contains -> {
+          submit_tag(value, input_attributes)
+        }
+
+        before_build -> {
+          # if we are not part of a form, we don't get a default id
+          begin
+            super()
+          rescue
+            add_class(config[:class])
+            remove_class('submit')
           end
+        }
+
+        def value
+          config[:value]
         end
 
       end

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

@@ -38,11 +38,18 @@ module ExpressTemplates
     #
 
     class TreeFor < Configurable
-      emits -> (customize_block) {
+
+      tag :ul
+
+      has_attributes :class => 'tree'
+
+      contains -> (&customize_block) {
         @customize_block = customize_block
-        ul(id: config[:id], class: "#{config[:id]} tree") {
-          list_items(eval(config[:id].to_s))
-        }
+        list_items(eval(config[:id].to_s))
+      }
+
+      before_build -> {
+        add_class config[:id]
       }
 
       def list_items(nodes)

data/vendor/gems/express_templates/lib/express_templates/renderer.rb

@@ -1,8 +1,6 @@
 module ExpressTemplates
   module Renderer
-    # render accepts source or block, expands to macros
-    # compiles the resulting macros 
-    # and then evaluates the resulting string of ruby in the context provided
+    # render accepts source or block, evaluates the resulting string of ruby in the context provided
     def render context=nil, template_or_src=nil, &block
       compiled_template = compile(template_or_src, &block)
       context.instance_eval compiled_template

data/vendor/gems/express_templates/lib/express_templates/version.rb

@@ -1,3 +1,3 @@
 module ExpressTemplates
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/vendor/gems/express_templates/test/components/base_test.rb

@@ -2,45 +2,66 @@ require 'test_helper'
 
 class BaseTest < ActiveSupport::TestCase
 
-  def assigns
-    {}
+  class Context
+    def assigns
+      {}
+    end
+  end
+
+  def render(&block)
+    ExpressTemplates.render(Context.new, &block)
   end
 
-  class NoLogic < ExpressTemplates::Components::Base
-    emits {
-      h1 { span "Some stuff" }
+  class UnorderedList < ExpressTemplates::Components::Base
+    tag :ul
+
+    has_attributes :class       => 'something',
+                   'data-foo'   => 'something-else'
+
+    contains {
+      li { "Some stuff" }
     }
   end
 
-  test ".has_markup makes compile return the block passed through express compiled" do
-    assert_equal "<h1>\n  <span>Some stuff</span>\n</h1>\n", ExpressTemplates.render(self) { no_logic }
+  test ".tag_name determines the enclosing tag" do
+    assert_match /^\<ul/, render { unordered_list }
   end
 
-  test "components register themselves as arbre builder methods" do
-    assert Arbre::Element::BuilderMethods.instance_methods.include?(:no_logic)
+  test ".has_attributes creates default attributes" do
+    assert_match /class="[^"]*something[^"]*"/, render { unordered_list }
+    assert_match /data-foo="[^"]*something-else[^"]*"/, render { unordered_list }
   end
 
-  class Context
-    def assigns
-      {:foo => ['bar', 'baz']}
-    end
+  test ".contains places fragment inside the enclosing tag" do
+    markup = render { unordered_list }
+    assert_match /\<ul.*\<li.*\/li\>.*\/ul\>/, markup.gsub("\n", '')
   end
 
-  class HelperExample < ECB
-    def title_helper
-      foo.first
-    end
+  test "class name is dasherized instead of underscored" do
+    assert_match /class="[^"]*unordered-list[^"]*"/, render { unordered_list }
+  end
 
-    emits {
-      h1 {
-        title_helper
-      }
-    }
+  test "options are passed to html attributes" do
+    assert_match /rows="5"/, render { unordered_list(rows: 5) }
+  end
 
+  test "class option adds a class, does not override" do
+    markup = render { unordered_list(class: 'extra') }
+    assert_match /class="[^"]*something[^"]*"/, markup
+    assert_match /class="[^"]*unordered-list[^"]*"/, markup
+    assert_match /class="[^"]*extra[^"]*"/, markup
+  end
+
+  class BeforeBuildHook < ExpressTemplates::Components::Base
+    before_build :add_my_foo
+
+    def add_my_foo
+      set_attribute('data-foo', 'bar')
+    end
   end
 
-  test "helpers defined in component are evaluated in context" do
-    assert_equal "<h1>bar</h1>\n", ExpressTemplates.render(Context.new) { helper_example }
+  test "before_build hook runs before build" do
+    assert_match /data-foo="bar"/, render { before_build_hook }
   end
 
 end

data/vendor/gems/express_templates/test/components/capabilities/resourceful_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 module AdminModule
   module Engine
   end
-  class SmartThing
+  class SmartThing < ExpressTemplates::Components::Configurable
     include ExpressTemplates::Components::Capabilities::Resourceful
 
     attr_accessor :virtual_path, :config

data/vendor/gems/express_templates/test/components/configurable_test.rb

@@ -2,48 +2,126 @@ require 'test_helper'
 
 class ConfigurableTest < ActiveSupport::TestCase
 
-  ETC = ExpressTemplates::Components
-
-  class ConfigurableComponent < ETC::Configurable
-    def markup
-      div(id: my[:id], class: 'bar')
+  class Context
+    def assigns
+      {}
     end
   end
 
-  test "renders id argument as dom id" do
-    compiled_src = ExpressTemplates.render(self) { configurable_component(:foo) }
-    assert_equal "<div id=\"foo\" class=\"bar\"></div>\n", compiled_src
+  def render(&block)
+    ExpressTemplates.render(Context.new, &block)
+  end
+
+  ETCC = ExpressTemplates::Components::Configurable
+
+  class ConfigurableComponent < ETCC
+  end
+
+  test "renders first argument as dom id" do
+    assert_match /id="foo"/, render { configurable_component(:foo) }
   end
 
-  class ConfigurableContainerComponent < ETC::Configurable
+  test "has no id attribute if not specified" do
+    assert_no_match /id="foo"/, render { configurable_component }
+  end
 
-    # make sure a helper can take arguments
-    # helper(:name) {|name| name.to_s }
-    def name(name)
-      name.to_s
+  class ConfigWithOption < ETCC
+    has_option :thing, 'Something about things'
+  end
+
+  test "supports option declaration" do
+    markup = render { config_with_option }
+    assert_equal %Q(<div class="config-with-option"></div>\n), markup
+  end
+
+  test "does not pass declared options as html attributes" do
+    markup = render { config_with_option(thing: 'whatever') }
+    assert_equal %Q(<div class="config-with-option"></div>\n), markup
+  end
+
+  test "unrecognized options raises an exception" do
+    assert_raises(ArgumentError) do
+      class ConfigWithUnrecognizedOptions < ETCC
+        has_option :title, 'asdfasdf', something_unrecognized: 'whatever'
+      end
     end
+  end
 
-    def markup &block
-      div(id: my[:id]) {
-        h1 { name(my[:id]) }
-        yield(block) if block
-      }
+  class ConfigWithDefaultOption < ETCC
+    has_option :rows, 'Number of rows', type: :integer, default: 5, attribute: true
+  end
+
+  test "default values are supported" do
+    markup = render { config_with_default_option }
+    assert_equal %Q(<div class="config-with-default-option" rows="5"></div>\n), markup
+  end
+
+  test "default values for attributes can be overridden" do
+    markup = render { config_with_default_option(rows: 999) }
+    assert_equal %Q(<div class="config-with-default-option" rows="999"></div>\n), markup
+  end
+
+  class ConfigWithRequiredOptions < ETCC
+    has_option :title, 'adds a title', required: true
+  end
+
+  test "required options are required" do
+    assert_raises(RuntimeError) do
+      render { config_with_required_options }
     end
+    assert render { config_with_required_options(title: 'foo') }
+  end
+
+  class ConfigSubclass < ConfigWithRequiredOptions
+    has_option :status, 'something'
+  end
+
+  test "options are inherited" do
+    assert_equal [:title, :status], ConfigSubclass.supported_options.keys
+  end
+
+  class ConfigArgument < ETCC
+    has_argument :name, "The name.", type: :string
+
+    has_option :something, "else"
+
+    contains {
+      text_node config[:name]
+    }
   end
 
-  def assigns
-    {}
+  test ".has_argument adds a positional configuration argument" do
+    assert_equal :name, ConfigArgument.new.supported_arguments.keys.last
+    assert_equal "The name.", ConfigArgument.new.supported_arguments.values.last[:description]
   end
 
-  test "a configurable component may have also be a container" do
-    html = ExpressTemplates.render(self) { configurable_container_component(:foo) { |c| para 'bar'} }
-    expected = <<-HTML
-<div id=\"foo\">
-  <h1>foo</h1>
-  <p>bar</p>
-</div>
-HTML
-    assert_equal "<div id=\"foo\">\n  <h1>foo</h1>\n  <p>bar</p>\n</div>\n", html
+  test ".has_argument makes builder arguments accessible by name according to position" do
+    html = render &-> {
+      config_argument :bar, 'Foo'
+    }
+    assert_match />Foo</, html
   end
 
-end
+  class ConfigAnotherArgument < ConfigArgument
+    has_argument :title, "comes after name", type: :string
+  end
+
+  test ".has_argument appends supported arguments in order of inheritence" do
+    assert_equal [:id, :name, :title], ConfigAnotherArgument.new.supported_arguments.keys
+  end
+
+  class ConfigOverwriteId < ConfigArgument
+    has_argument :id, 'Should overwrite :id',
+                      as: :foo, type: :symbol
+    contains -> {
+      text_node config[:foo]
+    }
+  end
+
+  test ".has_argument as: allows overwrite of inherited argument" do
+    html = render {
+      config_overwrite_id(:whatever, 'Ignore me')
+    }
+    assert_match /div.*>whatever/, html
+  end
+end