cerubis 0.0.1

data/lib/cerubis/syntax_error.rb

@@ -0,0 +1,4 @@
+class Cerubis
+  class SyntaxError < Exception
+  end
+end

data/lib/cerubis/template.rb

@@ -0,0 +1,21 @@
+class Cerubis
+  class Template
+    attr :content
+    attr :context
+    attr :nodes
+
+    def initialize(content, context={})
+      @content = content
+      @context = Context.new(context)
+      @nodes   = Parser.new(@content, :parent => self).nodes
+    end
+
+    def compile
+      @template ||= nodes.map(&:render).join
+    end
+
+    alias :to_html :compile
+    alias :to_text :compile
+    alias :to_s    :compile
+  end
+end

data/lib/cerubis/text_node.rb

@@ -0,0 +1,10 @@
+class Cerubis
+  class TextNode
+    include Node
+    include VariableReplacement
+
+		def render
+			replace_variables(pre_render)
+		end
+  end
+end

data/lib/cerubis/variable_replacement.rb

@@ -0,0 +1,34 @@
+class Cerubis
+  module VariableReplacement
+    def replace_variables(str, ctx=context)
+      str.gsub(Matcher::Variable) do |variable|
+        match_var = variable.match(Matcher::Variable)[1]
+        if match = match_var.match(Matcher::Helpers)
+          helper_method = match[1]
+          helper_args   = match[2].to_s.split(Matcher::CommaOutsideQuote).map do |arg|
+            ctx.get(arg.strip)
+          end
+
+          begin
+            if helper_mod = Cerubis.helpers[helper_method.to_sym] || Cerubis.helpers[helper_method]
+              helper = Helper.new(ctx)
+              helper.extend helper_mod
+
+              if has_public_method?(helper, helper_method)
+                helper.send(helper_method, *helper_args)
+              end
+            end
+          rescue ArgumentError
+            raise SyntaxError, "A wrong number of arguments were passed to '#{helper_method}'"
+          end
+        else
+          ctx.get(match_var)
+        end
+      end
+    end
+
+    def has_public_method?(obj, meth)
+      obj.public_methods.include?(meth) || obj.public_methods.include?(meth.to_sym)
+    end
+  end
+end

data/lib/cerubis/version.rb

@@ -0,0 +1,3 @@
+class Cerubis
+  VERSION = "0.0.1"
+end

data/test/all.rb

@@ -0,0 +1,3 @@
+require 'test_helper'
+
+Dir["**/*_test.rb"].each { |path| require File.expand_path(path) }

