express_admin 1.2.1 → 1.3.0

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

@@ -1,17 +1,11 @@
 module ExpressTemplates
   module Components
     module Forms
-      class FormComponent < Base
-        include Capabilities::Configurable
-        include Capabilities::Adoptable
-
-        def compile(*args)
-          raise "#{self.class} requires a parent ExpressForm" if parent.nil? or parent_form.nil?
-          super(*args)
-        end
+      class FormComponent < Configurable
 
         # 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
         end
 
@@ -30,13 +24,13 @@ module ExpressTemplates
 
         # Return the text content for the label
         def label_text
-          @config[:label] || field_name.titleize
+          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
+          (config[:id] || (@args.first.is_a?(String) && @args.first)).to_s
         end
 
         # Return the field name attribute.  Currently handles only simple attributes
@@ -46,7 +40,7 @@ module ExpressTemplates
         end
 
         def field_wrapper_class
-          @config[:wrapper_class] || 'field-wrapper'
+          config[:wrapper_class] || 'field-wrapper'
         end
 
         # Search the parent graph until we find an ExpressForm.  Returns nil if none found.
@@ -58,6 +52,21 @@ 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
+            super(args)
+          end
+
       end
     end
   end

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

@@ -28,9 +28,9 @@ module ExpressTemplates
           reflection = belongs_to_association || has_many_through_association
           if reflection && !reflection.polymorphic?
             if cols.detect {|column| column.name.eql?('name') }
-              "#{reflection.klass}.all.select(:#{option_value_method}, :#{option_name_method}).order(:#{option_name_method})"
+              reflection.klass.select(option_value_method.to_sym, option_name_method.to_sym).order(option_name_method.to_sym)
             else
-              "#{reflection.klass}.all.sort_by(&:#{option_name_method})"
+              reflection.klass.all.sort_by(&option_name_method.to_sym)
             end
           end
         end

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

@@ -16,8 +16,7 @@ module ExpressTemplates
         }
 
         def use_options_from_collection_radio_buttons_helper
