opulent 1.5.5 → 1.6.0

data/.libold/opulent/parser/node.rb

@@ -1,232 +0,0 @@
-# @Opulent
-module Opulent
-  # @Parser
-  module Parser
-    # @node
-    module Node
-      # Check if we match an node node with its attributes and possibly
-      # inline text
-      #
-      # node [ attributes ] Inline text
-      #
-      # @param parent [Node] Parent node to which we append the node
-      #
-      def node(parent, indent = nil)
-        if (name = lookahead :identifier_lookahead)
-          return nil if Tokens.keyword name
-
-          # Get current line's indentation
-          unless indent
-            indent = accept_unstripped(:indent) || ""
-            indent = indent.size
-          end
-
-          # Get a theme if set, or set append definitions to the default
-          # element namespace
-          if (theme_name = accept_unstripped(:theme_node))
-            theme_name = theme_name.to_sym
-          else
-            theme_name = Engine::DEFAULT_THEME
-          end
-
-          # Accept either explicit node_name or implicit :div node_name
-          # with shorthand attributes
-          if (node_name = accept :identifier)
-            shorthand = shorthand_attributes
-          elsif (shorthand = shorthand_attributes)
-            node_name = :div
-          end
-
-          # Get leading and trailing whitespace
-          if accept_line_unstripped :leading_whitespace
-            leading_whitespace = true
-            if accept_line_unstripped :leading_trailing_whitespace
-              trailing_whitespace = true
-            end
-          elsif accept_line_unstripped :trailing_whitespace
-            trailing_whitespace = true
-          end
-
-          # Get wrapped node attributes
-          atts = attributes(shorthand) || {}
-
-          # Inherit attributes from definition
-          extension = extend_attributes
-
-          # Get unwrapped node attributes
-          atts = attributes_assignments atts, false
-
-          # Create a new node and set its extension
-          _node = @create.node node_name.to_sym, atts, parent, indent, []
-          _node.extension = extension
-          _node.theme = theme_name
-          _node.whitespace = [leading_whitespace, trailing_whitespace]
-
-          if(accept_line :inline_child)
-            if (child_node = node _node, indent + Engine[:indent])
-              _node.push child_node
-            else
-              error :inline_child
-            end
-          end
-
-          if(close = accept_line :self_enclosing)
-            _node.self_enclosing = true
-            unless close.strip.empty?
-              undo close
-              error :self_enclosing
-            end
-          end
-
-          # Accept inline text or multiline text feed as first child
-          if(text_node = text _node, " " * indent, false)
-            text_node.indent += Engine[:indent]
-            _node.push text_node unless text_node.nil?
-          end
-
-          return _node
-        end
-      end
-
-      def shorthand_attributes(atts = {})
-        find_shorthand = Proc.new do
-          Engine[:shorthand].find do |key, value|
-            if accept_unstripped :"shorthand@#{key}"
-              key
-            else
-              false
-            end
-          end
-        end
-
-        while (attribute = find_shorthand[])
-          key = attribute[0]
-
-          # Get the attribute value and process it
-          if (value = accept_unstripped(:identifier))
-            value = @create.expression "\"#{value}\""
-          elsif (value = (accept_unstripped(:exp_string) || paranthesis))
-            value = @create.expression "#{value}"
-          else
-            error :shorthand
-          end
-
-          # IDs are unique, the rest of the attributes turn into arrays in
-          # order to allow multiple values or identifiers
-          if key == :id
-            atts[key] = value
-          else
-            if atts[key].is_a? Array
-              atts[key] << value
-            elsif atts[key]
-              atts[key] = [atts[key], value]
-            else
-              atts[key] = [value]
-            end
-          end
-        end
-
-        return atts
-      end
-
-      # Extend node attributes with hash from
-      #
-      # [hash]
-      #
-      def extend_attributes
-        if (accept_unstripped :extend_attributes)
-          bracket = accept_unstripped :brackets, :*
-          extension = expression
-          accept bracket.to_sym, :*
-          return extension
-        end
-      end
-
-      # Check if we match node attributes
-      #
-      # [ assignments ]
-      #
-      # @param as_parameters [Boolean] Accept or reject identifier nodes
-      #
-      def attributes(list)
-        if (bracket = accept_unstripped :brackets)
-          attributes_assignments list
-          accept bracket.to_sym, :*
-        end
-
-        return list
-      end
-
-      # Check if we match an expression node or
-      # a node node
-      #
-      # [ assignments ]
-      #
-      # @param parent [Hash] Parent to which we append nodes
-      # @param as_parameters [Boolean] Accept or reject identifier nodes
-      #
-      def attributes_assignments(parent, wrapped = true)
-        unless wrapped
-          return parent if lookahead(:assignment_lookahead).nil?
-        end
-
-        if (argument = accept :identifier)
-          argument = argument.to_sym
-
-          if accept :assignment
-            # Check if we have an attribute escape or not
-            escaped = if accept_unstripped :assignment_unescaped
-              false
-            else
-              true
-            end
-
-            # Get the argument value if we have an assignment
-            if (value = expression(false, wrapped))
-              value.escaped = escaped
-
-              # Check if our argument already exists in the attributes list, and
-              # if it does, check if it's an array. If it isn't, turn it into an
-              # array literal, otherwise push the value into it. However, id
-              # attributes do not get turned into arrays as they are supposed
-              # to be unique
-              if parent[argument] && argument != :id
-                # Check if argument is already an array, otherwise create an
-                # array in which we will add values
-                if parent[argument].is_a? Array
-                  parent[argument] << value
-                else
-                  new_parent = []
-                  new_parent.push parent[argument]
-
-                  parent[argument] = new_parent
-                  parent[argument] << value
-                end
-              else
-                parent[argument] = value
-              end
-            else
-              error :assignments_colon
-            end
-          else
-            parent[argument] = @create.expression "true" unless parent[argument]
-          end
-
-          # If our attributes are wrapped, we allow method calls without
-          # paranthesis, ruby style, therefore we need a terminator to signify
-          # the expression end. If they are not wrapped (inline), we require
-          # paranthesis and allow inline calls
-          if wrapped && accept_line(:assignment_terminator)
-            attributes_assignments parent, wrapped
-          elsif lookahead(:assignment_lookahead)
-            attributes_assignments parent, wrapped
-          end
-
-          return parent
-        elsif !parent.empty?
-          error :assignments_comma
-        end
-      end
-    end
-  end
-end

