opulent 0.0.9 → 1.0.2

data/.libold/opulent/parser/theme.rb

@@ -0,0 +1,36 @@
+# @Opulent
+module Opulent
+  # @Parser
+  module Parser
+    # @Define
+    module Theme
+      # Match a theme namespace node with its parameters and body
+      #
+      # theme node_name[ parameters ]
+      #   body nodes
+      #
+      # @param parent [Node] Parent node to which we append the definition
+      #
+      def theme(parent)
+        if lookahead :theme_lookahead
+          # Get current line's indentation
+          indent = accept_unstripped(:indent) || ""
+
+          if accept :theme
+            # Get definition name
+            theme_name = accept :theme_identifier, :*
+
+            # Create a new node
+            node = @create.theme theme_name.to_sym, parent, indent.size
+
+            # Consume the newline from the end of the element
+            error :theme unless accept_unstripped(:line_feed).strip.empty?
+            accept_unstripped :newline
+
+            return node
+          end
+        end
+      end
+    end
+  end
+end

data/.libold/opulent/preprocessor.rb

@@ -0,0 +1,102 @@
+# @Opulent
+module Opulent
+  # @PreProcessor
+  module PreProcessor
+    # @Singleton
+    class << self
+      # Preprocessor directives which will be checked before lexing starts.
+      # Each directive takes leading whitespace into account, therefore all the
+      # included lines will have the same indentation size as the directive
+      #
+      REQUIRE_DIRECTIVE =  /([\t ]*)\/\/= *require +("(.*)"|'(.*)')/
+
+      # Include required files using the \\=directive_name pattern and keep
+      # the expanded directory path to make the require relative to the input
+      #
+      # @param file [String] name of the file to be processed
+      #
+      def process(input, mode = :file, &block)
+        # We can preprocess the code in file mode without requiring a block, but
+        # if we're preprocessing code directly, we need a block to get the
+        # caller file path, otherwise we return an error
+        if mode == :file
+          # Get the complete path of the input file
+          dir = File.dirname File.expand_path input
+          # Process the file contents
+          code = File.read input
+        elsif block
+          # Get the complete path of the input file
+          dir = File.dirname File.expand_path eval('__FILE__', block.binding)
+          # Process the file contents
+          code = input
+        elsif input =~ REQUIRE_DIRECTIVE
+          error :block, 'require', $~
+        else
+          return input
+        end
+
+        return require_files code, dir
+      end
+
+      private
+
+      # Replace the found \\=require directive with the file's contents
+      #
+      # @param contents [String] contents of the input file
+      # @param dir [String] complete path of the input file
+      #
+      def require_files(contents, dir)
+        contents.gsub REQUIRE_DIRECTIVE do |path|
+          require_contents = ''
+          match = $2[1..-2]
+
+          # Check if file already has extension
+          path = "#{dir}/#{match}"
+
+          # Check if the required file exists
+          if File.file? path
+            # Get contents
+            require_contents = process path
+          else
+            error :file, $2
+          end
+
+          # Indent lines
+          indent_lines $1, require_contents
+        end
+      end
+
+      # Add indentation to each line if the require directive is indented
+      #
+      # @param indent [String] a string containing whitespace
+      # @param contents [String] required file's contents
+      #
+      def indent_lines(indent, contents)
+        unless indent.empty?
+           contents.lines.map!{ |line| indent + line }.join
+        end
+
+        return contents
+      end
+
+      # Give an explicit error report where an unexpected sequence of tokens
+      # appears and give indications on how to solve it
+      #
+      def error(context, *data)
+        message = case context
+        when :file
+          "The file #{data[0]} does not exist at the specified path."
+        when :block
+          "Found a #{data[0]} directive at \"#{data[1]}\" but no block was given as rendering environment.\n" +
+          "Please include a block when rendering to fix this issue.\n\n" +
+          "E.g. opulent.render(code, locals){}"
+        end
+
+        # Reconstruct lines to display where errors occur
+        fail "\n\nOpulent " + Logger.red('[Preprocessor Error]') + "\n---\n" +
+        "#{message}\n\n"
+      end
+
+    end
+  end
+end

