cerubis 0.0.1

data/examples/variables.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'cerubis'
+
+content = <<-STR
+  Welcome {{name}}!
+  You are {{age}} years old today
+STR
+
+template = Cerubis.render(content, name: 'Dane Harrigan', age: 26)
+puts template.to_html

data/lib/cerubis.rb

@@ -0,0 +1,55 @@
+require 'cerubis/variable_replacement'
+require 'cerubis/block'
+require 'cerubis/blocks/if'
+require 'cerubis/blocks/unless'
+require 'cerubis/blocks/loop'
+
+class Cerubis
+  autoload :Node,        'cerubis/node'
+  autoload :TextNode,    'cerubis/text_node'
+  autoload :BlockNode,   'cerubis/block_node'
+  autoload :Matcher,     'cerubis/matcher'
+  autoload :Template,    'cerubis/template'
+  autoload :Parser,      'cerubis/parser'
+  autoload :Condition,   'cerubis/condition'
+  autoload :Context,     'cerubis/context'
+  autoload :Method,      'cerubis/method'
+  autoload :Helper,      'cerubis/helper'
+  autoload :SyntaxError, 'cerubis/syntax_error'
+
+  def self.register_block(name, klass)
+    blocks[name] = klass
+  end
+
+  def self.register_helper(*mods)
+    mod = mods.pop
+    mods.each { |key| helpers[key] = mod }
+  end
+
+  def self.blocks
+    @blocks ||= {}
+  end
+
+  def self.helpers
+    @helpers ||= {}
+  end
+
+  def self.render(template, context={})
+    new.render(template, context)
+  end
+
+  def render(template, context={})
+    Template.new(template, context)
+  end
+end
+
+# Patching Ruby core objects
+require 'cerubis/objects/array'
+require 'cerubis/objects/float'
+require 'cerubis/objects/fixnum'
+require 'cerubis/objects/hash'
+require 'cerubis/objects/string'
+
+Cerubis.register_block :if, Cerubis::Blocks::If
+Cerubis.register_block :unless, Cerubis::Blocks::Unless
+Cerubis.register_block :loop, Cerubis::Blocks::Loop

data/lib/cerubis/block.rb

@@ -0,0 +1,27 @@
+class Cerubis
+  module Block
+    def self.included(base)
+      base.send(:attr, :condition)
+      base.send(:attr, :node)
+    end
+
+    def initialize(options)
+      @node = options[:node]
+      @condition = Condition.new(options[:condition], :context => node.context, :type => options[:type])
+    end
+
+    def true?
+      condition.true?
+    end
+
+    def render
+      return unless true?
+      replace_variables(yield)
+    end
+
+    private
+      def context
+        node.context
+      end
+  end
+end

data/lib/cerubis/block_node.rb

