hotcell 0.0.1 → 0.1.0

data/ext/lexerc/lexerc.rl

@@ -0,0 +1,167 @@
+%%{
+  machine puffer_lexer;
+
+  plus = '+';
+  minus = '-';
+  multiply = '*';
+  power = '**';
+  divide = '/';
+  modulo = '%';
+  arithmetic = plus | minus | multiply | power | divide | modulo;
+
+  and = '&&';
+  or = '||';
+  not = '!';
+  equal = '==';
+  inequal = '!=';
+  gt = '>';
+  gte = '>=';
+  lt = '<';
+  lte = '<=';
+  logic = and | or | not | equal | inequal | gt | gte | lt | lte;
+
+  assign = '=';
+  comma = ',';
+  period = '.';
+  colon = ':';
+  question = '?';
+  semicolon = ';';
+  newline = '\n';
+  flow = assign | comma | period | colon | question | semicolon | newline;
+
+  array_open = '[';
+  array_close = ']';
+  hash_open = '{';
+  hash_close = '}';
+  bracket_open = '(';
+  bracket_close = ')';
+  structure = array_open | array_close | hash_open | hash_close | bracket_open | bracket_close;
+
+
+  escaped_symbol = '\\' any;
+
+  squote = "'";
+  snon_quote = [^\\'];
+  sstring = squote (snon_quote | escaped_symbol)* squote @lerr{ raise_unterminated_string; };
+
+  dquote = '"';
+  dnon_quote = [^\\"];
+  dstring = dquote (dnon_quote | escaped_symbol)* dquote @lerr{ raise_unterminated_string; };
+
+  rquote = '/';
+  rnon_quote = [^\\/];
+  regexp = rquote @{ regexp_ambiguity(fgoto expression;) }
+    (rnon_quote | escaped_symbol)* rquote alpha* @lerr{ raise_unterminated_regexp; };
+
+
+  numeric = '-'? digit* ('.' digit+)?;
+  identifer = (alpha | '_') (alnum | '_')* [?!]?;
+  operator = arithmetic | logic | flow | structure;
+  comment = '#' ([^\n}]+ | '}' [^}])*;
+  blank = [\t\v\f\r ];
+
+  tag_open = '{{' '!'?;
+  tag_close = '}}';
+  template = [^{]+ | '{';
+
+  template_comment_open = '{{#';
+  template_comment_close = '#}}';
+  template_comment_body = [^\#]+ | '#';
+
+
+  expression := |*
+    tag_close => { emit_tag; fret; };
+    operator => { emit_operator; };
+    numeric => { emit_numeric; };
+    identifer => { emit_identifer; };
+    sstring => { emit_sstring; };
+    dstring => { emit_dstring; };
+    regexp => { emit_regexp; };
+    comment => { emit_comment; };
+    blank;
+  *|;
+
+  template_comment := |*
+    template_comment_close => { emit_comment; fret; };
+    template_comment_body => { emit_comment; };
+  *|;
+
+  main := |*
+    tag_open => { emit_tag; fcall expression; };
+    template_comment_open => { emit_comment; fcall template_comment; };
+    template => { emit_template; };
+  *|;
+}%%
+
+#include <ruby.h>
+#include <lexerc.h>
+
+static VALUE mHotcell;
+static VALUE cHotcellLexer;
+
+%% write data;
+
+static char *p;
+static char *ts;
+static char *te;
+static char *data;
+static VALUE encoding;
+
+static VALUE tokenize(VALUE self) {
+  VALUE source = rb_iv_get(self, "@source");
+  encoding = rb_funcall(source, rb_intern("encoding"), 0);
+  VALUE string = rb_funcall(source, rb_intern("source"), 0);
+  rb_iv_set(self, "@token_array", rb_ary_new());
+
+  data = RSTRING_PTR(string);
+  unsigned long length = RSTRING_LEN(string);
+
+  int cs, top, act;
+  int *stack = malloc(sizeof(int) * 300);
+
+  p = data;
+  char *pe = data + length;
+  char *eof = pe;
+
+  %% write init;
+  %% write exec;
+
+  free(stack);
+
+  if (ts > 0 && ((ts - data) < (pe - data - 1))) {
+    raise_unexpected_symbol;
+  }
+
+  return rb_iv_get(self, "@token_array");
+}
+
+static VALUE current_position(VALUE self) {
+  return INT2FIX(ts - data);
+}
+
+static VALUE current_value(VALUE self) {
+  VALUE string = rb_str_new(ts, te - ts);
+  return rb_funcall(string, rb_intern("force_encoding"), 1, encoding);
+}
+
+static VALUE current_error(VALUE self) {
+  VALUE parsed = rb_str_new(ts, p - ts == 0 ? 1 : p - ts);
+  VALUE encoded = rb_funcall(parsed, rb_intern("force_encoding"), 1, encoding);
+
+  VALUE source = rb_iv_get(self, "@source");
+  VALUE info = rb_funcall(source, rb_intern("info"), 1, INT2FIX(ts - data));
+  VALUE line = rb_funcall(info, rb_intern("[]"), 1, ID2SYM(rb_intern("line")));
+  VALUE column = rb_funcall(info, rb_intern("[]"), 1, ID2SYM(rb_intern("column")));
+
+  return rb_ary_new3(3, encoded, line, column);
+}
+
+void Init_lexerc() {
+  mHotcell = rb_const_get(rb_cObject, rb_intern("Hotcell"));
+  cHotcellLexer = rb_const_get(mHotcell, rb_intern("Lexer"));
+
+  rb_define_method(cHotcellLexer, "tokenize", tokenize, 0);
+  rb_define_method(cHotcellLexer, "current_position", current_position, 0);
+  rb_define_method(cHotcellLexer, "current_value", current_value, 0);
+  rb_define_method(cHotcellLexer, "current_error", current_error, 0);
+}

data/hotcell.gemspec

@@ -4,19 +4,20 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hotcell/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "hotcell"
+  gem.name          = 'hotcell'
   gem.version       = Hotcell::VERSION
-  gem.authors       = ["pyromaniac"]
-  gem.email         = ["kinwizard@gmail.com"]
+  gem.authors       = ['pyromaniac']
+  gem.email         = ['kinwizard@gmail.com']
   gem.description   = %q{Sandboxed ruby template processor}
   gem.summary       = %q{Sandboxed ruby template processor}
-  gem.homepage      = ""
+  gem.homepage      = ''
 
   gem.files         = `git ls-files`.split($/)
+  gem.extensions    = ['ext/lexerc/extconf.rb']
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
 
-  gem.add_runtime_dependency "activesupport"
-  gem.add_runtime_dependency "racc"
+  gem.add_runtime_dependency 'racc'
+  gem.add_runtime_dependency 'activesupport'
 end

data/lib/hotcell/commands/case.rb

@@ -0,0 +1,59 @@
+module Hotcell
+  module Commands
+    class Case < Hotcell::Block
+      class When < Hotcell::Command
+        validate_arguments_count min: 1
+      end
+
+      subcommand else: Hotcell::Commands::If::Else, when: When
+      validate_arguments_count 1
+
+      def subcommand_error subcommand, *allowed_names
+        raise Hotcell::BlockError.new(
+          "Unexpected `#{subcommand.name}` for `#{name}` command",
+          *subcommand.position_info
+        ) unless allowed_names.flatten.include?(subcommand.name)
+      end
+
+      def expected_when_error other = nil
+        raise Hotcell::BlockError.new(
+          "Expected `when` for `#{name}` command",
+          *(other ? other.position_info : position_info)
+        )
+      end
+
+      def validate!
+        subcommand_error subcommands.first, 'when' if subcommands.count == 1
+
+        last = subcommands.length - 1
+        subcommands.each_with_index do |subcommand, index|
+          subcommand_error subcommand, (index == last ? ['when', 'else'] : ['when'])
+        end
+
+        super
+
+        expected_when_error subnodes.first unless subnodes.first.is_a?(Command) && subnodes.first.name == 'when'
+      end
+
+      def process context, value
+        conditions = []
+        subnodes.each do |subnode|
+          if subnode.is_a?(Hotcell::Command)
+            conditions.last[1] = '' if conditions.last && conditions.last[1] == nil
+            conditions << (subnode.name == 'when' ? [subnode] : [true])
+          else
+            conditions.last[1] = subnode
+          end
+        end
+
+        condition = conditions.detect do |condition|
+          condition[0].is_a?(Hotcell::Command) ?
+            condition[0].render_children(context).include?(value) : condition[0]
+        end
+        condition ? condition[1].render(context) : nil
+      end
+    end
+  end
+end
+
+Hotcell.register_command case: Hotcell::Commands::Case

data/lib/hotcell/commands/cycle.rb

@@ -0,0 +1,38 @@
+module Hotcell
+  module Commands
+    class Cycle < Hotcell::Command
+      def process context, *arguments
+        targets, group = normalize_arguments arguments
+
+        context.shared[:cycle] ||= {}
+        index = context.shared[:cycle][group] || 0
+
+        result = targets[index]
+        index += 1
+        index = 0 if index >= targets.size
+
+        context.shared[:cycle][group] = index
+        result
+      end
+
+      def normalize_arguments arguments
+        if arguments.count == 1
+          if arguments.first.is_a? Hash
+            [Array.wrap(arguments.first.values.first), arguments.first.keys.first]
+          else
+            [Array.wrap(arguments.first), default_group]
+          end
+        else
+          options = arguments.extract_options!
+          [arguments, options['group'].to_s.presence || default_group]
+        end
+      end
+
+      def default_group
+        @default_group ||= object_id.to_s
+      end
+    end
+  end
+end
+
+Hotcell.register_command cycle: Hotcell::Commands::Cycle

data/lib/hotcell/commands/for.rb

@@ -0,0 +1,70 @@
+module Hotcell
+  module Commands
+    class For < Hotcell::Block
+      validate_arguments_count 2
+
+      def validate!
+        super
+
+        raise Hotcell::SyntaxError.new(
+          "Expected IDENTIFER as first argument in `#{name}` command", *position_info
+        ) unless children[0].is_a?(Hotcell::Summoner)
+
+        children[0] = children[0].name
+      end
+
+      def process context, variable, options
+        forloop = options['loop'] == true ? 'loop' : options['loop']
+        items = Array.wrap(options['in'])
+        length = items.size
+
+        items.map.with_index do |item, index|
+          scope = { variable => item }
+          scope.merge!(forloop => Forloop.new(items, index)) if forloop
+
+          context.scoped scope do
+            subnodes.first.try(:render, context)
+          end
+        end
+      end
+
+      class Forloop < Hotcell::Manipulator
+        attr_reader :index
+
+        def initialize object, index
+          @object, @index = object, index
+        end
+
+        def prev
+          @next ||= @object[index - 1] if index - 1 >= 0
+        end
+
+        def next
+          @next ||= @object[index + 1]
+        end
+
+        def size
+          @size ||= @object.size
+        end
+        alias_method :length, :size
+        alias_method :count, :size
+
+        def rindex
+          @rindex ||= size - index - 1
+        end
+
+        def first
+          @first ||= index == 0
+        end
+        alias_method :first?, :first
+
+        def last
+          @last ||= index == size - 1
+        end
+        alias_method :last?, :last
+      end
+    end
+  end
+end
+
+Hotcell.register_command for: Hotcell::Commands::For

data/lib/hotcell/commands/if.rb

@@ -0,0 +1,51 @@
+module Hotcell
+  module Commands
+    class If < Hotcell::Block
+      class Else < Hotcell::Command
+        validate_arguments_count 0
+      end
+
+      class Elsif < Hotcell::Command
+        validate_arguments_count 1
+      end
+
+      subcommand else: Else, elsif: Elsif
+      validate_arguments_count 1
+
+      def subcommand_error subcommand, *allowed_names
+        raise Hotcell::BlockError.new(
+          "Unexpected `#{subcommand.name}` for `#{name}` command",
+          *subcommand.position_info
+        ) unless allowed_names.flatten.include?(subcommand.name)
+      end
+
+      def validate!
+        last = subcommands.length - 1
+        subcommands.each_with_index do |subcommand, index|
+          subcommand_error subcommand, (index == last ? ['elsif', 'else'] : ['elsif'])
+        end
+
+        super
+      end
+
+      def process context, condition
+        conditions = [[condition]]
+        subnodes.each do |subnode|
+          if subnode.is_a?(Hotcell::Command)
+            conditions.last[1] = '' if conditions.last[1] == nil
+            conditions << (subnode.name == 'elsif' ? [subnode] : [true])
+          else
+            conditions.last[1] = subnode
+          end
+        end
+        condition = conditions.detect do |condition|
+          condition[0].is_a?(Hotcell::Command) ?
+            condition[0].render_children(context).first : condition[0]
+        end
+        condition ? condition[1].render(context) : nil
+      end
+    end
+  end
+end
+
+Hotcell.register_command if: Hotcell::Commands::If

data/lib/hotcell/commands/include.rb

@@ -0,0 +1,21 @@
+module Hotcell
+  module Commands
+    class Include < Hotcell::Command
+      def process context, *arguments
+        locals = arguments.extract_options!
+        path = arguments.first
+
+        context.scoped locals do
+          template(path, context).render(context)
+        end
+      end
+
+      def template path, context
+        resolver = context.shared[:resolver] || Hotcell.resolver
+        resolver.template(path, context)
+      end
+    end
+  end
+end
+
+Hotcell.register_command include: Hotcell::Commands::Include

data/lib/hotcell/commands/scope.rb

@@ -0,0 +1,13 @@
+module Hotcell
+  module Commands
+    class Scope < Hotcell::Block
+      def process context, scope = {}
+        context.scoped scope do
+          subnodes.first.try(:render, context)
+        end
+      end
+    end
+  end
+end
+
+Hotcell.register_command scope: Hotcell::Commands::Scope

data/lib/hotcell/commands/unless.rb

@@ -0,0 +1,23 @@
+module Hotcell
+  module Commands
+    class Unless < Hotcell::Block
+      subcommand else: Hotcell::Commands::If::Else
+      validate_arguments_count 1
+
+      def validate!
+        raise Hotcell::BlockError.new(
+          "Unexpected `#{subcommands[1].name}` for `#{name}` command",
+          *subcommands[1].position_info
+        ) if subcommands[1]
+
+        super
+      end
+
+      def process context, condition
+        condition ? subnodes[2].try(:render, context) : subnodes[0].try(:render, context)
+      end
+    end
+  end
+end
+
+Hotcell.register_command unless: Hotcell::Commands::Unless

data/lib/hotcell/commands.rb

@@ -0,0 +1,13 @@
+module Hotcell
+  module Commands
+
+  end
+end
+
+require 'hotcell/commands/if'
+require 'hotcell/commands/unless'
+require 'hotcell/commands/for'
+require 'hotcell/commands/scope'
+require 'hotcell/commands/cycle'
+require 'hotcell/commands/case'
+require 'hotcell/commands/include'

data/lib/hotcell/config.rb

@@ -4,22 +4,37 @@ module Hotcell
   class Config
     include Singleton
 
-    attr_reader :commands, :blocks, :subcommands
+    attr_reader :commands, :blocks, :helpers
+    attr_accessor :resolver
 
     def initialize
       @commands = {}
       @blocks = {}
-      @subcommands = {}
+      @helpers = []
+      @resolver = Hotcell::Resolver.new
     end
 
-    def register_command name, klass
+    # Adds command or block to the list of default commands or blocks returned
+    # by `Hotcell.commands` and `Hotcell.blocks` accessors respectively
+    #
+    # Usage:
+    #
+    #   Hotcell.register_command :block, BlockClass
+    #   Hotcell.register_command :command, CommandClass
+    #   Hotcell.register_command block: BlockClass, command: CommandClass
+    #
+    def register_command name, klass = nil
+      if name.is_a? Hash
+        name.each do |(name, klass)|
+          register_command name, klass
+        end
+        return
+      end
+
       name = name.to_s
       if klass < ::Hotcell::Block
         raise "Command `#{name}` already defined, you can not define block with the same name" if commands.key?(name)
         blocks[name] = klass
-        klass.subcommands.each do |subcommand|
-          subcommands[subcommand] = klass
-        end
       elsif klass < ::Hotcell::Command
         raise "Block `#{name}` already defined, you can not define command with the same name" if blocks.key?(name)
         commands[name] = klass
@@ -27,5 +42,17 @@ module Hotcell
         raise "Cannot register command `#{name}` because handler is not a Hotcell::Command or Hotcell::Block"
       end
     end
+
+    # Adds helper to the list of default helpers, accessible by `Hotcell.helpers`
+    #
+    # Usage:
+    #
+    #   Hotcell.register_helpers Helper
+    #   Hotcell.register_helpers Helper1, Helper2
+    #   Hotcell.register_helpers helpers_array
+    #
+    def register_helpers *helpers
+      @helpers |= helpers.flatten
+    end
   end
 end

data/lib/hotcell/context.rb

@@ -2,35 +2,68 @@ require 'hotcell/scope'
 
 module Hotcell
   class Context
-    attr_reader :scope, :rescuer, :reraise
+    attr_reader :options
     delegate :[], :[]=, :key?, :scoped, to: :scope
 
     DEFAULT_RESCUER = ->(e){ "#{e.class}: #{e.message}" }
 
     def initialize options = {}
+      @options = normalize_options options
+    end
+
+    def normalize_options options
       options = options.dup
 
       scope = options.delete(:scope) || {}
       scope.merge! (options.delete(:variables) || {}).stringify_keys
       scope.merge! (options.delete(:environment) || {}).symbolize_keys
 
-      @rescuer = options.delete(:rescuer) || DEFAULT_RESCUER
-      @reraise = !!options.delete(:reraise)
+      shared = options.delete(:shared).presence || {}
+      helpers = Array.wrap(options.delete(:helpers))
+
+      rescuer = options.delete(:rescuer) || DEFAULT_RESCUER
+      reraise = !!options.delete(:reraise)
+
+      scope.merge!(options.stringify_keys)
 
-      @scope = Scope.new scope.merge!(options.stringify_keys)
+      { scope: scope, shared: shared, helpers: helpers, reraise: reraise, rescuer: rescuer }
+    end
+
+    def scope
+      @scope ||= Scope.new options[:scope]
+    end
+
+    def shared
+      @shared ||= options[:shared]
     end
 
     def safe *default
       yield
     rescue => e
-      rescue_result = rescuer.call(e)
+      rescue_result = options[:rescuer].call(e)
       default.size > 0 ? default.first : rescue_result
     ensure
-      raise e if e && reraise
+      raise e if e && options[:reraise]
     end
 
     def manipulator_invoke method, *arguments
-      scope[method]
+      if arguments.any?
+        helpers.manipulator_invoke(method, *arguments)
+      else
+        scope.key?(method) ? scope[method] : helpers.manipulator_invoke(method)
+      end
+    end
+
+  private
+
+    def helpers
+      @helpers ||= helpers_class.new
+    end
+
+    def helpers_class
+      @helpers_class ||= Class.new(Hotcell::Manipulator).tap do |klass|
+        options[:helpers].each { |helper| klass.send(:include, helper) }
+      end
     end
   end
 end