blockly_interpreter 0.2.0

data/lib/blockly_interpreter/dsl.rb

@@ -0,0 +1,291 @@
+require 'nokogiri'
+
+module BlocklyInterpreter::DSL
+  class BlockContext
+    attr_reader :blocks, :procedure_blocks
+
+    def self.register_block_class(block_class)
+      if block_class.const_defined?(:DSLMethods)
+        self.include block_class.const_get(:DSLMethods)
+      end
+    end
+
+    def initialize
+      @blocks = []
+      @procedure_blocks = []
+    end
+
+    def block(block_type, &proc)
+      @blocks << BlockBuilder.new(block_type).tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+    end
+
+    def with_comment(comment, pinned = false, &proc)
+      instance_exec(&proc)
+      @blocks.last.tap { |block| block.set_comment(comment, pinned) }
+    end
+
+    def shadow(&proc)
+      instance_exec(&proc)
+      @blocks.last.tap { |block| block.shadow! }
+    end
+
+    def with_position(x, y, &proc)
+      instance_exec(&proc)
+      @blocks.last.tap { |block| block.set_position!(x, y) }
+    end
+
+    def procedures(&proc)
+      procedures_context = BlockContext.new.tap do |builder|
+        builder.instance_exec(&proc) if proc
+      end
+
+      @procedure_blocks.push(*procedures_context.blocks)
+    end
+
+    def to_xml(doc, block_index = 0)
+      return unless blocks.any?
+
+      block = blocks[block_index]
+      Nokogiri::XML::Node.new(block.tag_name, doc).tap do |node|
+        blocks[block_index].to_xml(node)
+
+        if blocks.size > block_index + 1
+          next_node = Nokogiri::XML::Node.new('next', doc)
+          next_node.add_child to_xml(doc, block_index + 1)
+          node.add_child(next_node)
+        end
+      end
+    end
+  end
+
+  class BlockBuilder
+    attr_reader :block_type, :values, :statements, :fields, :mutation_attrs, :mutation_child_procs, :comment, :comment_pinned, :is_shadow, :x, :y
+
+    def initialize(block_type)
+      @block_type = block_type
+      @values = {}
+      @statements = {}
+      @fields = {}
+      @mutation_attrs = {}
+      @mutation_child_procs = []
+      @comment = nil
+      @comment_pinned = nil
+      @is_shadow = false
+      @x = nil
+      @y = nil
+    end
+
+    def to_xml(node)
+      node['type'] = block_type
+      document = node.document
+
+      node['x'] = x if x
+      node['y'] = y if y
+
+      node.add_child(mutations_to_xml(document)) if mutation_attrs.any? || mutation_child_procs.any?
+      node.add_child(comment_to_xml(document)) if comment.present?
+
+      values.each do |name, context|
+        node.add_child subblock_to_xml('value', name, context, document)
+      end
+
+      statements.each do |name, context|
+        node.add_child subblock_to_xml('statement', name, context, document)
+      end
+
+      fields.each do |name, value|
+        node.add_child field_to_xml(name, value, document)
+      end
+    end
+
+    def subblock_to_xml(tag_name, subblock_name, context, doc)
+      Nokogiri::XML::Node.new(tag_name, doc).tap do |node|
+        node['name'] = subblock_name
+        node.add_child context.to_xml(doc)
+      end
+    end
+
+    def mutations_to_xml(document)
+      Nokogiri::XML::Node.new('mutation', document).tap do |mutation_node|
+        mutation_attrs.each do |name, value|
+          mutation_node[name] = value.to_s
+        end
+
+        mutation_child_procs.each do |(tag_name, proc)|
+          child = Nokogiri::XML::Node.new(tag_name.to_s, document)
+          proc.call(child)
+          mutation_node.add_child child
+        end
+      end
+    end
+
+    def field_to_xml(name, value, document)
+      Nokogiri::XML::Node.new('field', document).tap do |field_node|
+        field_node['name'] = name
+        field_node.add_child Nokogiri::XML::Text.new(value.to_s, document)
+      end
+    end
+
+    def comment_to_xml(document)
+      Nokogiri::XML::Node.new('comment', document).tap do |comment_node|
+        comment_node.content = comment
+        comment_node['pinned'] = comment_pinned.inspect unless comment_pinned.nil?
+      end
+    end
+
+    def build_subblock(&proc)
+      BlockContext.new.tap do |builder|
+        builder.instance_exec(&proc)
+      end
+    end
+
+    def value(name, &proc)
+      @values[name.to_s] = build_subblock(&proc)
+    end
+
+    def statement(name, &proc)
+      @statements[name.to_s] = build_subblock(&proc)
+    end
+
+    def field(name, value)
+      @fields[name.to_s] = value
+    end
+
+    def mutation_attr(name, value)
+      @mutation_attrs[name.to_s] = value
+    end
+
+    def mutation_child(tag_name, &proc)
+      @mutation_child_procs << [tag_name, proc]
+    end
+
+    def set_comment(comment, pinned = false)
+      @comment = comment
+      @comment_pinned = pinned
+    end
+
+    def set_position!(x, y)
+      @x = x
+      @y = y
+    end
+
+    def tag_name
+      if is_shadow
+        'shadow'
+      else
+        'block'
+      end
+    end
+
+    def shadow!
+      @is_shadow = true
+    end
+  end
+
+  class BinaryOperationBlockBuilder < BlockBuilder
+    def initialize(block_type, op, a = nil, b = nil)
+      super block_type
+      field :OP, op
+
+      a(a) unless a.nil?
+      b(b) unless b.nil?
+    end
+
+    def cast_static_value_proc(static_value)
+      case static_value
+      when Numeric then -> { math_number(static_value) }
+      when String then -> { text(static_value) }
+      when true, false then -> { logic_boolean(static_value) }
+      end
+    end
+
+    def value_with_static_option(name, static_value = nil, &proc)
+      proc ||= cast_static_value_proc(static_value)
+      value name, &proc
+    end
+
+    def a(static_value = nil, &proc)
+      value_with_static_option :A, static_value, &proc
+    end
+
+    def b(static_value = nil, &proc)
+      value_with_static_option :B, static_value, &proc
+    end
+  end
+
+  class BinaryOperationDSLGenerator
+    include BlocklyInterpreter::DSLGenerator
+
+    attr_reader :block, :dsl_method_name
+
+    def initialize(block, dsl_method_name)
+      @block = block
+      @dsl_method_name = dsl_method_name
+    end
+
+    def castable_static_value(value)
+      case value
+      when BlocklyInterpreter::CoreBlocks::NumberBlock then value.fields['NUM'].to_i
+      when BlocklyInterpreter::CoreBlocks::BooleanBlock then value.to_bool
+      when BlocklyInterpreter::CoreBlocks::TextBlock then value.fields['TEXT']
+      end
+    end
+
+    def cast_operands
+      @cast_operands ||= begin
+        a, b = ['A', 'B'].map { |value_name| block.values[value_name] }
+        [a, b].map { |value| castable_static_value value }
+      end
+    end
+
+    def value_block(value_name, cast_operand)
+      return if cast_operand
+      method_call_with_block_or_nothing(value_name.downcase, '', block.values[value_name])
+    end
+
+    def block_contents
+      cast_a, cast_b = cast_operands
+      [
+        value_block('A', cast_a),
+        value_block('B', cast_b)
+      ].compact
+    end
+
+    def method_args
+      args = [block.fields['OP'].to_sym.inspect]
+      cast_a, cast_b = cast_operands
+
+      args << cast_a.inspect if cast_a || cast_b
+      args << cast_b.inspect if cast_b
+
+      args
+    end
+
+    def dsl
+      method_call_with_possible_block(dsl_method_name, method_args.join(', '), block_contents)
+    end
+  end
+
+  def self.build_xml(&block)
+    doc = Nokogiri::XML::Document.new
+    root = Nokogiri::XML::Node.new('xml', doc)
+    root['xmlns'] = 'http://www.w3.org/1999/xhtml'
+    doc.add_child root
+
+    context = BlockContext.new
+    context.instance_exec(&block)
+    first_block = context.to_xml(doc)
+    root.add_child(first_block) if first_block
+
+    context.procedure_blocks.each do |proc|
+      Nokogiri::XML::Node.new(proc.tag_name, doc).tap do |node|
+        proc.to_xml(node)
+        root.add_child(node)
+      end
+    end
+
+    doc.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION | Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)
+  end
+end

