blockly_interpreter 0.2.0

data/app/assets/javascripts/blockly_interpreter/extension_blocks/text.js.erb

@@ -0,0 +1,21 @@
+'use strict';
+
+goog.provide('BlocklyInterpreter.ExtensionBlocks.text');
+goog.require('Blockly.Blocks');
+
+Blockly.Blocks['text_inflect'] = {
+  init: function() {
+    var inflections = <%= BlocklyInterpreter::ExtensionBlocks::TextInflectBlock::INFLECTIONS.to_json %>;
+    var dropdownOptions = _.map(inflections, function (inflection) {
+      return [inflection, inflection]
+    });
+
+    this.appendValueInput('TEXT')
+      .appendField(new Blockly.FieldDropdown(dropdownOptions), 'OP')
+      .appendField('text')
+      .setCheck('String');
+
+    this.setOutput(true, 'String');
+    this.setColour(Blockly.Blocks.texts.HUE);
+  }
+}

data/bin/_guard-core

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application '_guard-core' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('guard', '_guard-core')

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "blockly_interpreter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/guard

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'guard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('guard', 'guard')

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/blockly_interpreter.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'blockly_interpreter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "blockly_interpreter"
+  spec.version       = BlocklyInterpreter::VERSION
+  spec.authors       = ["Nat Budin"]
+  spec.email         = ["natbudin@gmail.com"]
+
+  spec.summary       = %q{An interpreter for Blockly programs}
+  spec.description   = %q{Blockly is a library from Google for building visual programming editors.  This gem is an interpreter for Blockly programs in Ruby.}
+  spec.homepage      = "https://github.com/patientslikeme/blockly_interpreter"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency "terminal-notifier-guard"
+end

data/exe/blocklyi

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "blockly_interpreter"
+
+program_name = ARGV[0]
+unless program_name
+  puts "Please specify a program name to run."
+  exit!
+end
+
+xml = File.open(program_name).read
+BlocklyInterpreter::ConsoleInterpreter.new(xml).execute

data/exe/rublocklyc

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "blockly_interpreter"
+
+program_name = ARGV[0]
+unless program_name
+  puts "Please specify a program name to compile."
+  exit!
+end
+
+module ConsoleDSL
+  def console_print(content = nil, &proc)
+    block :console_print do
+      value :VALUE do
+        if block_given?
+          instance_exec &proc
+        else
+          text content
+        end
+      end
+    end
+  end
+end
+BlocklyInterpreter::DSL::BlockContext.send :include, ConsoleDSL
+
+xml = BlocklyInterpreter::DSL.build_xml do
+  binding.eval(File.open(program_name).read, program_name)
+end
+
+STDOUT.write xml

data/lib/blockly_interpreter.rb

@@ -0,0 +1,25 @@
+require "blockly_interpreter/version"
+require "active_support/dependencies/autoload"
+require "active_support/core_ext"
+
+if defined?(::Rails::Engine)
+  # Rails autoloading will take care of the requires for us, and explicitly doing it will
+  # break it.
+  require 'blockly_interpreter/engine'
+else
+  module BlocklyInterpreter
+    extend ActiveSupport::Autoload
+
+    autoload :Block
+    autoload :BlockLibrary
+    autoload :CoreBlocks
+    autoload :DSL
+    autoload :DSLGenerator
+    autoload :ExecutionContext
+    autoload :GenericBlockDSLGenerator
+    autoload :Interpreter
+    autoload :Parser
+    autoload :ProgramCache
+    autoload :Program
+  end
+end

data/lib/blockly_interpreter/block.rb

