opulent 0.0.9 → 1.0.2

data/.libold/opulent/nodes.rb

@@ -0,0 +1,13 @@
+# Include Opulent nodes which know how to evaluate themselves
+require_relative 'nodes/helper'
+require_relative 'nodes/root'
+require_relative 'nodes/node'
+require_relative 'nodes/define'
+require_relative 'nodes/eval'
+require_relative 'nodes/expression'
+require_relative 'nodes/text'
+require_relative 'nodes/filter'
+require_relative 'nodes/control'
+require_relative 'nodes/theme'
+require_relative 'nodes/block'
+require_relative 'nodes/comment'

data/.libold/opulent/nodes/block.rb

@@ -0,0 +1,29 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Yield
+    #
+    class Yield < Node
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        self
+      end
+    end
+
+    # @Block
+    #
+    class Block < Node
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        @children.map do |child|
+          child.evaluate context
+        end.flatten.compact
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/comment.rb

@@ -0,0 +1,35 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Text
+    #
+    # The text class will output raw or escaped HTML text
+    #
+    class Comment
+      # Allow direct access to literal value and type
+      attr_accessor :value, :visible, :parent, :indent, :name
+
+      # Initialize literal instance variables
+      #
+      # @param value stores the literal's explicit value
+      #
+      def initialize(value = nil, parent = nil, indent = 0)
+        @value = value
+        @parent = parent
+        @indent = indent
+        @name = :comment
+      end
+
+      # Value evaluation method which returns the processed value of the
+      # literal
+      #
+      def evaluate(context)
+        comment = self.dup
+        comment.value = context.evaluate "\"#{@value}\""
+        
+        return comment
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/control.rb

@@ -0,0 +1,230 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @CnditionalControl
+    #
+    # Control structure for if-elsif-else and unless
+    #
+    class CnditionalControl
+      attr_accessor :name, :value, :parent, :indent, :children
+
+      # Ruby code evaluation node
+      #
+      # @param name [String] name of the html node
+      # @param value [String] condition to be met
+      # @param parent [Node] parent of the element
+      # @param indent [Fixnum] node indentation for restructuring
+      # @param children [Array] contents to be interpreted
+      #
+      def initialize(name = '', value = '', parent = nil, indent = 0, children = [[]])
+        @name = name
+        @value = [value]
+        @parent = parent
+        @indent = indent
+        @children = children
+      end
+
+      # Add a new node to the nodes array
+      #
+      def push(node)
+        @children[-1] << node
+        self
+      end
+
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        index = @value.index do |value|
+          value.empty? || context.evaluate(value)
+        end
+
+        if index
+          @children[index].map do |child|
+            child.evaluate context
+          end
+        end
+      end
+    end
+
+    # @IfControl
+    #
+    # Control structure for if-elsif-else directive
+    #
+    class CaseControl
+      attr_accessor :name, :case, :value, :parent, :indent, :children
+
+      # Ruby code evaluation node
+      #
+      # @param name [String] name of the html node
+      # @param value [String] condition to be met
+      # @param parent [Node] parent of the element
+      # @param indent [Fixnum] node indentation for restructuring
+      # @param children [Array] contents to be interpreted
+      #
+      def initialize(name = '', switch_case = '', parent = nil, indent = 0, children = [[]])
+        @name = name
+        @case = switch_case
+        @value = []
+        @parent = parent
+        @indent = indent
+        @children = children
+      end
+
+      # Add a new node to the nodes array
+      #
+      def push(node)
+        @children[-1] << node
+        self
+      end
+
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        switch_case = context.evaluate @case
+        index = @value.index do |value|
+          value.empty? || switch_case == context.evaluate(value)
+        end
+
+        if index
+          @children[index].map do |child|
+            child.evaluate context
+          end.flatten.compact
+        end
+      end
+    end
+
+    # @LoopControl
+    #
+    # Control structure for while and until directives
+    #
+    class LoopControl
+      attr_accessor :name, :value, :parent, :indent, :children
+
+      # Ruby code evaluation node
+      #
+      # @param name [String] name of the html node
+      # @param value [String] condition to be met
+      # @param parent [Node] parent of the element
+      # @param indent [Fixnum] node indentation for restructuring
+      # @param children [Array] contents to be interpreted
+      #
+      def initialize(name = '', value = '', parent = nil, indent = 0, children = [])
+        @name = name
+        @value = value
+        @parent = parent
+        @indent = indent
+        @children = children
+      end
+
+      # Add a new node to the nodes array
+      #
+      def push(node)
+        @children << node
+        self
+      end
+
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        result = []
+
+        evaluate_children = Proc.new do |context|
+          result << @children.map do |child|
+            child.evaluate context
+          end.flatten
+        end
+
+        case @name
+        when :while
+          while context.evaluate @value
+            evaluate_children[context]
+          end
+        when :until
+          until context.evaluate @value
+            evaluate_children[context]
+          end
+        end
+
+        return result.flatten.compact
+      end
+    end
+
+    # @EachControl
+    #
+    # Control structure for while and until directives
+    #
+    class EachControl < LoopControl
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        result = []
+
+        # Process named variables for each structure
+        variables = @value[0].clone
+
+        # The each structure accept missing arguments as well, therefore we need to
+        # substitute them with our defaults
+        #
+        # each in iterable
+        # each value in iterable
+        # each key, value in iterable
+
+        # Value argument name provided only
+        if variables.length == 1
+          variables.unshift Engine[:each][:default_key]
+
+        # Missing key and value arguments
+        elsif variables.empty?
+          variables[0] = Engine[:each][:default_key]
+          variables[1] = Engine[:each][:default_value]
+        end
+
+        # Evaluate in current context and add to results
+        evaluate_children = Proc.new do |key, value, context|
+          # Update the local variables in the each context with the values from the
+          # current loop iteration
+          locals = {
+            variables[0] => key,
+            variables[1] => value
+          }
+          context.extend_context locals
+
+          # Add the mapped child elements
+          result << @children.map do |child|
+            child.evaluate context
+          end.flatten
+        end
+
+        # Create a new context based on the parent context and progressively update
+        # variables in the new context
+        each_context = Context.new({}, context.binding.clone)
+
+        # Evaluate the iterable object
+        enumerable = each_context.evaluate(@value[1])
+
+        # Check if input can be iterated
+        Runtime.error :enumerable, @value[1] unless enumerable.respond_to? :each
+
+        # Selectively iterate through the input and add the result using the previously
+        # defined proc object
+        case enumerable
+        when Hash
+          enumerable.each do |key, value|
+            evaluate_children[key, value, context]
+          end
+        else
+          enumerable.each_with_index do |value, key|
+            evaluate_children[key, value, context]
+          end
+        end
+
+        return result.flatten.compact
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/define.rb

