opulent 1.5.5 → 1.6.0

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

@@ -1,42 +0,0 @@
-# @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

@@ -1,41 +0,0 @@
-# @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

@@ -1,28 +0,0 @@
-# @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

@@ -1,70 +0,0 @@
-# @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

data/.libold/opulent/nodes/helper.rb

@@ -1,69 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @NodeFactory
-    class Helper
-      def root
-        Root.new
-      end
-
-      def node(name = '', atts = {}, parent = nil, indent = 0, children = [])
-        Node.new name, atts, parent, indent, children
-      end
-
-      def block_yield(name = '', parent = nil, indent = 0, children = [])
-        Yield.new name, {}, parent, indent, children
-      end
-
-      def block(name = '', parent = nil, indent = 0, children = [])
-        Block.new name, {}, parent, indent, children
-      end
-
-      def theme(name = '', parent = nil, indent = 0, children = [])
-        Theme.new name, parent, indent, children
-      end
-
-      def filter(name = '', atts = {}, parent = nil, indent = 0, value = '')
-        Filter.new name, atts, parent, indent, value
-      end
-
-      def evaluate(value, parent = nil, indent = 0, children = [])
-        Evaluate.new value, parent, indent, children
-      end
-
-      def control(name, value = '', parent = nil, indent = 0, children = [[]])
-        case name
-        when :if, :unless
-          CnditionalControl.new name, value, parent, indent, children
-        when :case
-          CaseControl.new name, value, parent, indent, children.first
-        when :while, :until
-          LoopControl.new name, value, parent, indent, children.first
-        when :each
-          EachControl.new name, value, parent, indent, children.first
-        end
-      end
-
-      def expression(value = [])
-        Expression.new value
-      end
-
-      def definition(name, params = [], parent = nil, indent = 0)
-        Define.new name, params, parent, indent
-      end
-
-      def text(value = nil, escaped = true, parent = nil, indent = 0)
-        Text.new value, escaped, parent, indent
-      end
-
-      def print(value = nil, escaped = true, parent = nil, indent = 0)
-        Print.new value, escaped, parent, indent
-      end
-
-      def comment(value = nil, parent = nil, indent = 0)
-        Comment.new value, parent, indent
-      end
-    end
-  end
-end

data/.libold/opulent/nodes/node.rb

@@ -1,101 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @Node
-    #
-    # Node class used to describe a HTML Element used for building a
-    # page model during the parsing process
-    #
-    class Node
-      # Allow direct access to node variables
-      attr_accessor :name, :attributes, :children, :whitespace, :parent, :indent, :extension, :theme, :blocks, :yields, :self_enclosing
-
-      # 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 children [Array] collection of the node's child elements
-      #
-      def initialize(name = '', attributes = {}, parent = nil, indent = 0, children = [])
-        @name = name
-        @parent = parent
-        @indent = indent
-        @attributes = attributes
-        @children = children
-        @extension = nil
-        @theme = Engine::DEFAULT_THEME
-        @self_enclosing = Engine::SELF_ENCLOSING.include? name
-        @whitespace = [nil, nil]
-        @blocks = {
-          Engine::DEFAULT_YIELD => @children
-        }
-        @yields = []
-      end
-
-      # Add a new node to the nodes array
-      #
-      def push(node)
-        @children << node
-        self
-      end
-
-      # Return extended attributes if an extension was set using the [extend]
-      # identifier of the node
-      #
-      def extend_attributes(attributes, extension)
-        return attributes if extension.nil?
-
-        extension.each do |key, value|
-          case attributes[key]
-          when Array
-            attributes[key] = (attributes[key] << value).flatten
-          when Hash
-            attributes[key] = value.merge attributes[key]
-          when nil
-            attributes[key] = value
-          end
-        end
-
-        attributes
-      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, @extension, context
-
-        # Evaluate all provided blocks
-        blocks = Hash[@blocks.map{ |key, value|
-          children = value.map do |child|
-            child.evaluate context
-          end.flatten.compact
-
-          [key, children]
-        }]
-
-        # Map self to a different node and set evaluated children nodes and
-        # evaluated attributes and add a pointer to the children block
-        mapped_node = self.dup
-        mapped_node.attributes = attributes
-        mapped_node.blocks = blocks
-        mapped_node.children = mapped_node.blocks[Engine::DEFAULT_YIELD]
-
-        # Replace node with its definition if it has one
-        if Runtime[@theme]
-          if Runtime[@theme][@name] && @name != context.name
-            return Runtime.define mapped_node, attributes, context
-          else
-            return mapped_node
-          end
-        else
-          # Theme does not exist
-          Runtime.error :theme, @theme
-        end
-      end
-    end
-  end
-end

data/.libold/opulent/nodes/root.rb

@@ -1,62 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @Root
-    #
-    # HTML Root from which the construction of the final page starts. The root
-    # stores all the node definitions that will be replaced in the components.
-    #
-    class Root
-      # Allow direct access to node variables
-      attr_accessor :themes, :children, :indent, :blocks, :yields
-
-      # Initialize node instance variables
-      #
-      # @param definitions [Hash] node definitions to be replaced in children
-      # @param children [Array] collection of the node's child elements
-      #
-      def initialize
-        @themes = {
-          Engine::DEFAULT_THEME => {}
-        }
-        @children = []
-        @blocks = {}
-        @yields = {}
-        @indent = -1
-      end
-
-      # Add a new node to the nodes array
-      #
-      # @param node [Node] Node to be added to the parent
-      #
-      def push(node)
-        @children << node
-        self
-      end
-
-      # Shorthand theme access for root definitions
-      #
-      # @param key [Symbol] definition or theme name
-      #
-      def [](key)
-        if @themes.has_key? key
-          @themes[key]
-        else
-          @themes[Engine::DEFAULT_THEME][key]
-        end
-      end
-
-      # Evaluate all child nodes using the given context and the
-      # node definitions from the root knowledgebase
-      #
-      # @param context [Context] Call environment binding object
-      #
-      def evaluate(context)
-        @children.map do |node|
-          node.evaluate(context)
-        end.flatten.compact
-      end
-    end
-  end
-end

data/.libold/opulent/nodes/text.rb

@@ -1,54 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @Text
-    #
-    # The text class will output raw or escaped HTML text
-    #
-    class Text
-      # Allow direct access to literal value and type
-      attr_accessor :value, :escaped, :parent, :indent, :name
-
-      # Initialize literal instance variables
-      #
-      # @param value stores the literal's explicit value
-      #
-      def initialize(value = nil, escaped = true, parent = nil, indent = 0)
-        @value = value
-        @escaped = escaped
-        @parent = parent
-        @indent = indent
-        @name = :text
-      end
-
-      # Value evaluation method which returns the processed value of the
-      # literal
-      #
-      def evaluate(context)
-        value = context.evaluate "\"#{@value}\""
-
-        evaluated_text = self.dup
-        evaluated_text.value = @escaped ? Runtime.escape(value) : value
-        return evaluated_text
-      end
-    end
-
-    # @Print
-    #
-    # The print class will evaluate the ruby code and return a new text
-    # node containing the escaped or unescaped eval sequence
-    #
-    class Print < Text
-      # Value evaluation method which returns the processed value of the literal
-      #
-      def evaluate(context)
-        value = context.evaluate @value
-
-        evaluated_text = self.dup
-        evaluated_text.value = @escaped ? Runtime.escape(value) : value
-        return evaluated_text
-      end
-    end
-  end
-end