express_templates 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b560214168f6753cf3a9d186ee89c8a12f277816
-  data.tar.gz: 99a27ad570c78b032251ce6c6472c2aebbfb8dc0
+  metadata.gz: 16e00189a36058717818d7a7c66638c0164fcef6
+  data.tar.gz: 559bf6b66e66bf2caacd9c7594a9227ed2208cee
 SHA512:
-  metadata.gz: 16523908d29f4f748c767a40b98a45e97b69c7e33b5ee5bb3e0085438e2a8282929ed60e176a12dfacc97ea6673cb04582c0ad3f1e6b2f3af69c93ba62a96e1d
-  data.tar.gz: 2885c82c2e0b31dc34866324d701362d2ff007b316e821a1713588362dad690e873430be2f906b371e5201c9a9b6205aa1aa72ca8515a084fd5eb199edcde50d
+  metadata.gz: bfbbac386e1b3db30466f8517dc7c9a82f65ebce01c548357ba2754399f3808ef9601eb157cc78775fc67f571930f06dfc4da57ed7ee57e267b5624ad9a82b83
+  data.tar.gz: 20b4d748cb8780f9366ae4875f1795af827ce0db5b59c128d096a5cb47de38d7639bb90d55d53183ce4df2349341d68d52e6084f328e510090cc899ae706fb07

data/lib/core_extensions/proc.rb

@@ -2,9 +2,13 @@ require 'ripper'
 require 'pp'
 class Proc
 
-  TOKEN_PAIRS = {[:on_lbrace, '{']  => [:on_rbrace, '}'],
+  TLAMBEG = [:on_tlambeg, "{"]
+  TLAMBDA = [:on_tlambda, "->"]
+  LBRACE  = [:on_lbrace, '{']
+
+  TOKEN_PAIRS = {LBRACE             => [:on_rbrace, '}'],
                  [:on_kw, 'do']     => [:on_kw, 'end'],
-                 [:on_tlambeg, '{'] => [:on_rbrace, '}']}
+                 TLAMBDA            => [:on_rbrace, '}']}
 
   # Make a best effort to provide the original source for a block
   # based on extracting a string from the file identified in
@@ -18,25 +22,73 @@ class Proc
   # If you require only the source of blocks-within-other-blocks, start them
   # on a new line as would be best practice for clarity and readability.
   def source
-    file, line_no = source_location
-    raise "no line number provided for source_location: #{self}" if line_no.nil?
-    tokens =  Ripper.lex File.read(file)
-    tokens_on_line = tokens.select {|pos, lbl, str| pos[0].eql?(line_no) }
-    starting_token = tokens_on_line.detect do |pos, lbl, str| 
-      TOKEN_PAIRS.keys.include? [lbl, str] 
+    @source ||= begin
+      file, line_no = source_location
+      raise "no line number provided for source_location: #{self}" if line_no.nil?
+      tokens =  Ripper.lex File.read(file)
+      tokens_on_line = tokens.select {|pos, lbl, str| pos[0].eql?(line_no) }
+      starting_token = tokens_on_line.detect do |pos, lbl, str|
+          TOKEN_PAIRS.keys.include? [lbl, str]
+      end
+      starting_token_type = [starting_token[1], starting_token[2]]
+      ending_token_type = TOKEN_PAIRS[starting_token_type]
+      source_str = ""
+      remaining_tokens = tokens[tokens.index(starting_token)..-1]
+      nesting = -1
+      starting_nesting_token_types = if [TLAMBDA, LBRACE].include?(starting_token_type)
+        [TLAMBDA, LBRACE]
+      else
+        [starting_token_type]
+      end
+
+      while token = remaining_tokens.shift
+        token = [token[1], token[2]] # strip position
+        source_str << token[1]
+        nesting += 1 if starting_nesting_token_types.include? token
+        is_ending_token = token.eql?(ending_token_type)
+        break if is_ending_token && nesting.eql?(0)
+        nesting -= 1 if is_ending_token
+      end
+      source_str
+    end
+  end
+
+  # Examines the source of a proc to extract the body by
+  # removing the outermost block delimiters and any surrounding.
+  # whitespace.
+  #
+  # Raises exception if the block takes arguments.
+  #
+  def source_body
+    raise "Cannot extract proc body on non-zero arity" unless arity.eql?(0)
+    tokens = Ripper.lex source
+    body_start_idx = 2
+    body_end_idx = -1
+    if tokens[0][1].eql?(:on_tlambda)
+      body_start_idx = tokens.index(tokens.detect { |t| t[1].eql?(:on_tlambeg) }) + 1
     end
