express_templates 0.2.7 → 0.3.0

data/lib/express_templates/components/table_for.rb

@@ -0,0 +1,119 @@
+module ExpressTemplates
+  module Components
+    # Create an html table from a collection of data.
+    #
+    # Typically this will be a collection of models
+    # of the same type.  Each member of the collection must
+    # respond to the column names provided.
+    #
+    # Example:
+    #
+    # ```ruby
+    # table_for(:people) do |t|
+    #   t.column :name
+    #   t.column :email
+    #   t.column :phone
+    # end
+    # ```
+    #
+    # This assumes that a @people variable will exist in the
+    # view and that it will be a collection whose members respond to
+    # :name, :email, and :phone
+    #
+    # This will result in markup like the following:
+    #
+    #     <table id="people">
+    #       <thead>
+    #         <tr>
+    #           <th class="name">Name</th>
+    #           <th class="email">Email</th>
+    #           <th class="phone">Phone</th>
+    #         </tr>
+    #       </thead>
+    #       <tbody>
+    #         <tr id="person-1">
+    #           <td class="name">Steven Talcott Smith</td>
+    #           <td class="email">steve@aelogica.com</td>
+    #           <td class="phone">415-555-1212</td>
+    #         </tr>
+    #       </tbody>
+    #     </table>
+    #
+    class TableFor < Base
+      include Capabilities::Configurable
+      include Capabilities::Building
+
+      def initialize(*args)
+        super(*args)
+        _process_args!(args) # from Configurable
+        yield(self) if block_given?
+      end
+
+      attr :columns
+
+      def column(name, options = {})
+        @columns ||= []
+        @columns << Column.new(name, options)
+      end
+
+      emits -> {
+        table(my[:id]) {
+          thead {
+            tr {
+              columns.each do |column|
+                th.send(column.name) {
+                  column.title
+                }
+              end
+            }
+          }
+          tbody {
+            for_each(my[:id]) {
+
+              tr(id: -> {"item-#{item.id}"},
+                 class: my[:id].to_s.singularize) {
+
+                columns.each do |column|
+                  td(class: column.name) {
+                    column.format(:item)
+                  }
+                end
+              }
+            }
+          }
+        }
+      }
+
+      def wrap_for_stack_trace(body)
+        "ExpressTemplates::Components::TableFor.render_in(self) {\n#{body}\n}"
+      end
+
+      def compile
+        wrap_for_stack_trace(lookup(:markup))
+      end
+
+      class Column
+        attr :name, :options
+        def initialize(name, options = {})
+          @name = name
+          @options = options
+          @formatter = options[:formatter]
+        end
+
+        def format(item_name)
+          if @formatter.nil?
+            "\#\{#{item_name}.#{name}\}"
+          elsif @formatter.kind_of?(Proc)
+            "\#\{(#{@formatter.source}).call(#{item_name}.#{name})\}"
+          end
+        end
+
+        def title
+          @name.to_s.try(:titleize)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/express_templates/components/tree_for.rb

@@ -0,0 +1,41 @@
+module ExpressTemplates
+  module Components
+    #
+    # Create an html <tt>table</tt> or <tt>ol</tt> (ordered list) for
+    # a model object representing a tree of similar objects.
+    #
+    # The objects must respond to <tt>:children</tt>.
+    #
+    # The block is passed a NodeBuilder which may accept field names.
+    #
+    # Example:
+    #
+    # ```ruby
+    # tree_for(:roles) do |role|
+    #   role.name
+    # end
+    # ```
+    #
+    # If the view has an @roles variable with a Role having children,
+    # this will turn into markup such as the following:
+    #
+    #     <ul id="roles" class="roles tree">
+    #       <li>SuperAdmin
+    #         <ul>
+    #           <li>Admin</li>
+    #             <ul>
+    #               <li>Publisher</li>
+    #                 <ul>
+    #                    <li>Author</li>
+    #                 </ul>
+    #               <li>Auditor</li>
+    #             </ol>
+    #           </li>
+    #         </ol>
+    #       </li>
+    #     </ol>
+    #
+    class TreeFor < Container
+    end
+  end
+end