data/.libold/opulent/runtime.rb

@@ -0,0 +1,144 @@
+# @Opulent
+module Opulent
+  # @Runtime
+  module Runtime
+    # @Singleton
+    class << self
+      # HTML Entities Object for escaping and unescaping strings
+      @@entities = HTMLEntities.new
+
+      # Definitions knowledgebase
+      @@themes = {}
+
+      # Remodel a structured abstract syntax tree using a given context
+      #
+      # @param syntax [Root] Root node with contents and definitions
+      # @param context [Context] Context holding environment variables
+      #
+      def remodel(syntax, context)
+        @@themes = syntax.themes
+        syntax.evaluate(context)
+      end
+
+      # Apply given context to node attributes through evaluation
+      #
+      # @param attributes [Hash] Node attributes
+      # @param extension [String] Inline attributes extension code
+      # @param context [Context] Context holding environment variables
+      #
+      def attributes(attributes, extension, context)
+        atts = Hash[attributes.map{ |key, value|
+          case value
+          when Nodes::Expression
+            evaluated = value.evaluate(context)
+          when Array
+            evaluated = value.map do |v| v.evaluate(context) end
+          when Hash
+            evaluated = value.each do |k, v| value[k] = v.evaluate(context) end
+          end
+
+          [key, evaluated]
+        }]
+
+        # If we have an extension, we evaluate it and we merge it with the
+        # old attributes hash
+        if extension
+          atts_extension = context.evaluate extension.value
+          if atts_extension.is_a? Hash
+            atts.merge! atts_extension
+          else
+            error :extension, extension
+          end
+        end
+
+        return atts
+      end
+
+      # Create a node from the chosen theme and definition
+      #
+      def define(node, attributes, context)
+        # Get the definition model
+        model = @@themes[node.theme][node.name].dup
+
+        # Create a new definition context
+        definition_context = Context.new
+        definition_context.extend_nonlocals context.binding
+        definition_context.name = node.name
+
+        # 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
+        model.attributes.each do |key, value|
+          if attributes[key]
+            arguments[key] = attributes.delete key
+          else
+            arguments[key] = value.evaluate definition_context
+          end
+        end
+
+        # Set the remaining attributes as a value in the arguments
+        arguments[:attributes] = attributes
+
+        # Set variable to determine available blocks
+        arguments[:blocks] = Hash[node.blocks.keys.map do |blk| [blk, true] end]
+
+        # Create local variables from argument variables
+        definition_context.extend_locals arguments
+
+        # Evaluate the model using the new context
+        model.evaluate definition_context, node.blocks
+      end
+
+      # Escape a given input value using htmlentities
+      #
+      # @param value [String] String to be escaped
+      #
+      def escape(value)
+        @@entities.encode value
+      end
+
+      # Quick access wrapper to defined runtime themes
+      #
+      def [](theme)
+        @@themes[theme]
+      end
+
+      # Give an explicit error report where an unexpected sequence of tokens
+      # appears and give indications on how to solve it
+      #
+      # @param context [Symbol] Context name in which the error happens
+      # @param data [Array] Additional error information
+      #
+      def error(context, *data)
+        message = case context
+        when :theme
+          "The theme \"#{data[0]}\" cannot be found in the theme knowledgebase."
+        when :enumerable
+          "The provided each structure iteration input \"#{data[0]}\" is not Enumerable."
+        when :binding
+          data[0] = data[0].to_s.match(/\`(.*)\'/)
+          data[0] = data[0][1] if data[0]
+          "Found an undefined local variable or method \"#{data[0]}\" at \"#{data[1]}\"."
+        when :variable_name
+          data[0] = data[0].to_s.match(/\`(.*)\'/)[1]
+          "Found an undefined local variable or method \"#{data[0]}\" in locals."
+        when :extension
+          "The extension sequence \"#{data[0]}\" is not a valid attributes extension. " +
+          "Please use a Hash to extend attributes."
+        when :filter_registered
+          "The \"#{data[0]}\" filter could not be recognized by Opulent."
+        when :filter_load
+          "The gem required for the \"#{data[0]}\" filter is not installed. You can install it by running:\n\n#{data[1]}"
+        end
+
+        # Reconstruct lines to display where errors occur
+        fail "\n\nOpulent " + Logger.red("[Runtime Error]") + "\n---\n" +
+        "A runtime error has been encountered when building the compiled node tree.\n" +
+        "#{message}\n\n\n"
+      end
+    end
+  end
+end

data/.libold/opulent/template.rb

@@ -0,0 +1,43 @@
+# @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
+      @engine = ::Opulent::Opulent.new
+      @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)
+      locals[:scope] = scope
+      @output = @engine.render_file @file, locals, &block
+    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)
+      @output
+    end
+  end
+
+  ::Tilt.register OpulentTemplate, 'op', 'opl', 'opulent'
+end

data/.libold/opulent/tokens.rb

@@ -0,0 +1,276 @@
+# @Opulent
+module Opulent
+  # @Tokens
+  module Tokens
+    # @Token
+    #
+    # Structure holding matching data for each Opulent token
+    #
+    # @param regex [RegEx] Regular expression for matching the token
+    # @param extra [FixNum] Extra characters around the first capture group
+    #
+    Token = Struct.new :regex, :extra
+
+    # @Singleton
+    class << self
+      # Token knowledgebase
+      @@tokens = {}
+
+      # Opulent Keywords
+      KEYWORDS = %w(def theme block yield if else elsif unless case when each while until)
+
+      def keyword(word)
+        KEYWORDS.include? word
+      end
+
+      # Shorthand Attributes
+      @@shorthand_lookahead = []
+      Opulent::Engine[:shorthand].each do |key, value|
+        @@tokens["shorthand@#{key}".to_sym] = Token.new /\A(#{value})/
+        @@shorthand_lookahead << "#{value}[a-zA-Z\"(]"
+      end
+
+      # Node identifier
+      @@tokens[:identifier] = Token.new /\A([a-zA-Z]([\-\_]?[a-zA-Z0-9]+)*)/
+      @@tokens[:identifier_lookahead] = Token.new /\A([a-zA-Z]\w*\:\:)?(?<capture>([a-zA-Z]([\-\_]?[a-zA-Z0-9]+)*|#{@@shorthand_lookahead.join '|'}))/
+
+      # Attribute lookahead
+      @@tokens[:attribute_lookahead] = Token.new /\A([a-zA-Z]([\-\_]?[a-zA-Z0-9]+)*)/
+
+      # Self enclosing nodes
+      @@tokens[:self_enclosing] = Token.new /\A\/(.*)/, 1
+
+      # Node assignments
+      @@tokens[:assignment] = Token.new /\A(\:|\=)/
+      @@tokens[:assignment_unescaped] = Token.new /\A(\~)/
+      @@tokens[:assignment_terminator] = Token.new /\A((\,|\;)\s*)/
+      @@tokens[:assignment_lookahead] = Token.new /\A *(?<capture>[a-zA-Z]([\-\_]?[a-zA-Z0-9]+)* *[\:\=])/
+
+      # Node extension
+      @@tokens[:extend_attributes] = Token.new /\A(\+)/
+
+      # Node inline child
+      @@tokens[:inline_child] = Token.new /\A(\>)/
+
+      # Node output whitespace
+      @@tokens[:leading_whitespace] = Token.new /\A(\<\-)/
+      @@tokens[:leading_trailing_whitespace] = Token.new /\A(\>)/
+      @@tokens[:trailing_whitespace] = Token.new /\A(\-\>)/
+
+      # Comments
+      @@tokens[:comment] = Token.new /\A\/(.*)/, 1
+      @@tokens[:comment_lookahead] = Token.new /\A *(?<capture>\/)/
+
+      # Intepreted filters
+      @@tokens[:filter] = Token.new /\A\:([a-zA-Z]([\-\_]?[a-zA-Z0-9]+)*)/, 1
+      @@tokens[:filter_lookahead] = Token.new /\A *\:(?<capture>[a-zA-Z]([\-\_]?[a-zA-Z0-9]+)*)/
+
+      # Text
+      @@tokens[:escaped_text] = Token.new /\A(.*)/
+      @@tokens[:unescaped_text] = Token.new /\A\~(.*)/, 1
+
+      # Print
+      @@tokens[:escaped_print] = Token.new /\A\=(.*)/, 1
+      @@tokens[:unescaped_print] = Token.new /\A\=\~(.*)/, 2
+      @@tokens[:print_lookahead] = Token.new /\A *(?<capture>\=)/
+
+      # Multiline Text
+      @@tokens[:multiline] = Token.new /\A(\|)/
+
+      # HTML Text
+      @@tokens[:html_text] = Token.new /\A(\<.+\>.*)/
+
+      # Definitions
+      @@tokens[:def] = Token.new /\A(def +)/
+      @@tokens[:def_lookahead] = Token.new /\A *(?<capture>def )/
+
+      # Yield
+      @@tokens[:yield] = Token.new /\A(yield)/
+      @@tokens[:yield_lookahead] = Token.new /\A *(?<capture>yield)/
+      @@tokens[:yield_identifier] = Token.new  /\A( +[a-zA-Z]([\_]?[a-zA-Z0-9]+)*)/
+
+      # Yield
+      @@tokens[:block] = Token.new /\A(block)/
+      @@tokens[:block_lookahead] = Token.new /\A *(?<capture>block)/
+
+      # Theme
+      @@tokens[:theme] = Token.new /\A(theme +)/
+      @@tokens[:theme_lookahead] = Token.new /\A *(?<capture>theme )/
+      @@tokens[:theme_identifier] = Token.new /\A([a-zA-Z]\w*)/
+      @@tokens[:theme_node] = Token.new /\A([a-zA-Z]\w*)\:\:/, 2
+
+      # Conditional Structures
+      @@tokens[:control] = Token.new /\A(if|elsif|else|unless|case|when|each|while|until)/
+      @@tokens[:control_lookahead] = Token.new /\A *(?<capture>if|elsif|else|unless|case|when|each|while|until)/
+      @@tokens[:each_pattern] = Token.new /\A(\w+( *, *\w+)? +)?in +.+/
+
+      # Brackets
+      @@tokens[:round_bracket_open] = Token.new /\A(\()/
+      @@tokens[:round_bracket_close] = Token.new /\A(\))/
+      @@tokens[:square_bracket_open] = Token.new /\A(\[)/
+      @@tokens[:square_bracket_close] = Token.new /\A(\])/
+      @@tokens[:curly_bracket_open] = Token.new /\A(\{)/
+      @@tokens[:curly_bracket_close] = Token.new /\A(\})/
+      @@tokens[:angular_bracket_open] = Token.new /\A(\<)/
+      @@tokens[:angular_bracket_close] = Token.new /\A(\>)/
+
+      # Receive matching brackets for allowing multiple bracket types for
+      # element attributes
+      @@tokens[:brackets] = Token.new /\A([\(\[\{])/
+      @@tokens[:'('] = @@tokens[:round_bracket_close]
+      @@tokens[:'['] = @@tokens[:square_bracket_close]
+      @@tokens[:'{'] = @@tokens[:curly_bracket_close]
+      @@tokens[:'<'] = @@tokens[:angular_bracket_close]
+
+      # Terminators
+      @@tokens[:comma] = Token.new /\A(\s*\,\s*)/
+      @@tokens[:colon] = Token.new /\A(\s*\:\s*)/
+      @@tokens[:semicolon] = Token.new /\A(\s*\;\s*)/
+
+      # Array
+      @@tokens[:array_open] = @@tokens[:square_bracket_open]
+      @@tokens[:array_terminator] = @@tokens[:comma]
+      @@tokens[:array_close] = @@tokens[:square_bracket_close]
+
+      # Hash
+      @@tokens[:hash_open] = @@tokens[:curly_bracket_open]
+      @@tokens[:hash_terminator] = Token.new /\A(\s*(\,)\s*)/
+      @@tokens[:hash_assignment] = Token.new /\A(\s*(\=\>)\s*)/
+      @@tokens[:hash_symbol] = Token.new /\A([a-zA-Z\_][a-zA-Z0-9\_]*\:(?!\:))/
+      @@tokens[:hash_close] = @@tokens[:curly_bracket_close]
+
+      # Expressions
+      @@tokens[:exp_context] = Token.new /\A(\$(.|\-.)?|\@|\@\@)/
+      @@tokens[:exp_method_call] = Token.new /\A(\.[a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?)/
+      @@tokens[:exp_module] = Token.new /\A(\:\:)/
+      @@tokens[:exp_identifier] = Token.new /\A([a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?)/
+      @@tokens[:exp_assignment] = Token.new /\A(\=)/
+      @@tokens[:exp_operation] = Token.new /\A( *(\+|\-|\*\*|\*|\/|\<\<|\>\>|\.\.|\%|\<\=\>|\<\=|\^|\<|\>\=|\>|\=\~|\!\~|\=\=\=|\=\=|\=~|\!|not|\&\&|\&|and|\|\||\||or) *)/
+      @@tokens[:exp_regex] = Token.new /\A(\/((?:[^\/\\]|\\.)*?)\/)/
+      @@tokens[:exp_string] = Token.new /\A(("((?:[^"\\]|\\.)*?)")|('(?:[^'\\]|\\.)*?'))/
+      @@tokens[:exp_percent] = Token.new /\A(\%[wWqQrxsiI]?.)/
+      @@tokens[:exp_double] = Token.new /\A([0-9]+\.[0-9]+([eE][-+]?[0-9]+)?)/
+      @@tokens[:exp_fixnum] = Token.new /\A([0-9]+)/
+      @@tokens[:exp_nil] = Token.new /\A(nil)/
+      @@tokens[:exp_boolean] = Token.new /\A(true|false)/
+      @@tokens[:exp_ternary] = Token.new /\A( *\? *)/
+      @@tokens[:exp_ternary_else] = Token.new /\A( *\: *)/
+
+      # Expression identifier lookahead
+      @@tokens[:exp_identifier_lookahead] = Token.new /\A(?<capture>[a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?)/
+
+      # Evaluation
+      @@tokens[:eval] = Token.new /\A\-(.*)/, 1
+      @@tokens[:eval_multiline] = Token.new /\A\+(.*)/, 1
+
+      # Whitespace
+      @@tokens[:newline] = Token.new /\A(\n+)/
+      @@tokens[:whitespace] = Token.new /\A( +)/
+      @@tokens[:whitespace_lookahead] = Token.new /\A(?<capture> +)/
+
+      # Indentation
+      @@tokens[:indent] = Token.new /\A( *)/
+      @@tokens[:indent_lookahead] = Token.new /\A\n?(?<capture> *)/
+
+      # Feed
+      @@tokens[:line_feed] = Token.new /\A(.*)/
+
+      # Return the matching closing bracket
+      #
+      # @param bracket [String] Opening bracket for the capture group
+      #
+      def 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 [](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 []=(name, token)
+        @@tokens[name] = token
+      end
+
+      #
+      # # Control structures
+      # T_IF = /\A(if)/
+      # T_ELSIF = /\A(elsif)/
+      # T_ELSE = /\A(else)/
+      # T_EACH = /\A(each)/
+      # T_IN = /\A(in)/
+      #
+      # # Punctuation
+      # T_COLON = /\A(\:)/
+      # T_SEMICOLON = /\A(\;)/
+      #
+      # # Assignments terminator
+      # T_TERMINATOR = /\A(\,|\;)/
+      #
+      # # Assignments identifier
+      # T_ASSIGNMENT = /\A(\:|=)/
+      #
+      # # Paranthesis
+      # T_SQUARE_BRACKET_OPEN = /\A(\[)/
+      # T_SQUARE_BRACKET_CLOSE = /\A(\])/
+      # T_CURLY_BRACKET_OPEN = /\A(\{)/
+      # T_CURLY_BRACKET_CLOSE = /\A(\})/
+      # T_PARANTHESIS_OPEN = /\A(\()/
+      # T_PARANTHESIS_CLOSE = /\A(\))/
+      #
+      # # Embedded Ruby
+      # T_RUBY_CONTEXT = /\A(\$[0-9]*?|\@|\@\@)/
+      # T_RUBY_CONSTANT = /\A([a-zA-Z\_][a-zA-Z0-9\_]*)/
+      # T_RUBY_INDEX = /\A(\[\s*\:?(([0-9]+)|([a-zA-Z\_][a-zA-Z0-9\-\_]*)|("((?:[^"\\]|\\.)*?)")|('(?:[^'\\]|\\.)*?')|(.+\.\..+))\s*\])/
+      # T_RUBY_MODULES = /\A(\:\:[a-zA-Z\_][a-zA-Z0-9\_]*)/
+      # T_RUBY_METHOD = /\A(\.[a-zA-Z\_][a-zA-Z0-9\_]*[\!\?]?)/
+      #
+      # # Literals
+      # T_STRING = /\A(("((?:[^"\\]|\\.)*?)")|('(?:[^'\\]|\\.)*?'))/
+      # T_DOUBLE = /\A([0-9]+\.[0-9]+([eE][-+]?[0-9]+)?)/
+      # T_INTEGER = /\A([0-9]+)/
+      # T_UNDEFINED = /\A(nil)/
+      # T_BOOLEAN_TRUE = /\A(true)/
+      # T_BOOLEAN_FALSE = /\A(false)/
+      #
+      # # Operation Signs
+      # T_MULTIPLICATIVE = /\A(\*\*|\*|\/)/
+      # T_ADDITIVE = /\A(\<\<|\+|\-)/
+      # T_EQUALITY = /\A(\<\=|\<|\>\=|\>|\=\=)/
+      # T_BOOLEAN_NOT = /\A(\!|not)/
+      # T_BOOLEAN_AND = /\A(\&\&|and)/
+      # T_BOOLEAN_OR = /\A(\|\||or)/
+      #
+      # # Operation Signs Lookahead
+      # T_SIGN_LOOKAHEAD = /\A\*\*|\*|\/|\+|\-|\<\<|\<\=|\<|\>\=|\>|\=\=|\=|\!|not|\&\&|and|\|\||or/
+      #
+      # # Whitespace
+      # T_WHITESPACE = /\A( +)/
+      # T_NEWLINE = /\A(\n*)/
+      # T_INDENT = /\A( *)/
+      #
+      # # Whitespace Lookahead
+      # T_INDENT_LOOKAHEAD = /\A\n?( *)/
+      #
+      # # Line and char feeds
+      # T_LINE_FEED = /\A(.*)/
+      # T_CHAR_FEED = /\A([\s\S])/
+      # T_UNESCAPED_TEXT = /\A\!(.*)/
+      # T_UNESCAPED_MULTILINE_TEXT = /\A(\!\=)/
+      # T_ESCAPED_MULTILINE_TEXT = /\A(\=)/
+    end
+  end
+end