cadenza 0.7.2 → 0.8.0

data/lib/cadenza/source_renderer.rb

@@ -0,0 +1,225 @@
+
+module Cadenza
+
+   # SourceRenderer is a rendering implementation that turns a Cadenza AST back
+   # into Cadenza source code.
+   #
+   # This is mainly intended for users who wish to migrate templates stored in
+   # databases, or other storage devices, as their product progresses.  
+   #
+   # For example: if in v1.0 of your app you define a filter X and deprecate it 
+   # in favour of filter Y you can use this renderer to automatically replace 
+   # instances of filter X with filter Y
+   #
+   # I'm sure there are many other exciting use cases for the imaginitive user,
+   # feel free to let me know what else you do with it!
+   #
+   class SourceRenderer < BaseRenderer
+      # This exception is raised when you try to transition to an undefined state
+      IllegalStateError = Class.new(RuntimeError)
+
+      # This exception is raised when you try to transition from one state to
+      # another which is not allowed
+      IllegalStateTransitionError = Class.new(RuntimeError)
+
+      # A list of all valid states for the renderer
+      ValidStates = [:text, :var, :tag]
+
+      # returns the current state of the renderer (see {#ValidStates})
+      attr_reader :state
+
+      # Renders the document given with the given context directly to a string 
+      # returns.
+      # @param [DocumentNode] document_node the root of the AST you want to render.
+      # @param [Context] context the context object to render the document with
+      def self.render(document_node, context={})
+         io = StringIO.new
+         new(io).render(document_node, context)
+         io.string
+      end
+
+      # creates a new {SourceRenderer} and places it into the :text state
+      def initialize(*args)
+         @state = :text
+         super
+      end
+
+      # transitions from the current state into the new state and emits opening
+      # and closing tag markers appropriately during the transition.
+      #
+      # @raise [IllegalStateError] if you try to transition to an invalid state
+      # @raise [IllegalStateTransitionError] if you try to transition from one
+      #        one state to another which is not allowed
+      def state=(new_state)
+         # if trying to transition to a new state raise an exception
+         raise IllegalStateError.new(new_state) unless ValidStates.include?(new_state)
+
+         # no special transition for the same state
+         return if @state == new_state
+
+         # handle any actions that occur on that state transition
+         case @state
+            when :text
+               output << "{{ " if new_state == :var
+               output << "{% " if new_state == :tag
+            when :var
+               output << " }}" if new_state == :text
+               raise IllegalStateTransitionError if new_state == :tag
+            when :tag
+               output << " %}" if new_state == :text
+               raise IllegalStateTransitionError if new_state == :var
+         end
+
+         # update to the new state
+         @state = new_state
+      end
+
+   private
+      def render_document(node, context, blocks)
+         output << %Q[{% extends "#{node.extends}" %}] if node.extends
+
+         node.children.each {|child| render(child, context, blocks) }
+
+         self.state = :text
+      end
+
+      def render_text(node, context, blocks)
+         self.state = :text
+         output << node.text
+      end
+
+      def render_constant(node, context, blocks)
+         self.state = :var unless self.state == :tag
+         if node.value.is_a?(String)
+            output << node.value.inspect
+         else
+            output << node.value
+         end
+      end
+
+      def render_variable(node, context, blocks)
+         self.state = :var unless self.state == :tag
+         
+         output << node.identifier 
+         
+         node.parameters.each_with_index do |param_node, i|
+            output << " "
+            render(param_node, context, blocks)
+            output << "," if i < node.parameters.length - 1
+         end
+      end
+
+      def render_filtered_value(node, context, blocks)
+         self.state == :var unless self.state == :tag
+
+         render(node.value, context, blocks)
+
+         node.filters.each do |filter|
+            output << " | #{filter.identifier}"
+
+            output << ": " if filter.parameters.any?
+
+            filter.parameters.each_with_index do |param, i|
+               render(param, context, blocks)
+
+               output << ", " if i < filter.parameters.length - 1
+            end
+         end
+      end
+
+      def render_operation(node, context, blocks)
+         self.state = :var unless self.state == :tag
+
+         # calculate the operator precedence of the left, right and parent node
+         node_precedence  = calculate_precedence(node)
+         left_precedence  = calculate_precedence(node.left)
+         right_precedence = calculate_precedence(node.right)
+
+         need_left_brackets = left_precedence < node_precedence
+         need_right_brackets = right_precedence <= node_precedence && !(node.right.is_a?(OperationNode) && node.right.operator == node.operator) 
+
+         # render the left node, wrapping in brackets if it is lower precedence
+         output << "(" if need_left_brackets
+         render(node.left, context, blocks)
+         output << ")" if need_left_brackets
+   
+         # render the parent node's operator
+         output << " #{node.operator} "
+
+         # render the right node, wrapping it brackets if it is lower precedences
+         output << "(" if need_right_brackets
+         render(node.right, context, blocks)
+         output << ")" if need_right_brackets
+      end
+
+      def render_if(node, context, blocks)
+         self.state = :tag
+
+         output << "if "
+
+         render(node.expression, context, blocks)
+
+         self.state = :text
+
+         node.true_children.each {|n| render(n, context, blocks) }
+
+         output << "{% endif %}"
+      end
+
+      def render_for(node, context, blocks)
+         self.state = :tag
+
+         output << "for #{node.iterator.identifier} in "
+
+         render(node.iterable, context, blocks)
+
+         self.state = :text
+
+         node.children.each {|n| render(n, context, blocks) }
+
+         output << "{% endfor %}"
+      end
+
+      def render_block(node, context, blocks)
+         self.state = :tag
+
+         output << "block #{node.name}"
+
+         self.state = :text
+
+         node.children.each {|n| render(n, context, blocks) }
+
+         output << "{% endblock %}"
+      end
+
+      def render_generic_block(node, context, blocks)
+         self.state = :tag
+
+         output << node.identifier
+
+         output << " " if node.parameters.any?
+
+         node.parameters.each_with_index do |param, i|
+            render(param, context, blocks)
+
+            output << ", " if i < node.parameters.length - 1
+         end
+
+         self.state = :text
+
+         node.children.each {|n| render(n, context, blocks) }
+
+         output << "{% end %}"
+      end
+
+      def calculate_precedence(node)
+         return 4 unless node.is_a?(OperationNode)
+
+         case node.operator
+            when '+', '-' then 2
+            when '*', '/' then 3
+            else 1
+         end
+      end
+   end
+end

