hotcell 0.0.1 → 0.1.0

data/lib/hotcell/parser.y

@@ -52,146 +52,194 @@ prechigh
 preclow
 start document
 rule
-  document: document document_unit { val[0].children.push(val[1]) }
-          | document_unit { result = Joiner.build :JOINER, val[0] }
-  document_unit: template | command_tag | block_tag | tag
+  document: document document_unit { pospoppush(2); val[0].children.push(val[1]) }
+          | document_unit { result = build Joiner, :JOINER, val[0], position: pospoppush(1) }
+  document_unit: template | tag | block_tag | command_tag
 
   template: TEMPLATE { result = val[0] }
-  tag: TOPEN TCLOSE { result = Tag.build :TAG, mode: TAG_MODES[val[0]] }
-     | TOPEN sequence TCLOSE { result = Tag.build :TAG, *val[1].flatten, mode: TAG_MODES[val[0]] }
-
-  command_tag: TOPEN assigned_command TCLOSE {
-    command = val[1][:command]
-    assign = val[1][:assign]
-    command.options[:mode] = TAG_MODES[val[0]]
-    command.options[:assign] = assign if assign
-    command.validate!
-    result = command
-  }
-  block_open: TOPEN assigned_block TCLOSE {
-    block = val[1][:block]
-    assign = val[1][:assign]
-    block.options[:mode] = TAG_MODES[val[0]]
-    block.options[:assign] = assign if assign
-    result = block
-  }
-  block_close: TOPEN endblock TCLOSE
-  block_body: block_body document_unit {
-                val[0][-1].is_a?(Joiner) ?
-                  val[0][-1].children.push(val[1]) :
-                  val[0].push(Joiner.build(:JOINER, val[1]))
+  tag: TOPEN TCLOSE { result = build Tag, :TAG, mode: TAG_MODES[val[0]], position: pospoppush(2) }
+     | TOPEN sequence TCLOSE {
+         result = build Tag, :TAG, *Array.wrap(val[1]).flatten, mode: TAG_MODES[val[0]], position: pospoppush(3)
+       }
+
+  command_body: COMMAND { result = build @commands[val[0]] || Command, val[0], position: pospoppush(1) }
+              | COMMAND arguments {
+                  result = build @commands[val[0]] || Command, val[0], *val[1], position: pospoppush(2)
+                }
+  command: command_body
+         | IDENTIFER ASSIGN command_body {
+             result = build Assigner, val[0], val[2], position: pospoppush(3)
+           }
+  command_tag: TOPEN command TCLOSE {
+                 command = val[1].is_a?(Command) ? val[1] : val[1].children[0]
+                 command.validate!
+                 result = build Tag, :TAG, val[1], mode: TAG_MODES[val[0]], position: pospoppush(3)
+               }
+
+  subcommand: SUBCOMMAND { result = build @substack.last[val[0]], val[0], position: pospoppush(1) }
+            | SUBCOMMAND arguments {
+                result = build @substack.last[val[0]], val[0], *val[1], position: pospoppush(2)
+              }
+  subcommand_tag: TOPEN subcommand TCLOSE { pospoppush(3); result = val[1] }
+
+  block_body: BLOCK { result = build @blocks[val[0]] || Block, val[0], position: pospoppush(1) }
+            | BLOCK arguments {
+                result = build @blocks[val[0]] || Block, val[0], *val[1], position: pospoppush(2)
+              }
+  block_open: block_body
+            | IDENTIFER ASSIGN block_body {
+                result = build Assigner, val[0], val[2], position: pospoppush(3)
               }
-            | block_body subcommand_tag { val[0].push(val[1]) }
-            | document_unit { result = [Joiner.build(:JOINER, val[0])] }
-            | subcommand_tag { result = [val[0]] }
-  block_tag: block_open block_close
-           | block_open block_body block_close { val[0].options[:subnodes] = val[1]; val[0].validate! }
-  subcommand_tag: TOPEN subcommand TCLOSE { result = val[1] }
-
-  command: COMMAND { result = Command.build val[0] }
-         | COMMAND arguments { result = Command.build val[0], *val[1] }
-  assigned_command: command { result = { command: val[0] } }
-                  | IDENTIFER ASSIGN command { result = { command: val[2], assign: val[0] } }
-  block: BLOCK { result = Block.build val[0] }
-       | BLOCK arguments { result = Block.build val[0], *val[1] }
-  assigned_block: block { result = { block: val[0] } }
-                | IDENTIFER ASSIGN block { result = { block: val[2], assign: val[0] } }
-  endblock: ENDBLOCK
-          | END BLOCK
-  subcommand: SUBCOMMAND { result = { name: val[0] } }
-            | SUBCOMMAND arguments { result = { name: val[0], args: Arrayer.build(:ARRAY, *val[1]) } }
-
-  sequence: sequence SEMICOLON sequence { result = val[0].push(val[2]) }
-          | sequence SEMICOLON
-          | SEMICOLON sequence { result = val[1] }
+  block_close: ENDBLOCK
+             | END BLOCK { pospoppush(2) }
+             | END
+  block_open_tag: TOPEN block_open TCLOSE {
+                    result = build Tag, :TAG, val[1], mode: TAG_MODES[val[0]], position: pospoppush(3)
+                  }
+  block_close_tag: TOPEN block_close TCLOSE { pospoppush(3) }
+  block_subnodes: block_subnodes document_unit {
+                    pospoppush(2)
+                    val[0][-1].is_a?(Joiner) ?
+                      val[0][-1].children.push(val[1]) :
+                      val[0].push(build(Joiner, :JOINER, val[1]))
+                  }
+                | block_subnodes subcommand_tag { pospoppush(2); val[0].push(val[1]) }
+                | document_unit { result = [build(Joiner, :JOINER, val[0], position: pospoppush(1))] }
+                | subcommand_tag { result = [val[0]] }
+  block_tag: block_open_tag block_close_tag {
+               pospoppush(2)
+               block = val[0].children[0].is_a?(Block) ?
+                 val[0].children[0] : val[0].children[0].children[0]
+               block.validate!
+             }
+           | block_open_tag block_subnodes block_close_tag {
+               pospoppush(3)
+               block = val[0].children[0].is_a?(Block) ?
+                 val[0].children[0] : val[0].children[0].children[0]
+               block.options[:subnodes] = val[1]
+               block.validate!
+             }
+
+  sequence: sequence SEMICOLON sequence { pospoppush(2); result = val[0].push(val[2]) }
+          | sequence SEMICOLON { pospoppush(2) }
+          | SEMICOLON sequence { pospoppush(2, 1); result = val[1] }
           | SEMICOLON { result = [] }
-          | sequence NEWLINE sequence { result = val[0].push(val[2]) }
-          | sequence NEWLINE
-          | NEWLINE sequence { result = val[1] }
+          | sequence NEWLINE sequence { pospoppush(2); result = val[0].push(val[2]) }
+          | sequence NEWLINE { pospoppush(2) }
+          | NEWLINE sequence { pospoppush(2, 1); result = val[1] }
           | NEWLINE { result = [] }
           | expr { result = [val[0]] }
 
-  expr: expr MULTIPLY expr { result = Calculator.build :MULTIPLY, val[0], val[2] }
-      | expr POWER expr { result = Calculator.build :POWER, val[0], val[2] }
-      | expr DIVIDE expr { result = Calculator.build :DIVIDE, val[0], val[2] }
-      | expr PLUS expr { result = Calculator.build :PLUS, val[0], val[2] }
-      | expr MINUS expr { result = Calculator.build :MINUS, val[0], val[2] }
-      | expr MODULO expr { result = Calculator.build :MODULO, val[0], val[2] }
-      | MINUS expr =UMINUS { result = Calculator.build :UMINUS, val[1] }
-      | PLUS expr =UPLUS { result = Calculator.build :UPLUS, val[1] }
-      | expr AND expr { result = Calculator.build :AND, val[0], val[2] }
-      | expr OR expr { result = Calculator.build :OR, val[0], val[2] }
-      | expr GT expr { result = Calculator.build :GT, val[0], val[2] }
-      | expr GTE expr { result = Calculator.build :GTE, val[0], val[2] }
-      | expr LT expr { result = Calculator.build :LT, val[0], val[2] }
-      | expr LTE expr { result = Calculator.build :LTE, val[0], val[2] }
-      | expr EQUAL expr { result = Calculator.build :EQUAL, val[0], val[2] }
-      | expr INEQUAL expr { result = Calculator.build :INEQUAL, val[0], val[2] }
-      | NOT expr { result = Calculator.build :NOT, val[1] }
-      | IDENTIFER ASSIGN expr { result = Assigner.build val[0], val[2] }
-      | expr PERIOD method { val[2].children[0] = val[0]; result = val[2] }
-      | expr AOPEN arguments ACLOSE { result = Summoner.build val[0], '[]', *val[2] }
-      | POPEN PCLOSE { result = nil }
+  expr: expr MULTIPLY expr { result = build Calculator, :MULTIPLY, val[0], val[2], position: pospoppush(3) }
+      | expr POWER expr { result = build Calculator, :POWER, val[0], val[2], position: pospoppush(3) }
+      | expr DIVIDE expr { result = build Calculator, :DIVIDE, val[0], val[2], position: pospoppush(3) }
+      | expr PLUS expr { result = build Calculator, :PLUS, val[0], val[2], position: pospoppush(3) }
+      | expr MINUS expr { result = build Calculator, :MINUS, val[0], val[2], position: pospoppush(3) }
+      | expr MODULO expr { result = build Calculator, :MODULO, val[0], val[2], position: pospoppush(3) }
+      | MINUS expr =UMINUS { result = build Calculator, :UMINUS, val[1], position: pospoppush(2) }
+      | PLUS expr =UPLUS { result = build Calculator, :UPLUS, val[1], position: pospoppush(2) }
+      | expr AND expr { result = build Calculator, :AND, val[0], val[2], position: pospoppush(3) }
+      | expr OR expr { result = build Calculator, :OR, val[0], val[2], position: pospoppush(3) }
+      | expr GT expr { result = build Calculator, :GT, val[0], val[2], position: pospoppush(3) }
+      | expr GTE expr { result = build Calculator, :GTE, val[0], val[2], position: pospoppush(3) }
+      | expr LT expr { result = build Calculator, :LT, val[0], val[2], position: pospoppush(3) }
+      | expr LTE expr { result = build Calculator, :LTE, val[0], val[2], position: pospoppush(3) }
+      | expr EQUAL expr { result = build Calculator, :EQUAL, val[0], val[2], position: pospoppush(3) }
+      | expr INEQUAL expr { result = build Calculator, :INEQUAL, val[0], val[2], position: pospoppush(3) }
+      | NOT expr { result = build Calculator, :NOT, val[1], position: pospoppush(2) }
+      | IDENTIFER ASSIGN expr { result = build Assigner, val[0], val[2], position: pospoppush(3) }
+      | expr PERIOD method { pospoppush(3); val[2].children[0] = val[0]; result = val[2] }
+      | expr AOPEN arguments ACLOSE {
+          result = build Summoner, 'manipulator_brackets', val[0], *val[2], position: pospoppush(4)
+        }
+      | POPEN PCLOSE { pospoppush(2); result = nil }
       | POPEN sequence PCLOSE {
-        result = case val[1].size
-        when 0
-          nil
-        when 1
-          val[1][0]
-        else
-          Sequencer.build :SEQUENCE, *val[1].flatten
-        end
-      }
+          position = pospoppush(3)
+          result = case val[1].size
+          when 1
+            val[1][0]
+          else
+            build Sequencer, :SEQUENCE, *val[1].flatten, position: position
+          end
+        }
       | value
 
