smalruby-editor 0.1.6-x86-mingw32 → 0.1.7-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53e0d4cc07184d7d779bce31a30099140c72d191
-  data.tar.gz: ee93d3bd4b1a53590e2d0fb0af8d95851de81736
+  metadata.gz: 0bd06fb1b52286227744f48188c8f7da643f328e
+  data.tar.gz: 9f26a444410952686966a504032f23732dfc80f4
 SHA512:
-  metadata.gz: 998812bd17c0f42e82fac22a223219082807267f674e06158c50365ae88d1d325efd7f6a0a8364d6ca80ac4839708d7892201e2a94201cb46ad2016097b9a869
-  data.tar.gz: 540eb8e5125b96e2ae2ae8f2500dc2b76a9ef6d541e0a51efc7d63ce9c8b73abdbbbcb9575da2d0d69c47a4fdb8f5907023c0099388ff02febfbf32bbfe8eaff
+  metadata.gz: 147b02a2fa9819acd85149a19b8346d1e420eafe80ed8a6b846cdfe6dd0b54ccaa3b04e852fdc1de9f6e191bc7ae3a929dfdf2fefc9ce57e9ec541910d21934d
+  data.tar.gz: 3e6f91f3cfd1837d861cf488f757097d9afaec3d6eb0b9c0ebd07b1e96c9512d84147e3eae9764d5b45996fb8ead1252cc38ed743c27b86cb991caba2fc489f7

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/block/base.rb

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+
+module RubyToBlock
+  module Block
+    # すべてのブロックのベースクラス
+    class Base
+      attr_accessor :parent
+      attr_accessor :prev_sibling
+      attr_accessor :sibling
+      attr_accessor :fields
+      attr_accessor :values
+      attr_accessor :statements
+
+      def self.inherited(child)
+        Block.register(child)
+      end
+
+      def self.blocknize(regexp, options = {})
+        klass = (class << self; self; end)
+        klass.instance_eval do
+          define_method(:regexp_string) do
+            regexp
+          end
+
+          %w(
+            statement
+            value
+            indent
+            inline
+            priority
+          ).each do |name|
+            sym = name.to_sym
+            if options.key?(sym)
+              v = options[sym]
+              if v.is_a?(TrueClass) || v.is_a?(FalseClass)
+                sym = "#{name}?".to_sym
+              end
+              define_method(sym) do
+                v
+              end
+            end
+          end
+        end
+      end
+
+      def self.type
+        name.sub('RubyToBlock::Block::', '').underscore
+      end
+
+      # 正規表現を返す
+      def self.regexp
+        @regexp ||= Regexp.new(regexp_string)
+      end
+
+      # ステートメントかどうかを返す
+      #
+      # trueの場合、Block.statement_regexpに追加される
+      def self.statement?
+        false
+      end
+
+      # 値かどうかを返す
+      #
+      # trueの場合、Block.value_regexpに追加される
+      def self.value?
+        false
+      end
+
+      # 正規表現の優先度を返す
+      def self.priority
+        0
+      end
+
+      # インデントする必要があるかどうかを返す
+      def self.indent?
+        false
+      end
+
+      # インラインのブロックかどうかを返す
+      def self.inline?
+        false
+      end
+
+      # 正規表現にマッチしたデータを解析する
+      #
+      # @return [true] これ以上解析する必要がない
+      # @return [false] 解析できなかったのでさらなる解析が必要
+      def self.process_match_data(md, context)
+        true
+      end
+
+      # 値を格納した文字列を解析する
+      #
+      # @return [true] これ以上解析する必要がない
+      # @return [false] 解析できなかったのでさらなる解析が必要
+      def self.process_value_string(context, block, string, name)
+        # HACK: 最初と最後の括弧を取り除く
+        string = string[1..-2] while string[0] == '(' && string[-1] == ')'
+
+        value_md = Block.value_regexp.match(string)
+        return false unless value_md
+
+        _current_block = context.current_block
+        context.current_block = block
+        context.value_name_stack.push(name)
+
+        unless Block.process_match_data(value_md, context)
+          Block.process_match_data(value_md, context, 'ruby_expression')
+        end
+
+        context.value_name_stack.pop
+        context.current_block = _current_block
+
+        true
+      end
+
+      # elseを発見した時の処理
+      #
+      # @return [true] これ以上処理する必要がない
+      # @return [false] 処理できなかった
+      def self.process_else(context)
+        false
+      end
+
+      # endを発見した時の処理
+      #
+      # @return [true] これ以上処理する必要がない
+      # @return [false] 処理できなかった
+      def self.process_end(context)
+        context.current_block = context.statement[1]
+        context.statement_stack.pop
+
+        true
+      end
+
+      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.type
+      end
+
+      def inline?
+        @inline ||= self.class.inline?
+      end
+
+      def null?
+        false
+      end
+
+      def [](name)
+        @fields[name]
+      end
+
+      def add_statement(name, block)
+        b = @statements[name]
+        if b
+          b = b.sibling while b.sibling
+          b.sibling = block
+        else
+          block.parent = self
+          @statements[name] = block
+        end
+        self
+      end
+
+      def add_value(name, block)
+        b = @values[name]
+        if b
+          b = b.sibling while b.sibling
+          b.sibling = block
+        else
+          block.parent = self
+          @values[name] = block
+        end
+        self
+      end
+
+      def sibling=(block)
+        block.parent = parent
+        @sibling = block
+        block.prev_sibling = self
+      end
+
+      def indent_level
+        b = self
+        level = 0
+        while b.parent
+          b = b.parent
+          level += 1 if b.class.indent?
+        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|
+          next if v.null?
+          e = parent.add_element('value', 'name' => k.to_s)
+          v.to_xml(e)
+        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
+  end
+end

