h2o 0.2

data/lib/h2o/parser.rb

@@ -0,0 +1,225 @@
+module H2o
+  class Parser 
+    attr_reader :token, :env
+    attr_accessor :storage
+    
+    ParseRegex = /\G
+      (.*?)(?:
+        #{Regexp.escape(BLOCK_START)}    (.*?)
+        #{Regexp.escape(BLOCK_END)}          |
+        #{Regexp.escape(VAR_START)}      (.*?)
+        #{Regexp.escape(VAR_END)}            |
+        #{Regexp.escape(COMMENT_START)}  (.*?)
+        #{Regexp.escape(COMMENT_END)}
+      )(?:\r?\n)?
+    /xm
+
+    def initialize (source, filename, env = {})
+      @env = env
+      @storage = {}
+      @source = source
+      @filename = filename
+      @tokenstream = tokenize
+      @first = true
+    end
+
+    def tokenize
+      result = []
+      lstrip = false
+      rstrip = false
+
+      @source.scan(ParseRegex).each do |match|
+        result << [:text, match[0]] if match[0] and !match[0].empty?
+        # strip next left white spaces
+        result.last[1].lstrip! if lstrip
+
+        if data = match[1]
+          data = data.strip
+          
+          # strip right whitespaces on previous text node
+          if rstrip = data[0].chr == "-"
+            data.slice!(0)
+            result.last[1].rstrip! if rstrip
+          end
+          
+          if lstrip = data[data.length-1].chr == "-"
+            data.chop!
+          end
+
+          result << [:block, data.strip]
+        elsif data = match[2]
+          result << [:variable, data.strip]
+        elsif data = match[3]
+          result << [:comment, data.strip]
+        end
+      end
+      
+      rest = $~.nil? ? @source : @source[$~.end(0) .. -1]
+      unless rest.empty?
+        result << [:text, rest]
+        # strip next left white spaces
+        result.last[1].lstrip! if lstrip
+      end
+      result.reverse
+    end
+    
+    def first?
+      @first
+    end
+    
+    def parse(*untils)
+      nodelist = Nodelist.new(self)
+      
+      while @token = @tokenstream.pop
+        token, content = @token
+        case token
+          when :text
+            nodelist << TextNode.new(content) unless content.empty?
+          when :variable
+            names = []
+            filters = []
+            Parser.parse_arguments(content).each do |argument|
+              if argument.is_a? Array
+                filters << argument
+              else
+                names << argument
+              end
+            end
+            nodelist << VariableNode.new(names.first, filters)
+          when :block
+            name, args = content.split(/\s+/, 2)
+            name = name.to_sym
+            
+            if untils.include?(name)
+              return nodelist
+            end
+            
+            tag = Tags[name]
+            raise "Unknow tag #{name}" if tag.nil?
+            
+            nodelist << tag.new(self, args) if tag
+          when :comment
+            nodelist << CommentNode.new(content)
+        end
+        @first = false
+      end
+      nodelist
+    end
+
+    def self.parse_arguments (argument)
+      result = current_buffer = []
+      filter_buffer = []
+      data = nil
+      ArgumentLexer.lex(argument).each do |token|
+        token, data = token
+        case token
+          when :filter_start
+            current_buffer = filter_buffer.clear
+          when :filter_end
+            result << filter_buffer.dup unless filter_buffer.empty?
+            current_buffer = result
+          when :nil
+            current_buffer << nil
+          when :boolean
+            current_buffer << (data == 'true'? true : false)
+          when :name
+            current_buffer << data.to_sym
+          when :number
+            current_buffer << (data.include?('.') ? data.to_f : data.to_i)
+          when :string
+            data.match(STRING_RE)
+            current_buffer << ($1 || $2)
+          when :named_argument
+            current_buffer << {} unless current_buffer.last.is_a?(Hash)
+            
+            named_args = current_buffer.last
+            name, value = data.split(':', 2).map{|m| m.strip}
+            named_args[name.to_sym] = parse_arguments(value).first
+          when :operator
+            # replace exclaimation mark '!' into not
+            data = 'not' if data == '!'
+            current_buffer << {:operator => data.to_sym}
+        end
+      end
+      result
+    end
+    
+    def pretty_print pp
+      nil
+    end
+  end
+  
+  class ArgumentLexer
+    require 'strscan'
+
+    def initialize(argstring, pos = 0)
+      @argument = argstring
+    end
+    
+    def self.lex(argstring)
+      new(argstring).lexer()
+    end
+    
+    def lexer
+      s = StringScanner.new(@argument)
+      state = :initial
+      result = []
+      while ! s.eos?
+        next if s.scan(WHITESPACE_RE)
+        
+        if state == :initial
+          if match = s.scan(OPERATOR_RE)
+            result << [:operator, match]
+          elsif match = s.scan(BOOLEAN_RE)
+            result << [:boolean, match]
+          elsif match = s.scan(NIL_RE)
+            result << [:nil, match]
+          elsif match = s.scan(NAMED_ARGS_RE)
+            result << [:named_argument, match]
+          elsif match = s.scan(NAME_RE)
+            result << [:name, match]
+          elsif match = s.scan(PIPE_RE)
+            state = :filter
+            result << [:filter_start, nil]
+          elsif match = s.scan(SEPERATOR_RE)
+            result << [:seperator, nil]
+          elsif match = s.scan(STRING_RE)
+            result << [:string, match]
+          elsif match = s.scan(NUMBER_RE)
+            result << [:number, match]
+          else 
+            raise SyntaxError, "unexpected character #{s.getch} in tag"
+          end
+        elsif state == :filter
+          if match = s.scan(PIPE_RE)
+            result << [:filter_end, nil]
+            result << [:filter_start, nil]
+          elsif match = s.scan(SEPERATOR_RE)
+            result << [:seperator, nil]
+          elsif match = s.scan(FILTER_END_RE)
+            result << [:filter_end, nil]
+            state = :initial
+          elsif match = s.scan(BOOLEAN_RE)
+            result << [:boolean, match]
+          elsif match = s.scan(NIL_RE)
+            result << [:nil, match]
+          elsif match = s.scan(NAMED_ARGS_RE)
+            result << [:named_argument, match]
+          elsif match = s.scan(NAME_RE)
+            result << [:name, match]
+          elsif match = s.scan(STRING_RE)
+            result << [:string, match]
+          elsif match = s.scan(NUMBER_RE)
+            result << [:number, match]
+          else 
+            raise SyntaxError, "unexpected character #{s.getch} in filter"
+          end
+        end
+      end
+      result << [:filter_end, nil]  if state == :filter
+
+      result
+    end
+  
+  end
+end

