opulent 0.0.9 → 1.0.2

data/lib/opulent/parser/root.rb

@@ -0,0 +1,48 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Analyze the input code and check for matching tokens.
+    # In case no match was found, throw an exception.
+    # In special cases, modify the token hash.
+    #
+    # @param nodes [Array] Parent node to which we append to
+    #
+    def root(parent = @root, min_indent = -1)
+      while(@line = @code[(@i += 1)])
+        # Skip to next iteration if we have a blank line
+        if @line =~ /\A\s*\Z/ then next end
+
+        # Reset the line offset
+        @offset = 0
+
+        # Parse the current line by trying to match each node type towards it
+        # Add current indentation to the indent stack
+        indent = accept(:indent).size
+
+        # Stop using the current parent as root if it does not match the
+        # minimum indentation requirements
+        unless min_indent < indent
+          @i -= 1; break
+        end
+
+        # Try the main Opulent node types and process each one of them using
+        # their matching evaluation procedure
+        current_node =  node(parent, indent)        ||
+                        text(parent, indent)        ||
+                        comment(parent, indent)     ||
+                        define(parent, indent)      ||
+                        control(parent, indent)     ||
+                        evaluate(parent, indent)    ||
+                        filter(parent, indent)      ||
+                        block_yield(parent, indent) ||
+                        block(parent, indent)
+
+        # Throw an error if we couldn't find a valid node
+        error :unknown_node_type unless current_node
+      end
+
+      return parent
+    end
+  end
+end

data/lib/opulent/parser/text.rb

@@ -0,0 +1,127 @@
+# @Opulent
+module Opulent
+  # @Parser
+  class Parser
+    # Match one line or multiline, escaped or unescaped text
+    #
+    # @param parent [Array] Parent node element
+    # @param indent [Fixnum] Size of the current indentation
+    # @param multiline_or_print [Boolean] Allow only multiline text or print
+    #
+    def text(parent, indent = nil, multiline_or_print = true)
+      # Try to see if we can match a multiline operator. If we can accept_stripped only
+      # multiline, which is the case for filters, undo the operation.
+      if accept :multiline
+        multiline = true
+      elsif multiline_or_print
+        return nil unless lookahead :print_lookahead
+      end
+
+      # Get text node type
+      type = if accept(:print) then :print else :text end
+
+      # Check if the text or print node is escaped or unescaped
+      escaped = accept(:unescaped_value) ? false : true
+
+      # Get text value
+      value = accept :line_feed
+      value = value[1..-1] if value[0] == '\\'
+
+      # Create the text node using input data
+      text_node = [:plain, type, {value: value.strip, escaped: escaped, evaluate: false}, nil, indent]
+
+      # If we have a multiline node, get all the text which has higher
+      # indentation than our indentation node.
+      if multiline
+        text_node[@options][:value] += accept(:newline) || ""
+        text_node[@options][:value] += get_indented_lines(indent)
+        text_node[@options][:value].strip!
+      elsif value.empty?
+        # If our value is empty and we're not going to add any more lines to
+        # our buffer, skip the node
+        return nil
+      end
+
+      if text_node[@options][:value] =~ Settings::InterpolationCheck
+        text_node[@options][:evaluate] = true
+      end
+
+      # Increase indentation if this is an inline text node
+      text_node[@indent] += Settings[:indent] unless multiline_or_print
+
+      # Add text node to the parent element
+      parent[@children] << text_node
+    end
+
+    # Match one line or multiline, escaped or unescaped text
+    #
+    def html_text(parent, indent)
+      if (text_feed = accept_stripped :html_text)
+        text_node = [:plain, :text, {value: text_feed.strip, escaped: false}, nil, indent]
+
+        parent[@children] << text_node
+      end
+    end
+
+    # Match a whitespace by preventing code trimming
+    #
+    def whitespace(required = false)
+      accept :whitespace, required
+    end
+
+    # Gather all the lines which have higher indentation than the one given as
+    # parameter and put them into the buffer
+    #
+    # @param indentation [Fixnum] parent node strating indentation
+    #
+    def get_indented_lines(indent)
+      buffer = ''
+
+      # Gather multiple blank lines between lines of text
+      blank_lines = Proc.new do
+        while lookahead_next_line :line_whitespace
+          @line = @code[(@i += 1)]
+          @offset = 0
+
+          buffer += accept :line_whitespace
+        end
+      end
+
+      # Get blank lines until we match something
+      blank_lines[]
+
+      # Get the next indentation after the parent line
+      # and set it as primary indent
+      next_indent = first_indent = (lookahead_next_line(:indent).to_s || "").size
+
+      # While the indentation is smaller, add the line feed  to our buffer
+      while next_indent > indent
+        # Advance current line and reset offset
+        @line = @code[(@i += 1)]
+        @offset = 0
+
+        # Get leading whitespace trimmed with first_indent's size
+        next_line_indent = accept(:indent)[first_indent..-1] || ""
+        next_line_indent = next_line_indent.size
+
+        # Add next line feed, prepend the indent and append the newline
+        buffer += " " * next_line_indent if next_line_indent > 0
+        buffer += accept_stripped(:line_feed) || ""
+        buffer += accept_stripped(:newline) || ""
+
+        # Get blank lines until we match something
+        blank_lines[]
+
+        # Check the indentation on the following line. When we reach EOF,
+        # set the indentation to 0 and cause the loop to stop
+        if (next_indent = lookahead_next_line :indent)
+          next_indent = next_indent[0].size
+        else
+          next_indent = 0
+        end
+      end
+
+      return buffer
+    end
+  end
+end

