blockly_interpreter 0.2.0

data/lib/blockly_interpreter/core_blocks/comparison_operator_block.rb

@@ -0,0 +1,50 @@
+class BlocklyInterpreter::CoreBlocks::ComparisonOperatorBlock < BlocklyInterpreter::Block
+  self.block_type = :logic_compare
+
+  def value(execution_context)
+    a = values['A'].value(execution_context)
+    b = values['B'].value(execution_context)
+
+    a, b = cast_values(a, b)
+
+    begin
+      case fields['OP']
+      when 'EQ' then a == b
+      when 'NEQ' then a != b
+      when 'LT' then a < b
+      when 'GT' then a > b
+      when 'LTE' then a <= b
+      when 'GTE' then a >= b
+      end
+    rescue
+      false
+    end
+  end
+
+  def to_dsl
+    BlocklyInterpreter::DSL::BinaryOperationDSLGenerator.new(self, "logic_compare").dsl
+  end
+
+  module DSLMethods
+    def logic_compare(op, a = nil, b = nil, &proc)
+      @blocks << BlocklyInterpreter::DSL::BinaryOperationBlockBuilder.new("logic_compare", op, a, b).tap do |builder|
+        builder.instance_exec(&proc) if block_given?
+      end
+    end
+  end
+
+  private
+
+  def cast_values(a, b)
+    return a, b if a.nil? && b.nil?
+    return a, b if a.is_a?(b.class) || b.is_a?(a.class)
+
+    if a.is_a?(Float) || b.is_a?(Float)
+      [a.to_f, b.to_f]
+    elsif a.is_a?(Integer) || b.is_a?(Integer)
+      [a.to_i, b.to_i]
+    else
+      [a, b]
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/for_block.rb