@@ -0,0 +1,42 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Define
+    #
+    # Define a custom HTML element
+    #
+    class Define < Node
+      # Node evaluation method which goes through all the child nodes and
+      # evaluates them using their own eval method
+      #
+      def evaluate(context, blocks = {})
+        yields = @yields.clone
+
+        @children.map do |child|
+          evaluated_child = child.evaluate context
+
+          # Check to see if the child element being mapped is one of the yield
+          # node parent pointers
+          if yields.include? child
+            yields.delete child
+
+            # We need to replace the yield nodes with the matching named block
+            # in order to map the yield node correctly
+            evaluated_child.children.map! do |subchild|
+              if subchild.is_a?(Yield) && blocks[subchild.name]
+                blocks[subchild.name]
+              else
+                subchild
+              end
+            end
+            evaluated_child.children.compact!
+            evaluated_child.children.flatten!
+          end
+
+          evaluated_child
+        end
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/eval.rb

@@ -0,0 +1,41 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Evaluate
+    #
+    # The eval node evaluates ruby code in the given context without printing
+    # any output in the page
+    #
+    class Evaluate
+      attr_accessor :value, :parent, :indent, :children, :name
+
+      # Ruby code evaluation node
+      #
+      # @param name [String] name of the html node
+      # @param parent [Node] parent of the element
+      # @param indent [Fixnum] node indentation for restructuring
+      # @param children [Array] contents to be interpreted
+      #
+      def initialize(value = '', parent = nil, indent = 0, children = [])
+        @name = :eval
+        @value = value
+        @parent = parent
+        @indent = indent
+        @children = children
+      end
+
+      # Add a new node to the nodes array
+      #
+      def push(node)
+        @children << node
+        self
+      end
+
+      def evaluate(context)
+        context.evaluate @value
+        return nil
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/expression.rb

@@ -0,0 +1,28 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Expression
+    #
+    # Literals are static values that have a Ruby representation, eg.: a string, a number,
+    # true, false, nil, etc.
+    #
+    class Expression
+      attr_accessor :value, :escaped
+
+      def initialize(value = '')
+        @value = value
+        @escaped = true
+      end
+
+      def to_s
+        @value
+      end
+
+      def evaluate(context)
+        evaluated = context.evaluate @value
+        @escaped ? Runtime.escape(evaluated) : evaluated
+      end
+    end
+  end
+end

data/.libold/opulent/nodes/filter.rb

@@ -0,0 +1,70 @@
+# @Opulent
+module Opulent
+  # @Nodes
+  module Nodes
+    # @Filter
+    #
+    # Node class used to run a value interpretation
+    #
+    class Filter
+      # Allow direct access to node variables
+      attr_accessor :name, :attributes, :value, :parent, :indent
+
+      # Initialize node instance variables
+      #
+      # @param name [String] name of the html node
+      # @param indentation [Fixnum] node indentation for restructuring
+      # @param attributes [Hash] stores key="value" attributes
+      # @param value [String] Contents to be interpreted
+      #
+      def initialize(name = '', attributes = {}, parent = nil, indent = 0, value = '')
+        @name = name
+        @parent = parent
+        @indent = indent
+        @attributes = attributes
+        @value = value
+      end
+
+      # Update attributes with values from current evaluation context
+      #
+      def get_attributes(context)
+        Hash[@attributes.map{ |key, val|
+          unless val.nil?
+            value = val.evaluate(context)
+            value.flatten! if value.is_a?(Array)
+          end
+          [key, value]
+        }]
+      end
+
+      # Node evaluation method which goes through all the child nodes and evaluates
+      # them using their own eval method
+      #
+      def evaluate(context)
+        # Set attributes for current context
+        attributes = Runtime.attributes @attributes, nil, context
+
+        # Check if filter is registered
+        Runtime.error :filter_registered, name unless Engine.filter? name
+
+        # Load the required filter
+        Engine.filters[name].load_filter
+
+        # Render output using the chosen engine
+        output = Engine.filters[name].render @value
+
+        # Main output node which contains filter rendered value
+        text_node = Text.new output, false, @parent, @indent
+
+        # If we have a provided filter tag, wrap the text node in the wrapper
+        # node tag and further indent
+        if (wrapper_tag = Engine.filters[name].options[:tag])
+          text_node.indent = @indent + Engine[:indent]
+          return Node.new wrapper_tag, Engine.filters[name].options[:attributes], @parent, @indent, [text_node]
+        else
+          return text_node
+        end
+      end
+    end
+  end
+end