hotcell 0.0.1

data/lib/hotcell/lexer.rl

@@ -0,0 +1,299 @@
+%%{
+  #%
+  machine puffer_lexer;
+
+  variable data @data;
+  variable te @te;
+  variable ts @ts;
+
+  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_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_or_comment ->{ fcall expression; }, ->{ fcall template_comment; } };
+    template => { emit_template };
+  *|;
+}%%
+#%
+
+module Hotcell
+  class Lexer
+    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 }
+    BRACKETS = BOPEN.merge(BCLOSE)
+
+    OPERATORS = OPERATIONS.merge(BRACKETS).merge("\n" => :NEWLINE)
+
+    CONSTANTS = {
+      'nil' => [:NIL, nil], 'null' => [:NIL, nil],
+      'false' => [:FALSE, false], 'true' => [:TRUE, true]
+    }
+
+    SSTRING_ESCAPE_REGEXP = /\\\'|\\\\/
+    SSTRING_ESCAPE_MAP = { "\\'" => "'", "\\\\" => "\\" }
+
+    DSTRING_ESCAPE_REGEXP = /\\./
+    DSTRING_ESCAPE_MAP = {
+      '\\"' => '"', "\\\\" => "\\", '\n' => "\n",
+      '\s' => "\s", '\r' => "\r", '\t' => "\t"
+    }
+
+    TAGS = {
+      '{{' => :TOPEN, '{{!' => :TOPEN,
+      '}}' => :TCLOSE
+    }
+
+    PREREGEXP = Set.new [
+      :TOPEN, :NEWLINE, :SEMICOLON,
+      :COLON, :COMMA, :PERIOD,
+      :POPEN, :AOPEN, :HOPEN
+    ]
+
+    def initialize source
+      @source = source
+      @data = @source.unpack 'c*'
+
+      %% write data;
+      #%
+    end
+
+    def emit symbol, value
+      @token_array << [symbol, value]
+    end
+
+    def current_value
+      @data[@ts...@te].pack('c*').force_encoding('UTF-8')
+    end
+
+    def emit_operator
+      value = current_value
+      emit OPERATORS[value], value
+    end
+
+    def emit_numeric
+      # last = @token_array[-1]
+      # pre_last = @token_array[-2]
+      # # This need to give unary minus with numeric higher precedence then unari minus with
+      # last[0] = :NEGATIVE if last && last[0] == :MINUS &&
+      #   (!pre_last || pre_last[0].in?())
+
+      value = current_value
+      if value =~ /\./
+        emit :FLOAT, Float(value)
+      else
+        emit :INTEGER, Integer(value)
+      end
+    end
+
+    def emit_identifer
+      value = current_value
+      if args = CONSTANTS[value]
+        emit *args
+      else
+        emit :IDENTIFER, value
+      end
+    end
+
+    def emit_sstring
+      emit :STRING, current_value[1..-2].gsub(SSTRING_ESCAPE_REGEXP) { |match|
+        SSTRING_ESCAPE_MAP[match] }.force_encoding('UTF-8')
+    end
+
+    def emit_dstring
+      emit :STRING, current_value[1..-2].gsub(DSTRING_ESCAPE_REGEXP) { |match|
+        DSTRING_ESCAPE_MAP[match] || match[1] }
+    end
+
+    def regexp_ambiguity
+      unless regexp_possible?
+        emit_operator
+        yield
+      end
+    end
+
+    def regexp_possible?
+      last = @token_array[-1]
+      # Need more rules!
+      !last || PREREGEXP.include?(last[0])
+    end
+
+    def emit_regexp
+      value = current_value
+      finish = value.rindex('/')
+
+      options_string = value[finish+1..-1]
+      options = 0
+      options |= Regexp::EXTENDED if options_string.include?('x')
+      options |= Regexp::IGNORECASE if options_string.include?('i')
+      options |= Regexp::MULTILINE if options_string.include?('m')
+
+      emit :REGEXP, Regexp.new(value[1..finish-1], options)
+    end
+
+    def emit_template
+      # Hack this to glue templates going straight
+      last = @token_array[-1]
+      if last && last[0] == :TEMPLATE
+        last[1] += current_value
+      else
+        emit :TEMPLATE, current_value
+      end
+    end
+
+    def emit_tag_or_comment if_tag, if_comment
+      value = current_value
+      if value == '{{#'
+        emit_comment
+        if_comment.call
+      else
+        emit_tag
+        if_tag.call
+      end
+    end
+
+    def emit_tag
+      value = current_value
+      emit TAGS[value], value
+    end
+
+    def emit_comment
+      last = @token_array[-1]
+      if last && last[0] == :COMMENT
+        last[1] += current_value
+      else
+        emit :COMMENT, current_value
+      end
+    end
+
+    def current_position
+      parsed = @data[0..@ts].pack('c*').force_encoding('UTF-8')
+      line = parsed.count("\n") + 1
+      column = parsed.size  - 1 - (parsed.rindex("\n") || -1)
+      [line, column]
+    end
+
+    def raise_unexpected_symbol
+      raise Hotcell::Errors::UnexpectedSymbol.new *current_position
+    end
+
+    def raise_unterminated_string
+      raise Hotcell::Errors::UnterminatedString.new *current_position
+    end
+
+    def raise_unterminated_regexp
+      raise Hotcell::Errors::UnterminatedRegexp.new *current_position
+    end
+
+    def tokens
+      @tokens ||= tokenize
+    end
+
+    def tokenize
+      @token_array = []
+
+      %% write init;
+      #%
+
+      eof = pe
+      stack = []
+
+      %% write exec;
+      #%
+
+      raise_unexpected_symbol unless @ts.nil?
+
+      @token_array
+    end
+  end
+end