-  value: const | number | string | array | hash | method# | ternary
+  value: const | number | string | array | hash | method
 
   const: NIL | TRUE | FALSE
   number: INTEGER | FLOAT
   string: STRING | REGEXP
 
-  # ternary: expr QUESTION expr COLON expr =TERNARY { result = Node.build :TERNARY, val[0], val[2], val[4] }
-
-  array: AOPEN ACLOSE { result = Arrayer.build :ARRAY }
-       | AOPEN params ACLOSE { result = Arrayer.build :ARRAY, *val[1] }
-  params: params COMMA expr { val[0].push(val[2]) }
+  array: AOPEN ACLOSE { result = build Arrayer, :ARRAY, position: pospoppush(2) }
+       | AOPEN params ACLOSE { result = build Arrayer, :ARRAY, *val[1], position: pospoppush(3) }
+  params: params COMMA expr { pospoppush(3); val[0].push(val[2]) }
         | expr { result = [val[0]] }
 
-  hash: HOPEN HCLOSE { result = Hasher.build :HASH }
-      | HOPEN pairs HCLOSE { result = Hasher.build :HASH, *val[1] }
-  pairs: pairs COMMA pair { val[0].push(val[2]) }
+  hash: HOPEN HCLOSE { result = build Hasher, :HASH, position: pospoppush(2) }
+      | HOPEN pairs HCLOSE { result = build Hasher, :HASH, *val[1], position: pospoppush(3) }
+  pairs: pairs COMMA pair { pospoppush(3); val[0].push(val[2]) }
        | pair { result = [val[0]] }
