smalruby-editor 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 531341c4a66cfc4403c5920b096a7bc9da6c2d93
-  data.tar.gz: e6110e9a3814bdf0388d7621cffa81f39d5b508b
+  metadata.gz: 481219ecbb11af4414b736a08666df8c1d4b2a98
+  data.tar.gz: c0158c87c4892af0db1130770e55d3f8966f6a73
 SHA512:
-  metadata.gz: ece39fa8e6d0e898c34a2c338b8e91123cb1cc814410370921125a06af034e0624b68599f912be686c5057ab67282f061b92de9d46b9d17c2321a29ee2a05f8a
-  data.tar.gz: 2ea31229e0a0f5a411946c24c347c9a7c5d290cd4b5c5ac28fa70db4609fb67486a419d0404d8c1efdba339c60a879202ee8bddc4be69e6317dc5b1ebe808d6e
+  metadata.gz: 8eeaa4d664ad6fa1b258798787749a831b386d66ee40fa7e323d19686352c2b9f96e11f4fee0ed300b54dc59177e69c3103ce9a408a0bddaf8351b86b301561a
+  data.tar.gz: 4ace3c4984b24bc8f1996e11f6cbcd5de2aea320d00f5ce216b0c6ed7e47ec3128ee99b8cf396902249e0dca0b283976072397125adf01f88dc6fff4840ce7e2

data/app/assets/javascripts/blocks/hardware.js.coffee.erb

@@ -235,13 +235,50 @@ Blockly.Blocks['<%= n %>'] =
     @setTooltip('')
 
 Blockly.Ruby['<%= n %>'] = (block) ->
-  pin = @getFieldValue('PIN')  #p sensor("A0").value
-  #p sensor("A0").value.class
-  #p(sensor("A0").value / 6)
+  pin = @getFieldValue('PIN')
 
   pos = Blockly.Ruby.valueToCode(@, 'POS', Blockly.Ruby.ORDER_FUNCTION_CALL) || '5'
   Blockly.Ruby.characterMethodCall_("servo(#{Blockly.Ruby.quote_(pin)}).position = #{pos}")
 
+# 「車」サブジャンル
+
+# 「2WD車[▼ピン]を進める」ブロック
+# 「2WD車[▼ピン]をバックさせる」ブロック
+# 「2WD車[▼ピン]を左に曲げる」ブロック
+# 「2WD車[▼ピン]を右に曲げる」ブロック
+# 「2WD車[▼ピン]を止める」ブロック
+<%
+  [
+    ['forward', '進める'],
+    ['backward', 'バックさせる'],
+    ['turn_left', '左に曲げる'],
+    ['turn_right', '右に曲げる'],
+    ['stop', '止める'],
+  ].each do |method, label|
+    n = "#{category}_two_wheel_drive_car_#{method}"
+%>
+
+Blockly.Blocks['<%= n %>'] =
+  init: ()->
+    dropdown = (["D#{n}", "D#{n}"] for n in [2..10])
+
+    @setHelpUrl('')
+    @setColour(<%= color %>)
+    @appendDummyInput()
+      .appendField('2WD車')
+      .appendField(new Blockly.FieldDropdown(dropdown), 'PIN')
+      .appendField('を<%= label %>')
+    @setInputsInline(true)
+    @setPreviousStatement(true)
+    @setNextStatement(true)
+    @setTooltip('')
+
+Blockly.Ruby['<%= n %>'] = (block) ->
+  pin = @getFieldValue('PIN')
+
+  Blockly.Ruby.characterMethodCall_("two_wheel_drive_car(#{Blockly.Ruby.quote_(pin)}).<%= method %>")
+<% end %>
+
 # 「ボタン」サブジャンル
 
 # 条件:ボタン[▼]を押している

data/app/assets/stylesheets/toolbox.css.scss.erb

@@ -42,10 +42,9 @@
     208
     208
     208
+    208
   ).map(&:to_i)
 