data/lib/hotcell/manipulator.rb

@@ -0,0 +1,31 @@
+module Hotcell
+  class Manipulator
+    module Mixin
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :manipulator_methods, instance_writter: false
+        self.manipulator_methods = Set.new
+
+        def self.manipulator *methods
+          self.manipulator_methods = Set.new(manipulator_methods.to_a + methods.flatten.map(&:to_s))
+        end
+      end
+
+      def to_manipulator
+        self
+      end
+
+      def manipulator_invoke method, *arguments
+        send(method, *arguments) if manipulator_methods.include? method
+      end
+    end
+
+    include Mixin
+
+    def manipulator_methods
+      @manipulator_methods ||= Set.new((self.class.public_instance_methods -
+        Hotcell::Manipulator.public_instance_methods).map(&:to_s))
+    end
+  end
+end

data/lib/hotcell/node/arrayer.rb

@@ -0,0 +1,7 @@
+module Hotcell
+  class Arrayer < Hotcell::Node
+    def process context, *values
+      values
+    end
+  end
+end

data/lib/hotcell/node/assigner.rb

@@ -0,0 +1,11 @@
+module Hotcell
+  class Assigner < Hotcell::Node
+    def initialize *attrs
+      super :ASSIGN, *attrs
+    end
+
+    def process context, name, value
+      context[name] = value
+    end
+  end
+end

data/lib/hotcell/node/block.rb

@@ -0,0 +1,58 @@
+module Hotcell
+  class Block < Hotcell::Command
+    class_attribute :_subcommands, instance_writter: false
+    self._subcommands = []
+
+    def self.subcommands *names
+      if names.any?
+        self._subcommands = _subcommands + names.flatten.map(&:to_s)
+      else
+        _subcommands
+      end
+    end
+
+    def optimize
+      if klass = Hotcell.blocks[name]
+        klass.new name, *children, options
+      else
+        self
+      end
+    end
+
+    def subnodes
+      options[:subnodes] || []
+    end
+
+    def subcommands
+      subnodes.select { |node| node.is_a?(Hash) }
+    end
+
+    def validate!
+      valid = subcommands.map { |subcommand| subcommand[:name] } - _subcommands == []
+      raise Hotcell::Errors::BlockError.new 'Invalid block syntax' unless valid
+    end
+
+    def process context, subnodes, *args
+    end
+
+    def render context
+      context.safe do
+        subnodes = render_subnodes(context)
+        values = render_nodes(context, children)
+        concat context, process(context, subnodes, *values)
+      end
+    end
+
+    def render_subnodes context
+      subnodes.map do |node|
+        if node.is_a?(Hash)
+          subcommand = { name: node[:name] }
+          subcommand.merge!(args: node[:args].render(context)) if node[:args]
+          subcommand
+        else
+          node.render(context)
+        end
+      end
+    end
+  end
+end

data/lib/hotcell/node/calculator.rb

