opulent 0.0.9 → 1.0.2

data/lib/opulent/logger.rb

@@ -0,0 +1,47 @@
+# @Opulent
+module Opulent
+  # @Logger
+  module Logger
+    # @Singleton
+    class << self
+      # Color the input text with the chosen color
+      #
+      # @param text [String] the string that will be colored
+      # @param color_code [String] preset code for certain colors
+      #
+      def colorize(text, color_code)
+        require_windows_libs
+        "#{color_code}#{text}\e[0m"
+      end
+
+      # Colors available in the terminal
+      #
+      def black(text); colorize(text, "\e[30m"); end
+      def red(text); colorize(text, "\e[31m"); end
+      def green(text); colorize(text, "\e[32m"); end
+      def yellow(text); colorize(text, "\e[33m"); end
+      def blue(text); colorize(text, "\e[34m"); end
+      def magenta(text); colorize(text, "\e[35m"); end
+      def cyan(text); colorize(text, "\e[36m"); end
+      def white(text); colorize(text, "\e[37m"); end
+      def default(text); colorize(text, "\e[38m"); end
+
+      # Require windows libraries for ANSI Console output
+      #
+      def require_windows_libs
+        begin
+          require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+        rescue LoadError
+          raise 'You must run "gem install win32console" to use Opulent\'s
+                error reporting on Windows.'
+        end
+      end
+
+      # Pretty print Nodes with their important details
+      #
+      def pretty_print(model, indent = 0)
+
+      end
+    end
+  end
+end

data/lib/opulent/parser.rb

@@ -0,0 +1,196 @@
+require_relative 'parser/block.rb'
+require_relative 'parser/comment.rb'
+require_relative 'parser/control.rb'
+require_relative 'parser/define.rb'
+require_relative 'parser/eval.rb'
+require_relative 'parser/expression.rb'
+require_relative 'parser/filter.rb'
+require_relative 'parser/node.rb'
+require_relative 'parser/root.rb'
+require_relative 'parser/text.rb'
+
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    attr_reader :type, :value, :options, :children, :indent
+
+    # All node Objects (Array) must follow the next convention in order
+    # to make parsing faster
+    #
+    # [:node_type, :value, :attributes, :children, :indent]
+    #
+    def initialize
+      @type = 0
+      @value = 1
+      @options = 2
+      @children = 3
+      @indent = 4
+    end
+
+    # Initialize the parsing process by splitting the code into lines and
+    # instantiationg parser variables with their default values
+    #
+    # @param code [String] Opulent code that needs to be analyzed
+    #
+    # @return Nodes array
+    #
+    def parse(code)
+      # Split the code into lines and parse them one by one
+      @code = code.lines
+
+      # Node definitions encountered up to the current point
+      @definitions = {}
+
+      # Current line index
+      @i = -1
+
+      # Initialize root node
+      @root = [:root, nil, {}, [], -1]
+
+      # Get all nodes starting from the root element
+      root @root
+    end
+
+    # Check and accept or reject a given token as long as we have tokens
+    # remaining. Shift the code with the match length plus any extra character
+    # count around the capture group
+    #
+    # @param token [RegEx] Token to be accepted by the parser
+    # @param required [Boolean] Expect the given token syntax
+    # @param strip [Boolean] Left strip the current code to remove whitespace
+    #
+    def accept(token, required = false, strip = false)
+      # Consume leading whitespace if we want to ignore it
+      accept :whitespace if strip
+
+      # We reached the end of the parsing process and there are no more lines
+      # left to parse
+      return nil unless @line
+
+      # Match the token to the current line. If we find it, return the match.
+      # If it is required, signal an :expected error
+      if (match = @line[@offset..-1].match(Tokens[token]))
+        # Advance current offset with match length
+        @offset += match[0].size
+
+        return match[0]
+      elsif required
+        error :expected, token
+      end
+    end
+
+    # Helper method which automatically sets the stripped options to true, so that we
+    # do not have to explicitly specify it
+    #
+    # @param token [RegEx] Token to be accepted by the parser
+    # @param required [Boolean] Expect the given token syntax
+    #
+    def accept_stripped(token, required = false)
+      accept(token, required, true)
+    end
+
+    # Check if the lookahead matches the chosen regular expression
+    #
+    # @param token [RegEx] Token to be checked by the parser
+    #
+    def lookahead(token)
+      return nil unless @line
+
+      # Check if we match the token to the current line.
+      @line[@offset..-1].match Tokens[token]
+    end
+
+    # Check if the lookahead matches the chosen regular expression on the
+    # following line which needs to be parsed
+    #
+    # @param token [RegEx] Token to be checked by the parser
+    #
+    def lookahead_next_line(token)
+      return nil unless @code[@i + 1]
+
+      # Check if we match the token to the current line.
+      @code[@i + 1].match Tokens[token]
+    end
+
+    # Undo a found match by removing the token from the consumed code and
+    # adding it back to the code chunk
+    #
+    # @param match [String] Matched string to be undone
+    #
+    def undo(match)
+      unless match.empty?
+        @offset -= match.size
+        return nil
+      end
+    end
+
+    # Allow expressions to continue on a new line in certain conditions
+    #
+    def accept_newline
+      if @line[@offset..-1].strip.empty?
+        @line = @code[(@i += 1)]
+        @offset = 0
+      end
+    end
+
+    # Give an explicit error report where an unexpected sequence of tokens
+    # appears and give indications on how to solve it
+    #
+    # @param message [Symbol] Error message to display to the user
+    #
+    def error(error, *data)
+      message = case error
+      when :unknown_node_type
+        "An unknown node type has been encountered at:\n\n#{Logger.red @line}"
+      when :expected
+        data[0] = "#{Tokens.bracket data[0]}" if [:'(', :'{', :'[', :'<'].include? data[0]
+        "Expected to find a :#{data[0]} token at: \n\n#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :root
+        "Unknown node type encountered on line #{@i+1} of input at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :assignments_colon
+        "Unexpected end of element attributes reached on line #{@i+1} of input.\n\n" +
+        "Expected to find an attribute at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :assignments_comma
+        "Unexpected end of element attributes reached on line #{@i+1} of input.\n\n" +
+        "Expected to find an attribute value at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :expression
+        "Unexpected end of expression reached on line #{@i+1} of input.\n\n" +
+        "Expected to find another expression term at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :control_child
+        "Unexpected control structure child found on line #{@i+1} of input.\n\n" +
+        "Expected to find a parent #{data[0]} structure at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :case_children
+        "Unexpected control structure child found on line #{@i+1} of input.\n\n" +
+        "Case structure cannot have any child elements at:\n\n" +
+        "#{@code[@i-1][0..@offset-1]}#{Logger.red @code[@i][@offset..-1].rstrip}"
+      when :whitespace_expression
+        "Unexpected end of expression reached on line #{@i+1} of input.\n\n" +
+        "Please use paranthesis for method parameters at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :definition
+        "Unexpected start of definition on line #{@i+1} of input.\n\n" +
+        "Found a definition inside another definition or element at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :self_enclosing
+        "Unexpected content found after self enclosing node on line #{@i+1} of input at:\n\n" +
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      when :self_enclosing_children
+        "Unexpected child elements found for self enclosing node on line #{data[0]+1} of input at:\n\n" +
+        "#{@code[data[0]]}#{Logger.red @code[data[0] + 1]}"
+      else
+        "#{@line[0..@offset-1]}#{Logger.red @line[@offset..-1].rstrip}"
+      end
+
+      # Reconstruct lines to display where errors occur
+      fail "\n\nOpulent " + Logger.red("[Parser Error]") +
+      "\n---\n" +
+      "#{message}\n\n\n"
+    end
+  end
+end

