hotcell 0.0.1 → 0.1.0

data/lib/hotcell/node/block.rb

@@ -1,22 +1,27 @@
 module Hotcell
   class Block < Hotcell::Command
-    class_attribute :_subcommands, instance_writter: false
-    self._subcommands = []
+    class_attribute :subcommands, instance_writter: false, instance_reader: false
+    self.subcommands = {}
 
-    def self.subcommands *names
-      if names.any?
-        self._subcommands = _subcommands + names.flatten.map(&:to_s)
+    def self.subcommand name_or_hash, &block
+      if name_or_hash.is_a? Hash
+        self.subcommands = subcommands.merge(name_or_hash.stringify_keys)
       else
-        _subcommands
+        subcommand name_or_hash => Class.new(Hotcell::Command, &block)
       end
     end
 
-    def optimize
-      if klass = Hotcell.blocks[name]
-        klass.new name, *children, options
-      else
-        self
+    def validate!
+      subcommands.each do |subcommand|
+        raise Hotcell::BlockError.new(
+          "Unexpected subcommand `#{subcommand.name}` for `#{name}` command",
+          *subcommand.position_info
+        ) unless self.class.subcommands.key?(subcommand.name)
       end
+
+      super
+
+      subcommands.each(&:validate!)
     end
 
     def subnodes
@@ -24,35 +29,7 @@ module Hotcell
     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
+      subnodes.select { |node| node.is_a?(Hotcell::Command) }
     end
   end
 end

data/lib/hotcell/node/command.rb

@@ -1,22 +1,39 @@
 module Hotcell
   class Command < Hotcell::Node
-    attr_reader :mode, :assign
+    class_attribute :_validations
+    self._validations = {}
 
-    def initialize *_
-      super
-      @mode = options[:mode] || :normal
-      @assign = options[:assign]
-    end
-
-    def optimize
-      if klass = Hotcell.commands[name]
-        klass.new name, *children, options
+    def self.validate_arguments_count options
+      arguments_count = case options
+      when Hash
+        Range.new(options[:min].to_i,
+          options[:max].present? ? options[:max].to_i : Float::INFINITY)
+      when Range
+        options
       else
-        self
+        options.to_i
       end
+
+      self._validations = _validations.merge(arguments_count: arguments_count)
+    end
+
+    def validate_arguments_count!
+      return unless _validations.key?(:arguments_count)
+
+      args_count = children.count
+      valid_args_count = _validations[:arguments_count]
+
+      valid = valid_args_count.is_a?(Integer) ?
+        args_count == valid_args_count : valid_args_count.include?(args_count)
+
+      raise Hotcell::ArgumentError.new(
+        "Wrond number of arguments for `#{name}` (#{args_count} for #{valid_args_count})",
+        *position_info
+      ) unless valid
     end
 
     def validate!
+      validate_arguments_count!
     end
 
     def process context, *args
@@ -24,17 +41,7 @@ module Hotcell
 
     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
-        ''
+        process(context, *render_children(context))
       end
     end
   end

data/lib/hotcell/node/hasher.rb

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

data/lib/hotcell/node/summoner.rb

@@ -1,11 +1,7 @@
 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)
+    def process context, target = nil, *arguments
+      (target ? target.to_manipulator : context).manipulator_invoke(name, *arguments)
     end
   end
 end

data/lib/hotcell/node/tag.rb

@@ -13,13 +13,16 @@ module Hotcell
 
     def render context
       context.safe do
-        values = render_nodes(context, children)
-        case mode
-        when :normal
-          process context, *values
-        else
-          ''
-        end
+        concat context, process(context, *render_children(context))
+      end
+    end
+
+    def concat context, result
+      case mode
+      when :normal
+        result
+      else
+        ''
       end
     end
   end

data/lib/hotcell/node.rb

@@ -1,6 +1,7 @@
 module Hotcell
   class Node
     attr_accessor :name, :children, :options
+    attr_reader :position, :source
 
     def self.build *args
       new(*args).optimize
@@ -9,9 +10,15 @@ module Hotcell
     def initialize name, *args
       @name = name
       @options = args.extract_options!
+      @source = @options.delete(:source)
+      @position = @options.delete(:position)
       @children = args
     end
 
+    def position_info
+      source.info(position).values_at(:line, :column)
+    end
+
     def optimize
       self
     end
@@ -21,7 +28,7 @@ module Hotcell
     end
 
     def render context
-      process context, *render_nodes(context, children)
+      process context, *render_children(context)
     end
 
     def process context, *values
@@ -34,6 +41,10 @@ module Hotcell
       end
     end
 
+    def render_children context
+      render_nodes context, children
+    end
+
     def == other
       other.is_a?(self.class) &&
       name == other.name &&