-          # Note {{ }} will get stripped.  This prevents the collection finder string being passed as string.
-          collection_radio_buttons(resource_var, field_name.to_sym, "{{#{collection_from_association}}}",
+          collection_radio_buttons(resource_var, field_name.to_sym, collection_from_association,
                                    option_value_method, option_name_method,
                                    field_options, html_options) do |b|
             b.label(class: "radio") {
@@ -31,11 +30,11 @@ module ExpressTemplates
         end
 
         def option_collection
-          @args.second
+          @args.first
         end
 
         def wrapper_class
-          @config[:wrapper_class] || 'wrapper-class'
+          config[:wrapper_class] || 'wrapper-class'
         end
 
         def generate_options_from_specified_values
@@ -44,14 +43,14 @@ module ExpressTemplates
             option_collection.each_with_index do |option, index|
               label(class: wrapper_class) {
                 radio_button(resource_var, field_name.to_sym, option, class: 'radio')
-                null_wrap { option }
+                current_arbre_element.add_child option
               }
             end
           when option_collection.kind_of?(Hash)
             option_collection.each_pair do |key, value|
               label(class: wrapper_class) {
                 radio_button(resource_var, field_name.to_sym, key, class: 'radio')
-                null_wrap { value }
+                current_arbre_element.add_child  value
               }
             end
           else
@@ -66,8 +65,8 @@ module ExpressTemplates
         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.size > 3 && @args[2].is_a?(Hash)
-            @args[2]
+          if @args[1] && @args[1].is_a?(Hash)
+            @args[1]
           else
             {}
           end

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

@@ -26,39 +26,63 @@ module ExpressTemplates
         }
 
         def select_tag_args
-          args = [field_name_attribute, select_options, field_options]
-          args << html_options unless html_options.nil? or html_options.empty?
+          args = [field_name_attribute, select_options, select_helper_options]
           args
         end
 
-        # Returns the options which will be supplied to the select_tag helper.
-        def select_options
-          options_specified = [Array, Hash, Proc].include?(@args.second.class) && @args.size > 2
-          if options_specified
-            if @args.second.respond_to?(:source) # can be a proc
-              options = "#{@args.second.source}.call()"
-            else
-              options = @args.second
-            end
+        def select_options_supplied?
+          [Array, Hash, Proc].include?(supplied_component_options[:options].class)
+        end
 
+        def use_supplied_options
+          opts = supplied_component_options[:options]
+          if opts.respond_to?(:call) # can be a proc
+            opts.call()
           else
-            options = "@#{resource_var}.class.distinct(:#{field_name}).pluck(:#{field_name})"
+            opts
           end
+        end
 
-          if belongs_to_association && !options_specified
-            if belongs_to_association.polymorphic?
-              "{{options_for_select([[]])}}"
-            else
-              "{{options_from_collection_for_select(#{related_collection}, :id, :#{option_name_method}, @#{resource_name}.#{field_name})}}"
-            end
+        def generate_options_from_field_values
+          resource.class.distinct(field_name.to_sym).pluck(field_name.to_sym)
+        end
+
+        def options_from_supplied_or_field_values
+          if select_options_supplied?
+            use_supplied_options
+          else
+            generate_options_from_field_values
+          end
+        end
+
+        def options_from_belongs_to
+          if belongs_to_association.polymorphic?
+            helpers.options_for_select([[]]) # we can't really handle polymorhic yet
+          else
+            helpers.options_from_collection_for_select(related_collection, :id, option_name_method, resource.send(field_name))
+          end
+        end
+
+        def options_from_has_many_through
+          helpers.options_from_collection_for_select(related_collection, :id, option_name_method, resource.send(field_name).map(&:id))
+        end
+
+        def simple_options_with_selection
+          if selection = field_options[:selected]
+            helpers.options_for_select(options_from_supplied_or_field_values, selection)
+          else
+            helpers.options_for_select(options_from_supplied_or_field_values, resource.send(field_name))
+          end
+        end
+
+        # Returns the options which will be supplied to the select_tag helper.
+        def select_options
+          if belongs_to_association && !select_options_supplied?
+            options_from_belongs_to
           elsif has_many_through_association
-            "{{options_from_collection_for_select(#{related_collection}, :id, :#{option_name_method}, @#{resource_name}.#{field_name}.map(&:id))}}"
+            options_from_has_many_through
           else
-            if selection = field_options.delete(:selected)
-              "{{options_for_select(#{options}, \"#{selection}\")}}"
-            else
-              "{{options_for_select(#{options}, @#{resource_name}.#{field_name})}}"
-            end
+            simple_options_with_selection
           end
         end
 
@@ -74,26 +98,26 @@ module ExpressTemplates
           # 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_field_options.reject {|k,v| k.eql?(:select2)})
+          defaults.merge(supplied_component_options)
         end
 
-        def html_options
-          supplied_html_options
+        def select_helper_options
+          component_option_names = [:select2, :options, :selected]
+          add_select2_class( field_options.reject {|k,v| component_option_names.include?(k)})
         end
 
         protected
 
-          def supplied_field_options
-            if @args.size > 3 && @args[2].is_a?(Hash)
-              @args[2]
-            else
-              {}
-            end
+          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_html_options
-            if @args.size > 4 && @args[3].is_a?(Hash)
-              @args[3]
+          def supplied_component_options
+            if @args.last && @args.last.is_a?(Hash)
+              @args.last
             else
               {}
             end
@@ -102,4 +126,4 @@ module ExpressTemplates
       end
     end
   end
-end
+end

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

@@ -17,7 +17,6 @@ module ExpressTemplates
             # 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)
           }
         }
@@ -25,14 +24,13 @@ module ExpressTemplates
         def collection_select_tag_args
           [ resource_name,
             multi_field_name,
-            select_options, :id, :name,
+            related_collection, :id, :name,
             field_options,
             html_options ]
         end
 
         def field_options
-          selected_options_ruby = "@#{resource_name}.#{multi_field_name}".to_view_code
-          super.merge(include_blank: false, selected: selected_options_ruby)
+          super.merge(include_blank: false)
         end
 
         def html_options
@@ -47,10 +45,6 @@ module ExpressTemplates
           end
         end
 
-
-        def select_options
-          "{{#{related_collection}}}"
-        end
       end
     end
   end

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

@@ -3,11 +3,15 @@ module ExpressTemplates
     module Forms
       class Submit < FormComponent
 
-        emits -> {
+        def build(*args)
           div(class: field_wrapper_class) {
-            submit_tag(value, html_options)
+            if args.first.is_a?(String) or args.empty?
+              submit_tag(args.first || 'Save', (args[1]||{}))
+            else
+              submit_tag 'Save', (args[1] || {})
+            end
           }
-        }
+        end
 
         def value
           if @args.first.is_a?(String)
@@ -17,9 +21,6 @@ module ExpressTemplates
           end
         end
 
-        def html_options
-          @config
-        end
       end
     end
   end

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