-  pair: IDENTIFER COLON expr { result = Arrayer.build :PAIR, val[0], val[2] }
+  pair: IDENTIFER COLON expr { result = build Arrayer, :PAIR, val[0], val[2], position: pospoppush(3) }
 
-  arguments: params COMMA pairs { result = [*val[0], Hasher.build(:HASH, *val[2])] }
+  arguments: params COMMA pairs { result = [*val[0], build(Hasher, :HASH, *val[2], position: pospoppush(3))] }
            | params
-           | pairs { result = Hasher.build(:HASH, *val[0]) }
-  method: IDENTIFER { result = Summoner.build nil, val[0] }
-        | IDENTIFER POPEN PCLOSE { result = Summoner.build nil, val[0] }
-        | IDENTIFER POPEN arguments PCLOSE { result = Summoner.build nil, val[0], *val[2] }
+           | pairs { result = build Hasher, :HASH, *val[0], position: pospoppush(1) }
+  method: IDENTIFER { result = build Summoner, val[0], position: pospoppush(1) }
+        | IDENTIFER POPEN PCLOSE { result = build Summoner, val[0], position: pospoppush(3) }
+        | IDENTIFER POPEN arguments PCLOSE {
+            result = build Summoner, val[0], nil, *val[2], position: pospoppush(4)
+          }
 
