express_templates 0.2.0 → 0.2.2

data/lib/express_templates/expander.rb

@@ -4,72 +4,87 @@ module ExpressTemplates
 
     cattr_accessor :module_search_space
 
-    attr_accessor :stack
+    attr_accessor :stack, :handlers, :locals
 
-    def self.expand(template, source)
-      expanded = new(template).expand(source)
-      compiled = expanded.map(&:compile)
-      return compiled.join("+")
-    end
-
-    def initialize(template)
+    def initialize(template, handlers = {}, locals = {})
       @template = template
       @stack = Stack.new
+      @handlers = handlers
+      @locals = locals
     end
 
     def expand(source=nil, &block)
-      if source
-        modified = source.gsub(/(\W)(yield)(\.*)?/, '\1 (stack << ExpressTemplates::Components::Yielder.new(\3))')
-        modified.gsub!(/(\W)(@\w+)(\W)?/, '\1 (stack << ExpressTemplates::Components::Wrapper.new("\2") )\3')
+      case
+      when block.nil? && source
+        modified = _wrap_instance_vars( _replace_yield_with_yielder(source) )
         instance_eval(modified, @template.inspect)
-        stack.current
+      when block
+        instance_exec &block
       else
-        instance_eval &block
-        stack.current
+        raise ArgumentError
       end
+      stack.current
+    end
+
+    def process_children!(parent, &block)
+      begin
+        stack.descend!
+        result = instance_exec &block
+        if stack.current.empty? && result.is_a?(String)
+          stack << result
+        end
+        parent.children += stack.current
+        stack.ascend!
+      end
+      stack.current
     end
 
     # define a "macro" method for a component
     # these methods accept args which are passed to the
     # initializer for the component
-    # blocks supplied are evaluated and any returned objects are
-    # added as children to the component
+    # blocks supplied are evaluated and children added to the "stack"
+    # are added as children to the component
     def self.register_macros_for(*components)
       components.each do |component|
         define_method(component.macro_name.to_sym) do |*args, &block|
-            stack << if block
-                begin
-                  stack.descend!
-                  block.call
-                  # anything stored on stack.current or on stack.next is added as a child
-                  # this is a bit problematic in the case where we would have
-                  # blocks and helpers or locals mixed
-                  component.new(*(args.push(*(stack.current))))
-                ensure
-                  stack.ascend!
-                end
-              else
-                component.new(*(args))
-              end
+            new_component = component.new(*(args.push(self)))
+            process_children!(new_component, &block) unless block.nil?
+            stack << new_component
         end
       end
     end
 
 
-    @module_search_space = [ExpressTemplates::Components]
+    @module_search_space = [ExpressTemplates::Markup, ExpressTemplates::Components]
 
     @module_search_space.each do |mod|
       register_macros_for(*
         mod.constants.map { |const| [mod.to_s, const.to_s].join("::").constantize }.
-          select { |klass| klass.ancestors.include? (ExpressTemplates::Component) }
+          select { |klass| klass.ancestors.include? (ExpressTemplates::Markup::Tag) }
       )
     end
 
-    def method_missing(name, *args)
-      stack.current << ExpressTemplates::Components::Wrapper.new(name.to_s, *args)
+    def method_missing(name, *args, &block)
+      return locals[name] if locals.keys.include?(name)
+
+      if handlers.keys.include?(name)
+        stack << handlers[name].send(name, *args)
+      else
+        stack << ExpressTemplates::Markup::Wrapper.new(name.to_s, *args, &block)
+      end
       nil
     end
 
+    private
+
+      def _replace_yield_with_yielder(source)
+        source.gsub(/(\W)(yield)(\([^\)]*\))?/, '\1 (stack << ExpressTemplates::Markup::Yielder.new\3)')
+      end
+
+      def _wrap_instance_vars(source)
+        source.gsub(/(\W)(@\w+)(\W)?/, '\1 (stack << ExpressTemplates::Markup::Wrapper.new("\2") )\3')
+      end
+
     class Stack
       def initialize
         @stack = [[]]
@@ -82,7 +97,8 @@ module ExpressTemplates
 
       def dump
         puts "Current frame: #{@frame}"
