blockly_interpreter 0.2.0

data/lib/blockly_interpreter/extension_blocks.rb

@@ -0,0 +1,25 @@
+module BlocklyInterpreter::ExtensionBlocks
+  extend ActiveSupport::Autoload
+  extend BlocklyInterpreter::BlockLibrary
+
+  autoload :DateHashBlock
+  autoload :DateTodayBlock
+  autoload :DebugMessageBlock
+  autoload :ListsAppendBlock
+  autoload :ListsConcatBlock
+  autoload :ListsIncludeOperatorBlock
+  autoload :ObjectPresentBlock
+  autoload :SwitchBlock
+  autoload :TextInflectBlock
+
+  self.block_classes = [
+    DateTodayBlock,
+    DebugMessageBlock,
+    ListsAppendBlock,
+    ListsConcatBlock,
+    ListsIncludeOperatorBlock,
+    ObjectPresentBlock,
+    SwitchBlock,
+    TextInflectBlock
+  ]
+end

data/lib/blockly_interpreter/extension_blocks/date_today_block.rb

@@ -0,0 +1,17 @@
+class BlocklyInterpreter::ExtensionBlocks::DateTodayBlock < BlocklyInterpreter::Block
+  self.block_type = :date_today
+
+  def value(execution_context)
+    Date.today
+  end
+
+  def to_dsl
+    "date_today"
+  end
+
+  module DSLMethods
+    def date_today
+      block :date_today
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/debug_message_block.rb

@@ -0,0 +1,18 @@
+class BlocklyInterpreter::ExtensionBlocks::DebugMessageBlock < BlocklyInterpreter::Block
+  self.block_type = 'debug_message'
+
+  def execute_statement(execution_context)
+    message = values['MESSAGE'].value(execution_context)
+    message = message.inspect unless message.is_a?(String)
+    execution_context.add_debug_message message
+  end
+
+  module DSLMethods
+    def debug_message(msg = nil, &proc)
+      proc ||= Proc.new { text msg }
+      block 'debug_message' do
+        value 'MESSAGE', &proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/lists_append_block.rb

@@ -0,0 +1,34 @@
+class BlocklyInterpreter::ExtensionBlocks::ListsAppendBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :lists_append
+
+  def execute_statement(execution_context)
+    list = values['LIST'].value(execution_context)
+    list << values['VALUE'].value(execution_context)
+  end
+
+  def to_dsl
+    method_call_with_possible_block('lists_append', '', [
+      method_call_with_block_or_nothing('list', '', values['LIST']),
+      method_call_with_block_or_nothing('item', '', values['VALUE'])
+    ])
+  end
+
+  module DSLMethods
+    class ListsAppendBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def list(&proc)
+        value("LIST", &proc)
+      end
+
+      def item(&proc)
+        value("VALUE", &proc)
+      end
+    end
+
+    def lists_append
+      @blocks << BlocklyInterpreter::ExtensionBlocks::ListsAppendBlock::DSLMethods::ListsAppendBlockBuilder.new('lists_append').tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/lists_concat_block.rb

@@ -0,0 +1,37 @@
+class BlocklyInterpreter::ExtensionBlocks::ListsConcatBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :lists_concat
+
+  def value(execution_context)
+    list(execution_context, 1) + list(execution_context, 2)
+  end
+
+  def list(execution_context, n)
+    values["LIST#{n}"].try!(:value, execution_context) || []
+  end
+
+  def to_dsl
+    method_call_with_possible_block("lists_concat", "", [
+      method_call_with_block_or_nothing("list1", "", values['LIST1']),
+      method_call_with_block_or_nothing("list2", "", values['LIST2'])
+    ])
+  end
+
+  module DSLMethods
+    class ListsConcatBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      def list1(&proc)
+        value("LIST1", &proc)
+      end
+
+      def list2(&proc)
+        value("LIST2", &proc)
+      end
+    end
+
+    def lists_concat
+      @blocks << BlocklyInterpreter::ExtensionBlocks::ListsConcatBlock::DSLMethods::ListsConcatBlockBuilder.new('lists_concat').tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/lists_include_operator_block.rb