-  ruby_genre_index = hues.index(340) + 1
-
   colors = hues.map { |h|
     [hsv_to_rgb(h, 100, 80), hsv_to_rgb(h, 100, 100)]
   }
@@ -55,10 +54,6 @@
 %>
 
 #\:<%= ids[index] %> {
-    <% if index == ruby_genre_index %>
-    display: none;
-
-    <% end %>
     .blocklyTreeRow {
         padding-top: 0.25em;
         padding-bottom: 0.25em;

data/app/controllers/source_codes_controller.rb

@@ -61,7 +61,11 @@ class SourceCodesController < ApplicationController
     source_code = SourceCode.new(source_code_params)
     render text: source_code.to_blocks
   rescue
-    head :bad_request
+    if Rails.env == 'development'
+      raise
+    else
+      head :bad_request
+    end
   end
 
   private

data/app/models/concerns/ruby_to_block.rb

@@ -1,391 +1,48 @@
 # -*- coding: utf-8 -*-
 
-# rubocop:disable all
+require_relative 'ruby_to_block/block'
+require_relative 'ruby_to_block/context'
+require_relative 'ruby_to_block/formatter'
 
 # Rubyのソースコードをブロックに変換するモジュール
 module RubyToBlock
   extend ActiveSupport::Concern
 
-  SUCCESS_DATA_MOCK = <<-EOS.strip_heredoc
-    require "smalruby"
-
-    car1 = Character.new(costume: "car1.png", x: 0, y: 0, angle: 0)
-
-    car1.on(:start) do
-      loop do
-        move(10)
-        turn_if_reach_wall
-      end
-    end
-  EOS
-
-  SUCCESS_XML_MOCK = <<-XML.strip_heredoc
-    <xml xmlns="http://www.w3.org/1999/xhtml">
-      <character name="car1" x="0" y="0" angle="0" costumes="car1.png" />
-      <block type="character_new" x="4" y="4">
-        <field name="NAME">car1</field>
-        <statement name="DO">
-          <block type="events_on_start">
-            <statement name="DO">
-              <block type="control_loop">
-                <statement name="DO">
-                  <block type="motion_move" inline="true">
-                    <value name="STEP">
-                      <block type="math_number">
-                        <field name="NUM">10</field>
-                      </block>
-                    </value>
-                    <next>
-                      <block type="motion_turn_if_reach_wall" />
-                    </next>
-                  </block>
-                </statement>
-              </block>
-            </statement>
-          </block>
-        </statement>
-      </block>
-    </xml>
-  XML
-
   # XML形式のブロックに変換する
   def to_blocks
     fail if data == '__FAIL__'
-    return SUCCESS_XML_MOCK if data == SUCCESS_DATA_MOCK
 
-    characters = {}
-    character_stack = []
-    receiver_stack = []
-    statement_stack = []
-    blocks = []
-    current_block = nil
-    lines = data.lines
-    while (line = lines.shift)
+    context = Context.new(data.lines)
+    while (line = context.next_line)
       line.chomp!
       next if line.strip.empty?
+      md = Block.statement_regexp.match(line)
+      next if Block.process_match_data(md, context)
+      Block.process_match_data(md, context, 'ruby_statement')
+    end
 
-      md = STATEMENT_REGEXP.match(line)
-
-      unless md
-        block = Block.new('ruby_statement', fields: { STATEMENT: line })
-        if current_block # TODO: リファクタリング
-          current_block.sibling = block
-        else
-          blocks.push(block)
-        end
-        current_block = block
-
-        next
-      end
-
-      next if md[:require_smalruby]
-
-      if (s = md[:character])
-        md2 = /#{CHARACTER_RE}/.match(s)
-        name = md2[1]
-
-        characters[name] = Character.new(name: name, costumes: [md2[2]],
-                                         x: md2[3], y: md2[4], angle: md2[5])
-        next
-      end
-
-      if (s = md[:events_on_start])
-        md2 = /#{EVENTS_ON_START_RE}/.match(s)
-        name = md2[1] ? md2[1] : receiver_stack.last.name
-        c = characters[name]
-        character_stack.push(c)
-
-        do_block = Block.new('null')
-        events_on_start_block = Block.new('events_on_start', statements: { DO: do_block })
-        if current_block && current_block.type == 'character_new' &&
-            current_block[:NAME] == name
-          current_block.add_statement(:DO, events_on_start_block)
-          character_new_block = current_block
-        else
-          if c == receiver_stack.last
-            current_block.sibling = events_on_start_block
-            character_new_block = current_block.parent
-          else
-            character_new_block =
-              Block.new('character_new',
-                        fields: { NAME: name }, statements: { DO: events_on_start_block })
-            if current_block
-              if current_block.type == 'character_new'
-                blocks.push(character_new_block)
-              else
-                current_block.sibling = character_new_block
-              end
-            else
-              blocks.push(character_new_block)
-            end
-          end
-        end
-        statement_stack.push([:events_on_start, character_new_block])
-
-        receiver_stack.push(c)
-
-        current_block = do_block
-
-        next
-      end
-
-      if md[:end]
-        ends_num = lines.select { |l|
-          md2 = STATEMENT_REGEXP.match(l)
-          md2 && md2[:end]
-        }.length + 1
-        ends_num -= lines.select { |l|
-          md2 = STATEMENT_REGEXP.match(l)
-          md2 && (md2[:events_on_start])
-        }.length
-        if (ss = statement_stack.last) &&
-            ends_num <= statement_stack.length
-          case ss.first
-          when :events_on_start
-            current_block = ss[1]
-
-            receiver_stack.pop
-            character_stack.pop
-            statement_stack.pop
-          else
-            # TODO
-          end
-        else
-          block = Block.new('ruby_statement', fields: { STATEMENT: line })
-          if current_block # TODO: リファクタリング
-            current_block.sibling = block
-          else
-            blocks.push(block)
-          end
-          current_block = block
-        end
+    make_xml(context)
+  end
 
-        next
-      end
-    end
+  private
 
-    return '' if characters.empty? && blocks.empty?
+  def make_xml(context)
+    return '' if context[:characters].empty? && context[:blocks].empty?
 
     xml = REXML::Document.new('<xml xmlns="http://www.w3.org/1999/xhtml" />',
                               attribute_quote: :quote,
                               respect_whitespace: :all)
-    characters.values.each do |c|
+    context[:characters].values.each do |c|
       c.to_xml(xml.root)
     end
-    blocks.each do |b|
+    context[:blocks].each do |b|
       b.to_xml(xml.root)
     end
 
     output = StringIO.new
-    formatter = REXML::Formatters::Pretty.new(2, true)
-    formatter.compact = true
-    # HACK: 行頭、行末などのスペースが1つになってしまうのを修正している
-    def formatter.write_text( node, output )
-      s = node.to_s()
-      s.gsub!(/\s/,' ')
-      if !node.is_a?(REXML::Text) ||
-          node.is_a?(REXML::Text) && !node.parent.whitespace()
-        s.squeeze!(" ")
-      end
-      s = wrap(s, @width - @level)
-      s = indent_text(s, @level, " ", true)
-      output << (' '*@level + s)
-    end
+    formatter = Formatter.new
     formatter.write(xml, output)
 
     output.string + "\n"
   end
-
-  private
-
-  # require "smalruby"
-  REQUIRE_SMALRUBY_RE = '^require\ "smalruby"$'
-
-  # car1 = Character.new(costume: "car1.png", x: 0, y: 0, angle: 0)
-  CHARACTER_RE =
-    '^\s*(\S+)\ =\ Character\.new\(costume:\ "([^"]+)",\ x:\ (\d+),\ y:\ (\d+),\ angle:\ (\d+)\)$'
-
-  EVENTS_ON_START_RE = '^\s*(?:(\S+)\.)?on\(:start\)\ do$'
-
-  END_RE = '^\s*end$'
-
-  STATEMENT_REGEXP = %r{
-    (?<require_smalruby>#{REQUIRE_SMALRUBY_RE})
-    |
-    (?<character>#{CHARACTER_RE})
-    |
-    (?<events_on_start>#{EVENTS_ON_START_RE})
-    |
-    (?<end>#{END_RE})
-  }x
-
-  EXPRESSION_REGEXP = %r{}x
-  LITERAL_REGEXP = %r{}x
-
-  # ソースコードに含まれるキャラクターを表現するクラス
-  class Character
-    attr_accessor :name
-    attr_accessor :costumes
-    attr_accessor :x
-    attr_accessor :y
-    attr_accessor :angle
-
-    def initialize(options)
-      @name = options[:name]
-      @costumes = options[:costumes]
-      @x = options[:x]
-      @y = options[:y]
-      @angle = options[:angle]
-    end
-
-    def to_xml(parent)
-      parent.add_element('character',
-                         'name' => @name,
-                         'x' => @x, 'y' => @y, 'angle' => @angle,
-                         'costumes' => @costumes.join(','))
-    end
-  end
-
-  # ブロック群を表現するモジュール
-  module Block
-    # ブロックのインスタンスを生成する
-    def self.new(type, *args)
-      const_get(type.camelize).new(*args)
-    end
-
-    # すべてのブロックのベースクラス
-    class Base
-      attr_accessor :parent
-      attr_accessor :sibling
-      attr_accessor :fields
-      attr_accessor :values
-      attr_accessor :statements
-
-      def initialize(options = {})
-        @fields = options[:fields] || {}
-        @values = options[:values] || {}
-        @statements = options[:statements] || {}
-
-        if @statements.length > 0
-          @statements.values.each do |s|
-            s.parent = self
-          end
-        end
-      end
-
-      def to_xml(parent)
-        e = parent.add_element('block', 'type' => type)
-        e.add_attribute('inline', 'true') if inline?
-        fields_to_xml(e)
-        values_to_xml(e)
-        statements_to_xml(e)
-        sibling_to_xml(e)
-        e
-      end
-
-      def type
-        @type ||= self.class.name.sub('RubyToBlock::Block::', '').underscore
-      end
-
-      def inline?
-        false
-      end
-
-      def null?
-        false
-      end
-
-      def [](name)
-        @fields[name]
-      end
-
-      def add_statement(name, block)
-        b = @statements[name]
-        b = b.sibling while b.sibling
-        b.sibling = block
-      end
-
-      def sibling=(block)
-        block.parent = self.parent
-        @sibling = block
-      end
-
-      def indent?
-        false
-      end
-
-      def indent_level
-        b = self
-        level = 0
-        while b.parent
-          level += 1 if b.indent?
-          b = b.parent
-        end
-        level
-      end
-
-      private
-
-      def fields_to_xml(parent)
-        @fields.each do |k, v|
-          e = parent.add_element('field', 'name' => k.to_s)
-          if v.is_a?(String)
-            e.text = v
-          else
-            # TODO
-          end
-        end
-      end
-
-      def values_to_xml(parent)
-        @values.each do |k, v|
-          # TODO
-        end
-      end
-
-      def statements_to_xml(parent)
-        @statements.each do |k, v|
-          next if v.null?
-          e = parent.add_element('statement', 'name' => k.to_s)
-          v.to_xml(e)
-        end
-      end
-
-      def sibling_to_xml(parent)
-        return nil unless @sibling
-
-        e = parent.add_element('next')
-        @sibling.to_xml(e)
-      end
-    end
-
-    class Null < Base
-      def to_xml(parent)
-        return nil unless @sibling
-
-        @sibling.to_xml(parent)
-      end
-
-      def null?
-        !@sibling
-      end
-    end
-
-    class CharacterNew < Base; end
-
-    class RubyStatement < Base
-      def parent=(block)
-        @parent = block
-        @original_statement ||= @fields[:STATEMENT]
-        @fields[:STATEMENT] =
-          @original_statement.sub(/^ {0,#{indent_level * 2}}/, '')
-      end
-    end
-
-    class EventsOnStart < Base
-      def indent?
-        true
-      end
-    end
-  end
 end