data/lib/cadenza/text_renderer.rb

@@ -16,19 +16,23 @@ module Cadenza
          io.string
       end
 
+      def render(node, context, blocks={})
+         passed_blocks = blocks.is_a?(BlockHierarchy) ? blocks : BlockHierarchy.new(blocks)
+
+         super(node, context, passed_blocks)
+      end
+
    private
    
       def render_document(node, context, blocks)
          if node.extends
             # merge the inherited blocks onto this document's blocks to
             # determine what to pass to the layout template
-            blocks = node.blocks.merge(blocks)
+            blocks.merge(node.blocks)
 
             # load the template of the document and render it to the same output stream
             template = context.load_template!(node.extends)
 
-            document = template
-
             render(template, context, blocks)
          else
             node.children.each {|x| render(x, context, blocks) }
@@ -36,17 +40,29 @@ module Cadenza
       end
 
       def render_block(node, context, blocks)
-         (blocks[node.name] || node).children.each {|x| render(x, context, blocks) }
+         # create the full inheritance chain with this node on top, making sure
+         # not to mutate the block hierarchy's internals
+         chain = blocks[node.name].dup << node
+         
+         super_fn = lambda do |params|
+            parent_node = chain.shift
+
+            parent_node.children.each {|x| render(x, context, blocks) } if parent_node
+
+            nil
+         end
+
+         context.push('super' => super_fn)
+
+         chain.shift.children.each {|x| render(x, context, blocks) }
+
+         context.pop
       end
 
       def render_text(node, context, blocks)
          output << node.text
       end
 
-      def render_inject(node, context, blocks)
-         output << node.evaluate(context).to_s
-      end
-
       def render_if(node, context, blocks)
          node.evaluate_expression_for_children(context).each {|x| render(x, context, blocks) }
       end
@@ -86,8 +102,6 @@ module Cadenza
          output << context.evaluate_block(node.identifier, node.children, node.parameters)
       end
 
-      # none of these should appear directly inside the body of the 
-      # document but for safety we will render them anyways
       def render_constant(node, context, blocks)
          output << node.eval(context).to_s
       end