----- header
-  require 'hotcell/lexer'
 ---- inner
-  NEWLINE_PRED = Set.new(Lexer::BOPEN.values + Lexer::OPERATIONS.values)
-  NEWLINE_NEXT = Set.new(Lexer::BCLOSE.values + [:NEWLINE])
+  OPERATIONS = {
+    '+' => :PLUS, '-' => :MINUS, '*' => :MULTIPLY, '**' => :POWER, '/' => :DIVIDE, '%' => :MODULO,
+
+    '&&' => :AND, '||' => :OR, '!' => :NOT, '==' => :EQUAL, '!=' => :INEQUAL,
+    '>' => :GT, '>=' => :GTE, '<' => :LT, '<=' => :LTE,
+
+    '=' => :ASSIGN, ',' => :COMMA, '.' => :PERIOD, ':' => :COLON, '?' => :QUESTION,
+    ';' => :SEMICOLON
+  }
+
+  BOPEN = { '[' => :AOPEN, '{' => :HOPEN, '(' => :POPEN }
+  BCLOSE = { ']' => :ACLOSE, '}' => :HCLOSE, ')' => :PCLOSE }
+
+  NEWLINE_PRED = Set.new(BOPEN.values + OPERATIONS.values)
+  NEWLINE_NEXT = Set.new(BCLOSE.values + [:NEWLINE])
 
   TAG_MODES = { '{{' => :normal, '{{!' => :silence }
 
