opulent 1.5.5 → 1.6.0

data/.libold/opulent/preprocessor.rb

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

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

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

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