data/lib/opulent/parser/block.rb

@@ -0,0 +1,56 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match a yield with a explicit or implicit target
+    #
+    # yield target
+    #
+    # @param parent [Node] Parent node to which we append the definition
+    #
+    def block_yield(parent, indent)
+      if accept :yield
+        # Get definition name
+        if(yield_name = accept_stripped(:yield_identifier))
+          yield_name = yield_name.strip.to_sym
+        else
+          yield_name = Settings::DefaultYield
+        end
+
+        # Consume the newline from the end of the element
+        error :yield unless accept(:line_feed).strip.empty?
+
+        # Create a new node
+        yield_node = [:yield, yield_name, {}, [], indent]
+
+        parent[@children] << yield_node
+      end
+    end
+
+    # Match a block with a explicit target
+    #
+    # block target
+    #
+    # @param parent [Node] Parent node to which we append the definition
+    #
+    def block(parent, indent)
+      if accept :block
+        # Get definition name
+        if(block_name = accept_stripped(:yield_identifier))
+          block_name = block_name.strip.to_sym
+        else
+          block_name = Settings::DefaultYield
+        end
+
+        # Consume the newline from the end of the element
+        error :block unless accept(:line_feed).strip.empty?
+
+        # Create a new node
+        block_node = [:block, block_name, {}, [], indent]
+        root block_node, indent
+
+        parent[@children] << block_node
+      end
+    end
+  end
+end

data/lib/opulent/parser/comment.rb

