blockly_interpreter 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d3824303297d44e4ce4640333b83678e1bb5120
+  data.tar.gz: aa31793222b180d74e9df43699108c8b6747f524
+SHA512:
+  metadata.gz: fb39b11fc79c8cc234cf2fd193dcc57f78f9b68db53d81c432b906963663cdb11e0dce89f0dc3bff2349bb3315f9e79dfe1fd496b357f04144bcb17e58046d84
+  data.tar.gz: 6f1566950f8a85f5d9421bfac75fe71155148ebdd6341b244f98b756800a5ff14d94ed13b649887c534a1df9d69f00513e0c78d37bb07eb3c78904e8ee65452e

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.2
+before_install: gem install bundler -v 1.10.6

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## Version 0.2.0 - August 16, 2016
+
+* Initial public release.
+* Add `to_xml` and `to_xml_document` methods to `BlocklyInterpreter::Program`, and `to_xml_element` to `BlocklyInterpreter::Block`.
+
+## Version 0.1.1 - June 20, 2016
+
+* Expose the helper classes from test_helper to the outside world (although not by default) so that code depending on this gem can use them
+
+## Version 0.1.0 - June 8, 2016
+
+* Initial internal release.

data/COPYING

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2015-2016 PatientsLikeMe, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in blockly_interpreter.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,91 @@
+PATH
+  remote: .
+  specs:
+    blockly_interpreter (0.2.0)
+      activesupport
+      nokogiri
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    ansi (1.5.0)
+    builder (3.2.2)
+    coderay (1.1.1)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-minitest (2.4.4)
+      guard-compat (~> 1.2)
+      minitest (>= 3.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    listen (3.0.6)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9.7)
+    lumberjack (1.0.10)
+    method_source (0.8.2)
+    mini_portile2 (2.1.0)
+    minitest (5.8.4)
+    minitest-reporters (1.1.8)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    nenv (0.3.0)
+    nokogiri (1.6.8)
+      mini_portile2 (~> 2.1.0)
+      pkg-config (~> 1.1.7)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pkg-config (1.1.7)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    ruby-progressbar (1.7.5)
+    shellany (0.0.1)
+    slop (3.6.0)
+    terminal-notifier-guard (1.7.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    timecop (0.8.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  blockly_interpreter!
+  bundler (~> 1.10)
+  guard
+  guard-minitest
+  minitest
+  minitest-reporters
+  pry
+  rake (~> 10.0)
+  terminal-notifier-guard
+  timecop
+
+BUNDLED WITH
+   1.10.5

data/Guardfile

@@ -0,0 +1,22 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  watch(%r{^test/(.*)\/?(.*)_test\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { "test" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+end

data/README.md

@@ -0,0 +1,72 @@
+# blockly_interpreter
+
+An interpreter for [Blockly](https://developers.google.com/blockly/) programs, written in Ruby.  blockly_interpreter provides:
+
+* Implementations of most (but not all) of the blocks that Blockly ships with
+* The capability to easily implement your own block types
+* Several optional extension blocks to allow accessing Ruby and Rails features
+* A DSL for writing Blockly programs in Ruby
+* Automatic import and export capabilities to translate between that DSL and Blockly XML code
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'blockly_interpreter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install blockly_interpreter
+
+## Basic Usage
+
+To begin with, you'll probably want a global instance of `BlocklyInterpreter::ProgramCache`.  This class is thread-safe, so you can use a global instance in multithreaded apps.
+
+```ruby
+my_program_cache = BlocklyInterpreter::ProgramCache.new
+```
+
+Then, load and parse the program, which will return a `BlocklyInterpreter::Program` object.
+
+```ruby
+program = my_program_cache.load_program("<xml>...</xml>")
+```
+
+Finally, spin up a `BlocklyInterpreter::Interpreter` and run your program:
+
+```ruby
+interpreter = BlocklyInterpreter::Interpreter.new
+interpreter.execute(program)
+```
+
+## Custom Interpreters and Execution Contexts
+
+In many situations, you might need to create a custom interpreter subclass.  For example:
+
+* You might want the Blockly program to produce some particular type of output
+* You might want to provide additional context for the program to use when it runs
+* You might want to create custom blocks for certain types of Blockly programs to use
+
+To do this, you'll likely need to create subclasses of two things: `BlocklyInterpreter::ExecutionContext` and `BlocklyInterpreter::Interpreter`.  The `BlocklyInterpreter::ExecutionContext` object is passed into all Block classes in their `execute_statement` and `value` methods, so it can be used to expose external objects to custom blocks, or to allow custom blocks to set output values from the program.  The `BlocklyInterpreter::Interpreter` object is the external interface that allows programs to be run, so it will need to be configured to use your custom `ExecutionContext` class, to set it up with the right input values, and to expose any output values it might produce.
+
+For an example of how this might work, see `TestInterpreter` and `TestInterpreter::ExecutionContext` in `test/test_helper.rb`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nbudin/blockly_interpreter.
+
+## License
+
+blockly_interpreter is Copyright &copy; Nat Budin and is distributed under the terms and conditions of the MIT License.  See the COPYING file for details.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

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

@@ -0,0 +1 @@
+//= require_tree './extension_blocks'

data/app/assets/javascripts/blockly_interpreter/extension_blocks/dates.js

@@ -0,0 +1,16 @@
+'use strict';
+
+goog.provide('BlocklyInterpreter.ExtensionBlocks.dates');
+goog.require('Blockly.Blocks');
+
+BlocklyInterpreter.ExtensionBlocks.dates.HUE = 280;
+
+Blockly.Blocks['date_today'] = {
+  init: function() {
+    this.appendDummyInput()
+      .setAlign(Blockly.ALIGN_RIGHT)
+      .appendField('today');
+    this.setOutput(true, "Date");
+    this.setColour(BlocklyInterpreter.ExtensionBlocks.dates.HUE);
+  }
+};

data/app/assets/javascripts/blockly_interpreter/extension_blocks/debugging.js

@@ -0,0 +1,17 @@
+'use strict';
+
+goog.provide('BlocklyInterpreter.ExtensionBlocks.debugging');
+goog.require('Blockly.Blocks');
+
+BlocklyInterpreter.ExtensionBlocks.debugging.HUE = 310;
+
+Blockly.Blocks["debug_message"] = {
+  init: function() {
+    this.appendValueInput("MESSAGE")
+      .appendField("log debugging message");
+    this.setInputsInline(true);
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setColour(BlocklyInterpreter.ExtensionBlocks.debugging.HUE);
+  }
+};

data/app/assets/javascripts/blockly_interpreter/extension_blocks/lists.js

@@ -0,0 +1,45 @@
+'use strict';
+
+goog.provide('BlocklyInterpreter.ExtensionBlocks.lists');
+goog.require('Blockly.Blocks');
+
+Blockly.Blocks["lists_include"] = {
+  init: function() {
+    this.appendValueInput("A")
+      .setCheck("Array");
+    this.appendDummyInput()
+      .appendField(new Blockly.FieldDropdown([["includes", "INCLUDE"], ["does not include", "NINCLUDE"]]), "OP");
+    this.appendValueInput("B");
+    this.setInputsInline(true);
+    this.setOutput(true, "Boolean");
+    this.setColour(Blockly.Blocks.lists.HUE);
+    this.setTooltip('Checks a list to see if a particular value is part of it or not');
+  }
+};
+
+Blockly.Blocks['lists_append'] = {
+  init: function() {
+    this.appendValueInput("VALUE")
+      .setAlign(Blockly.ALIGN_RIGHT)
+      .appendField("append value");
+    this.appendValueInput("LIST")
+      .setCheck("Array")
+      .setAlign(Blockly.ALIGN_RIGHT)
+      .appendField("to list");
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setColour(Blockly.Blocks.lists.HUE);
+  }
+};
+
+Blockly.Blocks['lists_concat'] = {
+  init: function() {
+    this.appendValueInput("LIST1")
+      .setCheck("Array")
+      .appendField("list by combining lists");
+    this.appendValueInput("LIST2")
+      .setCheck("Array");
+    this.setOutput(true);
+    this.setColour(Blockly.Blocks.lists.HUE);
+  }
+};

data/app/assets/javascripts/blockly_interpreter/extension_blocks/logic.js

@@ -0,0 +1,274 @@
+'use strict';
+
+goog.provide('BlocklyInterpreter.ExtensionBlocks.logic');
+goog.require('Blockly.Blocks');
+
+Blockly.Blocks["object_present"] = {
+  init: function() {
+    this.appendValueInput("VALUE");
+    this.appendDummyInput()
+      .appendField("is present");
+    this.setInputsInline(true);
+    this.setOutput(true);
+    this.setColour(Blockly.Blocks.logic.HUE);
+  }
+};
+
+Blockly.Blocks['controls_switch'] = {
+  /**
+   * Block for if/elseif/else condition.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.logic.HUE);
+    this.appendValueInput('SWITCH_VAL')
+      .setAlign(Blockly.ALIGN_RIGHT)
+      .appendField("when");
+    this.setInputsInline(false);
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setMutator(new Blockly.Mutator(['controls_switch_case',
+                                         'controls_switch_else']));
+    // Assign 'this' to a variable for use in the tooltip closure below.
+    var thisBlock = this;
+    this.caseCount_ = 0;
+    this.elseCount_ = 0;
+    this.captureCount_ = 0;
+  },
+  /**
+   * Create XML to represent the number of else-if and else inputs.
+   * @return {Element} XML storage element.
+   * @this Blockly.Block
+   */
+  mutationToDom: function() {
+    if (!this.caseCount_ && !this.elseCount_) {
+      return null;
+    }
+    var container = document.createElement('mutation');
+    if (this.caseCount_) {
+      container.setAttribute('case', this.caseCount_);
+    }
+    if (this.elseCount_) {
+      container.setAttribute('else', 1);
+    }
+    if (this.captureCount_) {
+      container.setAttribute('capture', 1);
+    }
+    return container;
+  },
+  /**
+   * Parse XML to restore the else-if and else inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this Blockly.Block
+   */
+  domToMutation: function(xmlElement) {
+    this.caseCount_ = parseInt(xmlElement.getAttribute('case'), 10) || 0;
+    this.elseCount_ = parseInt(xmlElement.getAttribute('else'), 10) || 0;
+    this.captureCount_ = parseInt(xmlElement.getAttribute('capture'), 10) || 0;
+    if (this.captureCount_) {
+      this.appendDummyInput("CAPTURE_DUMMY")
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField("which we call")
+        .appendField(new Blockly.FieldVariable("captured_value"), "CAPTURE_VAR");
+    }
+    for (var i = 0; i < this.caseCount_; i++) {
+      this.appendValueInput('CASE' + i)
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField("is equal to");
+      this.appendStatementInput('DO' + i)
+        .appendField("then");
+    }
+    if (this.elseCount_) {
+      this.appendStatementInput('ELSE')
+          .appendField("else");
+    }
+  },
+  /**
+   * Populate the mutator's dialog with this block's components.
+   * @param {!Blockly.Workspace} workspace Mutator's workspace.
+   * @return {!Blockly.Block} Root block in mutator.
+   * @this Blockly.Block
+   */
+  decompose: function(workspace) {
+    var containerBlock = Blockly.Block.obtain(workspace, 'controls_switch_switch');
+    if (this.captureCount_) {
+      containerBlock.setFieldValue('TRUE', 'CAPTURE');
+    }
+    containerBlock.initSvg();
+    var connection = containerBlock.getInput('STACK').connection;
+    for (var i = 0; i < this.caseCount_; i++) {
+      var caseBlock = Blockly.Block.obtain(workspace, 'controls_switch_case');
+      caseBlock.initSvg();
+      connection.connect(caseBlock.previousConnection);
+      connection = caseBlock.nextConnection;
+    }
+    if (this.elseCount_) {
+      var elseBlock = Blockly.Block.obtain(workspace, 'controls_switch_else');
+      elseBlock.initSvg();
+      connection.connect(elseBlock.previousConnection);
+    }
+    return containerBlock;
+  },
+  /**
+   * Reconfigure this block based on the mutator dialog's components.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this Blockly.Block
+   */
+  compose: function(containerBlock) {
+    // Disconnect the capture block and remove the input.
+    if (this.captureCount_) {
+      this.removeInput("CAPTURE_DUMMY");
+    }
+    this.captureCount_ = 0;
+    // Disconnect the else input blocks and remove the inputs.
+    if (this.elseCount_) {
+      this.removeInput('ELSE');
+    }
+    this.elseCount_ = 0;
+    // Disconnect all the elseif input blocks and remove the inputs.
+    for (var i = 0; i < this.caseCount_; i++) {
+      this.removeInput('CASE' + i);
+      this.removeInput('DO' + i);
+    }
+    this.caseCount_ = 0;
+    // Rebuild the block's optional inputs.
+    if (containerBlock.getFieldValue('CAPTURE') == "TRUE") {
+      this.appendDummyInput("CAPTURE_DUMMY")
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField("which we call")
+        .appendField(new Blockly.FieldVariable(containerBlock.captureVar_ || "captured_value"), "CAPTURE_VAR");
+        this.captureCount_++;
+    }
+    var clauseBlock = containerBlock.getInputTargetBlock('STACK');
+    while (clauseBlock) {
+      switch (clauseBlock.type) {
+        case 'controls_switch_case':
+          var caseInput = this.appendValueInput('CASE' + this.caseCount_)
+            .setAlign(Blockly.ALIGN_RIGHT)
+            .appendField("is equal to");
+          var doInput = this.appendStatementInput('DO' + this.caseCount_);
+          doInput.appendField("then");
+          // Reconnect any child blocks.
+          if (clauseBlock.valueConnection_) {
+            caseInput.connection.connect(clauseBlock.valueConnection_);
+          }
+          if (clauseBlock.statementConnection_) {
+            doInput.connection.connect(clauseBlock.statementConnection_);
+          }
+          this.caseCount_++;
+          break;
+        case 'controls_switch_else':
+          var elseInput = this.appendStatementInput('ELSE');
+          elseInput.appendField("else");
+          // Reconnect any child blocks.
+          if (clauseBlock.statementConnection_) {
+            elseInput.connection.connect(clauseBlock.statementConnection_);
+          }
+          this.elseCount_++;
+          break;
+        default:
+          throw 'Unknown block type.';
+      }
+      clauseBlock = clauseBlock.nextConnection &&
+          clauseBlock.nextConnection.targetBlock();
+    }
+  },
+  /**
+   * Store pointers to any connected child blocks.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this Blockly.Block
+   */
+  saveConnections: function(containerBlock) {
+    containerBlock.captureVar_ = this.getFieldValue('CAPTURE_VAR');
+
+    var clauseBlock = containerBlock.getInputTargetBlock('STACK');
+    var i = 0;
+    while (clauseBlock) {
+      switch (clauseBlock.type) {
+        case 'controls_switch_case':
+          var inputCase = this.getInput('CASE' + i);
+          var inputDo = this.getInput('DO' + i);
+          clauseBlock.valueConnection_ =
+              inputCase && inputCase.connection.targetConnection;
+          clauseBlock.statementConnection_ =
+              inputDo && inputDo.connection.targetConnection;
+          i++;
+          break;
+        case 'controls_switch_else':
+          var inputDo = this.getInput('ELSE');
+          clauseBlock.statementConnection_ =
+              inputDo && inputDo.connection.targetConnection;
+          break;
+        default:
+          throw 'Unknown block type.';
+      }
+      clauseBlock = clauseBlock.nextConnection &&
+          clauseBlock.nextConnection.targetBlock();
+    }
+  },
+
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    var captureVarName = this.getFieldValue('CAPTURE_VAR');
+
+    if (captureVarName && Blockly.Names.equals(oldName, captureVarName)) {
+      this.setFieldValue(newName, 'CAPTURE_VAR');
+    }
+  },
+
+  getVars: function() {
+    return [this.getFieldValue('CAPTURE_VAR')];
+  }
+};
+
+Blockly.Blocks['controls_switch_switch'] = {
+  /**
+   * Mutator block for if container.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.logic.HUE);
+    this.appendDummyInput()
+      .appendField("when value");
+    this.appendDummyInput()
+      .appendField(new Blockly.FieldCheckbox(false), "CAPTURE")
+      .appendField("capture value");
+    this.appendStatementInput('STACK');
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['controls_switch_case'] = {
+  /**
+   * Mutator bolck for else-if condition.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.logic.HUE);
+    this.appendDummyInput()
+        .appendField("is equal to");
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['controls_switch_else'] = {
+  /**
+   * Mutator block for else condition.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.logic.HUE);
+    this.appendDummyInput()
+        .appendField("else");
+    this.setPreviousStatement(true);
+    this.contextMenu = false;
+  }
+};