data/lib/h2o/tags.rb

@@ -0,0 +1,22 @@
+module H2o
+  module Tags
+    @tags = {}
+    class << self
+      def [] name
+        @tags[name]
+      end
+
+      def register(tag, name)
+        @tags[name] = tag
+      end
+    end
+    
+    class Tag < Node; end
+  end
+end
+
+require File.dirname(__FILE__) + '/tags/if'
+require File.dirname(__FILE__) + '/tags/for'
+require File.dirname(__FILE__) + '/tags/block'
+require File.dirname(__FILE__) + '/tags/with'
+require File.dirname(__FILE__) + '/tags/recurse'

data/lib/h2o/tags/block.rb

@@ -0,0 +1,64 @@
+module H2o
+  module Tags
+    # Block tag allows to divide document into reusable blocks
+    #
+    class Block < Tag
+      attr_reader :name
+      attr_accessor :parent
+
+      def initialize parser, argstring
+        @name = argstring.to_sym
+        @stack = [ parser.parse(:endblock) ]
+        blocks = parser.storage[:blocks] ||= {}
+        raise SyntaxError, "block name needs to be unique" if blocks.include? @name
+        blocks[@name] = self
+      end
+
+      def stack_size
+        @stack.size
+      end
+
+      def add_layer nodelist
+        @stack << nodelist
+      end
+
+      def render context, stream, index=-1
+        context.stack do
+          context[:block] = BlockContext.new(self, context, stream, index)
+          @stack[index].render(context, stream)
+        end
+      end
+      Tags.register(self, :block)
+    end
+
+    class Extends < Tag
+      Syntax = /\"(.*?)\"|\'(.*?)\'/
+      
+      def initialize parser, argstring
+        unless parser.first? 
+          raise SyntaxError, "extend tag needs to be at the beginning of the document"
+        end
+        # parser the entire subtemplate
+        parser.parse()
+
+        # load the parent template into nodelist
+        @nodelist = Template.load(argstring[1...-1], parser.env)
+        
+        blocks = @nodelist.parser.storage[:blocks] || {}
+        
+        (parser.storage[:blocks] || []).each do |name, block|
+          if blocks.include? name
+            blocks[name].add_layer(block)
+            block.parent =  blocks[name]
+          end
+        end
+      end
+
+      def render context, stream
+       @nodelist.render(context, stream)
+      end
+      
+      Tags.register(self, :extends)
+    end
+  end
+end