-  def initialize string, options = {}
-    @lexer = Lexer.new(string)
+  def initialize source, options = {}
+    @source = Source.wrap(source)
+    @lexer = Lexer.new(source)
     @tokens = @lexer.tokens
     @position = -1
 
-    @commands = Set.new(Array.wrap(options[:commands]).map(&:to_s))
-    @blocks = Set.new(Array.wrap(options[:blocks]).map(&:to_s))
-    @endblocks = Set.new(Array.wrap(options[:blocks]).map { |identifer| "end#{identifer}" })
-    @subcommands = Set.new(Array.wrap(options[:subcommands]).map(&:to_s))
+    @commands = options[:commands] || {}
+    @blocks = options[:blocks] || {}
+    @endblocks = Set.new(@blocks.keys.map { |identifer| "end#{identifer}" })
+
+    @substack = []
+    @posstack = []
+  end
+
+  def build klass, *args
+    options = args.extract_options!
+    options[:source] = @source
+    klass.build *args.push(options)
+  end
+
+  def pospoppush pop, push = 0
+    # because fuck the brains, that's why!
+    last = @posstack.pop
+    reduced = @posstack.push(@posstack.pop(pop)[push])[-1]
+    @posstack.push last
+    reduced
   end
 
   def parse
     if @tokens.size == 0
-      Joiner.build :JOINER
+      build Joiner, :JOINER, position: 0
     else
       do_parse
     end
@@ -199,27 +247,32 @@ rule
 
   def next_token
     @position = @position + 1
-
     tcurr = @tokens[@position]
-    tnext = @tokens[@position.next]
-    tpred = @tokens[@position.pred]
 
     if tcurr && (tcurr[0] == :COMMENT || tcurr[0] == :NEWLINE && (
-      (tpred && NEWLINE_PRED.include?(tpred[0])) ||
-      (tnext && NEWLINE_NEXT.include?(tnext[0]))
+      ((tpred = @tokens[@position.pred]) && NEWLINE_PRED.include?(tpred[0])) ||
+      ((tnext = @tokens[@position.next]) && NEWLINE_NEXT.include?(tnext[0]))
     ))
       next_token
     else
+      if tcurr
+        @posstack << tcurr[1][1]
+        tcurr = [tcurr[0], tcurr[1][0]]
+      end
+
       if tcurr && tcurr[0] == :IDENTIFER
-        if @commands.include?(tcurr[1])
+        if @commands.key?(tcurr[1])
           [:COMMAND, tcurr[1]]
-        elsif @blocks.include?(tcurr[1])
+        elsif @blocks.key?(tcurr[1])
+          @substack.push(@blocks[tcurr[1]].subcommands)
           [:BLOCK, tcurr[1]]
+        elsif @substack.last && @substack.last.key?(tcurr[1])
+          [:SUBCOMMAND, tcurr[1]]
         elsif @endblocks.include?(tcurr[1])
+          @substack.pop
           [:ENDBLOCK, tcurr[1]]
-        elsif @subcommands.include?(tcurr[1])
-          [:SUBCOMMAND, tcurr[1]]
         elsif tcurr[1] == 'end'
+          @substack.pop
           [:END, tcurr[1]]
         else
           tcurr
@@ -229,3 +282,8 @@ rule
       end
     end
   end
+
+  def on_error(token, value, vstack)
+    raise Hotcell::UnexpectedLexem.new("#{token_to_str(token) || '?'} `#{value}`",
+      *@source.info(@posstack.last).values_at(:line, :column))
+  end

