Changeset 28021 for lang/ruby/starframe

Show
Ignore:
Timestamp:
01/06/09 21:24:25 (4 years ago)
Author:
isaisstillalive
Message:
  • Eventableモジュールを完全に削除
Location:
lang/ruby/starframe
Files:
2 removed
5 modified

Legend:

Unmodified
Added
Removed

  • lang/ruby/starframe/lib/starframe/renderable.rb

    r27966 r28021  
    11# = StarFrame::Updatable -- 描画モジュール 
    2  
    32require "forwardable" 
    4 require "starframe/eventable" 
    53 
    64module StarFrame #:nodoc: 
    … …  
    2725  module Renderable 
    2826    extend Forwardable 
    29     extend Eventable 
     27     
     28    #:stopdoc: 
     29    def self.included klass 
     30      klass.extend ClassMethods 
     31    end 
     32    #:startdoc: 
    3033     
    3134    attr_accessor :screen 
     35     
    3236    def_delegators :@screen, 
    3337      :fill, :fill_rect, 
    … …  
    3539      :render_in_perspective, :transform_in_perspective 
    3640     
    37     ## 
    38     # :method: 
    3941    # 描画する。 
    40     define_event :render 
     42    #  
     43    # このメソッドは、サブクラスで再定義しないでください。 
     44    def render 
     45      renderable_methods = self.class._renderable_methods 
     46      renderable_methods[:before].each{|method| __send__ method } 
     47      rendered 
     48    ensure 
     49      renderable_methods[:after].each{|method| __send__ method } 
     50    end 
     51     
     52    def rendered #:nodoc: 
     53    end 
    4154     
    4255    module ClassMethods 
    43       ## 
    44       # :method: reader 
    45       # 描画イベント及び描画イベントフックを定義する 
     56      @@method_count = 0 
     57       
     58      #:stopdoc: 
     59      attr_reader :_renderable_methods 
     60       
     61      private 
     62      def self.extended klass 
     63        klass.instance_variable_set :@_renderable_methods, {:before => [], :after => []} 
     64      end 
     65       
     66      def inherited klass 
     67        renderable_methods = @_renderable_methods.dup 
     68        renderable_methods[:before] = renderable_methods[:before].dup 
     69        renderable_methods[:after]  = renderable_methods[:after].dup 
     70        klass.instance_variable_set :@_renderable_methods, renderable_methods 
     71        super 
     72      end 
     73      #:startdoc: 
     74       
     75      # 描画イベントを定義する 
    4676      #  
    4777      # :call-seq: 
    … …  
    6292      #     # イベント後フック定義 
    6393      #   end 
    64       private 
     94      def render hook_type = nil, method_name = nil, &block 
     95        if hook_type 
     96          if method_name 
     97            raise ArgumentError if block 
     98          else 
     99            raise ArgumentError unless block 
     100            method_name = :"_renderable_method_#{@@method_count}" 
     101            @@method_count += 1 
     102          end 
     103           
     104          case hook_type 
     105          when :before 
     106            @_renderable_methods[hook_type].unshift method_name 
     107          when :after 
     108            @_renderable_methods[hook_type].push method_name 
     109          else 
     110            raise TypeError 
     111          end 
     112        else 
     113          raise ArgumentError if method_name 
     114          raise ArgumentError unless block 
     115          method_name = :rendered 
     116        end 
     117        define_method method_name, &block if block 
     118      end 
    65119       
    66       ## 
    67       # :method: register_render_hook 
    68       # 描画イベントフックを定義する。 
    69       #  
    70       # :call-seq: 
    71       #   register_render_hook(hook_type, method_name) 
    72       #  
    73120      public 
    74        
    75       ## 
     121      # 描画イベントフックを定義する 
     122      def register_render_hook hook_type, method_name 
     123        render hook_type, method_name 
     124      end 
    76125    end 
    77126  end 

  • lang/ruby/starframe/lib/starframe/sprite/collection.rb

    r27950 r28021  
    1 require "starframe/eventable" 
    21require "starframe/updatable" 
    32 

  • lang/ruby/starframe/lib/starframe/updatable.rb

    r27966 r28021  
    11# = StarFrame::Updatable -- 更新モジュール 
    2  
    3 require "starframe/eventable" 
    42 
    53module StarFrame #:nodoc: 
    … …  
    2523  #   end 
    2624  module Updatable 
    27     extend Eventable 
     25    #:stopdoc: 
     26    def self.included klass 
     27      klass.extend ClassMethods 
     28    end 
     29    #:startdoc: 
    2830     
    29     ## 
    30     # :method: update 
    3131    # 更新する。 
    32     define_event :update 
     32    #  
     33    # このメソッドは、サブクラスで再定義しないでください。 
     34    def update 
     35      updatable_methods = self.class._updatable_methods 
     36      updatable_methods[:before].each{|method| __send__ method } 
     37      updated 
     38    ensure 
     39      updatable_methods[:after].each{|method| __send__ method } 
     40    end 
    3341    alias call update 
    3442     
     43    def updated #:nodoc: 
     44    end 
     45     
    3546    module ClassMethods 
    36       ## 
    37       # :method: update 
     47      @@method_count = 0 
     48       
     49      #:stopdoc: 
     50      attr_reader :_updatable_methods 
     51       
     52      private 
     53      def self.extended klass 
     54        klass.instance_variable_set :@_updatable_methods, {:before => [], :after => []} 
     55      end 
     56       
     57      def inherited klass 
     58        updatable_methods = @_updatable_methods.dup 
     59        updatable_methods[:before] = updatable_methods[:before].dup 
     60        updatable_methods[:after]  = updatable_methods[:after].dup 
     61        klass.instance_variable_set :@_updatable_methods, updatable_methods 
     62        super 
     63      end 
     64      #:startdoc: 
     65       
    3866      # 更新イベント及び更新イベントフックを定義する 
    3967      #  
    … …  
    5583      #     # イベント後フック定義 
    5684      #   end 
    57       private 
     85      def update hook_type = nil, method_name = nil, &block 
     86        if hook_type 
     87          if method_name 
     88            raise ArgumentError if block 
     89          else 
     90            raise ArgumentError unless block 
     91            method_name = :"_updatable_method_#{@@method_count}" 
     92            @@method_count += 1 
     93          end 
     94           
     95          case hook_type 
     96          when :before 
     97            @_updatable_methods[hook_type].unshift method_name 
     98          when :after 
     99            @_updatable_methods[hook_type].push method_name 
     100          else 
     101            raise TypeError 
     102          end 
     103        else 
     104          raise ArgumentError if method_name 
     105          raise ArgumentError unless block 
     106          method_name = :updated 
     107        end 
     108        define_method method_name, &block if block 
     109      end 
    58110       
    59       ## 
    60       # :method: register_update_hook 
    61       # 更新イベントフックを定義する。 
    62       #  
    63       # :call-seq: 
    64       #   register_update_hook(hook_type, method_name) 
    65       #  
    66111      public 
    67        
    68       ## 
     112      # 更新イベントフックを定義する 
     113      def register_update_hook hook_type, method_name 
     114        update hook_type, method_name 
     115      end 
    69116    end 
    70117  end 

  • lang/ruby/starframe/test/starframe/test_renderable.rb

    r27966 r28021  
    9191   
    9292  def test_renderable_object_should_have_renderable_methods 
    93     actual = RenderableObject.instance_variable_get(:@_render_hook_methods) 
     93    actual = RenderableObject.instance_variable_get(:@_renderable_methods) 
    9494    expected = {:before => [], :after => []} 
    9595    assert_equal expected, actual 
    … …  
    108108   
    109109  def test_rendered_event_should_return_block 
    110     assert_equal :rendered, RenderableObject.new._render_main 
     110    assert_equal :rendered, RenderableObject.new.rendered 
    111111  end 
    112112  def test_render_should_send_rendered_event 
    … …  
    160160   
    161161  def test_rendered_hook_should_register_renderable_methods 
    162     actual = HookedRenderableObject.instance_variable_get(:@_render_hook_methods) 
     162    actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    163163    assert_equal 2, actual[:before].size 
    164164    assert_equal 2, actual[:after].size 
    … …  
    166166  def test_rendered_hook_should_define_methods 
    167167    hooked_object = HookedRenderableObject.new 
    168     actual = HookedRenderableObject.instance_variable_get(:@_render_hook_methods) 
     168    actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    169169    assert_equal true, actual[:before].all?{ |method_name| hooked_object.respond_to? method_name } 
    170170    assert_equal true, actual[:after].all?{ |method_name| hooked_object.respond_to? method_name } 
    … …  
    172172   
    173173  def test_rendered_before_hook_should_return_block 
    174     actual = HookedRenderableObject.instance_variable_get(:@_render_hook_methods) 
     174    actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    175175    assert_equal :before, HookedRenderableObject.new.__send__(actual[:before][-1]) 
    176176  end 
    177177  def test_rendered_after_hook_should_return_block 
    178     actual = HookedRenderableObject.instance_variable_get(:@_render_hook_methods) 
     178    actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    179179    assert_equal :after, HookedRenderableObject.new.__send__(actual[:after][0]) 
    180180  end 
    181181   
    182182  def test_rendered_before_hook_with_method_name_should_return_method 
    183     actual = HookedRenderableObject.instance_variable_get(:@_render_hook_methods) 
     183    actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    184184    assert_equal :before2, HookedRenderableObject.new.__send__(actual[:before][-2]) 
    185185  end 
    186186  def test_rendered_after_hook_with_method_name_should_return_method 
    187     actual = HookedRenderableObject.instance_variable_get(:@_render_hook_methods) 
     187    actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    188188    assert_equal :after2, HookedRenderableObject.new.__send__(actual[:after][1]) 
    189189  end 

  • lang/ruby/starframe/test/starframe/test_updatable.rb

    r27966 r28021  
    6060   
    6161  def test_updatable_object_should_have_updatable_methods 
    62     actual = UpdatableObject.instance_variable_get(:@_update_hook_methods) 
     62    actual = UpdatableObject.instance_variable_get(:@_updatable_methods) 
    6363    expected = {:before => [], :after => []} 
    6464    assert_equal expected, actual 
    … …  
    8080   
    8181  def test_updated_event_should_return_block 
    82     assert_equal :updated, UpdatableObject.new._update_main 
     82    assert_equal :updated, UpdatableObject.new.updated 
    8383  end 
    8484  def test_update_should_send_updated_event 
    … …  
    135135   
    136136  def test_updated_hook_should_register_updatable_methods 
    137     actual = HookedUpdatableObject.instance_variable_get(:@_update_hook_methods) 
     137    actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    138138    assert_equal 2, actual[:before].size 
    139139    assert_equal 2, actual[:after].size 
    … …  
    141141  def test_updated_hook_should_define_methods 
    142142    hooked_object = HookedUpdatableObject.new 
    143     actual = HookedUpdatableObject.instance_variable_get(:@_update_hook_methods) 
     143    actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    144144    assert_equal true, actual[:before].all?{ |method_name| hooked_object.respond_to? method_name } 
    145145    assert_equal true, actual[:after].all?{ |method_name| hooked_object.respond_to? method_name } 
    … …  
    147147   
    148148  def test_updated_before_hook_should_return_block 
    149     actual = HookedUpdatableObject.instance_variable_get(:@_update_hook_methods) 
     149    actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    150150    assert_equal :before, HookedUpdatableObject.new.__send__(actual[:before][-1]) 
    151151  end 
    152152  def test_updated_after_hook_should_return_block 
    153     actual = HookedUpdatableObject.instance_variable_get(:@_update_hook_methods) 
     153    actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    154154    assert_equal :after, HookedUpdatableObject.new.__send__(actual[:after][0]) 
    155155  end 
    156156   
    157157  def test_updated_before_hook_with_method_name_should_return_method 
    158     actual = HookedUpdatableObject.instance_variable_get(:@_update_hook_methods) 
     158    actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    159159    assert_equal :before2, HookedUpdatableObject.new.__send__(actual[:before][-2]) 
    160160  end 
    161161  def test_updated_after_hook_with_method_name_should_return_method 
    162     actual = HookedUpdatableObject.instance_variable_get(:@_update_hook_methods) 
     162    actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    163163    assert_equal :after2, HookedUpdatableObject.new.__send__(actual[:after][1]) 
    164164  end