@@ -0,0 +1,27 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match one line or multiline comments
+    #
+    def comment(parent, indent)
+      if (accept :comment)
+        multiline = true if (accept :comment)
+
+        buffer = accept(:line_feed)
+        buffer += accept(:newline) || ""
+        buffer += get_indented_lines indent if multiline
+
+
+        # If we have a comment which is visible in the output, we will
+        # create a new comment element. Otherwise, we ignore the current
+        # gathered text and we simply begin the root parsing again
+        if buffer[0] == '!'
+          parent[@children] << [:comment, buffer[1..-1].strip, {}, nil, indent]
+        end
+
+        return parent
+      end
+    end
+  end
+end

data/lib/opulent/parser/control.rb

@@ -0,0 +1,112 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match an if-else control structure
+    #
+    def control(parent, indent)
+      # Accept eval or multiline eval syntax and return a new node,
+      if (structure = accept(:control))
+        structure = structure.to_sym
+
+        # Handle each and the other control structures
+        condition = accept(:line_feed).strip
+
+        # Process each control structure condition
+        if structure == :each
+          # Check if arguments provided correctly
+          error :each_arguments unless condition.match Tokens[:each_pattern]
+
+          # Split provided arguments for the each structure
+          condition = condition.split('in').map(&:strip)
+          condition[0] = condition[0].split(',').map(&:strip).map(&:to_sym)
+        end
+
+        # Else and default structures are not allowed to have any condition
+        # set and the other control structures require a condition
+        if structure == :else
+          error :condition_exists unless condition.empty?
+        else
+          error :condition_missing if condition.empty?
+        end
+
+        # Add the condition and create a new child to the control parent.
+        # The control parent keeps condition -> children matches for our
+        # document's content
+        add_options = Proc.new do |control_parent|
+          control_parent.value << condition
+          control_parent.children << []
+
+          root control_parent
+        end
+
+        # If the current control structure is a parent which allows multiple
+        # branches, such as an if or case, we create an array of conditions
+        # which can be matched and an array of children belonging to each
+        # conditional branch
+        if [:if, :unless].include? structure
+          # Create the control structure and get its child nodes
+          control_structure = [structure, [condition], {}, [], indent]
+          root control_structure, indent
+
+          # Turn children into an array because we allow multiple branches
+          control_structure[@children] = [control_structure[@children]]
+
+          # Add it to the parent node
+          parent[@children] << control_structure
+
+        elsif structure == :case
+          # Create the control structure and get its child nodes
+          control_structure = [structure, [], {condition: condition}, [], indent]
+
+
+          # Add it to the parent node
+          parent[@children] << control_structure
+
+        # If the control structure is a child structure, we need to find the
+        # node it belongs to amont the current parent. Search from end to
+        # beginning until we find the node parent
+        elsif control_child structure
+          # During the search, we try to find the matching parent type
+          unless control_parent(structure).include? parent[@children][-1][@type]
+            error :control_child, control_parent(structure)
+          end
+
+          # Gather child elements for current structure
+          control_structure = [structure, [condition], {}, [], indent]
+          root control_structure, indent
+
+          # Add the new condition and children to our parent structure
+          parent[@children][-1][@value] << condition
+          parent[@children][-1][@children] << control_structure[@children]
+
+        # When our control structure isn't a complex composite, we create
+        # it the same way as a normal node
+        else
+          control_structure = [structure, condition, {}, [], indent]
+          root control_structure, indent
+
+          parent[@children] << control_structure
+        end
+      end
+    end
+
+    # Check if the current control structure requires a parent node and
+    # return the parent's node type
+    #
+    def control_child(structure)
+      [:else, :elsif, :when].include? structure
+    end
+
+    # Check if the current control structure requires a parent node and
+    # return the parent's node type
+    #
+    def control_parent(structure)
+      case structure
+      when :else then [:if, :unless, :case]
+      when :elsif then [:if]
+      when :when then [:case]
+      end
+    end
+  end
+end

data/lib/opulent/parser/define.rb

@@ -0,0 +1,30 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Check if we match a new node definition to use within our page.
+    #
+    # Definitions will not be recursive because, by the time we parse
+    # the definition children, the definition itself is not in the
+    # knowledgebase yet.
+    #
+    # However, we may use previously defined nodes inside new definitions,
+    # due to the fact that they are known at parse time.
+    #
+    # @param nodes [Array] Parent node to which we append to
+    #
+    def define(parent, indent)
+      if(match = accept :def)
+        # Process data
+        name = accept(:node, :*).to_sym
+
+        # Create node
+        definition = [:def, name, {parameters: attributes}, [], indent]
+        root(definition, indent)
+
+        # Add to parent
+        @definitions[name] = definition
+      end
+    end
+  end
+end