data/lib/hotcell/resolver.rb

@@ -0,0 +1,44 @@
+module Hotcell
+  # Base template resolving class for `include` command.
+  # Please inherit your own resolvers from it.
+  class Resolver
+    def template path, context = nil
+      cache(path, context) do
+        source = resolve path, context
+        Template.parse(source)
+      end
+    end
+
+    # Returns template source
+    # Not implemented by default
+    def resolve path, context = nil
+      raise NotImplementedError, 'Default resolver`s template resolve function is not implemented'
+    end
+
+    # Caches parsed template
+    # No cache by default
+    def cache path, context = nil, &block
+      @cache ||= {}
+      @cache[path] ||= block.call
+    end
+  end
+
+  # Basic file system resolver class.
+  # Ex:
+  #   resolver = Hotcell::FileSystemResolver.new('/Users/username/work/project/app/views')
+  #   resolver.template('articles/new') #=> returns Hotcell::Template instance
+  #                                     # for `/Users/username/work/project/app/views/articles/new.hc`
+  class FileSystemResolver < Resolver
+    attr_reader :root
+
+    def initialize root
+      @root = root.to_s
+    end
+
+    def resolve path, context = nil
+      full_path = File.expand_path path, root
+      full_path = "#{full_path}.hc"
+      File.read(full_path)
+    end
+  end
+end

data/lib/hotcell/source.rb

@@ -0,0 +1,35 @@
+module Hotcell
+  class Source
+    PACK_MODE = 'c*'
+
+    attr_reader :source, :file
+
+    def self.wrap source, *args
+      source.is_a?(Hotcell::Source) ? source : Source.new(source, *args)
+    end
+
+    def initialize source, file = nil
+      @source, @file = source, file
+    end
+
+    def encoding
+      'UTF-8'
+    end
+
+    def data
+      @data ||= source.unpack(PACK_MODE)
+    end
+
+    def info position
+      parsed = data[0..position]
+      line = parsed.count(10) + 1
+      lastnl = (parsed.rindex(10) || -1) + 1
+      column = parsed[lastnl..position].pack(PACK_MODE).force_encoding(encoding).size
+      { line: line, column: column }
+    end
+
+    def inspect
+      "Source: `#{source}`"
+    end
+  end
+end

data/lib/hotcell/template.rb

@@ -4,25 +4,34 @@ module Hotcell
 
     def self.parse source
       new source,
-        commands: Hotcell.commands.keys,
-        blocks: Hotcell.blocks.keys,
-        subcommands: Hotcell.subcommands.keys
+        commands: Hotcell.commands,
+        blocks: Hotcell.blocks
     end
 
     def initialize source, options = {}
-      @source = source
+      @source = Source.wrap(source, options.delete(:file))
       @options = options
     end
 
     def syntax
-      @syntax ||= Parser.new(source, options.slice(:commands, :blocks, :subcommands)).parse
+      @syntax ||= Parser.new(source, options.slice(:commands, :blocks)).parse
     end
 
     def render context = {}
       if context.is_a?(Context)
         syntax.render(context)
       else
-        syntax.render(Context.new(context))
+        default_context = { helpers: Hotcell.helpers }
+        syntax.render(Context.new(default_context.merge!(context)))
+      end
+    end
+
+    def render! context = {}
+      if context.is_a?(Context)
+        context.options[:reraise] = true
+        render context
+      else
+        render context.merge(reraise: true)
       end
     end
   end

data/lib/hotcell/version.rb

@@ -1,3 +1,3 @@
 module Hotcell
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/hotcell.rb

@@ -1,19 +1,24 @@
 require 'active_support/all'
 require 'hotcell/version'
+require 'hotcell/resolver'
 require 'hotcell/config'
 require 'hotcell/errors'
