h2o 0.2

data/lib/core_ext/object.rb

@@ -0,0 +1,13 @@
+class Object
+  def self.h2o_expose(*attrs)
+    @h2o_safe = attrs
+  end
+  
+  def self.h2o_safe_methods
+    @h2o_safe
+  end
+  
+  def to_h2o
+    self
+  end
+end

data/lib/h2o.rb

@@ -0,0 +1,43 @@
+module H2o
+  require 'pathname'
+
+  class Template
+    attr_reader :context
+    
+    def initialize (filename, env = {})
+      @file = Pathname.new(filename)
+      env[:search_path] = @file.dirname
+      @nodelist = Template.load(@file, env)
+    end
+    
+    def render (context = {})
+      @context = Context.new(context)
+      output_stream = []
+      @nodelist.render(@context, output_stream)
+      output_stream.join
+    end
+
+    def self.parse source, env = {}
+      parser = Parser.new(source, false, env)
+      parsed = parser.parse
+    end
+    
+    def self.load file, env = {}
+      file = env[:search_path] + file if file.is_a? String
+      parser = Parser.new(file.read, file, env)
+      parser.parse
+    end
+  end
+end
+
+require File.dirname(__FILE__) + '/core_ext/object'
+
+require File.dirname(__FILE__) + '/h2o/constants'
+require File.dirname(__FILE__) + '/h2o/errors'
+require File.dirname(__FILE__) + '/h2o/nodes'
+require File.dirname(__FILE__) + '/h2o/tags'
+require File.dirname(__FILE__) + '/h2o/parser'
+require File.dirname(__FILE__) + '/h2o/context'
+require File.dirname(__FILE__) + '/h2o/filters'
+
+

data/lib/h2o/constants.rb