data/lib/blockly_interpreter/dsl_generator.rb

@@ -0,0 +1,147 @@
+module BlocklyInterpreter::DSLGenerator
+  # Calls #flatten on an enumerable object recursively.  Any flattenable things inside obj will also be flattened.
+  def deep_flatten(obj)
+    if obj.respond_to?(:flatten)
+      obj.flatten.map { |item| deep_flatten(item) }
+    else
+      obj
+    end
+  end
+
+  # Given a piece of code as a string, removes any trailing whitespace from each line.
+  def strip_trailing_whitespace(code)
+    code.gsub(/[ \t]+$/, '')
+  end
+
+  # Given a piece of code, indents it by `level` spaces.
+  #
+  # indent can accept code as a string (obviously), but can also accept a BlocklyInterpreter::Block, which will
+  # automatically be converted to a DSL string and then indented.  It can also accept Arrays consisting of strings,
+  # BlocklyInterpreter::Blocks, other arrays, and nil, which will be concatenated and indented.
+  def indent(code, level = 2)
+    lines = case code
+    when String then code.split("\n")
+    when BlocklyInterpreter::Block then start_block_to_dsl(code).split("\n")
+    when Array then deep_flatten(code).compact.flat_map { |code| code.split("\n") }
+    else code
+    end
+
+    lines.map { |line| (" " * level) + line }.join("\n")
+  end
+
+  # Generates a Ruby method call given a method name and an arguments string.  If `parens` is true, the arguments
+  # will be wrapped in parentheses; otherwise, the parentheses will be omitted.
+  def method_call(method_name, args, parens = false)
+    code = if parens
+      method_name.dup.tap do |ruby|
+        ruby << "(#{args})" if args.present?
+      end
+    else
+      [method_name, args].map(&:presence).compact.join(" ")
+    end
+
+    strip_trailing_whitespace(code)
+  end
+
+  # Generates a Ruby method call with a block.  If `block_contents` is missing, generates the method call with the
+  # block omitted.  See `method_call_with_block_or_nothing` for argument descriptions.
+  def method_call_with_possible_block(method_name, args, block_contents, *block_arg_names)
+    method_call_with_block_or_nothing(method_name, args, block_contents, *block_arg_names) || method_call(method_name, args)
+  end
+
+  # Generates a Ruby method call with a block.  If `block_contents` is missing, this method will return nil.
+  #
+  # Arguments:
+  # * `method_name` - the name of the method, as a string
+  # * `args` - an arguments string for the method call, or nil if there are no arguments
+  # * `block_contents` - an indentable object (i.e. a string, BlocklyInterpreter::Block, or array thereof)
+  # * `block_arg_names` - an arguments string for the argument names that will be passed to the block
+  #
+  # Example:
+  #
+  #     > puts method_call_with_block_or_nothing("each", nil, "puts i + 3", "i")
+  #     each do |i|
+  #       puts i + 3
+  #     end
+  def method_call_with_block_or_nothing(method_name, args, block_contents, *block_arg_names)
+    return unless block_contents.present?
+
+    block_args = if block_arg_names.present?
+      " |#{block_arg_names.join(", ")}|"
+    else
+      ""
+    end
+
+    unindented_contents = indent(block_contents, 0)
+    code = if unindented_contents.size < 40 && !(unindented_contents =~ /\n/)
+      "#{method_call(method_name, args, true)} {#{block_args} #{unindented_contents} }"
+    else
+      <<-DSL
+#{method_call(method_name, args)} do#{block_args}
+#{indent block_contents}
+end
+DSL
+    end
+
+    strip_trailing_whitespace(code)
+  end
+
+  # Given a hash of keyword arguments to a method and a second hash containing that method's default arguments,
+  # returns a hash containing all the `keyword_args` omitting the ones that are already the method's default value
+  # for that argument.
+  #
+  # Example:
+  #
+  #     > keyword_args_without_defaults({ field_type: 'radio', placeholder_text: 'Enter an answer' }, { field_type: 'default', placeholder_text: 'Enter an answer' })
+  #     -> { field_type: 'radio' }
+  def keyword_args_without_defaults(keyword_args, default_args)
+    keyword_args.reject { |key, value| default_args[key] == value }
+  end
+
+  # Given a hash of keyword arguments for a method call, returns a string containing those arguments as they should
+  # be passed to the method.
+  def formatted_keyword_args(keyword_args)
+    keyword_args.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+  end
+
+  # Given a BlocklyInterpreter::Block, returns a DSL string that will generate that block.
+  def start_block_to_dsl(block)
+    return "" unless block
+
+    block_dsls = block.each_block(false).map do |block|
+      dsl_content = block.to_dsl
+
+      if block.has_comment?
+        dsl_content = method_call_with_possible_block(
+          "with_comment",
+          [block.comment, block.comment_pinned].compact.map(&:inspect).join(", "),
+          dsl_content
+        )
+      end
+
+      if block.is_shadow?
+        dsl_content = method_call_with_possible_block("shadow", "", dsl_content)
+      end
+
+      if block.has_position?
+        dsl_content = method_call_with_possible_block("with_position", [block.x, block.y].map(&:inspect).join(", "), dsl_content)
+      end
+
+      dsl_content
+    end
+    block_dsls.join("\n")
+  end
+
+  # Given a Time object (or nil), generates a Ruby string representation of that object.
+  #
+  # Example:
+  #
+  #     > puts timestamp_to_dsl(Time.now)
+  #     Time.utc(2016, 3, 31, 11, 54, 24, 0, 0)
+  def timestamp_to_dsl(time)
+    return "nil" unless time
+
+    args = [time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec].map(&:inspect).join(", ")
+    "Time.utc(#{args})"
+  end
+end