@@ -0,0 +1,52 @@
+class BlocklyInterpreter::ExtensionBlocks::ListsIncludeOperatorBlock < BlocklyInterpreter::Block
+  self.block_type = :lists_include
+
+  def value(execution_context)
+    a = values['A'].value(execution_context)
+    b = values['B'].value(execution_context)
+
+    case fields['OP']
+    when 'INCLUDE' then a.try(:include?, b)
+    when 'NINCLUDE' then !a.try(:include?, b)
+    end
+  end
+
+  class DSLGenerator < BlocklyInterpreter::DSL::BinaryOperationDSLGenerator
+    def initialize(block)
+      super(block, nil)
+    end
+
+    def dsl_method_name
+      case block.fields['OP']
+      when 'INCLUDE' then "lists_include"
+      when 'NINCLUDE' then "lists_not_include"
+      end
+    end
+
+    def method_args
+      args = super
+      args.slice(1, args.size - 1)
+    end
+  end
+
+  def to_dsl
+    DSLGenerator.new(self).dsl
+  end
+
+  module DSLMethods
+    class ListIncludesBlockBuilder < BlocklyInterpreter::DSL::BinaryOperationBlockBuilder
+    end
+
+    def lists_include(a = nil, b = nil, &proc)
+      @blocks << BlocklyInterpreter::ExtensionBlocks::ListsIncludeOperatorBlock::DSLMethods::ListIncludesBlockBuilder.new('lists_include', "INCLUDE", a, b).tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+
+    def lists_not_include(a = nil, b = nil, &proc)
+      @blocks << BlocklyInterpreter::ExtensionBlocks::ListsIncludeOperatorBlock::DSLMethods::ListIncludesBlockBuilder.new('lists_include', "NINCLUDE", a, b).tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/object_present_block.rb

@@ -0,0 +1,21 @@
+class BlocklyInterpreter::ExtensionBlocks::ObjectPresentBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+
+  self.block_type = :object_present
+
+  def value(execution_context)
+    values['VALUE'].try!(:value, execution_context).present?
+  end
+
+  def to_dsl
+    method_call_with_possible_block("object_present", "", values['VALUE'])
+  end
+
+  module DSLMethods
+    def object_present(&proc)
+      block :object_present do
+        value :VALUE, &proc
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/switch_block.rb

@@ -0,0 +1,107 @@
+class BlocklyInterpreter::ExtensionBlocks::SwitchBlock < BlocklyInterpreter::Block
+  include BlocklyInterpreter::DSLGenerator
+  self.block_type = :controls_switch
+
+  class Conditional
+    attr_reader :predicate_block, :action_block
+
+    def initialize(switch_block, num)
+      @predicate_block = switch_block.values["CASE#{num}"]
+      @action_block = switch_block.statements["DO#{num}"]
+    end
+
+    def matches?(value, execution_context)
+      predicate_block.value(execution_context) == value
+    end
+
+    def execute_statement(execution_context)
+      execution_context.execute(action_block)
+    end
+  end
+
+  def predicates
+    @predicates ||= begin
+      case_count = mutation.try(:[], 'case').try(:to_i) || 0
+      (0...case_count).map { |num| Conditional.new(self, num) }
+    end
+  end
+
+  def else_block
+    statements['ELSE']
+  end
+
+  def execute_statement(execution_context)
+    (matching_predicate(execution_context) || else_block).try!(:execute_statement, execution_context)
+  end
+
+  def matching_predicate(execution_context)
+    val = switch_value(execution_context)
+    execution_context.set_variable(fields['CAPTURE_VAR'], val) if fields['CAPTURE_VAR'].present?
+    predicates.detect { |predicate| predicate.matches? val, execution_context }
+  end
+
+  def switch_value(execution_context)
+    values['SWITCH_VAL'].value(execution_context)
+  end
+
+  def to_dsl
+    preamble_dsl = [method_call_with_possible_block('switch_value', '', values['SWITCH_VAL'])]
+    preamble_dsl << "capture_as #{fields['CAPTURE_VAR'].inspect}" if fields['CAPTURE_VAR'].present?
+
+    clauses_dsl = predicates.map do |predicate|
+      [
+        method_call_with_possible_block('predicate', '', predicate.predicate_block),
+        method_call_with_possible_block('action', '', predicate.action_block)
+      ].join("\n")
+    end
+
+    clauses_dsl << method_call_with_block_or_nothing('else_action', '', statements['ELSE'])
+
+    method_call_with_possible_block('controls_switch', '', [preamble_dsl.join("\n"), clauses_dsl.join("\n")].join("\n"))
+  end
+
+  module DSLMethods
+    class SwitchBlockBuilder < BlocklyInterpreter::DSL::BlockBuilder
+      attr_reader :predicate_number
+
+      def initialize(block_type)
+        super
+        @predicate_number = 0
+      end
+
+      def capture_as(var_name)
+        field "CAPTURE_VAR", var_name
+        mutation_attr('capture', 1)
+      end
+
+      def switch_value(&proc)
+        value "SWITCH_VAL", &proc
+      end
+
+      def predicate(&proc)
+        value "CASE#{predicate_number}", &proc
+      end
+
+      def action(&proc)
+        statement "DO#{predicate_number}", &proc
+        @predicate_number += 1
+      end
+
+      def else_action(&proc)
+        mutation_attr "else", 1
+        statement "ELSE", &proc
+      end
+
+      def to_xml(node)
+        mutation_attr("case", @predicate_number) if @predicate_number > 0
+        super
+      end
+    end
+
+    def controls_switch(&proc)
+      @blocks << BlocklyInterpreter::ExtensionBlocks::SwitchBlock::DSLMethods::SwitchBlockBuilder.new("controls_switch").tap do |builder|
+        builder.instance_exec(&proc)
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/extension_blocks/text_inflect_block.rb