@@ -0,0 +1,113 @@
+require 'nokogiri'
+
+class BlocklyInterpreter::Block
+  class << self
+    attr_accessor :block_type
+  end
+
+  attr_reader :block_type, :values, :statements, :fields, :next_block, :mutation, :comment, :comment_pinned, :is_shadow, :x, :y
+  alias_method :is_shadow?, :is_shadow
+
+  def initialize(block_type, fields, values, statements, next_block, mutation, comment, comment_pinned, is_shadow, x, y)
+    @block_type = block_type
+    @fields = fields
+    @values = values
+    @statements = statements
+    @next_block = next_block
+    @mutation = mutation
+    @comment = comment
+    @comment_pinned = comment_pinned
+    @is_shadow = is_shadow
+    @x = x
+    @y = y
+  end
+
+  def execute_statement(execution_context)
+  end
+
+  def value(execution_context)
+    nil
+  end
+
+  def each_block(iterate_subblocks = true)
+    return to_enum(:each_block, iterate_subblocks) unless block_given?
+
+    yield self
+
+    if iterate_subblocks
+      statements.each do |key, statement|
+        statement.each_block(iterate_subblocks) do |block|
+          yield block
+        end
+      end
+    end
+
+    if next_block
+      next_block.each_block(iterate_subblocks) do |block|
+        yield block
+      end
+    end
+  end
+
+  def to_dsl
+    BlocklyInterpreter::GenericBlockDSLGenerator.new(self).dsl
+  end
+
+  def has_comment?
+    comment.present?
+  end
+
+  def has_position?
+    x || y
+  end
+
+  def to_xml_element(document)
+    tag_name = is_shadow ? 'shadow' : 'block'
+
+    Nokogiri::XML::Element.new(tag_name, document).tap do |node|
+      node['type'] = block_type
+      node['x'] = x if x
+      node['y'] = y if y
+      node.add_child(mutation.dup) if mutation
+
+      if comment
+        comment_node = Nokogiri::XML::Element.new('comment', document)
+        comment_node['pinned'] = 'true' if comment_pinned
+        node.add_child comment_node
+      end
+
+      fields.each do |name, value|
+        field_node = Nokogiri::XML::Element.new('field', document)
+        field_node['name'] = name
+        field_node.add_child Nokogiri::XML::Text.new(value, document)
+        node.add_child field_node
+      end
+
+      values.each do |name, value|
+        value_node = Nokogiri::XML::Element.new('value', document)
+        value_node['name'] = name
+        value_node.add_child value.to_xml_element(document)
+        node.add_child value_node
+      end
+
+      statements.each do |name, value|
+        statement_node = Nokogiri::XML::Element.new('statement', document)
+        statement_node['name'] = name
+        statement_node.add_child value.to_xml_element(document)
+        node.add_child statement_node
+      end
+
+      if next_block
+        next_block_node = Nokogiri::XML::Element.new('next_block', document)
+        next_block_node.add_child next_block.to_xml_element(document)
+        node.add_child next_block_node
+      end
+    end
+  end
+
+  def to_xml(options = {})
+    doc = Nokogiri::XML::Document.new
+    element = to_xml_element(doc)
+    element.to_xml(options = {})
+  end
+end

data/lib/blockly_interpreter/block_library.rb

@@ -0,0 +1,14 @@
+module BlocklyInterpreter::BlockLibrary
+  attr_accessor :block_classes
+
+  def block_classes
+    @block_classes ||= []
+  end
+
+  def register!(parser_class = BlocklyInterpreter::Parser, block_context_class = BlocklyInterpreter::DSL::BlockContext)
+    block_classes.each do |block_class|
+      parser_class.register_block_class block_class
+      block_context_class.register_block_class block_class
+    end
+  end
+end

data/lib/blockly_interpreter/console_interpreter.rb

@@ -0,0 +1,15 @@
+class BlocklyInterpreter::ConsoleInterpreter < BlocklyInterpreter::Interpreter
+  class ConsolePrintBlock < BlocklyInterpreter::Block
+    def execute_statement(execution_context)
+      puts values['VALUE'].value(execution_context)
+    end
+  end
+
+  def block_class_for_element(element)
+    case element['type']
+    when 'console_print' then ConsolePrintBlock
+    else
+      super(element)
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks.rb

