blockly_interpreter 0.2.0

data/lib/blockly_interpreter/core_blocks/logic_negate_block.rb

@@ -0,0 +1,20 @@
+class BlocklyInterpreter::CoreBlocks::LogicNegateBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :logic_negate
+
+  def value(execution_context)
+    !values['BOOL'].value(execution_context)
+  end
+
+  def to_dsl
+    method_call_with_possible_block("logic_negate", "", values['BOOL'])
+  end
+
+  module DSLMethods
+    def logic_negate(&proc)
+      block :logic_negate do
+        value 'BOOL', &proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/logical_operator_block.rb

@@ -0,0 +1,22 @@
+class BlocklyInterpreter::CoreBlocks::LogicalOperatorBlock < BlocklyInterpreter::Block
+  self.block_type = :logic_operation
+
+  def value(execution_context)
+    case fields['OP']
+    when 'AND' then values['A'].value(execution_context) && values['B'].value(execution_context)
+    when 'OR' then values['A'].value(execution_context) || values['B'].value(execution_context)
+    end
+  end
+
+  def to_dsl
+    BlocklyInterpreter::DSL::BinaryOperationDSLGenerator.new(self, "logic_operation").dsl
+  end
+
+  module DSLMethods
+    def logic_operation(op, a = nil, b = nil, &proc)
+      @blocks << BlocklyInterpreter::DSL::BinaryOperationBlockBuilder.new("logic_operation", op, a, b).tap do |builder|
+        builder.instance_exec(&proc) if block_given?
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/number_block.rb

@@ -0,0 +1,23 @@
+class BlocklyInterpreter::CoreBlocks::NumberBlock < BlocklyInterpreter::Block
+  self.block_type = :math_number
+
+  def num
+    fields['NUM'].to_i
+  end
+
+  def value(execution_context)
+    num
+  end
+
+  def to_dsl
+    "math_number #{num.inspect}"
+  end
+
+  module DSLMethods
+    def math_number(n)
+      block :math_number do
+        field :NUM, n.to_s
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/procedure_block.rb

@@ -0,0 +1,49 @@
+class BlocklyInterpreter::CoreBlocks::ProcedureBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+
+  def arg_hash(parameters)
+    Hash[arg_names.zip(parameters)]
+  end
+
+  def arg_names
+    @arg_names ||= (mutation && mutation.css('> arg').map { |arg| arg['name'] }) || []
+  end
+
+  def arg_values(execution_context)
+    (0...arg_names.size).map do |arg_num|
+      values["ARG#{arg_num}"].value(execution_context)
+    end
+  end
+
+  def args_dsl
+    arg_names.each_with_index.map do |arg_name, i|
+      method_call_with_possible_block("arg", arg_name.inspect, values["ARG#{i}"])
+    end.compact
+  end
+
+  def to_dsl
+    method_call_with_possible_block "#{self.class.block_type}", procedure_name.inspect, args_dsl
+  end
+
+  module DSLMethods
+    class ProcedureCallBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      attr_reader :arg_number
+
+      def initialize(block_type, procedure_name)
+        super(block_type)
+
+        mutation_attr :name, procedure_name
+        @arg_number = 0
+      end
+
+      def arg(name, &proc)
+        mutation_child :arg do |child|
+          child['name'] = name
+        end
+
+        value "ARG#{arg_number}", &proc
+        @arg_number += 1
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/procedures_call_no_return_block.rb

@@ -0,0 +1,21 @@
+class BlocklyInterpreter::CoreBlocks::ProceduresCallNoReturnBlock < BlocklyInterpreter::CoreBlocks::ProcedureBlock
+  self.block_type = :procedures_callnoreturn
+
+  def procedure_name
+    @procedure_name ||= mutation.try!(:[], 'name')
+  end
+
+  def execute_statement(execution_context)
+    execution_context.execute_procedure(procedure_name, arg_values(execution_context))
+  end
+
+  module DSLMethods
+    def procedures_callnoreturn(name, &proc)
+      builder = BlocklyInterpreter::CoreBlocks::ProcedureBlock::DSLMethods::ProcedureCallBlockBuilder.new("procedures_callnoreturn", name)
+
+      @blocks << builder.tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/procedures_call_return_block.rb