data/lib/opulent/settings.rb

@@ -0,0 +1,79 @@
+# @Opulent
+module Opulent
+  # @Settings
+  module Settings
+    # Default yield target which is used for child block replacements
+    DefaultYield = :children
+
+    # Default yield target which is used for child block replacements
+    DefaultEachKey = :key
+
+    # Default yield target which is used for child block replacements
+    DefaultEachValue = :value
+
+    # List of self enclosing node elements
+    SelfEnclosing = %i(img link input meta br hr area base col command embed keygen param source track wbr)
+
+    # List of inline node parents which can be either inline or have complex
+    # structures inside of them, such as anchor tags
+    MultiNode = %i(a)
+
+    # List of inline node names
+    InlineNode = %i(text a span strong em br i b small label sub sup abbr var code kbd)
+
+    # Check whether text should or shouldn't be evaluated
+    InterpolationCheck = /(?<!\\)\#\{.*\}/
+
+    # Check if the attribute value is a bare string
+    EvaluationCheck = /\A(("((?:[^"\\]|\\.)*?)")|('(?:[^'\\]|\\.)*?')|true|false|nil)\Z/
+
+    # Shorthand attribute associations
+    Shorthand = {
+      :'.' => :class,
+      :'#' => :id,
+      :'&' => :name
+    }
+
+    # @Singleton
+    class << self
+      # Opulent runtime options
+      Defaults = {
+        pretty: true,
+        indent: 2,
+        dependency_manager: true
+      }
+
+      # Set defaults as initial options
+      @@options = Defaults
+
+      # Get an option at runtime
+      #
+      # @param name [Symbol] Identifier for the option
+      #
+      def [](name)
+        @@options[name]
+      end
+
+      # Set a new option at runtime
+      #
+      # @param name [Symbol] Identifier for the option
+      # @param value Option value to be set
+      #
+      def []=(name, value)
+        @@options[name] = value
+      end
+
+      # Update the engine options with the required option changes
+      #
+      # @param opts [Hash] Option extension hash
+      #
+      def update_settings(opts)
+        @@options = Defaults
+
+        opts.each do |key, value|
+          @@options[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/opulent/template.rb

@@ -0,0 +1,67 @@
+# @Opulent
+module Opulent
+  # @OpulentTemplate
+  class OpulentTemplate < ::Tilt::Template
+    self.default_mime_type = 'text/html'
+
+    # Do whatever preparation is necessary to setup the underlying template
+    # engine. Called immediately after template data is loaded. Instance
+    # variables set in this method are available when #evaluate is called.
+    #
+    # Subclasses must provide an implementation of this method.
+    #
+    def prepare
+      # Set the file which is being evaluated
+      @options[:file] = eval_file
+
+      # Enable caching for the current rendered file
+      @options[:cache] = true
+
+      # Set up the rendering engine
+      @engine = ::Opulent.new @options
+      #@engine.update_options @options
+    end
+
+    # Execute the compiled template and return the result string. Template
+    # evaluation is guaranteed to be performed in the scope object with the
+    # locals specified and with support for yielding to the block.
+    #
+    # This method is only used by source generating templates. Subclasses that
+    # override render() may not support all features.
+    #
+    def evaluate(scope, locals, &block)
+      # if @engine.respond_to?(:precompiled_method_return_value, true)
+      #   super
+      # else
+      #   @engine.render(data, locals, &block)
+      # end
+      if @engine.preamble
+        super
+      else
+        locals[:scope] = scope
+        @engine.render(data, locals, &block)
+      end
+    end
+
+    # A string containing the (Ruby) source code for the template. The
+    # default Template#evaluate implementation requires either this
+    # method or the #precompiled method be overridden. When defined,
+    # the base Template guarantees correct file/line handling, locals
+    # support, custom scopes, proper encoding, and support for template
+    # compilation.
+    #
+    def precompiled_template(locals)
+      # This here should be evaluated in order to return the precompiled code
+      # as text to the user.
+      # For example:
+      # _buff = [] # This should be in preamble
+      # _buff << "<html>",
+      # _buff << compile('a * b')
+      # _buff << "</html>"
+      @engine.preamble
+    end
+  end
+
+  # Register Opulent to Tilt
+  ::Tilt.register OpulentTemplate, 'op', 'opl', 'opulent'
+end

data/lib/opulent/tokens.rb

@@ -0,0 +1,166 @@
+module Opulent
+  # Opulent Keywords
+  Keywords = %i(def block yield if else elsif unless case when each while until)
+
+  # @Tokens
+  class Tokens
+    # All tokens available within Opulent
+    #
+    @@tokens = {
+      # Indentation
+      indent: /\A */,
+
+      # Node
+      node: /\A\w+(\-\w+)*/,
+      node_lookahead: /\A(\w+(\-\w+)*)/,
+
+      # Shorthand attributes
+      shorthand: /\A[\.\#\&]/,
+      shorthand_lookahead: /\A[\.\#\&][a-zA-Z\_\(\"]/,
+
+      # Leading and trailing whitespace
+      leading_whitespace: /\A(\<\-)/,
+      leading_trailing_whitespace: /\A(\>)/,
+      trailing_whitespace: /\A(\-\>)/,
+
+      # Self enclosing node
+      self_enclosing: /\A\/(.*)/,
+
+      # Definition
+      def: /\Adef +/,
+
+      # Node Attributes
+      attributes_bracket: /\A\(\[\{/,
+      extend_attributes: /\A(\+)/,
+
+      # Attribute assignments
+      assignment: /\A *(\:|\=)/,
+      assignment_unescaped: /\A\~/,
+      assignment_terminator: /\A(\,|\;)\s*/,
+      assignment_lookahead: /\A *([a-zA-Z]([\-\_]?[a-zA-Z0-9]+)* *[\:\=] *)/,
+
+      # Node inline child
+      inline_child: /\A *\> */,
+
+      # Comments
+      comment: /\A\//,
+
+      # Intepreted filters
+      filter: /\A\:[a-zA-Z]([\-\_]?[a-zA-Z0-9]+)*/,
+
+      # Print nodes
+      print: /\A\=/,
+      print_lookahead: /\A *=/,
+
+      # Unescaped value
+      unescaped_value: /\A\~/,
+
+      # Multiline Text
+      multiline: /\A(\|)/,
+
+      # HTML Text
+      html_text: /\A(\<.+\>.*)/,
+
+      # Yield
+      yield: /\A(yield)/,
+      yield_identifier: /\A[a-zA-Z]([\_]?[a-zA-Z0-9]+)*/,
+
+      # Yield
+      block: /\A(block)/,
+
+      # Conditional Structures
+      control: /\A(if|elsif|else|unless|case|when|each|while|until)/,
+      each_pattern: /\A(\w+( *, *\w+)? +)?in +.+/,
+
+      # Text
+      text: /\A\|/,
+
+      # Brackets
+      round_bracket: /\A(\()/,
+      square_bracket: /\A(\[)/,
+      curly_bracket: /\A(\{)/,
+      angular_bracket: /\A(\<)/,
+
+      # Receive matching brackets for allowing multiple bracket types for
+      # element attributes
+      :brackets => /\A([\(\[\{])/,
+      :'(' => /\A(\))/,
+      :'[' => /\A(\])/,
+      :'{' => /\A(\})/,
+      :'<' => /\A(\>)/,
+
+      # Terminators
+      comma: /\A(\s*\,\s*)/,
+      colon: /\A(\s*\:\s*)/,
+      semicolon: /\A(\s*\;\s*)/,
+
+      # Expression
+      exp_context: /\A(\$(.|\-.)?|\@|\@\@)/,
+      exp_method_call: /\A(\.[a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?)/,
+      exp_module: /\A(\:\:)/,
+      exp_identifier: /\A([a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?)/,
+      exp_assignment: /\A(\=)/,
+      exp_operation: /\A( *(\+|\-|\*\*|\*|\/|\<\<|\>\>|\.\.|\%|\<\=\>|\<\=|\^|\<|\>\=|\>|\=\~|\!\~|\=\=\=|\=\=|\!|not|\&\&|\&|and|\|\||\||or) *)/,
+      exp_regex: /\A(\/((?:[^\/\\]|\\.)*?)\/)/,
+      exp_string: /\A(("((?:[^"\\]|\\.)*?)")|('(?:[^'\\]|\\.)*?'))/,
+      exp_percent: /\A(\%[wWqQrxsiI]?.)/,
+      exp_double: /\A([0-9]+\.[0-9]+([eE][-+]?[0-9]+)?)/,
+      exp_fixnum: /\A([0-9]+)/,
+      exp_nil: /\A(nil)/,
+      exp_boolean: /\A(true|false)/,
+      exp_ternary: /\A( *\? *)/,
+      exp_ternary_else: /\A( *\: *)/,
+
+      exp_identifier_lookahead: /\A[a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?/,
+
+      # Hash
+      hash_terminator: /\A(\s*(\,)\s*)/,
+      hash_assignment: /\A(\s*(\=\>)\s*)/,
+      hash_symbol: /\A([a-zA-Z\_][a-zA-Z0-9\_]*\:(?!\:))/,
+
+      # Whitespace
+      whitespace: /\A +/,
+
+      # Evaluation
+      eval: /\A\-(.*)/,
+      eval_multiline: /\A\+(.*)/,
+
+      # Whitespace
+      newline: /\A(\n+)/,
+
+      # Feed
+      line_feed: /\A(.*)/,
+      line_whitespace: /\A\s*\Z/
+    }
+
+    # Return the matching closing bracket
+    #
+    # @param bracket [String] Opening bracket for the capture group
+    #
+    def self.bracket(bracket)
+      case bracket
+      when '(' then return ')'
+      when '[' then return ']'
+      when '{' then return '}'
+      when '<' then return '>'
+      end
+    end
+
+    # Return the requested token to the parser
+    #
+    # @param name [Symbol] Token requested by the parser accept method
+    #
+    def self.[](name)
+      @@tokens[name]
+    end
+
+    # Set a new token at runtime
+    #
+    # @param name [Symboidentifierl] Identifier for the token
+    # @param token [Token] Token data to be set
+    #
+    def self.[]=(name, token)
+      @@tokens[name] = token
+    end
+  end
+end