@@ -0,0 +1,68 @@
+class BlocklyInterpreter::CoreBlocks::ForBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = 'controls_for'
+
+  def execute_statement(execution_context)
+    from = values['FROM'].value(execution_context).to_i
+    to = values['TO'].value(execution_context).to_i
+    by = values['BY'].value(execution_context).to_i
+
+    from.step(by: by, to: to) do |i|
+      execution_context.set_variable(fields['VAR'], i)
+      execution_context.execute(statements['DO'])
+    end
+  end
+
+  def to_dsl
+    method_call_with_possible_block('controls_for', fields['VAR'].inspect, [
+      method_call_with_block_or_nothing('from', '', values['FROM']),
+      method_call_with_block_or_nothing('to', '', values['TO']),
+      method_call_with_block_or_nothing('by', '', values['BY']),
+      method_call_with_block_or_nothing('action', '', statements['DO'])
+    ])
+  end
+
+  module DSLMethods
+    class ForBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def initialize(block_type, var_name)
+        super(block_type)
+        field :VAR, var_name
+        by(1)
+      end
+
+      def from(val = nil, &proc)
+        proc ||= Proc.new { math_number val }
+        value "FROM", &proc
+      end
+
+      def to(val = nil, &proc)
+        proc ||= Proc.new { math_number val }
+        value "TO", &proc
+      end
+
+      def by(val = nil, &proc)
+        proc ||= Proc.new { math_number val }
+        @by_proc = proc
+      end
+
+      def action(&proc)
+        statement "DO", &proc
+      end
+
+      def to_xml(node)
+        value "BY", &@by_proc
+        super
+      end
+    end
+
+    def controls_for(var_name, from = nil, to = nil, by = nil, &proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::ForBlock::DSLMethods::ForBlockBuilder.new("controls_for", var_name).tap do |builder|
+        builder.from(from) if from
+        builder.to(to) if to
+        builder.by(by) if by
+
+        builder.instance_exec(&proc)
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/for_each_block.rb

@@ -0,0 +1,42 @@
+class BlocklyInterpreter::CoreBlocks::ForEachBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = 'controls_forEach'
+
+  def execute_statement(execution_context)
+    list = values['LIST'].value(execution_context)
+    list.each do |item|
+      execution_context.set_variable(fields['VAR'], item)
+      execution_context.execute(statements['DO'])
+    end
+  end
+
+  def to_dsl
+    method_call_with_possible_block("for_each", fields['VAR'].inspect, [
+      method_call_with_block_or_nothing("list", "", values['LIST']),
+      method_call_with_block_or_nothing("action", "", statements['DO'])
+    ].compact)
+  end
+
+  module DSLMethods
+    class ForEachBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def initialize(block_type, var_name)
+        super(block_type)
+        field :VAR, var_name
+      end
+
+      def list(&proc)
+        value "LIST", &proc
+      end
+
+      def action(&proc)
+        statement "DO", &proc
+      end
+    end
+
+    def for_each(var_name, &proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::ForEachBlock::DSLMethods::ForEachBlockBuilder.new("controls_forEach", var_name).tap do |builder|
+        builder.instance_exec(&proc)
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/get_variable_block.rb

@@ -0,0 +1,19 @@
+class BlocklyInterpreter::CoreBlocks::GetVariableBlock < BlocklyInterpreter::Block
+  self.block_type = :variables_get
+
+  def value(execution_context)
+    execution_context.get_variable(fields['VAR'])
+  end
+
+  def to_dsl
+    "variables_get #{fields['VAR'].inspect}"
+  end
+
+  module DSLMethods
+    def variables_get(name)
+      block :variables_get do
+        field :VAR, name
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/if_block.rb

@@ -0,0 +1,105 @@
+class BlocklyInterpreter::CoreBlocks::IfBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :controls_if
+
+  class Conditional
+    attr_reader :predicate_block, :action_block
+
+    def initialize(if_block, num)
+      @predicate_block = if_block.values["IF#{num}"]
+      @action_block = if_block.statements["DO#{num}"]
+    end
+
+    def matches?(execution_context)
+      predicate_block.value(execution_context).present?
+    end
+
+    def execute_statements(execution_context)
+      execution_context.execute(action_block)
+    end
+  end
+
+  def predicates
+    @predicates ||= begin
+      (0..elseif_count).map { |num| Conditional.new(self, num) }
+    end
+  end
+
+  def elseif_count
+    @elseif_count ||= mutation.try(:[], 'elseif').try(:to_i) || 0
+  end
+
+  def else_block
+    statements['ELSE']
+  end
+
+  def execute_statement(execution_context)
+    match = matching_predicate(execution_context)
+
+    if match
+      match.execute_statements(execution_context)
+    elsif else_block
+      execution_context.execute(else_block)
+    end
+  end
+
+  def matching_predicate(execution_context)
+    predicates.detect { |predicate| predicate.matches? execution_context }
+  end
+
+  def predicate_action_dsl(num)
+    [
+      method_call_with_possible_block("predicate", "", values["IF#{num}"]),
+      method_call_with_possible_block("action", "", statements["DO#{num}"])
+    ]
+  end
+
+  def to_dsl
+    block_contents = predicate_action_dsl(0) + (1..elseif_count).flat_map do |num|
+      method_call_with_possible_block("elsif_clause", "", predicate_action_dsl(num))
+    end
+    block_contents << method_call_with_block_or_nothing("else_action", "", else_block)
+
+    method_call_with_block_or_nothing("controls_if", "", block_contents.compact)
+  end
+
+  module DSLMethods
+    class IfBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      attr_reader :predicate_number
+
+      def initialize(block_type)
+        super
+        @predicate_number = 0
+      end
+
+      def predicate(&proc)
+        value "IF#{predicate_number}", &proc
+      end
+
+      def action(&proc)
+        statement "DO#{predicate_number}", &proc
+      end
+
+      def elsif_clause(&proc)
+        @predicate_number += 1
+        instance_exec(&proc)
+      end
+
+      def else_action(&proc)
+        mutation_attr "else", 1
+        statement "ELSE", &proc
+      end
+
+      def to_xml(node)
+        mutation_attr("elseif", @predicate_number) if @predicate_number > 0
+        super
+      end
+    end
+
+    def controls_if(&proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::IfBlock::DSLMethods::IfBlockBuilder.new("controls_if").tap do |builder|
+        builder.instance_exec(&proc)
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/lists_create_empty_block.rb

@@ -0,0 +1,17 @@
+class BlocklyInterpreter::CoreBlocks::ListsCreateEmptyBlock < BlocklyInterpreter::Block
+  self.block_type = :lists_create_empty
+
+  def value(execution_context)
+    []
+  end
+
+  def to_dsl
+    "lists_create_empty"
+  end
+
+  module DSLMethods
+    def lists_create_empty
+      block :lists_create_empty
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/lists_create_with_block.rb

@@ -0,0 +1,48 @@
+class BlocklyInterpreter::CoreBlocks::ListsCreateWithBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :lists_create_with
+
+  def item_count
+    @item_count ||= mutation.try(:[], 'items').try(:to_i) || 0
+  end
+
+  def items
+    @items ||= (0...item_count).map do |i|
+      values["ADD#{i}"]
+    end.compact
+  end
+
+  def value(execution_context)
+    items.map { |item| item.value(execution_context) }
+  end
+
+  def to_dsl
+    item_dsls = items.map { |item| method_call_with_possible_block("item", "", item) }
+    method_call_with_possible_block("lists_create_with", "", item_dsls)
+  end
+
+  module DSLMethods
+    class ListsCreateWithBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def initialize(block_type)
+        super
+        @item_number = 0
+      end
+
+      def item(&proc)
+        value("ADD#{@item_number}", &proc)
+        @item_number += 1
+      end
+
+      def to_xml(node)
+        mutation_attr("items", @item_number)
+        super
+      end
+    end
+
+    def lists_create_with(&proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::ListsCreateWithBlock::DSLMethods::ListsCreateWithBlockBuilder.new('lists_create_with').tap do |builder|
+        builder.instance_exec(&proc)
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/lists_get_index_block.rb

@@ -0,0 +1,95 @@
+class BlocklyInterpreter::CoreBlocks::ListsGetIndexBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :lists_getIndex
+
+  def is_statement?
+    mutation.try(:[], 'statement') == 'true'
+  end
+
+  def execute_statement(execution_context)
+    return unless is_statement?
+    value(execution_context)
+  end
+
+  def value(execution_context)
+    list = values['VALUE'].value(execution_context)
+    return unless list
+
+    list_index = index(execution_context, list)
+
+    value_at_index = list[list_index]
+    list.delete_at(list_index) if %w(GET_REMOVE REMOVE).include?(fields['MODE'])
+    value_at_index
+  end
+
+  def to_dsl
+    case fields['WHERE']
+    when 'FIRST', 'LAST', 'RANDOM'
+      method_call_with_possible_block("lists_get_#{fields['WHERE'].downcase}", "", values['VALUE'])
+    else
+      block_contents = [
+        method_call_with_block_or_nothing('at', '', values['AT']),
+        method_call_with_block_or_nothing('list', '', values['VALUE'])
+      ].compact
+
+      method_call_with_possible_block("lists_get_index", "mode: #{fields["MODE"].inspect}, where: #{fields["WHERE"].inspect}", block_contents)
+    end
+  end
+
+  module DSLMethods
+    class ListsGetIndexBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def at(index = nil, &proc)
+        proc ||= Proc.new { math_number index }
+        @has_at = true
+        value 'AT', &proc
+      end
+
+      def list(&proc)
+        value 'VALUE', &proc
+      end
+
+      def to_xml(node)
+        mutation_attr('statement', (@fields["MODE"] == 'REMOVE').to_s)
+        mutation_attr('at', (!!@has_at).to_s)
+        super
+      end
+    end
+
+    def lists_get_first(&proc)
+      lists_get_index where: 'FIRST' do
+        list &proc
+      end
+    end
+
+    def lists_get_last(&proc)
+      lists_get_index where: 'LAST' do
+        list &proc
+      end
+    end
+
+    def lists_get_random(&proc)
+      lists_get_index where: 'RANDOM' do
+        list &proc
+      end
+    end
+
+    def lists_get_index(mode: 'GET', where: 'FROM_START', &proc)
+      @blocks << BlocklyInterpreter::CoreBlocks::ListsGetIndexBlock::DSLMethods::ListsGetIndexBlockBuilder.new("lists_getIndex").tap do |builder|
+        builder.field 'MODE', mode
+        builder.field 'WHERE', where
+        builder.instance_exec(&proc)
+      end
+    end
+  end
+
+  private
+  def index(execution_context, list)
+    case fields['WHERE']
+    when 'FIRST' then 0
+    when 'LAST' then list.size - 1
+    when 'FROM_START' then values['AT'].value(execution_context) - 1
+    when 'FROM_END' then list.size - values['AT'].value(execution_context)
+    when 'RANDOM' then rand(list.size)
+    end
+  end
+end