-    starting_token_type = [starting_token[1], starting_token[2]]
-    ending_token_type = TOKEN_PAIRS[starting_token_type]
-    source_str = ""
-    remaining_tokens = tokens.slice(tokens.index(starting_token)..-1)
-    nesting = -1
-    while token = remaining_tokens.shift
-      source_str << token[2]
-      nesting += 1 if [token[1], token[2]] == starting_token_type
-      is_ending_token = [token[1], token[2]].eql?(ending_token_type)
-      break if is_ending_token && nesting.eql?(0)
-      nesting -= 1 if is_ending_token
+    body_tokens = tokens[body_start_idx..-1]
+
+    body_tokens.pop # ending token of proc
+    # remove trailing whitespace
+    whitespace = [:on_sp, :on_nl, :on_ignored_nl]
+    body_tokens.pop while whitespace.include?(body_tokens[-1][1])
+    # remove leading whitespace
+    body_tokens.shift while whitespace.include?(body_tokens[0][1])
+
+    # put them back together
+    body_tokens.map {|token| token[2] }.join
+  end
+
+  def self.from_source(prc_src)
+    raise ArgumentError unless prc_src.kind_of?(String)
+    prc = begin
+      eval(prc_src)
+    rescue ArgumentError => e
+      binding.pry
     end
-    source_str
+    prc.instance_variable_set(:@source, prc_src)
+    prc
   end
+
 end

data/lib/express_templates/compiler.rb

@@ -5,7 +5,15 @@ module ExpressTemplates
 
       expander = Expander.new(template)
 