data/lib/h2o/tags/for.rb

@@ -0,0 +1,76 @@
+module H2o
+  module Tags
+    class For < Tag
+      Syntax = /
+        (?:(#{H2o::IDENTIFIER_RE}),\s?)?
+        (#{H2o::IDENTIFIER_RE})\s+in\s+(#{H2o::NAME_RE})\s*
+        (reversed)?
+      /x
+
+      def initialize(parser, argstring)
+        @key = false
+        @else = false
+        @body = parser.parse(:else, :endfor)
+        @else = parser.parse(:endfor) if parser.token && parser.token.include?('else')
+        
+        if matches = Syntax.match(argstring)
+          @key = $1.to_sym unless $1.nil?
+          @item = $2.to_sym
+          @iteratable = $3.to_sym
+          @reverse = !$4.nil?
+        else
+          raise SyntaxError, "Invalid for loop syntax "
+        end
+      end
+
+      def render(context, stream)
+        iteratable = context.resolve(@iteratable)
+        iteratable.reverse! if @reverse
+        length = 0
+
+        if iteratable.respond_to?(:each)
+          length = iteratable.size || iterabe.length
+        end
+        
+        if length > 0
+          parent = context[:loop]
+          # Main iteration
+          context.stack do
+            iteratable.each_with_index do |*args|
+              value, index = args
+
+              if args.first.is_a? Array
+                key, value = value
+              else
+                key = index
+              end
+
+              is_even = index % 2 != 0
+              rev_count = length - index
+              context[@item] = value
+              context[@key] = key
+              context[:loop] = {
+                :parent => parent,
+                :first => index == 0,
+                :last => rev_count == 1,
+                :counter => index + 1,
+                :counter0 => index,
+                :revcounter => rev_count,
+                :revcounter0 => rev_count - 1,
+                :even => is_even,
+                :odd => !is_even
+              }
+              @body.render(context, stream)
+            end
+          end
+        else
+          # Else statement
+          @else.render(context, stream) if @else
+        end
+        nil
+      end
+      Tags.register(self, :for)
+    end
+
+  end
+end

data/lib/h2o/tags/if.rb

@@ -0,0 +1,77 @@
+module H2o
+  module Tags
+    class If < Tag
+      @else = false
+      @negated = false
+      
+      def initialize(parser, argstring)  
+        raise SyntaxError, "If tag doesn't support Keywords(and or)" if argstring =~ / and|or /
+
+        @body = parser.parse(:else, :endif)
+        @else = parser.parse(:endif) if parser.token.include? 'else'
+        @args = Parser.parse_arguments(argstring)
+        
+        # Negated condition
+        first = @args.first
+        if first.is_a?(Hash) && first[:operator] && [:"!", :not].include?(first[:operator])
+         @negated = true
+         @args.shift
+        end
+      end
+
+      def render(context, stream)
+        if self.evaluate(context)
+          @body.render(context, stream)
+        else
+          @else.render(context, stream) if @else
+        end
+      end
+      
+      def evaluate(context)
+        # Implicity evaluation
+        if @args.size == 1
+          object = context.resolve(@args.first)
+          if object == false
+            result = false
+          elsif object == true
+            result = true
+          elsif object.respond_to? :length
+            result = object.length != 0
+          elsif object.respond_to? :size
+            result = object.size != 0
+          else
+            result = !object.nil?
+          end
+        # Comparisons
+        elsif @args.size == 3
+          left, op, right = @args
+          right = context.resolve(right)
+          left = context.resolve(left)
+          
+          result = comparision(op[:operator], left, right)
+        end
+
+        return @negated ? !result : result
+      end
+      
+      def comparision(operator, left, right)
+        case operator
+          when :> 
+            left > right
+          when :>=
+            left >= right
+          when :==
+            left == right
+          when :<
+            left < right
+          when :<=
+            left <= right
+          else
+            false
+        end
+      end
+      
+      Tags.register(self, :if)
+    end
+  end
+end