+
+module Hotcell
+  def self.config; Config.instance; end
+
+  singleton_class.delegate :commands, :blocks, :helpers, :register_command, :register_helpers,
+    :resolver, :resolver=, to: :config
+end
+
+require 'hotcell/manipulator'
+require 'hotcell/extensions'
+require 'hotcell/source'
 require 'hotcell/lexer'
+require 'hotcell/lexerr'
+require 'hotcell/lexerc'
 require 'hotcell/parser'
 require 'hotcell/node'
+require 'hotcell/commands'
 require 'hotcell/context'
-require 'hotcell/manipulator'
-require 'hotcell/extensions'
 require 'hotcell/template'
-
-module Hotcell
-  [:commands, :blocks, :subcommands, :register_command].each do |method|
-    define_singleton_method method do
-      Config.instance.send(method)
-    end
-  end
-end

data/spec/data/templates/simple.hc

@@ -0,0 +1 @@
+Hello, {{ name }}

data/spec/lib/hotcell/commands/case_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::If do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  describe '#validate!' do
+    specify { expect { parse('{{ case }}{{ end case }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `case` (0 for 1) at 1:4' }
+    specify { expect { parse('{{ case 42 }}{{ when }}{{ end case }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `when` (0 for 1..Infinity) at 1:17' }
+    specify { expect { parse('{{ case 42 }}{{ when 42 }}{{ else 42 }}{{ end case }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `else` (1 for 0) at 1:30' }
+    specify { expect { parse('{{ case 42 }}{{ end case }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Expected `when` for `case` command at 1:4' }
+    specify { expect { parse('{{ case 42 }}foo{{ when 42 }}{{ end case }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Expected `when` for `case` command at 1:12' }
+    specify { expect { parse('{{ case 42 }}{{ else }}{{ end case }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `case` command at 1:17' }
+    specify { expect { parse('{{ case 42 }}{{ when 42 }}{{ else }}{{ when 43 }}{{ end case }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `case` command at 1:30' }
+    specify { expect { parse('{{ case 42 }}{{ when 42 }}{{ else }}{{ else }}{{ end case }}').syntax
+      }.to raise_error Hotcell::BlockError, 'Unexpected `else` for `case` command at 1:30' }
+  end
+
+  describe '#render' do
+    specify { parse('{{ case 42 }}{{ when 42 }}Hello{{ end case }}').render.should == 'Hello' }
+    specify { parse('{{ case 42 }}{{ when 43 }}Hello{{ end case }}').render.should == '' }
+    specify { parse('{{ case 42 }}{{ when 42 }}Hello{{ when 43}}World{{ end case }}').render.should == 'Hello' }
+    specify { parse('{{ case 43 }}{{ when 42 }}Hello{{ when 43}}World{{ end case }}').render.should == 'World' }
+    specify { parse('{{ case 42 }}{{ when 42, 43 }}Hello{{ else }}World{{ end case }}').render.should == 'Hello' }
+    specify { parse('{{ case 43 }}{{ when 42, 43 }}Hello{{ else }}World{{ end case }}').render.should == 'Hello' }
+    specify { parse('{{ case 44 }}{{ when 42, 43 }}Hello{{ else }}World{{ end case }}').render.should == 'World' }
+    specify { parse("{{ case 'hello' }}{{ when 'hello', 'world' }}Hello{{ else }}World{{ end case }}").render.should == 'Hello' }
+    specify { parse("{{ case 'world' }}{{ when 'hello', 'world' }}Hello{{ else }}World{{ end case }}").render.should == 'Hello' }
+    specify { parse("{{ case 'foo' }}{{ when 'hello', 'world' }}Hello{{ else }}World{{ end case }}").render.should == 'World' }
+  end
+end

data/spec/lib/hotcell/commands/cycle_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::Cycle do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  describe '#normalize_arguments' do
+    subject { described_class.new 'cycle' }
+    specify { subject.normalize_arguments([42]).should == [[42], subject.object_id.to_s] }
+    specify { subject.normalize_arguments([42, 43, 44]).should == [[42, 43, 44], subject.object_id.to_s] }
+    specify { subject.normalize_arguments(['hello' => 42]).should == [[42], 'hello'] }
+    specify { subject.normalize_arguments(['hello' => [42, 43, 44]]).should == [[42, 43, 44], 'hello'] }
+    specify { subject.normalize_arguments([42, { 'group' => 'hello' }]).should == [[42], 'hello'] }
+    specify { subject.normalize_arguments([42, 43, { 'group' => 'hello' }]).should == [[42, 43], 'hello'] }
+  end
+
+  describe '#render' do
+    specify { parse(
+      "{{ cycle 'one', 'two', 'three' }} {{ cycle 'one', 'two', 'three' }}"
+    ).render.should == 'one one' }
+    specify { parse(
+      "{{ cycle count: ['one', 'two', 'three'] }} {{ cycle 'one', 'two', 'three', group: 'count' }}"
+    ).render.should == 'one two' }
+    specify { parse(
+      "{{ for i, in: [1, 2, 3], loop: true }}{{ i }} {{ cycle ['one', 'two', 'three'] }}{{ unless loop.last? }}, {{ end unless }}{{ end for }}"
+    ).render.should == '1 one, 2 two, 3 three' }
+  end
+end

data/spec/lib/hotcell/commands/for_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Hotcell::Commands::For do
+  def parse source
+    Hotcell::Template.parse(source)
+  end
+
+  describe '#validate!' do
+    specify { expect { parse('{{ for }}{{ end for }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `for` (0 for 2) at 1:4' }
+    specify { expect { parse('{{ for item }}{{ end for }}').syntax
+      }.to raise_error Hotcell::ArgumentError, 'Wrond number of arguments for `for` (1 for 2) at 1:4' }
+    specify { expect { parse("{{ for 'item', in: [] }}{{ end for }}").syntax
+      }.to raise_error Hotcell::SyntaxError, 'Expected IDENTIFER as first argument in `for` command at 1:4' }
+  end
+
+  describe '#render' do
+    specify { parse('{{ for item, in: [1, 2, 3] }}{{ end for }}').render.should == '' }
+    specify { parse('{{ for item, in: [1, 2, 3] }}{{ item }}{{ end for }}').render.should == '123' }
+    specify { parse(
+      '{{ for item, in: [1, 2, 3] }}{{ item }} * 3 = {{ item * 3 }}; {{ end for }}'
+    ).render(reraise: true).should == '1 * 3 = 3; 2 * 3 = 6; 3 * 3 = 9; ' }
+    specify { parse(
+      '{{ for item, in: [5, 6, 7], loop: true }}{{ loop.index }}{{ loop.last? }}{{ end for }}'
+    ).render.should == '0false1false2true' }
+  end
+end
+
+describe Hotcell::Commands::For::Forloop do
+  subject { described_class.new([5, 6, 7, 8], 2) }
+
+  its(:prev) { should == 6 }
+  its(:next) { should == 8 }
+  its(:length) { should == 4 }
+  its(:size) { should == 4 }
+  its(:count) { should == 4 }
+  its(:index) { should == 2 }
+  its(:rindex) { should == 1 }
+  its(:first) { should == false }
+  its(:first?) { should == false }
+  its(:last) { should == false }
+  its(:last?) { should == false }
+
+  context do
+    subject { described_class.new([5, 6, 7, 8], 0) }
+
+    its(:prev) { should be_nil }
+    its(:next) { should == 6 }
+    its(:first) { should be_true }
+    its(:first?) { should be_true }
+    its(:last) { should be_false }
+    its(:last?) { should be_false }
+  end
+
+  context do
+    subject { described_class.new([5, 6, 7, 8], 3) }
+
+    its(:prev) { should == 7 }
+    its(:next) { should be_nil }
+    its(:first) { should be_false }
+    its(:first?) { should be_false }
+    its(:last) { should be_true }
+    its(:last?) { should be_true }
+  end
+end