data/lib/express_templates/components/unless_block.rb

@@ -0,0 +1,40 @@
+module ExpressTemplates
+  module Components
+    class UnlessBlock < Components::Container
+
+      attr :conditional
+
+      def initialize(*args)
+        @conditional = args.shift
+        @alt = args.shift[:alt] if args.first.kind_of?(Hash)
+        parent = args.shift
+        if @conditional.kind_of?(Symbol)
+          @conditional = @conditional.to_s
+        elsif @conditional.kind_of?(Proc)
+          @conditional = "(#{@conditional.source}.call)"
+        elsif iterator.kind_of?(String)
+          @conditional = "(#{@conditional}.call)"
+        else
+          raise "UnlessBlock unknown conditional: #{@conditional.inspect}"
+        end
+
+        if @alt.kind_of?(Proc)
+          @alt = _compile_fragment @alt
+        elsif @alt.nil?
+          @alt = "''"
+        end
+      end
+
+      def compile
+        s = unless @alt
+          %Q((unless #{@conditional}#{compile_children}\nend))
+        else
+          %Q((unless #{@conditional}#{compile_children}\nelse #{@alt}\nend))
+        end
+        puts s if ENV['DEBUG'].eql?('true')
+        s
+      end
+
+    end
+  end
+end

data/lib/express_templates/components.rb

@@ -6,7 +6,11 @@ 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/form_rails_support'
 require 'express_templates/components/content_for'
+require 'express_templates/components/table_for'

data/lib/express_templates/expander.rb

@@ -6,11 +6,16 @@ module ExpressTemplates
 
     attr_accessor :stack, :handlers, :locals
 
-    def initialize(template, handlers = {}, locals = {})
+    def initialize(*args)
+      initialize_expander(*args)
+    end
+
+    def initialize_expander(template, handlers = {}, locals = {})
       @template = template
       @stack = Stack.new
       @handlers = handlers
       @locals = locals
+      self
     end
 
     def expand(source=nil, &block)
@@ -47,8 +52,14 @@ module ExpressTemplates
     def self.register_macros_for(*components)
       components.each do |component|
         define_method(component.macro_name.to_sym) do |*args, &block|
-            new_component = component.new(*(args.push(self)))
-            process_children!(new_component, &block) unless block.nil?
+            new_component = nil
+            # this is a code smell here.
+            if component.ancestors.include?(Components::Capabilities::Building)
+              new_component = component.new(*(args.push(self)), &block)
+            else
+              new_component = component.new(*(args.push(self)))
+              process_children!(new_component, &block) unless block.nil?
+            end
             stack << new_component
         end
       end
@@ -68,7 +79,7 @@ module ExpressTemplates
       return locals[name] if locals.keys.include?(name)
 
       if handlers.keys.include?(name)
-        stack << handlers[name].send(name, *args)
+        stack << handlers[name].send(name, *args, &block)
       else
         stack << ExpressTemplates::Markup::Wrapper.new(name.to_s, *args, &block)
       end

data/lib/express_templates/indenter.rb

@@ -23,10 +23,13 @@ module ExpressTemplates
           indent = WHITESPACE * current_indenters[name]
           yield indent, "\n#{indent}"
         ensure
-          current_indenters[name] -= 1
-          # if we have long-lived threads for some reason
-          # we want to clean up after ourselves
-          current_indenters.delete(name) if current_indenters[name].eql?(0)
+          if current_indenters[name].eql?(-1)
+            # if we have long-lived threads for some reason
+            # we want to clean up after ourselves
+            current_indenters.delete(name)
+          else
+            current_indenters[name] -= 1
+          end
         end
       else
         return WHITESPACE * current_indenters[name]
@@ -36,7 +39,7 @@ module ExpressTemplates
     private
       # For thread safety, scope indentation to the current thread
       def self.current_indenters
-        Thread.current[:indenters] ||= Hash.new {|hsh, key| hsh[key] = 0 }
+        Thread.current[:indenters] ||= Hash.new {|hsh, key| hsh[key] = -1 }
       end
 
   end

data/lib/express_templates/markup/tag.rb

@@ -22,6 +22,8 @@ module ExpressTemplates
           case
           when name.to_sym.eql?(:data) && value.kind_of?(Hash)
             value.each_pair.map {|k,v| %Q(data-#{k}=\\"#{v}\\") }.join(" ")
+          when value.kind_of?(Proc)
+            %Q(#{name}=\\"\#{(#{value.source}).call}\\")
           when code = value.to_s.match(/^\{\{(.*)\}\}$/).try(:[], 1)
             %Q(#{name}=\\"\#{#{code}}\\")
           else
@@ -66,56 +68,86 @@ module ExpressTemplates
       end
 
       def compile
-        ruby_fragments = @children.map do |child|
-          if child.respond_to?(:compile)
-            child.compile
-          else
-            if code = child.to_s.match(/\{\{(.*)\}\}/).try(:[], 1)
-              %Q("\#\{#{code}\}")
+        ExpressTemplates::Indenter.for(:markup) do |whitespace|
+          ruby_fragments = @children.map do |child|
+            if child.respond_to?(:compile)
+              child.compile
             else
-              %Q("#{child}")
+              if code = child.to_s.match(/\{\{(.*)\}\}/).try(:[], 1)
+                %Q("\#\{#{code}\}")
+              else
+                %Q("#{child}")
+              end
             end
           end
-        end
-        unless ruby_fragments.empty?
-          _wrap_with_tags(ruby_fragments)
-        else
-          if should_not_abbreviate?
-            _wrap_with_tags(ruby_fragments)
-          elsif transform_close_tag?
-            %Q("#{start_tag.gsub(/>$/, ' />')}")
+          unless ruby_fragments.empty?
+            _wrap_with_tags(ruby_fragments, whitespace)
           else
-            %Q("#{start_tag}")
+            if should_not_abbreviate?
+              _wrap_with_tags(ruby_fragments, whitespace)
+            elsif transform_close_tag?
+              %Q("#{start_tag.gsub(/>$/, ' />')}")
+            else
+              %Q("#{start_tag}")
+            end
           end
         end
       end
 
-      def to_template(depth = 0)
-        template_fragments = @children.map do |child|
-          if child.respond_to?(:to_template)
-            child.to_template(depth+1)
-          else
-            child
+      def to_template
+        # ExpressTemplates::Indenter.for(:template) do
+          template_fragments = @children.map do |child|
+            if child.respond_to?(:to_template)
+              child.to_template
+            else
+              child
+            end
           end
+          macro_name + _blockify(template_fragments.join("\n"))
+        # end
+      end
+
+      def self.formatted
+        old_setting = Thread.current[:formatted]
+        begin
+          Thread.current[:formatted] = true
+          yield if block_given?
+        ensure
+          Thread.current[:formatted] = old_setting
         end
-        indent = INDENT*(depth+1)
-        macro_name + _blockify(template_fragments.join("\n#{indent}"), depth)
       end
 
       private
 
-        def _wrap_with_tags(ruby_fragments)
-          ruby_fragments.unshift %Q("#{start_tag}")
-          ruby_fragments.push %Q("#{close_tag}")
+        def _wrap_with_tags(ruby_fragments, whitespace)
+          opening, closing = nil, nil
+          if !ENV['ET_NO_INDENT_MARKUP'].eql?('true') || #TODO: change to setting
+              Thread.current[:formatted]
+            child_code = ruby_fragments.join
+            should_format = ruby_fragments.size > 1 ||
+                            (child_code.size > 40 && !child_code.match(/^"\#\{.*\}"$/)) ||
+                            child_code.match(/\n/)
+
+            nl = should_format ? "\n" : nil
+            nl_after_start = !ruby_fragments.first.try(:match, /^"\n/) ? nl : nil
+            # binding.pry
+            nl_before_end = !ruby_fragments.last.try(:match, /\n"$/) ? nl : nil
+            opening = %Q("\n#{whitespace}#{start_tag}#{nl_after_start}")
+            closing = %Q("#{nl_before_end}#{should_format && whitespace}#{close_tag}#{nl}")
+          else
+            opening = %Q("#{start_tag}")
+            closing = %Q("#{close_tag}")
+          end
+          ruby_fragments.unshift opening
+          ruby_fragments.push closing
           ruby_fragments.reject {|frag| frag.empty? }.join("+")
         end
 
         def _indent(code)
-          code.split("\n").map {|line| INDENT + line }.join("\n")
+          code.split("\n").map {|line| ExpressTemplates::Indenter::WHITESPACE + line }.join("\n")
         end
 
-        def _blockify(code, depth)
-          indent = INDENT*depth
+        def _blockify(code)
           code.empty? ? code : " {\n#{_indent(code)}\n}\n"
         end
 

data/lib/express_templates/markup/wrapper.rb

@@ -67,7 +67,7 @@ module ExpressTemplates
               when value.is_a?(Hash)
                 s << value.inspect
               when value.is_a?(Proc)
-                s << "(-> #{value.source}).call"
+                s << "(#{value.source}).call"
               else
                 s << value.inspect  # immediate values 1, 2.0, true etc
               end

data/lib/express_templates/version.rb

@@ -1,3 +1,3 @@
 module ExpressTemplates
-  VERSION = "0.2.7"
+  VERSION = "0.3.0"
 end

data/test/components/base_test.rb

@@ -3,55 +3,32 @@ require 'test_helper'
 class BaseTest < ActiveSupport::TestCase
 
   class NoLogic < ExpressTemplates::Components::Base
-    has_markup {
+    has_markup -> {
       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 %Q("<h1><span>Some stuff</span></h1>"), NoLogic.new.compile
   end
 
   test "components register themselves as macros" do
     assert ExpressTemplates::Expander.instance_methods.include?(:no_logic)
   end
 
-  test ".render accepts a fragment name" do
-    assert_equal '<h1><span>Some stuff</span></h1>', NoLogic.render(self, :markup)
-  end
-
-
-  class SomeLogic < ECB
-    emits markup: -> {
-      span { foo }
-    }
-
-    using_logic { |component|
-      @foo.map do |foo|
-        eval(component[:markup])
-      end.join
-    }
-  end
-
   class Context
     def initialize ; @foo = ['bar', 'baz'] ; end
   end
 
-  test ".using_logic controls the markup generation" do
-    compiled = SomeLogic.new.compile
-    assert_equal 'BaseTest::SomeLogic.render(self)', compiled
-    assert_equal '<span>bar</span><span>baz</span>', Context.new.instance_eval(compiled)
-  end
-
   test "fragments and has_markup are synonyms for emits" do
-    assert_equal SomeLogic.method(:emits), SomeLogic.method(:fragments)
-    assert_equal SomeLogic.method(:emits), SomeLogic.method(:has_markup)
+    assert_equal NoLogic.method(:emits), NoLogic.method(:fragments)
+    assert_equal NoLogic.method(:emits), NoLogic.method(:has_markup)
   end
 
   class Helpers < ECB
     helper :title_helper, &-> { @foo.first }
 
-    emits {
+    emits -> {
       h1 {
         title_helper
       }
@@ -64,14 +41,4 @@ class BaseTest < ActiveSupport::TestCase
     assert_equal "<h1>bar</h1>", Context.new.instance_eval(compiled)
   end
 
-  class NullComponent < ECB
-    using_logic {
-      nil
-    }
-  end
-
-  test "render should not return a nil" do
-    compiled = NullComponent.new.compile
-    assert_equal "", Context.new.instance_eval(compiled)
-  end
 end

data/test/components/conditionality_test.rb

@@ -17,7 +17,7 @@ class ConditionalityTest < ActiveSupport::TestCase
   class ConditionalRenderer < ExpressTemplates::Components::Base
     include ExpressTemplates::Components::Capabilities::Conditionality
 
-      emits {
+      emits -> {
         h1 "{{@title}}"
       }
 

data/test/components/configurable_test.rb

@@ -6,7 +6,7 @@ class ConfigurableTest < ActiveSupport::TestCase
 
   class ConfigurableComponent < ETC::Base
     include ETC::Capabilities::Configurable
-    emits {
+    emits -> {
       div.bar(my[:id])
     }
   end
@@ -27,7 +27,7 @@ class ConfigurableTest < ActiveSupport::TestCase
     # make sure a helper can take arguments
     helper(:name) {|name| name.to_s }
 
-    emits {
+    emits -> {
       div(my[:id]) {
         h1 { name(my[:id]) }
         _yield

data/test/components/container_test.rb

@@ -26,7 +26,7 @@ class ContainerTest < ActiveSupport::TestCase
   end
 
   class TestContainer < ETC::Container
-    emits { p { _yield } }
+    emits -> { p { _yield } }
   end
 
   test "Container#compile calls #compile on its children" do

data/test/components/iterating_test.rb

@@ -3,26 +3,47 @@ require 'test_helper'
 class IteratingTest < ActiveSupport::TestCase
 
   class Context
-    def initialize ; @foo = ['bar', 'baz'] ; @empty = [] ; end
+    def initialize ; @things = ['bar', 'baz'] ; @empty = [] ; end
   end
 
   class ForEachLogic < ECB
     emits -> {
-      span { foo }
+      for_each(:@things) {
+        span { thing }
+      }
     }
+  end
 
-    for_each(:@foo)
+  test "#for_each expands to view logic" do
+    compiled = ForEachLogic.new.compile
+    assert_equal %q((@things.each_with_index.map do |thing, thing_index|
+"<span>#{thing}</span>"
+end).join), compiled
   end
 
-  test ".for_each iterates markup for each value" do
+  test "#for_each iterates markup for each value" do
     compiled = ForEachLogic.new.compile
     assert_equal '<span>bar</span><span>baz</span>', Context.new.instance_eval(compiled)
   end
 
+  class ForEachDeclarativeForm < ECB
+    emits -> {
+      span { thing }
+    }
+
+    for_each(:@things)
+  end
+
+  test ".for_each offers declarative form" do
+    compiled = ForEachLogic.new.compile
+    assert_equal '<span>bar</span><span>baz</span>', Context.new.instance_eval(compiled)
+  end
+
+
   class MultiFragments < ECB
 
     fragments item:  -> {
-                          li { foo }
+                          li { thing }
                         },
 
               wrapper: -> {
@@ -31,7 +52,7 @@ class IteratingTest < ActiveSupport::TestCase
                             }
                           }
 
-    for_each -> { @foo }, as: 'foo', emit: :item
+    for_each -> { @things }, as: 'thing', emit: :item
 
     wrap_with :wrapper
 
@@ -45,7 +66,7 @@ class IteratingTest < ActiveSupport::TestCase
   class EmptyState < ECB
 
     fragments item:       -> {
-                                li { foo }
+                                li { thing }
                               },
 
               wrapper:    -> {
@@ -57,7 +78,7 @@ class IteratingTest < ActiveSupport::TestCase
                                 p "Nothing here"
                               }
 
-    for_each -> { @empty }, as: 'foo', emit: :item, empty: :empty_state
+    for_each -> { @empty }, as: 'thing', emit: :item, empty: :empty_state
 
     wrap_with :wrapper, dont_wrap_if: -> { @empty.empty? }
 
@@ -69,7 +90,7 @@ class IteratingTest < ActiveSupport::TestCase
   end
 
   class EmptyEmptyState < ECB
-    emits {
+    emits -> {
       whatever
     }