data/lib/blockly_interpreter/engine.rb

@@ -0,0 +1,8 @@
+module BlocklyInterpreter
+  class Engine < ::Rails::Engine
+    engine_name 'blockly_interpreter'
+    isolate_namespace BlocklyInterpreter
+
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+  end
+end

data/lib/blockly_interpreter/execution_context.rb

@@ -0,0 +1,72 @@
+require 'logger'
+
+class BlocklyInterpreter::ExecutionContext
+  attr_reader :interpreter, :early_return_value, :terminated, :debug_messages
+
+  def initialize(interpreter)
+    @interpreter = interpreter
+    @variables = {}
+    @early_return_value = nil
+    @terminated = false
+    @debug_messages = []
+  end
+
+  def get_variable(name)
+    @variables[name.to_s.upcase]
+  end
+
+  def set_variable(name, value)
+    @variables[name.to_s.upcase] = value
+  end
+
+  def set_variables(hash)
+    hash.each do |name, value|
+      set_variable(name, value)
+    end
+  end
+
+  def merge_state_from(context)
+  end
+
+  def execute(block)
+    current_block = block
+
+    while current_block && !terminated
+      current_block.execute_statement(self)
+      current_block = current_block.next_block
+    end
+  end
+
+  def early_return!(value = nil)
+    @terminated = true
+    @early_return_value = value
+  end
+
+  def execute_procedure(name, parameters)
+    procedure_block = interpreter.program.procedures[name]
+
+    interpreter.build_execution_context.tap do |proc_context|
+      proc_context.set_variables(@variables.merge(procedure_block.arg_hash(parameters)))
+      proc_context.execute(procedure_block)
+      merge_state_from(proc_context)
+    end
+  end
+
+  def value_for_procedure(name, parameters)
+    procedure_block = interpreter.program.procedures[name]
+
+    proc_context = interpreter.build_execution_context
+    proc_context.set_variables(@variables.merge(procedure_block.arg_hash(parameters)))
+
+    procedure_block.value(proc_context).tap do |value|
+      merge_state_from(proc_context)
+    end
+  end
+
+  def add_debug_message(message)
+    if message.present?
+      Logger.new(STDERR).debug message
+      debug_messages << message
+    end
+  end
+end