-        puts all.map(&:inspect).join("\n")
+        require 'pp'
+        pp all
       end
 
       def <<(child)

data/lib/express_templates/indenter.rb

@@ -0,0 +1,44 @@
+module ExpressTemplates
+
+  # Tracks current indent level scoped to the current thread.
+  #
+  # May be used to track multiple indents simultaneously through
+  # namespacing.
+  class Indenter
+
+    DEFAULT = 2
+    WHITESPACE = " "*DEFAULT
+
+    # Returns whitespace for the named indenter or yields to a block
+    # for the named indentor.
+    #
+    # The block is passed the current whitespace indent.
+    #
+    # For convenience an optional second parameter is passed to the block
+    # containing a newline at the beginning of the indent.
+    def self.for name
+      if block_given?
+        current_indenters[name] += 1
+        begin
+          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)
+        end
+      else
+        return WHITESPACE * current_indenters[name]
+      end
+    end
+
+    private
+      # For thread safety, scope indentation to the current thread
+      def self.current_indenters
+        Thread.current[:indenters] ||= Hash.new {|hsh, key| hsh[key] = 0 }
+      end
+
+  end
+
+end

data/lib/express_templates/macro.rb

@@ -0,0 +1,44 @@
+module ExpressTemplates
+  module Macro
+
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+
+      module ClassMethods
+        def macro_name
+          to_s.split('::').last.underscore
+        end
+      end
+      module InstanceMethods
+        def macro_name ; self.class.macro_name end
+
+        def initialize(*children_or_options)
+          @children = []
+          @options = {}.with_indifferent_access
+          # expander passes itself as last arg
+          @expander = children_or_options.pop if children_or_options.last.kind_of?(ExpressTemplates::Expander)
+          _process(*children_or_options)
+        end
+
+        private
+
+          def _process(*children_or_options)
+            children_or_options.each do |child_or_option|
+              case
+              when child_or_option.kind_of?(Hash)
+                @options.merge!(child_or_option)
+              when child_or_option.kind_of?(Symbol)
+                @options.merge!(id: child_or_option.to_s)
+              else
+                @children << child_or_option
+              end
+            end
+          end
+
+      end
+  end
+end

data/lib/express_templates/markup.rb

@@ -0,0 +1,9 @@
+module ExpressTemplates
+  module Markup
+  end
+end
+
+require 'express_templates/markup/tag'
+require 'express_templates/markup/html_tag'
+require 'express_templates/markup/wrapper'
+require 'express_templates/markup/yielder'

data/lib/express_templates/{components → markup}/html_tag.rb

@@ -1,6 +1,6 @@
 module ExpressTemplates