@@ -0,0 +1,37 @@
+class Cerubis
+  class BlockNode
+    include Node
+    attr_accessor :block
+
+    def render
+      @render ||= begin
+        define_node!
+        parse!
+        block.render { pre_render }
+      end
+    end
+
+    def pre_render
+      return children.map(&:render).join if children?
+      content
+    end
+
+    private
+      def parse!
+        self.children = Parser.new(content, :parent => self).nodes
+      end
+
+      def define_node!
+        open_block    = content.match(/^([\s\t]*)(#{Matcher::OpenBlock})/m)
+        close_block   = Matcher::CloseBlockPlaceholder.sub('block_name', open_block[3])
+        block_name    = open_block[3].to_sym
+        condition_str = open_block[4]
+
+        content.sub!(/^#{open_block[0]}/, open_block[1])
+        content.sub!(/#{close_block}+\Z/,'')
+
+        options = { :context => context, :node => self, :condition => condition_str, :type => block_name }
+        self.block = Cerubis.blocks[block_name].new(options)
+      end
+  end
+end

data/lib/cerubis/blocks/if.rb

@@ -0,0 +1,8 @@
+class Cerubis
+  module Blocks
+    class If
+      include VariableReplacement
+      include Block
+    end
+  end
+end

data/lib/cerubis/blocks/loop.rb

@@ -0,0 +1,20 @@
+class Cerubis
+  module Blocks
+    class Loop
+      include VariableReplacement
+      include Block
+
+      def render
+        return unless true?
+        collection   = condition.context_objects[1]
+        item_key     = condition.parsed_content[0].to_sym
+        loop_context = context.dup
+
+        collection.map do |item|
+          loop_context[item_key] = item
+          replace_variables(yield, loop_context)
+        end.join
+      end
+    end
+  end
+end

data/lib/cerubis/blocks/unless.rb

@@ -0,0 +1,9 @@
+class Cerubis
+	module Blocks
+		class Unless < If
+			def true?
+				!super
+			end
+		end
+	end
+end

data/lib/cerubis/condition.rb

@@ -0,0 +1,59 @@
+class Cerubis
+  class Condition
+    attr :content
+    attr :type
+    attr :context
+    attr :context_objects
+    attr :parsed_content
+
+    def initialize(content, options={})
+      @content = content.to_s.strip
+      @context = options[:context]
+      @type    = options[:type]
+      @context_objects = []
+
+      define_condition!
+    end
+
+    def true?
+      if @parsed_content.size == 3
+        validate_object_and_operator
+      else
+        validate_object
+      end
+    end
+
+    private
+      def define_condition!
+        match = content.match Matcher::Conditions
+        @parsed_content = match ? [match[1], match[6], match[7]].compact : []
+      end
+
+      def validate_object
+        @context_objects << context.get(@parsed_content[0])
+        @context_objects[0]
+      end
+
+      def validate_object_and_operator
+        operator     = @parsed_content[1].to_sym
+        obj          = context.get(@parsed_content[0])
+        obj_compared = context.get(@parsed_content[2])
+
+        @context_objects << obj
+        @context_objects << obj_compared
+
+        case operator
+          when :==    then (obj ==  obj_compared)
+          when :===   then (obj === obj_compared)
+          when :'!='  then (obj !=  obj_compared)
+          when :<     then (obj <   obj_compared)
+          when :>     then (obj >   obj_compared)
+          when :<=    then (obj <=  obj_compared)
+          when :>=    then (obj >=  obj_compared)
+          when :in
+            raise SyntaxError, 'Invalid block conditions' unless type == :loop
+            obj_compared && !obj_compared.empty?
+        end
+      end
+  end
+end

data/lib/cerubis/context.rb

@@ -0,0 +1,30 @@
+class Cerubis
+  class Context < Hash
+    def initialize(hash={})
+      super(nil)
+      hash.each { |key, value| self[key] = value }
+    end
+
+		def get(key)
+			case key
+				when /^true$/   then true
+				when /^false$/  then false
+				when /^[0-9]+$/ then Integer(key)
+				when /^[0-9]+\.[0-9]+$/ then Float(key)
+        when /^'.*'$/ then key[1..-2]
+				else
+					object_methods = key.split('.')
+					object = self[object_methods.shift.to_sym]
+					while meth = object_methods.shift do
+            if object.respond_to?(:cerubis_respond_to?) && object.cerubis_respond_to?(meth.to_sym)
+              object = object.send(meth)
+            else
+              object = nil
+            end
+					end
+
+					object
+			end
+		end
+  end
+end

data/lib/cerubis/helper.rb

@@ -0,0 +1,12 @@
+class Cerubis
+  class Helper
+    def initialize(context)
+      @context = context
+    end
+
+    private
+      def context
+        @context
+      end
+  end
+end

data/lib/cerubis/matcher.rb

@@ -0,0 +1,19 @@
+class Cerubis
+  module Matcher
+    OpenTag       = '{{'
+    CloseTag      = '}}'
+    BlockName     = '[a-z_]+'
+    Method        = '[a-z_0-9]+'
+    ObjectMethod  = /\'([^\']*)\'|[a-z0-9_]+((\.#{Method}\??)+)?/
+    Operators     = [:==, :===, :'!=', :'!==', :<, :>, :<=, :>=, :in]
+    Conditions    = /(#{ObjectMethod})(\s*(#{Operators.join('|')})\s*(#{ObjectMethod}))?/
+    OpenBlockStr  = "#{OpenTag}\#(#{BlockName})(\s+#{Conditions})?#{CloseTag}"
+    CloseBlockPlaceholder = "#{OpenTag}\/(block_name)#{CloseTag}"
+    CloseBlockStr = CloseBlockPlaceholder.sub('block_name', BlockName)
+    OpenBlock     = /#{OpenBlockStr}/
+    CloseBlock    = /#{CloseBlockStr}/
+    Helpers       = /(#{Method})\s+(#{ObjectMethod}+(,\s+#{ObjectMethod})*)/
+    Variable      = /#{OpenTag}\s*(#{Helpers}|#{ObjectMethod})\s*#{CloseTag}/
+    CommaOutsideQuote = /,(?=(?:[^']|'[^']*')*$)/
+  end
+end

data/lib/cerubis/method.rb

@@ -0,0 +1,19 @@
+class Cerubis
+  module Method
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def cerubis_respond_to?(meth)
+      availabe_methods = self.class.instance_variable_get(:@cerubis_method) || []
+      availabe_methods.include? meth
+    end
+
+    module ClassMethods
+      def cerubis_method(*args)
+        @cerubis_method ||= []
+        @cerubis_method  += args
+      end
+    end
+  end
+end

data/lib/cerubis/node.rb

@@ -0,0 +1,27 @@
+class Cerubis
+  module Node
+    def self.included(base)
+      base.send(:attr, :content)
+      base.send(:attr, :parent)
+      base.send(:attr_accessor, :children)
+    end
+
+    def initialize(content, options)
+      @content  = content
+      @parent   = options[:parent]
+      @children = []
+    end
+
+    def context
+      parent.context
+    end
+
+    def children?
+      !@children.empty?
+    end
+
+		def pre_render
+			return content
+		end
+  end
+end

data/lib/cerubis/objects/array.rb

@@ -0,0 +1,4 @@
+class Array
+  include Cerubis::Method
+  cerubis_method :empty?, :size, :first, :last
+end

data/lib/cerubis/objects/fixnum.rb

@@ -0,0 +1,4 @@
+class Fixnum
+  include Cerubis::Method
+  cerubis_method :zero?
+end

data/lib/cerubis/objects/float.rb

@@ -0,0 +1,4 @@
+class Float
+  include Cerubis::Method
+  cerubis_method :zero?
+end

data/lib/cerubis/objects/hash.rb

@@ -0,0 +1,4 @@
+class Hash
+  include Cerubis::Method
+  cerubis_method :size, :empty?
+end

data/lib/cerubis/objects/string.rb

@@ -0,0 +1,4 @@
+class String
+  include Cerubis::Method
+  cerubis_method :empty?, :size
+end

data/lib/cerubis/parser.rb

@@ -0,0 +1,125 @@
+require 'strscan'
+
+class Cerubis
+  class Parser
+    attr :nodes
+
+    def initialize(content, options)
+      @content = content || ''
+      @options = options
+      @scanner = StringScanner.new(@content)
+      @nodes   = []
+      parse!
+    end
+
+    private
+      def parse!
+        @default_regex = Regexp.new("(#{Matcher::OpenBlock})|(#{Matcher::CloseBlock})")
+        @current_regex = @default_regex
+        @blocks = []
+
+        record_positions until @scanner.eos?
+        raise SyntaxError, "An open '#{last_block_name}' block is not closed" if blocks_not_closed?
+
+        build_nodes
+      end
+
+      def build_nodes
+        if !@blocks.empty?
+          str_position = @blocks.first[1] # start of first block
+          @blocks.unshift([:text, 0, str_position.pred]) unless str_position.zero?
+
+          str_position = @blocks.last[2] # end of last block
+          if str_position != @content.size
+            @blocks << [:text, str_position.next, @content.size]
+          end
+
+          # loop and fill in missing ranges with text nodes
+          @blocks.each_with_index do |block, index|
+            next_block = @blocks[index.next]
+            position   = block[2]
+
+            if next_block && next_block[1] != position.next
+              next_index        = index.next
+              previous_position = next_block[1].pred
+
+              @blocks.insert(next_index, [:text, position.next, previous_position])
+            end
+          end
+        elsif !@content.empty? && @options[:parent].is_a?(Template)
+          @blocks << [:text, 0, @content.size]
+        end
+
+        create_node(@blocks.shift) until @blocks.empty?
+      end
+
+      def create_node(block)
+        start_of_str = block[1]
+        end_of_str   = block[2]
+        content      = @content[start_of_str..end_of_str]
+
+        if block[0] == :text
+          @nodes << TextNode.new(content, @options)
+        else
+          @nodes << BlockNode.new(content, @options)
+        end
+      end
+
+      def record_positions
+        @scanner.scan_until @current_regex
+        current_match = @scanner[0]
+
+        if current_match
+          if current_match =~ Matcher::OpenBlock
+            parse_open_block
+          elsif current_match =~ Matcher::CloseBlock
+            parse_close_block
+          end
+        else
+          @scanner.terminate
+        end
+      end
+
+      def nested_block?
+        return false if @blocks.empty?
+        return false if @blocks.last.is_a?(Array) && @blocks.last.size === 3
+        true
+      end
+
+      def blocks_not_closed?
+        # a proper closed block is prepresented as an array of 3 elements
+        # [block_name, start_of_block, end_of_block]
+        # any less than 3 and its not closed
+        !@blocks.empty? && (!@blocks.last.is_a?(Array) || @blocks.last.size < 3)
+      end
+
+      def parse_open_block
+        block_name = @scanner[2].to_sym
+
+        if nested_block?
+          @blocks << block_name
+        else
+          @blocks << [block_name, (@scanner.pos - @scanner.matched_size)]
+        end
+      end
+
+      def parse_close_block
+        raise SyntaxError, "Closing '#{@scanner[15]}' block was found without an opening" if @blocks.empty?
+        block_name = @scanner[15].to_sym
+
+        if @blocks.last == block_name # found the nested closing block
+          @blocks.pop
+
+          close_regex    = Matcher::CloseBlockPlaceholder.sub('block_name', last_block_name.to_s)
+          @current_regex = Regexp.new("(#{Matcher::OpenBlock})|(#{close_regex})")
+        elsif @blocks && @blocks.last.is_a?(Array) && @blocks.last[0] == block_name
+          @blocks.last << @scanner.pos.pred
+          @current_regex = @default_regex
+        end
+      end
+
+      def last_block_name
+        @blocks.last.is_a?(Array) ? @blocks.last[0] : @blocks.last
+      end
+  end
+end