@@ -0,0 +1,21 @@
+class BlocklyInterpreter::CoreBlocks::ProceduresCallReturnBlock < BlocklyInterpreter::CoreBlocks::ProcedureBlock
+  self.block_type = :procedures_callreturn
+
+  def procedure_name
+    @procedure_name ||= mutation.try!(:[], 'name')
+  end
+
+  def value(execution_context)
+    execution_context.value_for_procedure(procedure_name, arg_values(execution_context))
+  end
+
+  module DSLMethods
+    def procedures_callreturn(name, &proc)
+      builder = BlocklyInterpreter::CoreBlocks::ProcedureBlock::DSLMethods::ProcedureCallBlockBuilder.new("procedures_callreturn", name)
+
+      @blocks << builder.tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/procedures_def_no_return_block.rb

@@ -0,0 +1,31 @@
+class BlocklyInterpreter::CoreBlocks::ProceduresDefNoReturnBlock < BlocklyInterpreter::CoreBlocks::ProcedureBlock
+  self.block_type = :procedures_defnoreturn
+
+  def procedure_name
+    fields['NAME']
+  end
+
+  def execute_statement(execution_context)
+    execution_context.execute(statements['STACK'])
+  end
+
+  def to_dsl
+    method_call_with_possible_block("procedures_defnoreturn", ([procedure_name] + arg_names).map(&:inspect).join(", "), statements['STACK'])
+  end
+
+  module DSLMethods
+    def procedures_defnoreturn(name, *arg_names, &proc)
+      block :procedures_defnoreturn do
+        field :NAME, name
+
+        arg_names.each do |arg_name|
+          mutation_child :arg do |child|
+            child['name'] = arg_name
+          end
+        end
+
+        statement :STACK, &proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/procedures_def_return_block.rb

@@ -0,0 +1,64 @@
+class BlocklyInterpreter::CoreBlocks::ProceduresDefReturnBlock < BlocklyInterpreter::CoreBlocks::ProcedureBlock
+  self.block_type = :procedures_defreturn
+
+  def procedure_name
+    fields['NAME']
+  end
+
+  def value(execution_context)
+    execution_context.execute(statements['STACK'])
+
+    if execution_context.terminated
+      execution_context.early_return_value
+    else
+      values['RETURN'].value(execution_context)
+    end
+  end
+
+  def to_dsl
+    block_contents = [
+      method_call_with_block_or_nothing("body", "", statements['STACK']),
+      method_call_with_block_or_nothing("return_value", "", values['RETURN'])
+    ]
+
+    method_call_with_possible_block "#{self.class.block_type}", ([procedure_name] + arg_names).map(&:inspect).join(", "), block_contents
+  end
+
+  module DSLMethods
+    class ProceduresDefReturnBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      attr_reader :stack
+
+      def initialize(block_type, procedure_name, arg_names)
+        super(block_type)
+
+        field :NAME, procedure_name
+
+        arg_names.each do |arg_name|
+          mutation_child :arg do |child|
+            child['name'] = arg_name
+          end
+        end
+      end
+
+      def body(&proc)
+        statement :STACK, &proc
+      end
+
+      def return_value(&proc)
+        value :RETURN, &proc
+      end
+    end
+
+    def procedures_defreturn(name, *arg_names, &proc)
+      builder = BlocklyInterpreter::CoreBlocks::ProceduresDefReturnBlock::DSLMethods::ProceduresDefReturnBlockBuilder.new(
+        "procedures_defreturn",
+        name,
+        arg_names
+      )
+
+      @blocks << builder.tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/procedures_if_return_block.rb

@@ -0,0 +1,45 @@
+class BlocklyInterpreter::CoreBlocks::ProceduresIfReturnBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+
+  self.block_type = :procedures_ifreturn
+
+  def execute_statement(execution_context)
+    if values['CONDITION'].value(execution_context).present?
+      return_value = values['VALUE'].value(execution_context) if values['VALUE']
+      execution_context.early_return!(return_value)
+    end
+  end
+
+  def to_dsl
+    block_contents = [method_call_with_possible_block("condition", "", values['CONDITION'])]
+    block_contents << method_call_with_block_or_nothing("return_value", "", values['VALUE'])
+
+    method_call_with_possible_block("procedures_ifreturn", "", block_contents.compact)
+  end
+
+  module DSLMethods
+    class ProceduresIfReturnBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def initialize(block_type)
+        super
+        mutation_attr :value, 0
+      end
+
+      def condition(&proc)
+        value :CONDITION, &proc
+      end
+
+      def return_value(&proc)
+        mutation_attr :value, 1
+        value :VALUE, &proc
+      end
+    end
+
+    def procedures_ifreturn(&proc)
+      builder = BlocklyInterpreter::CoreBlocks::ProceduresIfReturnBlock::DSLMethods::ProceduresIfReturnBlockBuilder.new("procedures_ifreturn")
+
+      @blocks << builder.tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/repeat_times_block.rb