-  module Components
-    class HtmlTag < ExpressTemplates::Component
+  module Markup
+    class HtmlTag < Tag
       TAGS = [ :a, :abbr, :address, :area, :article, :aside, :audio,
                :b, :base, :bdi, :bdo, :blockquote, :body, :br, :button,
                :canvas, :caption, :cite, :code, :col, :colgroup,
@@ -29,7 +29,13 @@ module ExpressTemplates
 
     HtmlTag::TAGS.each do |tag|
       klass = tag.to_s.titleize
-      ExpressTemplates::Components.module_eval "class #{klass} < HtmlTag ; end"
+      ExpressTemplates::Markup.module_eval "class #{klass} < ExpressTemplates::Markup::HtmlTag ; end"
+    end
+
+    I.class_eval do
+      def should_not_abbreviate?
+        true
+      end
     end
 
   end

data/lib/express_templates/markup/tag.rb

@@ -0,0 +1,118 @@
+module ExpressTemplates
+  module Markup
+    class Tag
+      include ExpressTemplates::Macro
+
+      attr_accessor :children
+
+      INDENT = '  '
+
+      # These come from Macro but must remain overridden here for performance reasons.
+      # To verify, comment these two methods and
+      # run rake test and observe the performance hit.  Why?
+      def self.macro_name
+        @macro_name ||= to_s.split('::').last.underscore
+      end
+
+      def macro_name ; self.class.macro_name end
+
+
+      def html_options
+        @options.each_pair.map do |name, value|
+          case
+          when name.to_sym.eql?(:data) && value.kind_of?(Hash)
+            value.each_pair.map {|k,v| %Q(data-#{k}=\\"#{v}\\") }.join(" ")
+          when code = value.to_s.match(/^\{\{(.*)\}\}$/).try(:[], 1)
+            %Q(#{name}=\\"\#{#{code}}\\")
+          else
+            %Q(#{name}=\\"#{value}\\")
+          end
+        end.join(" ")
+      end
+
+      def start_tag
+        "<#{macro_name}#{html_options.empty? ? '' : ' '+html_options}>"
+      end
+
+      def close_tag
+        "</#{macro_name}>"
+      end
+
+      def add_css_class(css_class)
+        @options['class'] ||= ''
+        css_class = css_class.to_s.gsub('_', '-').gsub(/^-/,'') if css_class.to_s.match /^_.*_/
+        @options['class'] = (@options['class'].split + [css_class]).uniq.join(" ")
+      end
+
+      def method_missing(name, *args, &children)
+        add_css_class(name)
+        _process(*args) unless args.empty?
+        if children # in the case where CSS classes are specified via method
+          unless @expander.nil?
+            @expander.process_children! self, &children
+          else
+            raise "block passed without expander"
+          end
+        end
+        return self
+      end
+
+      def should_not_abbreviate?
+        false
+      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}\}")
+            else
+              %Q("#{child}")
+            end
+          end
+        end
+        unless ruby_fragments.empty?
+          _wrap_with_tags(ruby_fragments)
+        else
+          if should_not_abbreviate?
+            _wrap_with_tags(ruby_fragments)
+          else
+            %Q("#{start_tag.gsub(/>$/, ' />')}")
+          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
+          end
+        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}")
+          ruby_fragments.reject {|frag| frag.empty? }.join("+")
+        end
+
+        def _indent(code)
+          code.split("\n").map {|line| INDENT + line }.join("\n")
+        end
+
+        def _blockify(code, depth)
+          indent = INDENT*depth
+          code.empty? ? code : " {\n#{_indent(code)}\n}\n"
+        end
+
+    end
+  end
+end

data/lib/express_templates/markup/wrapper.rb

@@ -0,0 +1,88 @@
+module ExpressTemplates
+  module Markup
+    # wrap locals and helpers for evaluation during render
+    class Wrapper
+
+      attr_accessor :name, :args
+
+      def initialize(name, *args, &block)
+        @name = name
+        @args = args
+        @block_src = block ? block.source : nil
+      end
+
+      def compile
+        # insure nils do not blow up view
+        %Q("\#\{#{_compile}\}")
+      end
+
+      def to_template
+        _compile
+      end
+
+      def children
+        []
+      end
+
+      private
+        def _compile
+          string = "#{name}"
+
+          if !@args.empty?
+            args_string = args.slice(0..-2).map(&:inspect).map(&:_remove_double_braces).join(', ')
+            last_arg = ''
+            if args.last.is_a?(Hash) # expand a hash
+              last_arg = _convert_hash_to_argument_string(args.last)
+            else
+              last_arg = args.last.inspect._remove_double_braces
+            end
+            args_string << (args_string.empty? ? last_arg : ", #{last_arg}")
+            string << "(#{args_string})"
+          end
+
+          if @block_src
+            string << " #{@block_src}"
+          end
+
+          return string
+        end
+
+        def _convert_hash_to_argument_string(hash)
+          use_hashrockets = hash.keys.any? {|key| key.to_s.match /-/}
+          unless hash.empty?
+            return hash.map do |key, value|
+              s = if use_hashrockets
+                if key.to_s.match /-/
+                  "'#{key}' => "
+                else
+                  ":#{key} => "
+                end
+              else
+                "#{key}: "
+              end
+
+              case
+              when value.is_a?(String)
+                s << '"'+value+'"'
+              when value.is_a?(Hash)
+                s << value.inspect
+              when value.is_a?(Proc)
+                s << "(-> #{value.source}).call"
+              else
+                s << value.inspect  # immediate values 1, 2.0, true etc
+              end
+              s
+            end.join(", ")
+          else
+            "{}" # empty hash
+          end
+        end
+    end
+  end
+end
+
+class String
+  def _remove_double_braces
+    match(/\{\{(.*)\}\}/).try(:[], 1) || self
+  end
+end