@@ -0,0 +1,40 @@
+
+module H2o
+  BLOCK_START = '{%'
+  BLOCK_END = '%}'
+  VAR_START = '{{'
+  VAR_END = '}}'
+  COMMENT_START = '{*'
+  COMMENT_END = '*}'
+
+  PIPE_RE = /\|/
+  SEPERATOR_RE = /,/
+  FILTER_END_RE = /;/
+  
+  NIL_RE = /nil|null|none/
+  WHITESPACE_RE = /\s+/m
+  BOOLEAN_RE = /true|false/
+  NUMBER_RE = /\d+(\.\d*)?/
+  OPERATOR_RE = /(?:>=|<=|!=|==|>|<|!|and|not|or)/
+  
+  STRING_RE = /
+    (?:
+      "([^"\\]*(?:\\.[^"\\]*)*)"
+      |
+      '([^'\\]*(?:\\.[^'\\]*)*)'
+    )
+    /xm
+  
+  IDENTIFIER_RE = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+  NAME_RE = /
+    #{IDENTIFIER_RE}
+    (?:\.[a-zA-Z0-9][a-zA-Z0-9_-]*)*
+  /x
+
+  NAMED_ARGS_RE = /
+    (#{NAME_RE})(?:#{WHITESPACE_RE})?
+    :
+    (?:#{WHITESPACE_RE})?(#{STRING_RE}|#{NUMBER_RE}|#{NAME_RE})
+  /x
+end

data/lib/h2o/context.rb

@@ -0,0 +1,158 @@
+module H2o
+  class Context
+
+    def initialize(context ={})
+      @stack = [context]
+      @filter_env = Filters.build(self)
+    end
+
+    # doing a reverse lookup
+    # FIXME: need to double check this, also changed Block#add_layer in reverse order
+    def [](name)
+      @stack.each do |layer|
+        value = layer[name]
+        return value unless value.nil?
+      end
+      nil
+    end
+    
+    def []=(name, value)
+      @stack.first[name] = value
+    end
+
+    def pop
+      @stack.shift if @stack.size > 1
+    end
+    
+    def push(hash = {})
+      @stack.unshift hash
+    end
+    
+    def stack
+      result = nil
+      push
+      begin
+        result = yield
+      ensure
+        pop
+      end
+      result
+    end
+
+    def resolve(name)
+      return name unless name.is_a? Symbol
+      
+      object = self
+      parts = name.to_s.split('.')
+      part_sym = nil
+
+      parts.each do |part|
+        part_sym = part.to_sym
+
+        # Hashes
+        if object.respond_to?(:has_key?) && (object.has_key?(part_sym) || object.has_key?(part))
+            result = object[part_sym] || object[part]
+            # Proc object with extra caution
+            begin
+              result = object[part_sym] = result.call if result.is_a?(Proc) && object.respond_to?(:[]=)
+            rescue
+              return nil
+            end
+            object = result.to_h2o
+      
+        # Array and Hash like objects
+        elsif part.match(/^-?\d+$/)
+          if (object.respond_to?(:has_key?) || object.respond_to?(:fetch)) && value = object[part.to_i]
+            object = value.to_h2o
+          else
+            return nil
+          end
+        
+        # H2o::DataObject Type
+        elsif (object.is_a?(DataObject) || object.class.h2o_safe_methods && object.class.h2o_safe_methods.include?(part_sym) )&& \
+              object.respond_to?(part_sym)
+          object = object.__send__(part_sym).to_h2o
+        
+        # Sweet array shortcuts
+        elsif object.respond_to?(part_sym) && [:first, :length, :size, :last].include?(part_sym)
+          object = object.__send__(part_sym).to_h2o
+        else
+          return nil
+        end
+      end
+      
+      object
+    end
+
+    def has_key?(key)
+      !send(:[], key).nil?
+    end
+    
+    def apply_filters(object, filters)
+      filters.each do |filter|
+        name, *args = filter
+
+        raise FilterError, "Filter(#{name}) not found" unless @filter_env.respond_to?(name)
+        
+        args.map! do |arg|
+          if arg.kind_of? Symbol
+            resolve(arg)
+          else
+            arg
+          end
+        end
+
+        object = @filter_env.__send__(name, object, *args)
+      end
+      object
+    end
+
+  end
+  
+  class DataObject
+    INTERNAL_METHOD = /^__/
+    @@required_methods = [:__send__, :__id__, :object_id, :respond_to?, :extend, :methods, :class, :nil?, :is_a?]
+
+    def respond_to?(method)
+      method_name = method.to_s
+      return false if method_name =~ INTERNAL_METHOD
+      return false if @@required_methods.include?(method_name)
+      super
+    end
+
+    # remove all standard methods for security
+    instance_methods.each do |m|
+      unless @@required_methods.include?(m.to_sym)
+        undef_method m
+      end
+    end 
+  end
+  
+  class BlockContext < DataObject
+    
+    def self.h2o_safe_methods
+      [:super]
+    end
+    
+    def to_h2o
+      self
+    end
+    
+    def initialize(block, context, stream, index)
+      @block, @context, @stream, @index = block, context, stream, index
+    end
+    
+    def super
+      @block.parent.render(@context, @stream, @index-1) if @block.parent and @block.parent.stack_size > @index.abs
+      nil
+    end
+    
+    def depth
+      @index.abs
+    end
+    
+    def name
+      @block.name
+    end
+  end
+end

data/lib/h2o/datatype.rb

@@ -0,0 +1,11 @@
+module H2o
+  class Stream < Array
+    def << (item)
+      unshift item.to_s
+    end
+    
+    def close
+      reverse!
+    end
+  end
+end

data/lib/h2o/errors.rb

@@ -0,0 +1,7 @@
+module H2o
+  class RuntimeError < Exception ;end
+  class SyntaxError < Exception ;end
+  class TemplateNotFound < Exception ;end
+  class ParserError < Exception ;end
+  class FilterError < Exception ;end
+end

data/lib/h2o/filters.rb

@@ -0,0 +1,49 @@
+module H2o
+  module Filters
+    
+    class Base < H2o::DataObject
+      def initialize(context)
+        @context = context
+      end
+    end
+
+    @filters = []
+
+    # Class methods of filters
+    class << self
+      def [] name
+        @filters[name]
+      end
+      
+      def << (filter)
+        @filters << filter
+      end
+      
+      def register filter
+        @filters << filter
+      end
+      
+      def build(context)
+        @base = Base.new(context)
+
+        @filters.each do |filter|
+          @base.extend(filter)
+        end
+
+        @base
+      end
+      
+      def create name, &block
+        Base.class_eval do
+          define_method name, &block
+        end
+      end
+      
+      def all
+        @filters
+      end
+    end
+  end
+end
+
+require File.dirname(__FILE__) + '/filters/default'

data/lib/h2o/filters/default.rb

@@ -0,0 +1,47 @@
+module DefaultFilters
+  
+  # String filters
+  def upper string
+    string.to_s.upcase
+  end
+  
+  def lower string
+    string.to_s.downcase
+  end
+  
+  def capitalize string
+    string.to_s.capitalize
+  end
+
+  def escape string, attribute=false
+    string = string.dup.to_s
+
+    {
+      '&' => '&',
+      '>' => '>',
+      '<' => '&lt;'
+    }.each do |v, k|
+      string.tr!(v, k)
+    end
+    
+    string.gsub!(/"/, '&quot;') if attribute
+
+    string
+  end
+
+  # Array Filters
+  def join(list, delimiter=', ')
+    list.join(delimiter)
+  end
+
+  def first(list)
+    list.first
+  end
+
+  def last(list)
+    list.last
+  end
+
+
+  H2o::Filters << self
+end

data/lib/h2o/nodes.rb

@@ -0,0 +1,68 @@
+module H2o
+  class Node 
+    def initialize(parser, position = 0)
+      raise "Subclass should implement initialize method"
+    end
+    
+    def render(context, stream)
+      raise "Subclass should implement method method"
+    end
+  end
+  
+  # Nodelist
+  #
+  class Nodelist < Node
+    attr_reader :parser
+    
+    def initialize(parser, position = 0)
+     @parser = parser
+     @stack = []  
+    end
+    
+    def render(context = {}, stream = false)
+      stream = [] unless stream
+      context = Context.new(context) if context.is_a? Hash
+
+      @stack.each do |node|
+        node.render(context, stream)
+      end
+      
+      stream.join
+    end
+    
+    def <<(node)
+      @stack << node
+    end
+
+    def length
+      @stack.length
+    end
+  end
+  
+  class TextNode < Node
+    def initialize(content)
+      @content = content
+    end
+
+    def render(context, stream)
+      stream << @content
+    end
+  end
+  
+  class VariableNode < Node
+    def initialize (name, filters)
+      @name = name
+      @filters = filters.empty? ? nil : filters
+    end
+    
+    def render(context, stream)
+      variable = @name.is_a?(Symbol) ? context.resolve(@name) : @name
+      variable = context.apply_filters(variable, @filters) if @filters
+      stream << variable
+    end
+  end
+
+  class CommentNode < Node
+  end
+
+end