@@ -0,0 +1,33 @@
+class BlocklyInterpreter::CoreBlocks::RepeatTimesBlock < BlocklyInterpreter::Block
+  self.block_type = :controls_repeat_ext
+
+  def execute_statement(execution_context)
+    n = values['TIMES'].value(execution_context).to_i
+    n.times { execution_context.execute(statements['DO']) }
+  end
+
+  module DSLMethods
+    class RepeatBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def times(&proc)
+        value "TIMES", &proc
+      end
+
+      def action(&proc)
+        statement "DO", &proc
+      end
+    end
+
+    def controls_repeat_ext(&proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::RepeatTimesBlock::DSLMethods::RepeatBlockBuilder.new("controls_repeat_ext").tap do |builder|
+        builder.instance_exec(&proc)
+      end
+    end
+
+    def repeat_times(n, &proc)
+      controls_repeat_ext do
+        times { math_number n }
+        action &proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/set_variable_block.rb

@@ -0,0 +1,24 @@
+class BlocklyInterpreter::CoreBlocks::SetVariableBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+
+  self.block_type = :variables_set
+
+  def execute_statement(execution_context)
+    execution_context.set_variable(fields['VAR'], values['VALUE'].value(execution_context))
+  end
+
+  def to_dsl
+    method_call_with_possible_block("variables_set", fields['VAR'].inspect, values['VALUE'])
+  end
+
+  module DSLMethods
+    def variables_set(name, &proc)
+      block :variables_set do
+        field :VAR, name
+        value :VALUE do
+          instance_exec &proc
+        end
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/text_block.rb

@@ -0,0 +1,23 @@
+class BlocklyInterpreter::CoreBlocks::TextBlock < BlocklyInterpreter::Block
+  self.block_type = :text
+
+  def text
+    fields['TEXT']
+  end
+
+  def value(execution_context)
+    text
+  end
+
+  def to_dsl
+    "text #{text.inspect}"
+  end
+
+  module DSLMethods
+    def text(content)
+      block :text do
+        field :TEXT, content
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/text_change_case_block.rb

@@ -0,0 +1,32 @@
+class BlocklyInterpreter::CoreBlocks::TextChangeCaseBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :text_changeCase
+
+  def destination_case
+    fields['CASE']
+  end
+
+  def value(execution_context)
+    text = values['TEXT'].value(execution_context).to_s
+
+    case destination_case
+    when 'UPPERCASE' then text.upcase
+    when 'LOWERCASE' then text.downcase
+    when 'TITLECASE' then text.titleize
+    else raise "Unknown case: #{destination_case.inspect}"
+    end
+  end
+
+  def to_dsl
+    method_call_with_possible_block "text_change_case", destination_case.inspect, values['TEXT']
+  end
+
+  module DSLMethods
+    def text_change_case(destination_case, &proc)
+      block :text_changeCase do
+        field :CASE, destination_case
+        value :TEXT, &proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/text_join_block.rb

@@ -0,0 +1,50 @@
+class BlocklyInterpreter::CoreBlocks::TextJoinBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :text_join
+
+  def item_count
+    @item_count ||= mutation.try(:[], 'items').try(:to_i) || 0
+  end
+
+  def value(execution_context)
+    (0...item_count).map { |i| values["ADD#{i}"].value(execution_context) }.join
+  end
+
+  def to_dsl
+    item_dsls = (0...item_count).map do |i|
+      method_call_with_block_or_nothing("item", "", values["ADD#{i}"])
+    end.compact
+
+    method_call_with_possible_block("text_join", "", item_dsls)
+  end
+
+  module DSLMethods
+    class TextJoinBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def initialize(block_type)
+        super
+        @item_number = 0
+      end
+
+      def item(string = nil, &proc)
+        proc ||= Proc.new { text string }
+        value("ADD#{@item_number}", &proc)
+        @item_number += 1
+      end
+
+      def to_xml(node)
+        mutation_attr("items", @item_number)
+        super
+      end
+    end
+
+    def text_join(*strings, &proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::TextJoinBlock::DSLMethods::TextJoinBlockBuilder.new('text_join').tap do |builder|
+        strings.each do |string|
+          builder.item string
+        end
+
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end