-      compiled = expander.expand(src, &block).map(&:compile)
+      Thread.current[:first_whitepace_removed] ||= 0
+      Thread.current[:first_whitepace_removed] += 1
+      begin
+        compiled = expander.expand(src, &block).map(&:compile)
+        compiled.first.sub!(/^"\n+/, '"') if Thread.current[:first_whitepace_removed].eql?(1)
+        Thread.current[:first_whitepace_removed] -= 1
+      ensure
+        Thread.current[:first_whitepace_removed] = nil if Thread.current[:first_whitepace_removed].eql?(0)
+      end
 
       return compiled.join("+").gsub('"+"', '').tap do |s|
         puts("\n"+template.inspect+"\n"+s) if ENV['DEBUG'].eql?('true')

data/lib/express_templates/components/base.rb

@@ -37,7 +37,7 @@ module ExpressTemplates
     # * Capabilities::Wrapping
     # * Capabilities::Iterating
     #
-    class Base
+    class Base < Expander
       include ExpressTemplates::Macro
       include Capabilities::Templating
       include Capabilities::Rendering

data/lib/express_templates/components/capabilities/building.rb

@@ -0,0 +1,8 @@
+module ExpressTemplates
+  module Components
+    module Capabilities
+      module Building
+      end
+    end
+  end
+end

data/lib/express_templates/components/capabilities/conditionality.rb

@@ -37,12 +37,14 @@ module ExpressTemplates
           end
 
           def only_if condition_proc
-            @condition_proc = condition_proc
-
-            using_logic do |component, options|
-              condition = instance_exec(&component.condition_proc)
-              eval(component[:markup]) if condition
-            end
+            @condition_proc = Proc.from_source "-> {!(#{condition_proc.source_body})}"
+            inner_src = self[:markup]
+            fragment_src = %Q(-> {
+  unless_block(Proc.from_source(#{@condition_proc.source.inspect})) {
+    #{inner_src.source_body}
+  }
+})
+            _store :markup, Proc.from_source(fragment_src)
           end
 
         end

data/lib/express_templates/components/capabilities/configurable.rb

@@ -28,7 +28,6 @@ module ExpressTemplates
             # Stores arguments for later processing, eg., compile time
             def initialize(*args)
               @args = args.dup
-              @config = {}
               _process_args!(args)
               super(*args)
             end
@@ -57,7 +56,7 @@ module ExpressTemplates
         module InstanceMethods
 
           def config
-            @config
+            @config ||= {}
           end
 
           alias :my :config
@@ -67,8 +66,8 @@ module ExpressTemplates
           end
 
           # Override Templating#lookup to pass locals
-          def lookup(fragment_name)
-            self.class.send(:_lookup, fragment_name, expand_locals)
+          def lookup(fragment_name, options = {})
+            super(fragment_name, options.merge(expand_locals))
           end
 
 

data/lib/express_templates/components/capabilities/iterating.rb

@@ -47,31 +47,26 @@ module ExpressTemplates
           # An <tt>:empty</tt> option specifies a fragment to use for the
           # empty state when the iterator returns an empty collection.
           def for_each(iterator, as: :item, emit: :markup, empty: nil)
-            if iterator.kind_of?(Symbol)
-              var_name = iterator.to_s.gsub(/^@/,'').singularize.to_sym
+            as = as.to_sym
+            emit = emit.to_sym
+            iterator = iterator.kind_of?(Proc) ? iterator.source : iterator
+            fragment_src = if empty
+%Q(-> {
+  unless_block(Proc.from_source("-> {#{iterator}.call.empty?}"), alt: #{self[empty].source}) {
+    for_each(Proc.from_source("#{iterator}"), as: #{as.inspect}) {
+      #{self[emit].source_body}
+    }
+  }
+})
             else
-              var_name = as
-            end
-            using_logic do |component, options|
-              collection = if iterator.kind_of?(Proc)
-                if iterator.arity.eql?(1)
-                  instance_exec(options, &iterator)
-                else
-                  instance_exec &iterator
-                end
-              else
-                eval(iterator.to_s)
-              end
-              if collection.empty?
-                empty ? component[empty] : ''
-              else
-                collection.map do |item|
-                  b = binding
-                  b.local_variable_set(var_name, item)
-                  b.eval(component[emit], __FILE__)
-                end.join
-              end
+%Q(-> {
+  for_each(Proc.from_source("#{iterator}"), as: #{as.inspect}) {
+    #{self[emit].source_body}
+  }
+})
             end
+            fragment = Proc.from_source(fragment_src)
+            _store :markup, fragment
           end
         end
       end

data/lib/express_templates/components/capabilities/parenting.rb

@@ -30,20 +30,10 @@ module ExpressTemplates
         #
         def self.included(base)
           base.class_eval do
-            extend ClassMethods
             include InstanceMethods
           end
         end
 
-        module ClassMethods
-          def render_with_children(context, locals = {}, child_markup_src = nil)
-            _wrap_it(context, locals) do |component|
-              child_markup_src
-            end
-          end
-
-        end
-
         module InstanceMethods
           def children
             @children ||= []
@@ -54,13 +44,9 @@ module ExpressTemplates
           end
 
           def compile
-            locals = (expand_locals rescue nil).inspect
-            args = %w(self)
-            args << locals
-            compiled_children = compile_children
-            args << compiled_children unless compiled_children.empty?
-            closing_paren = compiled_children.empty? ? ')' : "\n#{Indenter.for(:compile)})"
-            "#{self.class.to_s}.render_with_children(#{args.join(', ')}#{closing_paren}"
+            null_wrapped_children = "null_wrap { #{compile_children} }"
+            wrap_children_src = self.class[:markup].source.gsub(/\W_yield\W/, null_wrapped_children)
+            _compile_fragment(Proc.from_source(wrap_children_src))
           end
 
           def compile_children
@@ -69,7 +55,7 @@ module ExpressTemplates
               compiled_children = children.map do |child|
                 indent_with_newline +
                 (child.compile rescue %Q("#{child}")) # Bare strings may be children
-              end.join("+")
+              end.join("+\n")
               compiled_children.gsub!('"+"', '') # avoid unnecessary string concatenation
             end
             return compiled_children

data/lib/express_templates/components/capabilities/rendering.rb

@@ -15,78 +15,15 @@ module ExpressTemplates
         def self.included(base)
           base.class_eval do
             extend ClassMethods
-            include InstanceMethods
           end
         end
 
         module ClassMethods
-
-          # Store a block of logic which will be evalutated in a context
-          # during rendering.
-          #
-          # The block will be passed a reference to the component's class.
-          #
-          def using_logic(&block)
-            @control_flow = block
-          end
-
-          # Returns a string containing markup generated by evaluating
-          # blocks of supplied logic or compiled template code in a <tt>context</tt>.
-          #
-          # The context may be any object however, it is generally an
-          # ActionView::Context.
-          #
-          # Components when compiled may yield something like:
-          #
-          #     "MyComponent.render(self, {id: 'foo'})"
-          #
-          # The supplied options hash may be used to modify any fragments
-          # or the behavior of any logic.
-          #
-          # If a fragment identifier is passed as a symbol in the first
-          # option position, this will render that fragment only.
-          #
-          def render(context, *opts, &context_logic_block)
-            fragment = opts.shift if opts.first.is_a?(Symbol)
-            begin
-              if fragment
-                context.instance_eval(_lookup(fragment, opts)) || ''
-              else
-                flow = context_logic_block || @control_flow
-                exec_args = [self, opts].take(flow.arity)
-                context.instance_exec(*exec_args, &flow) || ''
-              end
-            rescue => e
-              binding.pry if ENV['DEBUG'].eql?("true")
-              raise "Rendering error in #{self}: #{e.to_s}"
-            end
+          def render_in(context, &view_code)
+            context.instance_eval(&view_code)
           end
-
-          private
-
-            def _control_flow
-              @control_flow
-            end
-
         end
 
-        module InstanceMethods
-
-          def compile
-            if _provides_logic?
-              "#{self.class.to_s}.render(self)"
-            else
-              lookup :markup
-            end
-          end
-
-          private
-
-            def _provides_logic?
-              !!self.class.send(:_control_flow)
-            end
-
-        end
       end
     end
   end

data/lib/express_templates/components/capabilities/templating.rb

@@ -51,11 +51,13 @@ module ExpressTemplates
           # 
           def emits(*args, &template_code)
             if args.first.respond_to?(:call) or template_code
-              _store :markup, _compile_fragment(args.first||template_code) # default fragment is named :markup
+              fragment = (args.first||template_code)
+              raise "must use stabby lambda" unless fragment.lambda?
+              _store :markup, fragment# default fragment is named :markup
             else
               args.first.to_a.each do |name, block|
                 raise ArgumentError unless name.is_a?(Symbol) and block.is_a?(Proc)
-                _store(name, _compile_fragment(block))
+                _store(name, block)
               end
             end
           end
@@ -116,26 +118,9 @@ module ExpressTemplates
             # Returns a string containing ruby code which evaluates to markup.
             def _lookup(name, options = {})
               @fragments ||= Hash.new
-              fragment = @fragments[name] or raise "no template fragment supplied for: #{name}"
-              if fragment.kind_of?(Proc)
-                _compile_fragment(fragment, options)
-              else
-                fragment
-              end
+              @fragments[name] or binding.pry #raise "no template fragment supplied for: #{name}"
             end
 
-            # Expands and compiles the supplied block representing a
-            # template fragment.
-            #
-            # Any supplied options are passed as locals for use during expansion.
-            #
-            # Returns a string containing ruby code which evaluates to markup.
-            def _compile_fragment(block, options = {})
-              expander = ExpressTemplates::Expander.new(nil, special_handlers, options)
-              expander.expand(&block).map(&:compile).join("+")
-            end
-
-
           private
 
 
@@ -183,10 +168,27 @@ module ExpressTemplates
 
         module InstanceMethods
 
-          def lookup(fragment_name)
-            self.class[fragment_name]
+          def lookup(fragment_name, options={})
+            fragment = self.class[fragment_name]
+            if fragment.kind_of?(Proc)
+              _compile_fragment(fragment, options)
+            else
+              fragment
+            end
           end
 
+          # Expands and compiles the supplied block representing a
+          # template fragment.
+          #
+          # Any supplied options are passed as locals for use during expansion.
+          #
+          # Returns a string containing ruby code which evaluates to markup.
+          def _compile_fragment(block, options = {})
+            initialize_expander(nil, self.class.special_handlers, options)
+            expand(&block).map(&:compile).join("+").gsub('"+"', '')
+          end
+
+
         end
 
 

data/lib/express_templates/components/capabilities/wrapping.rb

@@ -30,6 +30,13 @@ module ExpressTemplates
         def self.included(base)
           base.class_eval do
             extend ClassMethods
+            include InstanceMethods
+          end
+        end
+
+        module InstanceMethods
+          def compile
+            lookup :markup
           end
         end
 
@@ -37,19 +44,24 @@ module ExpressTemplates
 
           # Enclose whatever the component would already generate
           # inside the specified fragment wherever we encounter _yield
-          #
-          # Note: this must come after any statements that affect the logic
-          # flow.
-          def wrap_with(fragment, dont_wrap_if: -> {false} )
+          def wrap_with(fragment, dont_wrap_if: false )
             wrapper_name(fragment)
-            prior_logic = @control_flow
-            using_logic do |component|
-              if instance_exec(&dont_wrap_if)
-                eval(component.render((self||Object.new), &prior_logic))
-              else
-                component._wrap_it(self, &prior_logic)
-              end
+            wrapper_src = _lookup(fragment).source
+            inner_src = _lookup(:markup).source_body
+            wrapped_src = wrapper_src.gsub!(/\W_yield\W/, inner_src)
+
+            fragment_src = if dont_wrap_if
+              %Q(-> {
+  unless_block(Proc.from_source(#{dont_wrap_if.source.inspect}), alt: Proc.from_source(%q(-> {#{inner_src}}))) {
+    #{Proc.from_source(wrapped_src).source_body}
+  }
+})
+            else
+              wrapped_src
             end
+
+            _store :markup, Proc.from_source(fragment_src)
+
           end
 
           def wrapper_name(name = nil)
@@ -60,34 +72,6 @@ module ExpressTemplates
             end
           end
 
-          # added back in for compatability with prior interface
-          # should probably be refactored away
-          def _wrap_using(fragment, context=nil, options={}, &to_be_wrapped)
-            old_wrapper_name = @wrapper_name
-            @wrapper_name = fragment
-            result = _wrap_it(context, options, &to_be_wrapped)
-            @wrapper_name = old_wrapper_name
-            return result
-          end
-
-          def _wrap_it(context=nil, options={}, &to_be_wrapped)
-            body = ''
-            if to_be_wrapped
-              body = render((context||Object.new), &to_be_wrapped)
-            end
-            if compiled_src = _lookup(wrapper_name, options)
-              if context.nil?
-                eval(compiled_src).gsub(/\{\{_yield\}\}/, body)
-              else
-                ctx = context.instance_eval("binding")
-                ctx.local_variable_set(:_yield, body)
-                ctx.eval(compiled_src)
-              end
-            else
-              raise "No wrapper fragment provided for '#{wrapper_name}'"
-            end
-          end
-
           def _yield(*args)
             "{{_yield}}"
           end

data/lib/express_templates/components/column.rb

@@ -3,7 +3,7 @@ module ExpressTemplates
     class Column < Container
       include Capabilities::Configurable
 
-      emits {
+      emits -> {
         div.column(my[:id]) {
           _yield
         }

data/lib/express_templates/components/for_each.rb

@@ -0,0 +1,28 @@
+module ExpressTemplates
+  module Components
+    class ForEach < Components::Container
+      attr :collection, :member
+
+      def initialize(*args)
+        iterator = args.shift
+        options = args.first.kind_of?(Hash) ? args.shift : {}
+        expander = args.shift
+        @collection, @member = nil, (options[:as]||"item")
+        if iterator.kind_of?(Symbol)
+          @collection = iterator.to_s
+          @member = collection.sub(/^@/, '').singularize
+        elsif iterator.kind_of?(Proc)
+          @collection = "(#{iterator.source}.call)"
+        elsif iterator.kind_of?(String)
+          @collection = "(#{iterator}.call)"
+        else
+          raise "ForEach unknown iterator: #{iterator}"
+        end
+      end
+
+      def compile
+        %Q((#{@collection}.each_with_index.map do |#{@member}, #{@member}_index|#{compile_children}\nend).join)
+      end
+    end
+  end
+end

data/lib/express_templates/components/form_for.rb

@@ -0,0 +1,19 @@
+module ExpressTemplates
+  module Components
+    #
+    # Create an html <tt>form</tt> for a model object.
+    #
+    # Example:
+    #
+    # ```ruby
+    # form_for(:people) do |t|
+    #   t.text_field  :name
+    #   t.email_field :email
+    #   t.phone_field :phone
+    # end
+    # ```
+    #
+    class FormFor < Container
+    end
+  end
+end

data/lib/express_templates/components/form_rails_support.rb

@@ -7,7 +7,7 @@ module ExpressTemplates
     # An optional method may be speficied.  Defaults to 'post'.
     class FormRailsSupport < Base
       include Capabilities::Configurable
-      emits {
+      emits -> {
         div(style: 'display:none') {
           utf8_enforcer_tag
           method_tag(my[:id] || :post)

data/lib/express_templates/components/null_wrap.rb

@@ -0,0 +1,9 @@
+module ExpressTemplates
+  module Components
+    class NullWrap < Components::Container
+      def compile
+        compile_children
+      end
+    end
+  end
+end

data/lib/express_templates/components/row.rb

@@ -18,7 +18,7 @@ module ExpressTemplates
     class Row < Container
       include Capabilities::Configurable
 
-      emits {
+      emits -> {
         div.row(my[:id]) {
           _yield
         }