express_templates 0.5.0 → 0.7.0

data/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/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/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/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/lib/express_templates/components/forms.rb

@@ -5,7 +5,6 @@ module ExpressTemplates
   end
 end
 
-require 'express_templates/components/forms/form_support'
 require 'express_templates/components/forms/express_form'
 require 'express_templates/components/forms/form_component'
 require 'express_templates/components/forms/option_support'

data/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/lib/express_templates/components.rb

@@ -3,16 +3,8 @@ module ExpressTemplates
   end
 end
 
-require 'express_templates/expander'
 require 'express_templates/components/base'
-require 'express_templates/components/container'
-require 'express_templates/components/null_wrap'
-require 'express_templates/components/for_each'
-require 'express_templates/components/unless_block'
-require 'express_templates/components/row'
-require 'express_templates/components/column'
+require 'express_templates/components/configurable'
 require 'express_templates/components/form_rails_support'
-require 'express_templates/components/content_for'
-require 'express_templates/components/table_for'
 require 'express_templates/components/tree_for'
 require 'express_templates/components/forms'

data/lib/express_templates/version.rb

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

data/lib/express_templates.rb

@@ -1,13 +1,12 @@
 module ExpressTemplates
+  require 'arbre'
+  require 'arbre/patches'
   require 'core_extensions/proc'
   require 'core_extensions/string'
   require 'express_templates/indenter'
-  require 'express_templates/macro'
-  require 'express_templates/markup'
   require 'express_templates/components'
   require 'express_templates/template/handler'
   require 'express_templates/renderer'
-  require 'express_templates/expander'
   require 'express_templates/compiler'
   require 'express_templates/interpolator'
   extend Renderer

data/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

data/test/components/capabilities/resourceful_test.rb

@@ -6,7 +6,7 @@ module AdminModule
   class SmartThing
     include ExpressTemplates::Components::Capabilities::Resourceful
 
-    attr_accessor :virtual_path
+    attr_accessor :virtual_path, :config
 
     def initialize(virtual_path, config = {})
       @virtual_path = virtual_path
@@ -14,8 +14,8 @@ module AdminModule
       @args = [self]
     end
 
-    def template
-      self
+    def template_virtual_path
+      @virtual_path
     end
   end
 end

data/test/components/configurable_test.rb

@@ -4,40 +4,46 @@ class ConfigurableTest < ActiveSupport::TestCase
 
   ETC = ExpressTemplates::Components
 
-  class ConfigurableComponent < ETC::Base
-    include ETC::Capabilities::Configurable
-    emits -> {
-      div.bar(my[:id])
-    }
-  end
-
-  test "a configurable component accepts an id argument" do
-    assert :foo, ConfigurableComponent.new(:foo).my[:id]
+  class ConfigurableComponent < ETC::Configurable
+    def markup
+      div(id: my[:id], class: 'bar')
+    end
   end
 
   test "renders id argument as dom id" do
-    compiled_src = ConfigurableComponent.new(:foo).compile
-    assert '<div id="foo" class="bar" />', compiled_src
+    compiled_src = ExpressTemplates.render(self) { configurable_component(:foo) }
+    assert_equal "<div id=\"foo\" class=\"bar\"></div>\n", compiled_src
   end
 
-  class ConfigurableContainerComponent < ETC::Base
-    include ETC::Capabilities::Configurable
-    include ETC::Capabilities::Parenting
+  class ConfigurableContainerComponent < ETC::Configurable
 
     # make sure a helper can take arguments
-    helper(:name) {|name| name.to_s }
+    # helper(:name) {|name| name.to_s }
+    def name(name)
+      name.to_s
+    end
 
-    emits -> {
-      div(my[:id]) {
+    def markup &block
+      div(id: my[:id]) {
         h1 { name(my[:id]) }
-        _yield
+        yield(block) if block
       }
-    }
+    end
+  end
+
+  def assigns
+    {}
   end
 
   test "a configurable component may have also be a container" do
-    html = ExpressTemplates.render { configurable_container_component(:foo) { p "bar" }}
-    assert_equal '<div id="foo"><h1>foo</h1><p>bar</p></div>', html
+    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
   end
 
 end

data/test/components/forms/basic_fields_test.rb

@@ -6,47 +6,87 @@ class BasicFieldsTest < ActiveSupport::TestCase
                     datetime_local number range
                     search telephone time url week)
 
-  test "text requires parent" do
-    fragment = -> {
-      text :name
-    }
-    assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
-    }
+  def assigns
+    {resource: resource}
+  end
+
+  def field_type_map
+    Hash[BASIC_FIELDS.map {|f| [f, f]}].merge(
+      {'phone'          => 'tel',
+       'telephone'          => 'tel',
+       'datetime_local' => 'datetime-local' })
+  end
+
+  def label_html
+    '<label for="foo_bar">Bar</label>'
   end
 
   test "all fields work" do
     BASIC_FIELDS.each do |type|
-      fragment = -> {
+      fragment = -> (ctx) {
         express_form(:foo) {
           send(type, :bar)
         }
       }
-      assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
-      assert_match "#{type}_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+      html = arbre(&fragment)
+      assert_match label_html, html
+      assert_match(/input.*type="#{field_type_map[type]}"/, html)
+      # assert_match "#{type}_field(:foo, :bar, {})", arbre(&fragment)
+    end
+  end
+
+  test "passing html options to fields work" do
+    options = {class: 'form-field'}
+    BASIC_FIELDS.each do |type|
+      html = arbre {
+        express_form(:foo) {
+          send(type, :bar, options)
+        }
+      }
+      assert_match label_html, html
+      assert_match /input.*type="#{field_type_map[type]}"/, html
+      assert_match /input.*class="form-field"/, html
     end
   end
 
   test "textarea uses rails text_area helper" do
-    fragment = -> {
+    html = arbre {
       express_form(:foo) {
         textarea :bar
       }
     }
-    assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
-    assert_match "text_area(:foo, :bar)", ExpressTemplates.compile(&fragment)
+    assert_match label_html, html
+    assert_match /<textarea name="foo\[bar\]" id="foo_bar"><\/textarea>/, html.gsub("\n", '')
   end
 
+  test "textarea passes additional html options to rails helper" do
+    html = arbre {
+      express_form(:foo) {
+        textarea :bar, rows: 5, class: 'tinymce form-field'
+      }
+    }
+    assert_match label_html, html
+    assert_match /<textarea rows="5" class="tinymce form-field" name="foo\[bar\]" id="foo_bar"><\/textarea>/, html.gsub("\n", '') 
+  end
 
   test "hidden uses rails hidden_tag helper" do
-    fragment = -> {
+    html = arbre {
       express_form(:foo) {
         hidden :bar
       }
     }
-    assert_no_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
-    assert_match "hidden_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+    assert_no_match label_html, html
+    assert_match '<input type="hidden"', html
   end
 
-end
+  test "hidden field passes additional html options to rails helper" do
+    html = arbre {
+      express_form(:foo) {
+        hidden :bar, class: 'hidden form-field', value: 'ninja'
+      }
+    }
+    assert_no_match label_html, html
+    assert_match /<input class="hidden form-field" value="ninja" type="hidden" name="foo\[bar\]" id="foo_bar"/, html
+  end
 
+end