data/.libold/opulent/parser/root.rb

@@ -1,96 +0,0 @@
-# @Opulent
-module Opulent
-  # @Parser
-  module Parser
-    # @Root
-    module Root
-      # Check if we match any root element. This is the starting point of the
-      # parser and it checks for any elements which can be considered as root
-      #
-      # @param parent [Node] Parent element to append to
-      # @param min_indent [Integer] Minimum indent to which the root responds
-      #
-      def root(parent)
-        # Starting line of the root method
-        starting_line = @current_line
-
-        # Skip any whitespace at the beginning of the document
-        accept_unstripped :newline
-
-        if(element = define(parent))
-          # Add definition elements to the root's knowledgebase and add elements
-          # and evaluate elements to their parent elements
-          if parent.is_a? Nodes::Root
-            @root.themes[Engine::DEFAULT_THEME][element.name] = element
-          elsif parent.is_a? Nodes::Theme
-            @root.themes[parent.name][element.name] = element
-          else
-            error :definition
-          end
-        elsif(element = theme(parent))
-          # Theme nodes cannot be nested, so we accept only a root parent and
-          # we add the node in the themes hash and we allow reopening the theme
-          # and adding more definitions to it, ruby style
-          if parent.is_a? Nodes::Root
-            @root.themes[element.name] ||= {}
-          else
-            error :theme
-          end
-        elsif (element =  node(parent)                ||
-                          text(parent)                ||
-                          comment(parent)             ||
-                          control(parent)             ||
-                          evaluate(parent)            ||
-                          filter_element(parent)      ||
-                          html_text(parent))
-          parent.push element
-        elsif (element = block_yield(parent))
-          # Handle yield node by searching for ther definition parent node
-          yield_parent = element.parent
-          begin
-            until [Nodes::Define, Nodes::Root].include? yield_parent.class
-              yield_parent = yield_parent.parent
-            end
-          rescue NoMethodError
-            error :yield_parent
-          end
-
-          # Add the yield element to the parent and keep a pointer to the parent
-          # for each yield element to avoid recursive searching as much as
-          # possible
-          parent.push element
-          yield_parent.yields << parent
-        elsif (element = block(parent))
-          # Blocks will be set as separate entities for the parent element in
-          # order to replace them fast in the definition yields
-          parent.blocks[element.name] ||= []
-          parent.blocks[element.name] << element
-        end
-
-        next_indent = lookahead(:indent_lookahead, false).length
-        if element
-          if next_indent > element.indent
-            # If we have an indentation which is greater than the current one,
-            # set the current element as a root element and add children to it
-            root element
-          elsif next_indent < element.indent
-            # If we have an indentation which is smaller than the current one,
-            # go through the current element's ancestors until we find one with
-            # the same indentation as the next element
-            next_parent = element.parent
-            while next_parent.indent > next_indent
-              next_parent = next_parent.parent
-            end
-            next_parent = next_parent.parent
-
-            root next_parent
-          else
-            # If the indentation level stays the same, the parent element will
-            # remain the current one
-            root parent
-          end
-        end
-      end
-    end
-  end
-end