data/test/cerubis/block_node_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require 'nodes/test_node_defaults'
+
+class Cerubis::BlockNodeTest < MiniTest::Unit::TestCase
+  include TestNodeDefaults
+
+  def test_open_and_close_block_text_removed_on_render
+    content = <<-STR
+    {{#if true}}
+      Foo Content
+    {{/if}}
+    STR
+
+    node = Cerubis::BlockNode.new(content, :parent => StubObject.new)
+    refute_match /\{\{/, node.render
+  end
+
+  def test_variable_replacement
+    content = <<-STR
+    {{#if true}}
+      <h1>{{title}}</h1>
+    {{/if}}
+    STR
+
+    node = Cerubis::BlockNode.new(content, options)
+    html = Capybara::Node::Simple.new(node.render)
+
+    assert html.has_selector?('h1', :text => 'Foo Title')
+    refute_match /\{\{/, node.render
+  end
+
+  private
+    def class_name
+      Cerubis::BlockNode
+    end
+end

data/test/cerubis/blocks/if_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class Cerubis::Blocks::IfTest < MiniTest::Unit::TestCase
+  def setup
+    parent  = StubObject.new
+    content = <<-STR
+    {{#if true}}
+      Foo Content
+    {{/if}}
+    STR
+
+    node    = Cerubis::BlockNode.new(content, :parent => parent)
+    @output = node.render
+    @block  = node.block
+  end
+
+  def test_block_is_instance_of_if_block_class
+    assert_instance_of Cerubis::Blocks::If, @block
+  end
+
+  def test_block_condition_is_true
+    assert @block.true?
+  end
+end

data/test/cerubis/blocks/loop_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class Cerubis::Blocks::LoopTest < MiniTest::Unit::TestCase
+  def setup
+    context = Cerubis::Context.new(:items => [1,2,3])
+    parent  = StubObject.new(:context => context)
+    content = <<-STR
+    {{#loop item in items}}
+      <p>{{ item }}</p>
+    {{/loop}}
+    STR
+
+    node    = Cerubis::BlockNode.new(content, :parent => parent)
+    @output = node.render
+    @block  = node.block
+  end
+
+  def test_block_is_instance_of_loop_block_class
+    assert_instance_of Cerubis::Blocks::Loop, @block
+  end
+
+  def test_block_condition_is_true
+    assert @block.true?
+  end
+end

data/test/cerubis/blocks/unless_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class Cerubis::Blocks::UnlessTest < MiniTest::Unit::TestCase
+  def setup
+		context = Cerubis::Context.new
+    parent  = StubObject.new(:context => context)
+    content = <<-STR
+    {{#unless false}}
+      Foo Content
+    {{/unless}}
+    STR
+
+    node    = Cerubis::BlockNode.new(content, :parent => parent)
+    @output = node.render
+    @block  = node.block
+  end
+
+  def test_block_is_instance_of_unless_block_class
+    assert_instance_of Cerubis::Blocks::Unless, @block
+  end
+
+  def test_block_condition_is_true
+    assert @block.true?
+  end
+end

data/test/cerubis/condition_test.rb

@@ -0,0 +1,142 @@
+require 'test_helper'
+
+class Cerubis::ConditionTest < MiniTest::Unit::TestCase
+  def test_context_objects
+    condition_str = '2 > 1'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+    assert_equal ['2', '>', '1'], condition.parsed_content
+  end
+
+  def test_parsed_content
+    condition_str = 'item > item2'
+    context   = Cerubis::Context.new(:item => 2, :item2 => 1)
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+    assert_equal 2, condition.context_objects.first
+    assert_equal 1, condition.context_objects.last
+  end
+
+  def test_if_true_condition
+    condition_str = 'true'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_if_2_greater_than_1
+    condition_str = '2 > 1'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_if_object_method
+    condition_str = 'item.empty?'
+    item      = StubObject.new(:empty? => true)
+    context   = Cerubis::Context.new(:item => item)
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_if_1_greater_than_2_fails
+    condition_str = '1 > 2'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    refute condition.true?
+  end
+
+  def test_in_operator_used_in_if_block
+    assert_raises Cerubis::SyntaxError do
+      condition_str = 'item in items'
+      context   = Cerubis::Context.new
+      condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+      condition.true?
+    end
+  end
+
+  def test_loop_in_block_true
+    condition_str = 'item in items'
+    context   = Cerubis::Context.new(:items => [1,2,3,4])
+    condition = Cerubis::Condition.new(condition_str, :type => :loop, :context =>  context)
+    assert condition.true?
+  end
+
+  def test_loop_in_block_false
+    condition_str = 'item in items'
+    context   = Cerubis::Context.new(:items => [])
+    condition = Cerubis::Condition.new(condition_str, :type => :loop, :context => context)
+    refute condition.true?
+  end
+
+  def test_double_equals_operator
+    condition_str = '1 == 1'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_triple_equals_operator
+    condition_str = 'foo === foo'
+    context   = Cerubis::Context.new(:foo => 'foo str')
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_not_equals_operator
+    condition_str = 'foo != bar'
+    context   = Cerubis::Context.new(:foo => 'foo str', :bar => 'bar str')
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_less_than_operator
+    condition_str = '1 < 2'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_greater_than_operator
+    condition_str = '2 > 1'
+    context   = Cerubis::Context.new
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+
+    assert condition.true?
+  end
+
+  def test_less_than_or_equals_operator
+    context   = Cerubis::Context.new
+
+    condition_str = '1 <= 2'
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+    assert condition.true?
+
+    condition_str = '2 <= 2'
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+    assert condition.true?
+  end
+
+  def test_greater_than_or_equals_operator
+    context   = Cerubis::Context.new
+
+    condition_str = '2 >= 1'
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+    assert condition.true?
+
+    condition_str = '2 >= 2'
+    condition = Cerubis::Condition.new(condition_str, :type => :if, :context => context)
+    assert condition.true?
+  end
+end

data/test/cerubis/context_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class Cerubis::ContextTest < MiniTest::Unit::TestCase
+	def test_context_returns_true
+		context = Cerubis::Context.new
+		assert_equal true, context.get('true')
+	end
+
+	def test_context_returns_false
+		context = Cerubis::Context.new
+		assert_equal false, context.get('false')
+	end
+
+	def test_context_returns_integer
+		context = Cerubis::Context.new
+		assert_equal 1, context.get('1')
+	end
+
+	def test_context_returns_float
+		context = Cerubis::Context.new
+		assert_equal 1.5, context.get('1.5')
+	end
+
+	def test_context_returns_item_from_context
+		context = Cerubis::Context.new(:item => :foo)
+		assert_equal :foo, context.get('item')
+	end
+
+	def test_context_returns_string_without_single_quotes
+		context = Cerubis::Context.new
+		assert_equal 'foo', context.get("'foo'")
+	end
+end

data/test/cerubis/helper_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class Cerubis::HelperTest < MiniTest::Unit::TestCase
+  def test_helper_can_access_context
+    context = Cerubis::Context.new(:bar => 'bar str')
+    helper  = Cerubis::Helper.new(context)
+    helper.extend FooHelper
+
+    assert_equal 'bar str', helper.foo_helper('bar')
+  end
+
+  module FooHelper
+    def foo_helper(obj)
+      "#{context[obj.to_sym]}"
+    end
+  end
+end

data/test/cerubis/matcher_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+require 'matchers/test_operators'
+require 'matchers/test_block_name'
+require 'matchers/test_object_method'
+require 'matchers/test_open_block'
+require 'matchers/test_close_block'
+require 'matchers/test_conditions'
+require 'matchers/test_variable'
+require 'matchers/test_helpers'
+
+class Cerubis::MatcherTest < MiniTest::Unit::TestCase
+  include TestOperators
+  include TestBlockName
+  include TestObjectMethod
+  include TestOpenBlock
+  include TestCloseBlock
+  include TestConditions
+  include TestVariable
+  include TestHelpers
+end

data/test/cerubis/method_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+require 'methods/test_array_methods'
+require 'methods/test_string_methods'
+require 'methods/test_float_methods'
+require 'methods/test_fixnum_methods'
+require 'methods/test_hash_methods'
+
+class Cerubis::MethodTest < MiniTest::Unit::TestCase
+  include TestArrayMethods
+  include TestStringMethods
+  include TestFloatMethods
+  include TestFixnumMethods
+  include TestHashMethods
+
+  def setup
+    @obj = FooObj.new
+  end
+
+  def test_method_is_allowed
+    assert @obj.cerubis_respond_to?(:foo)
+  end
+
+  def test_nested_method_is_allowed
+    assert @obj.foo.cerubis_respond_to?(:baz)
+  end
+
+  def test_method_is_not_allowed
+    refute @obj.cerubis_respond_to?(:bar)
+  end
+
+  def test_nested_method_is_not_allowed
+    refute @obj.foo.cerubis_respond_to?(:cux)
+  end
+end
+
+class FooObj
+  include Cerubis::Method
+  cerubis_method :foo
+
+  def foo
+    BazObj.new
+  end
+
+  def bar
+    "Not Allowed"
+  end
+end
+
+class BazObj
+  include Cerubis::Method
+  cerubis_method :baz
+
+  def baz
+    "Allowed"
+  end
+
+  def cux
+    "Not Allowed"
+  end
+end