opulent 0.0.9 → 1.0.2

data/.libold/opulent/parser/filter.rb

@@ -0,0 +1,41 @@
+# @SugarCube
+module Opulent
+  # @Parser
+  module Parser
+    # @Text
+    module Filter
+      # Check if we match an compile time filter
+      #
+      # :filter
+      #
+      # @param parent [Node] Parent node to which we append the element
+      #
+      def filter_element(parent)
+        if lookahead :filter_lookahead
+          # Get current line's indentation
+          indent = accept_unstripped(:indent) || ""
+
+          if (filter_name = accept :filter)
+            # Get element attributes
+            atts = attributes({}) || {}
+
+            # Create a new node and set its extension
+            filter_node = @create.filter filter_name.to_sym, atts, parent, indent.size
+
+            # Accept inline text or multiline text feed as first child
+            if(text_node = text filter_node, indent, true)
+              #filter_node.atts = accept_unstripped(:line_feed)
+              error :fiter unless accept_line(:line_feed).strip.empty?
+            end
+            accept_unstripped(:newline)
+
+            # Get everything under the filter and set it as the node value
+            filter_node.value += get_indented_lines(indent.size)
+
+            return filter_node
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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