@@ -11,8 +11,8 @@ module ExpressTemplates
     # Example:
     #
     # ```ruby
-    # tree_for(:roles) {
-    #   "{{role.name}}"
+    # tree_for(:roles) { |role|
+    #   role.name
     # }
     # ```
     #
@@ -36,51 +36,35 @@ module ExpressTemplates
     #       </li>
     #     </ul>
     #
-    class TreeFor < Container
-      def node_renderer
-        return (-> (node, renderer) {
-    ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-      "#{wsnl}<li>"+
-      _yield +
-      if node.children.any?
-        ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-          "#{wsnl}<ul>" +
-            node.children.map do |child|
-              renderer.call(child, renderer)
-            end.join +
-          "#{wsnl}</ul>"
-        end +
-        "#{wsnl}</li>"
-      else
-        "</li>"
-      end
-    end
-  }).source.sub(/\W_yield\W/, compile_children.lstrip)
+
+    class TreeFor < Configurable
+      emits -> (customize_block) {
+        @customize_block = customize_block
+        ul(id: config[:id], class: "#{config[:id]} tree") {
+          list_items(eval(config[:id].to_s))
+        }
+      }
+
+      def list_items(nodes)
+        nodes.each do |node|
+          list_item(node)
+        end
       end
 
-      def compile
-        collection = if @options[:collection]
-            "#{@options[:collection].source}.call()"
+      def list_item(node)
+        li {
+          if @customize_block
+            @customize_block.call(node)
           else
-            _variablize(@options[:id])
+            text_node "#{node.name}#{"\n" if node.children.any?}"
           end
-        member = @options[:id].to_s.singularize
-        return 'ExpressTemplates::Components::TreeFor.render_in(self) {
-  node_renderer = '+node_renderer.gsub(/node/, member)+'
-  ExpressTemplates::Indenter.for(:tree) do |ws, wsnl|
-    "#{ws}<ul id=\"'+@options[:id]+'\" class=\"'+@options[:id]+' tree\">" +
-      '+collection+'.map do |'+member+'|
-        node_renderer.call('+member+', node_renderer)
-      end.join +
-    "#{wsnl}</ul>\n"
-  end
-}'
+          if node.children.any?
+            ul {
+              list_items(node.children)
+            }
+          end
+        }
       end
-
-      private
-        def _variablize(sym)
-          "@#{sym}"
-        end
     end
   end
 end

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

@@ -1,3 +1,3 @@
 module ExpressTemplates
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

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

@@ -2,33 +2,36 @@ require 'test_helper'
 
 class BaseTest < ActiveSupport::TestCase
 
+  def assigns
+    {}
+  end
+
   class NoLogic < ExpressTemplates::Components::Base
-    has_markup -> {
+    emits {
       h1 { span "Some stuff" }
     }
   end
 
   test ".has_markup makes compile return the block passed through express compiled" do
-    assert_equal %Q("<h1><span>Some stuff</span></h1>"), NoLogic.new.compile
+    assert_equal "<h1>\n  <span>Some stuff</span>\n</h1>\n", ExpressTemplates.render(self) { no_logic }
   end
 
-  test "components register themselves as macros" do
-    assert ExpressTemplates::Expander.instance_methods.include?(:no_logic)
+  test "components register themselves as arbre builder methods" do
+    assert Arbre::Element::BuilderMethods.instance_methods.include?(:no_logic)
   end
 
   class Context
-    def initialize ; @foo = ['bar', 'baz'] ; end
-  end
-
-  test "fragments and has_markup are synonyms for emits" do
-    assert_equal NoLogic.method(:emits), NoLogic.method(:fragments)
-    assert_equal NoLogic.method(:emits), NoLogic.method(:has_markup)
+    def assigns
+      {:foo => ['bar', 'baz']}
+    end
   end
 
-  class Helpers < ECB
-    helper :title_helper, &-> { @foo.first }
+  class HelperExample < ECB
+    def title_helper
+      foo.first
+    end
 
-    emits -> {
+    emits {
       h1 {
         title_helper
       }
@@ -37,8 +40,7 @@ class BaseTest < ActiveSupport::TestCase
   end
 
   test "helpers defined in component are evaluated in context" do
-    compiled = Helpers.new.compile
-    assert_equal "<h1>bar</h1>", Context.new.instance_eval(Interpolator.transform(compiled))
+    assert_equal "<h1>bar</h1>\n", ExpressTemplates.render(Context.new) { helper_example }
   end
 
 end