@@ -95,6 +109,7 @@ module Cadenza
       alias :render_variable        :render_constant
       alias :render_operation       :render_constant
       alias :render_boolean_inverse :render_constant
+      alias :render_filtered_value  :render_constant
 
    end
 end

data/lib/cadenza/version.rb

@@ -2,8 +2,8 @@
 module Cadenza
   module Version
      MAJOR = 0
-     MINOR = 7
-     PATCH = 2
+     MINOR = 8
+     PATCH = 0
      BUILD = nil
     
      STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cadenza
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-29 00:00:00.000000000 Z
+date: 2012-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -152,6 +152,12 @@ files:
 - lib/cadenza/filesystem_loader.rb
 - lib/cadenza/cli.rb
 - lib/cadenza/blocks/standard_blocks.rb
+- lib/cadenza/context/blocks.rb
+- lib/cadenza/context/loaders.rb
+- lib/cadenza/context/functional_variables.rb
+- lib/cadenza/context/stack.rb
+- lib/cadenza/context/filters.rb
+- lib/cadenza/block_hierarchy.rb
 - lib/cadenza/context_object.rb
 - lib/cadenza/filters/standard_filters.rb
 - lib/cadenza/error.rb
@@ -161,8 +167,8 @@ files:
 - lib/cadenza/nodes/for_node.rb
 - lib/cadenza/nodes/if_node.rb
 - lib/cadenza/nodes/generic_block_node.rb
-- lib/cadenza/nodes/inject_node.rb
 - lib/cadenza/nodes/variable_node.rb
+- lib/cadenza/nodes/filtered_value_node.rb
 - lib/cadenza/nodes/constant_node.rb
 - lib/cadenza/nodes/block_node.rb
 - lib/cadenza/nodes/boolean_inverse_node.rb
@@ -171,6 +177,7 @@ files:
 - lib/cadenza/version.rb
 - lib/cadenza/text_renderer.rb
 - lib/cadenza/cli/options.rb
+- lib/cadenza/source_renderer.rb
 - lib/cadenza/parser.rb
 - lib/cadenza/base_renderer.rb
 - lib/cadenza/token.rb

data/lib/cadenza/nodes/inject_node.rb

@@ -1,57 +0,0 @@
-module Cadenza
-  # The {InjectNode} is intended to write the given variable into the rendered
-  # output by evaluating it in the given {Context} and passing it through an
-  # optional series of {FilterNode}s.
-  class InjectNode
-    # @return [VariableNode|OperationNode|BooleanInverseNode|ConstantNode] the value being evaluated
-    attr_accessor :value
-
-    # @return [Array] a list of {FilterNode} to evaluate the value with, once the
-    #                 value has itself been evaluated.
-    attr_accessor :filters
-
-    # @return [Array] a list of Node objects passed to the {#value} for use in a
-    #         functional variable.  See {Context#define_functional_variable}.
-    attr_accessor :parameters
-    
-    # creates a new {InjectNode} with the given value, filters and parameters
-    # @param [VariableNode|OperationNode|BooleanInverseNode|ConstantNode] value see {#value}
-    # @param [Array] filters see {#filters}
-    # @param [Array] parameters see {#parameters}
-    def initialize(value, filters=[], parameters=[])
-      @value = value
-      @filters = filters
-      @parameters = parameters
-    end
-
-    # @param [InjectNode] rhs
-    # @return [Boolean] true if the given InjectNode is equivalent by value to this node.
-    def ==(rhs)
-      self.value == rhs.value and
-      self.filters == rhs.filters and
-      self.parameters == rhs.parameters
-    end
-
-    # @return [Array] a list of variable names implied to be global by this node
-    def implied_globals
-      (@value.implied_globals + @filters.map(&:implied_globals).flatten).uniq
-    end
-
-    # @param [Context] context
-    # @return [String] returns the evaluated {#value} of this node in the given 
-    #         {Context} with any applicable {#parameters} after passed through 
-    #         the given {#filters}.
-    def evaluate(context)
-      value = @value.eval(context)
-
-      if value.is_a? Proc
-        args = parameters.map {|p| p.eval(context) }
-        value = value.call(context, *args)
-      end
-
-      @filters.each {|filter| value = filter.evaluate(context, value) }
-
-      value
-    end
-  end
-end