data/app/models/concerns/ruby_to_block/block/character.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+module RubyToBlock
+  module Block
+    # ソースコードに含まれるキャラクターを表現するクラス
+    class Character < Base
+      # rubocop:disable LineLength
+      blocknize '^\s*(\S+)\s*=\s*Character\.new\(costume:\s*"(\s*[^"]+\s*)"\s*,\s*x:\s*(\s*\d+\s*)\s*,\s*y:\s*(\s*\d+\s*)\s*,\s*angle:\s*(\s*\d+\s*)\)\s*$',
+                statement: true
+      # rubocop:enable LineLength
+
+      attr_accessor :name
+      attr_accessor :costumes
+      attr_accessor :x
+      attr_accessor :y
+      attr_accessor :angle
+
+      def self.process_match_data(md, context)
+        md2 = regexp.match(md[type])
+        name = md2[1]
+        context[:characters][name] = new(name: name, costumes: [md2[2]],
+                                         x: md2[3], y: md2[4], angle: md2[5])
+
+        true
+      end
+
+      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
+  end
+end

data/app/models/concerns/ruby_to_block/block/character_event.rb

@@ -0,0 +1,27 @@
+module RubyToBlock
+  module Block
+    class CharacterEvent < CharacterMethodCall
+      def self.process_end(context)
+        context.receiver_stack.pop
+        context.character_stack.pop
+        super
+      end
+
+      def self.add_character_event_blocks(context, name, block)
+        do_block = Block.new('null')
+        block.add_statement(:DO, do_block)
+
+        character = get_character(context, name)
+        context.character_stack.push(character)
+
+        character_new_block, _ =
+          add_child_or_create_character_new_block(context, name, block)
+
+        context.receiver_stack.push(character)
+
+        context.statement_stack.push([type, character_new_block])
+        context.current_block = do_block
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/character_method_call.rb

@@ -0,0 +1,29 @@
+module RubyToBlock
+  module Block
+    class CharacterMethodCall < Base
+      include CharacterOperation
+
+      def self.process_match_data(md, context)
+        md2 = regexp.match(md[type])
+
+        block = new
+        _, context.current_block =
+          *add_child_or_create_character_new_block(context, md2[1], block)
+
+        true
+      end
+
+      def self.add_character_method_call_block(context, name, block,
+                                               values = {})
+        _, context.current_block =
+          *add_child_or_create_character_new_block(context, name, block)
+
+        values.each do |k, v|
+          process_value_string(context, block, v, k)
+        end
+
+        block
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/character_new.rb