@@ -0,0 +1,27 @@
+class BlocklyInterpreter::ExtensionBlocks::TextInflectBlock < BlocklyInterpreter::Block
+  INFLECTIONS = %w(
+    humanize
+    pluralize
+    singularize
+    titleize
+    camelize
+    classify
+    dasherize
+    deconstantize
+    demodulize
+    parameterize
+    tableize
+    underscore
+  )
+
+  self.block_type = :text_inflect
+
+  def value(execution_context)
+    text = values['TEXT'].value(execution_context)
+
+    case fields['OP']
+    when *INFLECTIONS then text.public_send(fields['OP'])
+    else text
+    end
+  end
+end

data/lib/blockly_interpreter/generic_block_dsl_generator.rb

@@ -0,0 +1,64 @@
+class BlocklyInterpreter::GenericBlockDSLGenerator
+  include BlocklyInterpreter::DSLGenerator
+
+  attr_reader :block
+
+  def initialize(block)
+    @block = block
+  end
+
+  def dsl
+    method_call_with_possible_block("block", block.class.block_type.to_sym.inspect, block_contents)
+  end
+
+  private
+  def mutation_attributes_dsl(mutation)
+    mutation.attributes.keys.map do |attribute|
+      "mutation_attr #{attribute.inspect}, #{mutation[attribute].inspect}"
+    end
+  end
+
+  def mutation_child_dsl(child)
+    attributes_dsl = child.attributes.keys.map do |child_attribute|
+      "child[#{child_attribute.inspect}] = #{child[child_attribute].inspect}"
+    end
+
+    if child.inner_html.present?
+      attributes_dsl << "child.inner_html = #{child.inner_html.inspect}"
+    end
+
+    method_call_with_possible_block("mutation_child", child.name.inspect, attributes_dsl, "child")
+  end
+
+  def mutation_dsl
+    if block.mutation
+      mutation_attributes_dsl(block.mutation) + block.mutation.children.map do |child|
+        mutation_child_dsl(child)
+      end
+    else
+      []
+    end
+  end
+
+  def fields_dsl
+    block.fields.map do |key, value|
+      "field #{key.inspect}, #{value.inspect}"
+    end
+  end
+
+  def values_dsl
+    block.values.map do |key, value_block|
+      method_call_with_possible_block("value", key.inspect, value_block) + "\n"
+    end
+  end
+
+  def statements_dsl
+    block.statements.map do |key, statement_block|
+      method_call_with_possible_block("statement", key.inspect, statement_block) + "\n"
+    end
+  end
+
+  def block_contents
+    @block_contents ||= (mutation_dsl + fields_dsl + values_dsl + statements_dsl)
+  end
+end

