smalruby-editor 0.1.6 → 0.1.7

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

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+module RubyToBlock
+  # ブロック群を表現するモジュール
+  module Block
+    @blocks = {}
+
+    # ブロックのインスタンスを生成する
+    def self.new(type, *args)
+      @blocks[type].new(*args)
+    end
+
+    # ステートメントを表現するブロックの正規表現を返す
+    def self.statement_regexp
+      @statement_regexp ||= make_regexp(:statement?)
+    end
+
+    # 値を表現するブロックの正規表現を返す
+    def self.value_regexp
+      @value_regexp ||= make_regexp(:value?)
+    end
+
+    # ブロックを登録する
+    def self.register(klass)
+      @blocks[klass.type] = klass
+    end
+
+    # ブロックの正規表現を返す
+    def self.regexp(type)
+      @blocks[type.to_s].regexp
+    end
+
+    # MatchDataを処理する
+    def self.process_match_data(md, context, type = nil)
+      type = md.names.find { |n| md[n.to_sym] } unless type
+      @blocks[type].process_match_data(md, context)
+    rescue
+      false
+    end
+
+    # elseを処理する
+    def self.process_else(context)
+      st = context.statement
+      @blocks[st.first].process_else(context)
+    rescue
+      false
+    end
+
+    # endを処理する
+    def self.process_end(context)
+      st = context.statement
+      @blocks[st.first].process_end(context)
+    rescue
+      false
+    end
+
+    # ブロックを表現するクラスを返す
+    def self.[](type)
+      @blocks[type.to_s]
+    end
+
+    def self.make_regexp(method_symbol)
+      regexps = @blocks.values.select(&method_symbol).sort_by(&:priority)
+        .reverse.map { |klass|
+        "(?<#{klass.type}>#{klass.regexp_string})"
+      }
+      Regexp.new(regexps.join('|'), 'x')
+    end
+    private_class_method :make_regexp
+  end
+end
+
+preloads = %w(
+  base
+  value
+  character_operation
+  character_method_call
+  character_event
+).map { |s|
+  "#{s}.rb"
+}
+preloads.each do |preload|
+  path = Pathname(__FILE__).dirname.join('block', preload)
+  silence_warnings do
+    load path.expand_path
+  end
+end
+
+block_pattern = Pathname(__FILE__).dirname.join('block', '*.rb')
+block_files = Pathname.glob(block_pattern)
+block_files.each do |path|
+  next if preloads.include?(path.basename)
+
+  silence_warnings do
+    load path.expand_path
+  end
+end

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