@@ -0,0 +1,55 @@
+module BlocklyInterpreter::CoreBlocks
+  extend ActiveSupport::Autoload
+  extend BlocklyInterpreter::BlockLibrary
+
+  autoload :ArithmeticOperatorBlock
+  autoload :BooleanBlock
+  autoload :ComparisonOperatorBlock
+  autoload :ForBlock
+  autoload :ForEachBlock
+  autoload :GetVariableBlock
+  autoload :IfBlock
+  autoload :ListsCreateEmptyBlock
+  autoload :ListsCreateWithBlock
+  autoload :ListsGetIndexBlock
+  autoload :LogicNegateBlock
+  autoload :LogicalOperatorBlock
+  autoload :NumberBlock
+  autoload :ProcedureBlock
+  autoload :ProceduresCallNoReturnBlock
+  autoload :ProceduresCallReturnBlock
+  autoload :ProceduresDefNoReturnBlock
+  autoload :ProceduresDefReturnBlock
+  autoload :ProceduresIfReturnBlock
+  autoload :RepeatTimesBlock
+  autoload :SetVariableBlock
+  autoload :TextBlock
+  autoload :TextChangeCaseBlock
+  autoload :TextJoinBlock
+
+  self.block_classes = [
+    ArithmeticOperatorBlock,
+    BooleanBlock,
+    ComparisonOperatorBlock,
+    ForBlock,
+    ForEachBlock,
+    GetVariableBlock,
+    IfBlock,
+    ListsCreateEmptyBlock,
+    ListsCreateWithBlock,
+    ListsGetIndexBlock,
+    LogicNegateBlock,
+    LogicalOperatorBlock,
+    NumberBlock,
+    ProceduresCallNoReturnBlock,
+    ProceduresCallReturnBlock,
+    ProceduresDefNoReturnBlock,
+    ProceduresDefReturnBlock,
+    ProceduresIfReturnBlock,
+    RepeatTimesBlock,
+    SetVariableBlock,
+    TextBlock,
+    TextChangeCaseBlock,
+    TextJoinBlock
+  ]
+end

data/lib/blockly_interpreter/core_blocks/arithmetic_operator_block.rb

@@ -0,0 +1,24 @@
+class BlocklyInterpreter::CoreBlocks::ArithmeticOperatorBlock < BlocklyInterpreter::Block
+  self.block_type = :math_arithmetic
+
+  def value(execution_context)
+    a = values['A'].value(execution_context)
+    b = values['B'].value(execution_context)
+
+    case fields['OP'].to_s.upcase
+    when 'ADD' then a + b
+    when 'MINUS' then a - b
+    when 'MULTIPLY' then a * b
+    when 'DIVIDE' then a / b
+    when 'POWER' then a ** b
+    end
+  end
+
+  module DSLMethods
+    def math_arithmetic(op, a = nil, b = nil, &proc)
+      @blocks << BlocklyInterpreter::DSL::BinaryOperationBlockBuilder.new("math_arithmetic", op, a, b).tap do |builder|
+        builder.instance_exec(&proc) if block_given?
+      end
+    end
+  end
+end

data/lib/blockly_interpreter/core_blocks/boolean_block.rb

@@ -0,0 +1,23 @@
+class BlocklyInterpreter::CoreBlocks::BooleanBlock < BlocklyInterpreter::Block
+  self.block_type = :logic_boolean
+
+  def to_bool
+    fields['BOOL'] == 'TRUE'
+  end
+
+  def value(execution_context)
+    to_bool
+  end
+
+  def to_dsl
+    "logic_boolean #{to_bool.inspect}"
+  end
+
+  module DSLMethods
+    def logic_boolean(value)
+      block :logic_boolean do
+        field :BOOL, value ? "TRUE" : "FALSE"
+      end
+    end
+  end
+end