data/.libold/opulent/parser/text.rb

@@ -1,114 +0,0 @@
-# @SugarCube
-module Opulent
-  # @Parser
-  module Parser
-    # @Text
-    module Text
-      # Match one line or multiline, escaped or unescaped text
-      #
-      def text(parent, indent = nil, only_multiline = true)
-        indent = indent || accept_unstripped(:indent) || ""
-
-        # Try to see if we can match a multiline operator. If we can accept only
-        # multiline, which is the case for filters, undo the operation.
-        if accept_line :multiline
-          multiline = true
-        elsif only_multiline
-          return undo indent unless lookahead :print_lookahead
-        end
-
-        indent = indent.size
-
-        # Unescaped Print Eval
-        if (text_feed = accept_unstripped :unescaped_print)
-          text_node = @create.print(text_feed.strip, false, parent, indent)
-        # Escaped Print Eval
-        elsif (text_feed = accept_unstripped :escaped_print)
-          text_node = @create.print(text_feed.strip, true, parent, indent)
-        # Unescaped Text
-        elsif (text_feed = accept_unstripped :unescaped_text)
-          text_node = @create.text(text_feed.strip, false, parent, indent)
-        # Escaped Text
-        elsif (text_feed = accept_unstripped :escaped_text)
-          text_node = @create.text(text_feed.strip, true, parent, indent)
-        else
-          # Undo by adding the found intentation back
-          undo indent
-          return nil
-        end
-
-
-        if text_node
-          text_node
-          if multiline
-            text_node.value += accept_unstripped(:newline) || ""
-            text_node.value += get_indented_lines(indent)
-
-            text_node
-          else
-            accept_unstripped :newline
-
-            text_node.value.strip!
-            text_node.value = text_node.value[1..-1] if text_node.value[0] == '\\'
-            text_node.value.size > 0 ? text_node : nil
-          end
-        else
-          return nil
-        end
-      end
-
-      # Match one line or multiline, escaped or unescaped text
-      #
-      def html_text(parent)
-        indent = accept_unstripped(:indent) || ""
-        indent_size = indent.size
-
-        if (text_feed = accept_unstripped :html_text)
-          text_node = @create.text(text_feed.strip, false, parent, indent_size)
-          accept_unstripped :newline
-          pp text_feed
-          return text_node
-        else
-          return undo indent
-        end
-      end
-
-      # Match a whitespace by preventing code trimming
-      #
-      def whitespace(required = false)
-        accept_unstripped :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 = ''
-
-        # Get the next indentation after the parent line
-        # and set it as primary indent
-        first_indent = lookahead(:indent_lookahead, false).size
-        next_indent = first_indent
-
-        # While the indentation is smaller, add the line feed  to our buffer
-        while next_indent > indent
-          # Get leading whitespace trimmed with first_indent's size
-          next_line_indent = accept_unstripped(: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_unstripped(:line_feed) || ""
-          buffer += accept_unstripped(:newline) || ""
-
-          # Get next indentation and repeat
-          next_indent = lookahead(:indent_lookahead, false).size
-        end
-
-        buffer
-      end
-    end
-  end
-end

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

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