data/lib/blockly_interpreter/interpreter.rb

@@ -0,0 +1,25 @@
+require 'nokogiri'
+
+class BlocklyInterpreter::Interpreter
+  attr_reader :program, :debug_messages
+
+  def initialize(program)
+    @program = program
+    @debug_messages = []
+  end
+
+  def build_execution_context
+    BlocklyInterpreter::ExecutionContext.new(self)
+  end
+
+  def execute
+    build_execution_context.tap do |context|
+      context.execute(program.first_block)
+      add_debug_messages context.debug_messages
+    end
+  end
+
+  def add_debug_messages(debug_messages)
+    @debug_messages.push *debug_messages
+  end
+end

data/lib/blockly_interpreter/parser.rb

@@ -0,0 +1,117 @@
+require 'nokogiri'
+
+class BlocklyInterpreter::Parser
+  class UnknownBlockTypeError < StandardError
+  end
+
+  def self.registered_block_types
+    @registered_block_types ||= {}
+  end
+
+  def self.register_block_class(block_class)
+    raise "Block class #{block_class} has no type specified" unless block_class.block_type
+    registered_block_types[block_class.block_type.to_sym] = block_class
+  end
+
+  def self.registered_block_class_for_type(block_type)
+    block_class = registered_block_types[block_type.to_sym]
+
+    if block_class
+      block_class
+    elsif superclass.respond_to?(:registered_block_class_for_type)
+      superclass.registered_block_class_for_type(block_type)
+    end
+  end
+
+  def parse(xml)
+    dom = Nokogiri::XML.parse(xml)
+
+    if dom.root
+      procs, nonprocs = dom.root.css('> block').partition do |element|
+        ['procedures_defreturn', 'procedures_defnoreturn'].include? element['type']
+      end
+
+      procedures = procs.map { |element| block_from_dom(element) }.index_by(&:procedure_name)
+      first_block = block_from_dom(nonprocs.first)
+    else
+      first_block = nil
+      procedures = {}
+    end
+
+    BlocklyInterpreter::Program.new(first_block, procedures)
+  end
+
+  def block_from_dom(element)
+    return unless element
+    block_class_for_element(element).new(
+      element['type'],
+      fields_from_element(element),
+      values_from_element(element),
+      statements_from_element(element),
+      next_block_from_element(element),
+      mutation_from_element(element),
+      comment_from_element(element),
+      comment_pinned_from_element(element),
+      element.name == 'shadow',
+      element['x'],
+      element['y']
+    )
+  end
+
+  private
+
+  def block_class_for_element(element)
+    block_type = element['type']
+    block_class = self.class.registered_block_class_for_type(block_type)
+
+    if block_class
+      block_class
+    else
+      raise UnknownBlockTypeError.new("#{element['type']} is not a registered block type")
+    end
+  end
+
+  def values_from_element(element)
+    children_by_name(element, '> value') do |child|
+      block_from_dom(child.css('> block').first || child.css('> shadow').first)
+    end
+  end
+
+  def statements_from_element(element)
+    children_by_name(element, '> statement') do |child|
+      block_from_dom(child.css('> block').first || child.css('> shadow').first)
+    end
+  end
+
+  def fields_from_element(element)
+    children_by_name(element, '> field') do |child|
+      child.text
+    end
+  end
+
+  def next_block_from_element(element)
+    next_block_element = element.css('> next > block').first || element.css('> next > shadow').first
+    block_from_dom(next_block_element) if next_block_element
+  end
+
+  def mutation_from_element(element)
+    element.css('> mutation').first
+  end
+
+  def comment_from_element(element)
+    element.css('> comment').first.try!(:text)
+  end
+
+  def comment_pinned_from_element(element)
+    element.css('> comment').first.try { |comment| comment['pinned'] == 'true' }
+  end
+
+  def children_by_name(xml, selector, &block)
+    xml.css(selector).map do |child|
+      processed_child = block_given? ? yield(child) : child
+      [child['name'], processed_child]
+    end.to_h
+  end
+end
+
+BlocklyInterpreter::CoreBlocks.register!