@@ -0,0 +1,7 @@
+module RubyToBlock
+  module Block
+    class CharacterNew < Base
+      include CharacterOperation
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/character_operation.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+module RubyToBlock
+  module Block
+    # キャラクターのメソッドや属性に共通するメソッドや定数を定義するモジュール
+    module CharacterOperation
+      extend ActiveSupport::Concern
+
+      CHAR_RE = '(?:(\S+)\.)?'
+
+      attr_accessor :character
+
+      module ClassMethods
+        # コンテキストからキャラクターを取得する
+        #
+        # キャラクターの名前がnil、または'self'の場合はコンテキストのレシー
+        # バの名前を利用する。
+        #
+        # コンテキストからキャラクターが取得できない場合は例外が発生する。
+        #
+        # @param [RubyToBlock::Context] context コンテキスト
+        # @param [String] name キャラクターの名前
+        # @return [Character] キャラクター
+        def get_character(context, name)
+          name = context.receiver.try(:name) if !name || name == 'self'
+          fail unless context.characters.key?(name)
+          context.characters[name]
+        end
+
+        # 必要であればcharacter_newブロックを作成してから指定したブロッ
+        # クをcharacter_newブロックの子供として追加する
+        #
+        # @param [RubyToBlock::Context] context コンテキスト
+        # @param [String] name キャラクターの名前
+        # @param [ブロック] block ブロックのインスタンス
+        # @return [Array<ブロック, ブロック>]
+        #   最初の要素がcharacter_newブロック、次の要素がカレントブロックの配列
+        def add_child_or_create_character_new_block(context, name, block)
+          character = get_character(context, name)
+
+          block.character = character
+
+          cb = context.current_block
+          if cb && cb.type == 'character_new' && cb.character == character
+            cb.add_statement(:DO, block)
+            [cb, cb]
+          elsif character == context.receiver
+            cb.sibling = block
+            [cb.parent, block]
+          else
+            character_new =
+              create_character_new_block(context, character, block)
+            [character_new, character_new]
+          end
+        end
+
+        # character_newブロックを生成する
+        #
+        # @param [RubyToBlock::Context] context コンテキスト
+        # @param [RubyToBlock::Block::Character] character キャラクター
+        # @param [RubyToBlock::Block::Baseのサブクラス] block ブロック
+        # @return [RubyToBlock::Block::CharacterNew] character_newブロック
+        def create_character_new_block(context, character, block)
+          character_new_block = Block.new('character_new',
+                                          fields: { NAME: character.name },
+                                          statements: { DO: block })
+          character_new_block.character = character
+
+          cb = context.current_block
+          if cb && cb.type != 'character_new'
+            cb.sibling = character_new_block
+          else
+            context.blocks.push(character_new_block)
+          end
+
+          character_new_block
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/control_if.rb

@@ -0,0 +1,45 @@
+module RubyToBlock
+  module Block
+    class ControlIf < Base
+      blocknize '^\s*if\s+(.*?)\s*$',
+                statement: true, indent: true, inline: true
+
+      def self.process_match_data(md, context)
+        then_block = Block.new('null')
+        block = new(statements: { THEN: then_block })
+
+        if context.current_block
+          context.current_block.sibling = block
+        else
+          context.blocks.push(block)
+        end
+
+        md2 = regexp.match(md[type])
+        process_value_string(context, block, md2[1], :COND)
+
+        context.current_block = then_block
+
+        context.statement_stack.push([type, block])
+
+        true
+      end
+
+      def self.process_else(context)
+        block = context.statement_block
+        else_block = Block.new('null')
+        block.add_statement(:ELSE, else_block)
+        context.current_block = else_block
+
+        true
+      end
+
+      def type
+        if @statements.key?(:ELSE)
+          'control_if_else'
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/control_loop.rb

@@ -0,0 +1,19 @@
+module RubyToBlock
+  module Block
+    class ControlLoop < Base
+      blocknize '^\s*loop\s+do\s*$', statement: true, indent: true
+
+      def self.process_match_data(md, context)
+        return false unless context.receiver
+
+        do_block = Block.new('null')
+        block = new(statements: { DO: do_block })
+        context.statement_stack.push([type, block])
+        context.current_block.sibling = block
+        context.current_block = do_block
+
+        true
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/control_sleep.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+module RubyToBlock
+  module Block
+    class ControlSleep < Base
+      blocknize '^\s*sleep\((.+)\)\s*$', statement: true, inline: true
+
+      def self.process_match_data(md, context)
+        block = new
+        context.add_block(block)
+
+        md2 = regexp.match(md[type])
+        process_value_string(context, block, md2[1], :SEC)
+
+        true
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/do.rb

@@ -0,0 +1,24 @@
+module RubyToBlock
+  module Block
+    class Do < RubyStatement
+      blocknize '^.*?\s*do\s*$',
+                statement: true, priority: -1
+
+      def self.process_match_data(md, context)
+        block = new(fields: { STATEMENT: md.string })
+        context.add_block(block)
+        context.statement_stack.push([type, block])
+        true
+      end
+
+      def self.process_end(context)
+        context.add_block(new(fields: { STATEMENT: 'end' }))
+        super
+      end
+
+      def type
+        'ruby_statement'
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/else.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+module RubyToBlock
+  module Block
+    class Else < Base
+      blocknize '^\s*else\s*$', statement: true
+
+      def self.process_match_data(md, context)
+        Block.process_else(context)
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_to_block/block/end.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+module RubyToBlock
+  module Block
+    class End < Base
+      blocknize '^\s*end$', statement: true
+
+      def self.process_match_data(md, context)
+        ends_num = 1
+        context.lines.each do |l|
+          md2 = Block.statement_regexp.match(l)
+          type = md2.names.find { |n| md2[n.to_sym] }
+          if type == 'end'
+            ends_num += 1
+          elsif Block[type].indent?
+            ends_num -= 1
+          end
+        end
+        if context.statement && ends_num <= context.statement_stack.length
+          Block.process_end(context)
+        else
+          false
+        end
+      end
+    end
+  end
+end