@@ -0,0 +1,35 @@
+module Hotcell
+  class Calculator < Hotcell::Node
+    HANDLERS = {
+      :PLUS => ->(value1, value2) { value1 + value2 },
+      :MINUS => ->(value1, value2) { value1 - value2 },
+      :UMINUS => ->(value) { -value },
+      :UPLUS => ->(value) { value },
+      :MULTIPLY => ->(value1, value2) { value1 * value2 },
+      :POWER => ->(value1, value2) { value1 ** value2 },
+      :DIVIDE => ->(value1, value2) { value1 / value2 },
+      :MODULO => ->(value1, value2) { value1 % value2 },
+      :AND => ->(value1, value2) { value1 && value2 },
+      :OR => ->(value1, value2) { value1 || value2 },
+      :NOT => ->(value) { !value },
+      :EQUAL => ->(value1, value2) { value1 == value2 },
+      :INEQUAL => ->(value1, value2) { value1 != value2 },
+      :GT => ->(value1, value2) { value1 > value2 },
+      :GTE => ->(value1, value2) { value1 >= value2 },
+      :LT => ->(value1, value2) { value1 < value2 },
+      :LTE => ->(value1, value2) { value1 <= value2 }
+    }
+
+    def optimize
+      handler = HANDLERS[name]
+      reducible = handler && children.none? { |child| child.is_a? Hotcell::Node }
+      reducible ? handler.call(*children) : super
+    end
+
+    def process context, *values
+      handler = HANDLERS[name]
+      raise "Could not find handler for `#{name}`" unless handler
+      handler.call *values
+    end
+  end
+end

data/lib/hotcell/node/command.rb

@@ -0,0 +1,41 @@
+module Hotcell
+  class Command < Hotcell::Node
+    attr_reader :mode, :assign
+
+    def initialize *_
+      super
+      @mode = options[:mode] || :normal
+      @assign = options[:assign]
+    end
+
+    def optimize
+      if klass = Hotcell.commands[name]
+        klass.new name, *children, options
+      else
+        self
+      end
+    end
+
+    def validate!
+    end
+
+    def process context, *args
+    end
+
+    def render context
+      context.safe do
+        concat context, process(context, *render_nodes(context, children))
+      end
+    end
+
+    def concat context, result
+      context[assign] = result if assign
+      case mode
+      when :normal
+        result
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/hotcell/node/hasher.rb

@@ -0,0 +1,7 @@
+module Hotcell
+  class Hasher < Hotcell::Node
+    def render context, *values
+      Hash[values]
+    end
+  end
+end

data/lib/hotcell/node/joiner.rb

@@ -0,0 +1,7 @@
+module Hotcell
+  class Joiner < Hotcell::Node
+    def process context, *values
+      values.join
+    end
+  end
+end

data/lib/hotcell/node/sequencer.rb

@@ -0,0 +1,7 @@
+module Hotcell
+  class Sequencer < Hotcell::Node
+    def process context, *values
+      values.last
+    end
+  end
+end

data/lib/hotcell/node/summoner.rb

@@ -0,0 +1,11 @@
+module Hotcell
+  class Summoner < Hotcell::Node
+    def initialize *attrs
+      super :METHOD, *attrs
+    end
+
+    def process context, object, method, *arguments
+      (object.to_manipulator || context).manipulator_invoke(method, *arguments)
+    end
+  end
+end

data/lib/hotcell/node/tag.rb

@@ -0,0 +1,26 @@
+module Hotcell
+  class Tag < Hotcell::Node
+    attr_reader :mode
+
+    def initialize *_
+      super
+      @mode = options[:mode] || :normal
+    end
+
+    def process context, *values
+      values.last
+    end
+
+    def render context
+      context.safe do
+        values = render_nodes(context, children)
+        case mode
+        when :normal
+          process context, *values
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/hotcell/node.rb

@@ -0,0 +1,55 @@
+module Hotcell
+  class Node
+    attr_accessor :name, :children, :options
+
+    def self.build *args
+      new(*args).optimize
+    end
+
+    def initialize name, *args
+      @name = name
+      @options = args.extract_options!
+      @children = args
+    end
+
+    def optimize
+      self
+    end
+
+    def [] key
+      children[key]
+    end
+
+    def render context
+      process context, *render_nodes(context, children)
+    end
+
+    def process context, *values
+      raise NotImplementedError
+    end
+
+    def render_nodes context, *values
+      values.flatten.map do |node|
+        node.is_a?(Hotcell::Node) ? node.render(context) : node
+      end
+    end
+
+    def == other
+      other.is_a?(self.class) &&
+      name == other.name &&
+      options == other.options &&
+      children == other.children
+    end
+  end
+end
+
+require 'hotcell/node/calculator'
+require 'hotcell/node/assigner'
+require 'hotcell/node/summoner'
+require 'hotcell/node/arrayer'
+require 'hotcell/node/hasher'
+require 'hotcell/node/sequencer'
+require 'hotcell/node/joiner'
+require 'hotcell/node/tag'
+require 'hotcell/node/command'
+require 'hotcell/node/block'