opulent 0.0.9 → 1.0.2

data/lib/opulent/compiler/block.rb

@@ -0,0 +1,31 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def yield_node(node, indent, context)
+      if @block_stack[-1].has_key? node[@value]
+        @block_stack[-1][node[@value]].each do |child|
+          root child, indent, context.parent
+        end
+      end
+    end
+
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def block_node(node, indent, context)
+      node[@children].each do |child|
+        root child, indent, context
+      end
+    end
+  end
+end

data/lib/opulent/compiler/comment.rb

@@ -0,0 +1,22 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def comment(node, indent, context)
+      indentation = " " * indent
+
+      value = context.evaluate "\"#{node[@value]}\""
+
+      comment_tag = "#{indentation}<!-- #{value} -->\n"
+
+      @node_stack << :comment
+      @code += comment_tag
+    end
+  end
+end

data/lib/opulent/compiler/control.rb

@@ -0,0 +1,152 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a if-elsif-else control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def if_node(node, indent, context)
+      # Check if we have any condition met, or an else branch
+      index = node[@value].index do |value|
+        value.empty? || context.evaluate(value)
+      end
+
+      # If we have a branch that meets the condition, generate code for the
+      # children related to that specific branch
+      if index
+        node[@children][index].each do |child|
+          root child, indent, context
+        end
+      end
+    end
+
+    # Generate the code for a case-when-else control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def case_node(node, indent, context)
+      # Evaluate the switching condition
+      switch_case = context.evaluate node[@options][:condition]
+
+      # Check if we have any condition met, or an else branch
+      index = node[@value].index do |value|
+        value.empty? || switch_case == context.evaluate(value)
+      end
+
+      # If we have a branch that meets the condition, generate code for the
+      # children related to that specific branch
+      if index
+        node[@children][index].each do |child|
+          root child, indent, context
+        end
+      end
+    end
+
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def while_node(node, indent, context)
+      # While we have a branch that meets the condition, generate code for the
+      # children related to that specific branch
+      while context.evaluate node[@value]
+        node[@children].each do |child|
+          root child, indent, context
+        end
+      end
+    end
+
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def until_node(node, indent, context)
+      # Until we have a branch that doesn't meet the condition, generate code for the
+      # children related to that specific branch
+      until context.evaluate node[@value]
+        node[@children].each do |child|
+          root child, indent, context
+        end
+      end
+    end
+
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def each_node(node, indent, context)
+      result = []
+
+      # Process named variables for each structure
+      variables = node[@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 Settings::DefaultEachKey
+
+      # Missing key and value arguments
+      elsif variables.empty?
+        variables[0] = Settings::DefaultEachKey
+        variables[1] = Settings::DefaultEachValue
+      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_locals locals
+
+        # Add the mapped child elements
+        node[@children].each do |child|
+          root child, indent, context
+        end
+      end
+
+      # Create a new context based on the parent context and progressively update
+      # variables in the new context
+      each_context = Context.new Hash.new, context.binding.clone
+      each_context.parent = context
+
+      # Evaluate the iterable object
+      enumerable = each_context.evaluate(node[@value][1])
+
+      # Check if input can be iterated
+      error :enumerable, node[@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
+    end
+  end
+end

data/lib/opulent/compiler/define.rb

@@ -0,0 +1,88 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate code for all nodes by calling the method with their type name
+    #
+    # @param current [Array] Current node data with options
+    # @param indent [Fixnum] Indentation size for current node
+    # @param context [Context] Context holding environment variables
+    #
+    def def_node(node, indent, context)
+      # Create a new definition context
+      definition_context = Context.new
+      definition_context.extend_nonlocals context.binding
+      definition_context.name = node[@value]
+      definition_context.parent = context
+
+      # Set call node
+      call_node = node[@options][:call]
+
+      # Get call node attributes
+      attributes = call_node[@options][:attributes]
+
+      # Evaluate node extension in the current context
+      if call_node[@options][:extension]
+        extension = context.evaluate call_node[@options][:extension][@value]
+      else
+        extension = {}
+      end
+
+      # Evaluate and generate node attributes, then process each one to
+      # by generating the required attribute code
+      attributes = {}
+      call_node[@options][:attributes].each do |key, attribute|
+        attributes[key] = map_attribute key, attribute, context
+      end
+
+      # Go through each extension attribute and use the value where applicable
+      extend_attributes attributes, extension
+
+      # Definition call arguments
+      arguments = {}
+
+      # Extract values which appear as definition parameters. If we have the
+      # key passed as argument, get its value. Otherwise, set the default
+      # parameter value
+      node[@options][:parameters].each do |key, value|
+        if attributes[key]
+          arguments[key] = attributes.delete key
+        else
+          arguments[key] = definition_context.evaluate value[@value]
+        end
+      end
+
+      # Set the remaining attributes as a value in the arguments
+      arguments[:attributes] = attributes
+
+      # Add call children to the block stack, depending on whether they're
+      # block elements or child elements
+      @block_stack << { @default_yield => [] }
+
+      # If we have a direct child, add it to the default yield (children)
+      # block and allow same block multiple times by appending nodes
+      call_node[@children].each do |child|
+        if child[@type] == :block
+          @block_stack[-1][child[@value]] ||= []
+          @block_stack[-1][child[@value]] += child[@children]
+        else
+          @block_stack[-1][@default_yield] << child
+        end
+      end
+
+      # Set variable to determine available blocks
+      #
+      arguments[:blocks] = Hash[@block_stack[-1].keys.map{|key| [key, true]}]
+
+      # Create local variables from argument variables
+      definition_context.extend_locals arguments
+
+      # Evaluate the model using the new context
+      node[@children].each do |child|
+        root child, indent, definition_context
+      end
+
+      @block_stack.pop
+    end
+  end
+end

data/lib/opulent/compiler/eval.rb

@@ -0,0 +1,15 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Evaluate the embedded ruby code using the current context
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def evaluate(node, indent, context)
+      context.evaluate node[@value]
+    end
+  end
+end

data/lib/opulent/compiler/filter.rb

@@ -0,0 +1,54 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a while control structure
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def filter(node, indent, context)
+      # Evaluate and generate node attributes, then process each one to
+      # by generating the required attribute code
+      attributes = {}
+      node[@options].each do |key, attribute|
+        attributes[key] = map_attribute key, attribute, context
+      end
+
+      # Get registered filter name
+      name = node[@value]
+
+      # Check if filter is registered
+      error :filter_registered, name unless Filters.filters.has_key? name
+
+      # Load the required filter
+      Filters.filters[name].load_filter
+
+      # Render output using the chosen engine
+      output = Filters.filters[name].render node[@children]
+
+      # Main output node which contains filter rendered value
+      text_node = [:plain, :text, {value: output.rstrip, escaped: false, evaluate: false}, [], nil]
+
+      # If we have a provided filter tag, wrap the text node in the wrapper
+      # node tag and further indent
+      if (wrapper_tag = Filters.filters[name].options[:tag])
+        # Set wrapper tag attributes as evaluable expressions
+        atts = {}
+        Filters.filters[name].options[:attributes].each do |key, value|
+          atts[key] = [:expression, value.inspect, {evaluate: false, escaped: false}]
+        end
+
+        # Create the wrapper node containing the output text node as a child
+        wrapper_node = [:node, wrapper_tag, {attributes: atts}, [text_node], indent]
+
+        # Begin code generation from the wrapper node
+        root wrapper_node, indent, context
+      else
+        # Generate code for output text node
+        root text_node, indent, context
+      end
+    end
+  end
+end

data/lib/opulent/compiler/node.rb

@@ -0,0 +1,232 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a standard node element, with closing tags or
+    # self enclosing elements
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def node(node, indent, context)
+      indentation = " " * indent
+
+      # Check if the current node and last node should be displayed inline
+      inline_current = @inline_node.include? node[@value]
+      inline_last = @inline_node.include? @node_stack.last
+
+      # Check if the node is a special node which can be either inline or
+      # block structure. Write the special node as inline if its children
+      # are all inline nodes
+      if @multi_node.include?(node[@value])
+        # First condition should be removed to ignore preceding node and make
+        # it be inline no matter what. Using the first check, we write it
+        # inline only if the element before it was inline
+        unless @sibling_stack.last > 1 && node[@children].all? do |child|
+          @inline_node.include?(child[@value])
+        end
+          inline_current = false
+          multi = true
+        end
+      end
+
+      # If we have an inline node, we remove the trailing newline character
+      # and write the tag code directly. Otherwise we add the tag code with
+      # normal indentation
+      if inline_last && inline_current
+        remove_trailing_newline
+      else
+        @code += indentation
+      end
+
+      # Add the tag opening, with leading whitespace to the code buffer
+      tag_open = "<#{node[@value]}"
+      @code += " " if node[@options][:leading_whitespace]
+      @code += tag_open
+
+      # Evaluate node extension in the current context
+      if node[@options][:extension]
+        extension = context.evaluate node[@options][:extension][@value]
+      else
+        extension = {}
+      end
+
+      # Evaluate and generate node attributes, then process each one to
+      # by generating the required attribute code
+      attributes = {}
+      node[@options][:attributes].each do |key, attribute|
+        attributes[key] = map_attribute key, attribute, context
+      end
+
+      # Go through each extension attribute and use the value where applicable
+      extend_attributes attributes, extension
+
+      # Join arrays, create new attributes by hash and set the
+      # value otherwise
+      attributes.each do |key, value|
+        @code += attribute_code key, value
+      end
+
+      # Set the current node as a parent for the node elements to follow
+      @node_stack << (multi ? :multi : node[@value])
+
+      # Check if the current node is self enclosing. Self enclosing nodes
+      # do not have any child elements
+      if node[@options][:self_enclosing]
+        # If the tag is self enclosing, it cannot have any child elements.
+        tag_close = ">"
+        tag_close += "\n"
+
+        @code += tag_close
+      else
+        # Set tag ending code
+        tag_end = ">"
+
+        # If the node is an inline node and doesn't have any child elements,
+        # we close it on the same line, without adding indentation
+        tag_end += "\n" unless inline_current || node[@children].empty?
+
+        # Set tag closing code
+        tag_close = "</#{node[@value]}>"
+        tag_close += " " if node[@options][:trailing_whitespace]
+        tag_close += "\n"
+
+        # Add tag ending to the buffer
+        @code += tag_end
+
+        # Get number of siblings
+        @sibling_stack << node[@children].size
+
+        # Process each child element recursively, increasing indentation
+        node[@children].each do |child|
+          root child, indent + Settings[:indent], context
+        end
+
+        # Remove the current node children count from the sibling stack
+        @sibling_stack.pop
+
+        # Remove all child nodes of the current node from the node stack
+        @node_stack.pop(node[@children].size)
+
+        # If we have an inline node, we remove the trailing newline from
+        # our buffer, otherwise add indentation
+        if inline_current
+          remove_trailing_newline
+
+        # If the node doesn't have any child elements, we close it on the same
+        # line, without adding indentation
+        elsif node[@children].any?
+          @code += indentation
+        end
+
+        # Close the current tag
+        @code += tag_close
+      end
+    end
+
+    # Map attributes by evaluating them in the current working context
+    #
+    # @param key [Symbol] Name of the attribute being processed
+    # @param attribute [Array] Attribute instance data
+    # @param context [Context] Processing environment data
+    #
+    def map_attribute(key, attribute, context)
+      # Process input value depending on its type. When array or hash, iterate
+      # and escape each string value.
+      process = Proc.new do |value|
+        case value
+        when Array
+          value.map do |v|
+            v.is_a?(String) ? escape(v) : v
+          end
+        when Hash
+          value.each do |k,v|
+            value[k] = value[k].is_a?(String) ? escape(v) : v
+          end
+        when String
+          escape value
+        else
+          value
+        end
+      end
+
+      # Process each attribute depending on whether it's an array of values,
+      # exclusive to the class attribute, or an individual attribute value
+      if key == :class
+        attribute.map do |attrib|
+          value = context.evaluate attrib[@value]
+          attrib[@options][:escaped] ? process[value] : value
+        end
+      else
+        value = context.evaluate attribute[@value]
+        attribute[@options][:escaped] ? process[value] : value
+      end
+    end
+
+    # Extend attributes using the extension directive where applicable.
+    # Concatenate arrays, merge hashes and replace otherwise
+    #
+    # @param attributes [Hash] Evaluated node attributes
+    # @param extension [Hash] Node extension input
+    #
+    def extend_attributes(attributes, extension)
+      extension.each do |key, value|
+        case attributes[key]
+        when Array
+          if key == :class
+            attributes[key] << value
+            attributes[key].flatten!
+          else
+            attributes[key] = value
+          end
+        when Hash
+          if value.is_a? Hash
+            attributes[key].merge! value
+          else
+            attributes[key] = value
+          end
+        else
+          attributes[key] = value
+        end
+      end
+    end
+
+    # Generate attribute code for the current key value pair. For string
+    # values, generate a key value pair. For false values, remove the
+    # attribute. For true values, generate a standalone attribute key
+    #
+    # @param key [Symbol] Name of the attribute being generated
+    # @param value [Object] Value of the attribute
+    #
+    def attribute_code(key, value)
+      attribute_code = ""
+
+      case value
+      when Array
+        if key == :class
+          attribute_value = value.join ' '
+        else
+          attribute_value = value.join '_'
+        end
+
+        attribute_code += " #{key}"
+        attribute_code += "=\"#{attribute_value}\"" unless attribute_value.empty?
+      when Hash
+        value.each do |k,v|
+          if v
+            attribute_code += " #{key}-#{k}"
+            attribute_code += "=\"#{v.to_s}\"" unless v == true
+          end
+        end
+      else
+        if value
+          attribute_code += " #{key}"
+          attribute_code += "=\"#{value.to_s}\"" unless value == true
+        end
+      end
+
+      return attribute_code
+    end
+  end
+end