Changeset 28046 for lang/ruby/starframe

Show
Ignore:
Timestamp:
01/07/09 00:37:54 (5 years ago)
Author:
isaisstillalive
Message:
  • Updatable及びRenderableモジュールからフック機構を削除
Location:
lang/ruby/starframe
Files:
5 modified

Legend:

Unmodified
Added
Removed
  • lang/ruby/starframe/lib/starframe/renderable.rb

    r28021 r28046  
    1313  #     render do 
    1414  #       # 描画イベント定義 
    15   #     end 
    16   #      
    17   #     render :before do 
    18   #       # イベント前フック定義 
    19   #     end 
    20   #      
    21   #     render :after do 
    22   #       # イベント後フック定義 
    2315  #     end 
    2416  #   end 
     
    4032     
    4133    # 描画する。 
    42     #  
    43     # このメソッドは、サブクラスで再定義しないでください。 
    4434    def render 
    45       renderable_methods = self.class._renderable_methods 
    46       renderable_methods[:before].each{|method| __send__ method } 
    4735      rendered 
    48     ensure 
    49       renderable_methods[:after].each{|method| __send__ method } 
    5036    end 
    5137     
     
    5440     
    5541    module ClassMethods 
    56       @@method_count = 0 
    57        
    58       #:stopdoc: 
    59       attr_reader :_renderable_methods 
    60        
    6142      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        
    7543      # 描画イベントを定義する 
    76       #  
    77       # :call-seq: 
    78       #   reader(&block) 
    79       #   reader(hook_type, &block) 
    80       #   reader(hook_type, method_name) 
    8144      #  
    8245      # == Example 
    8346      #   reader do 
    84       #     # イベント定義 
     47      #     # 描画イベント定義 
    8548      #   end 
    86       #    
    87       #   reader :before do 
    88       #     # イベント前フック定義 
    89       #   end 
    90       #    
    91       #   reader :after do 
    92       #     # イベント後フック定義 
    93       #   end 
    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 
    119        
    120       public 
    121       # 描画イベントフックを定義する 
    122       def register_render_hook hook_type, method_name 
    123         render hook_type, method_name 
     49      def render &block 
     50        raise ArgumentError unless block 
     51        define_method :rendered, &block 
    12452      end 
    12553    end 
  • lang/ruby/starframe/lib/starframe/sprite.rb

    r28015 r28046  
    293293    end 
    294294     
    295     update :after do #:nodoc: 
     295    # 更新する。 
     296    def update 
     297      super 
    296298      move 
    297299    end 
     300    alias call update 
    298301     
    299302    private 
  • lang/ruby/starframe/lib/starframe/updatable.rb

    r28021 r28046  
    1313  #       # イベント定義 
    1414  #     end 
    15   #      
    16   #     update :before do 
    17   #       # イベント前フック定義 
    18   #     end 
    19   #      
    20   #     update :after do 
    21   #       # イベント後フック定義 
    22   #     end 
    2315  #   end 
    2416  module Updatable 
     
    3022     
    3123    # 更新する。 
    32     #  
    33     # このメソッドは、サブクラスで再定義しないでください。 
    3424    def update 
    35       updatable_methods = self.class._updatable_methods 
    36       updatable_methods[:before].each{|method| __send__ method } 
    3725      updated 
    38     ensure 
    39       updatable_methods[:after].each{|method| __send__ method } 
    4026    end 
    4127    alias call update 
     
    4531     
    4632    module ClassMethods 
    47       @@method_count = 0 
    48        
    49       #:stopdoc: 
    50       attr_reader :_updatable_methods 
    51        
    5233      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        
    66       # 更新イベント及び更新イベントフックを定義する 
    67       #  
    68       # :call-seq: 
    69       #   update(&block) 
    70       #   update(hook_type, &block) 
    71       #   update(hook_type, method_name) 
     34      # 更新イベントを定義する 
    7235      #  
    7336      # == Example 
    7437      #   update do 
    75       #     # イベント定義 
     38      #     # 更新イベント定義 
    7639      #   end 
    77       #    
    78       #   update :before do 
    79       #     # イベント前フック定義 
    80       #   end 
    81       #    
    82       #   update :after do 
    83       #     # イベント後フック定義 
    84       #   end 
    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 
    110        
    111       public 
    112       # 更新イベントフックを定義する 
    113       def register_update_hook hook_type, method_name 
    114         update hook_type, method_name 
     40      def update &block 
     41        raise ArgumentError unless block 
     42        define_method :updated, &block 
    11543      end 
    11644    end 
  • lang/ruby/starframe/test/starframe/test_renderable.rb

    r28021 r28046  
    3636end 
    3737 
     38 
    3839class TestStarFrameRenderable < Test::Unit::TestCase 
    3940  def test_render_without_block_raised_arg_error 
     
    4546    end 
    4647  end 
    47   def test_render_with_method_name_raised_arg_error 
    48     assert_raise ArgumentError do 
    49       klass = Class.new do 
    50         include StarFrame::Renderable 
    51         render nil, :method_name 
    52       end 
    53     end 
    54   end 
    55    
    56   def test_render_hook_without_method_name_and_block_raised_arg_error 
    57     assert_raise ArgumentError do 
    58       klass = Class.new do 
    59         include StarFrame::Renderable 
    60         render :after 
    61       end 
    62     end 
    63   end 
    64   def test_render_hook_with_method_name_and_block_raised_arg_error 
    65     assert_raise ArgumentError do 
    66       klass = Class.new do 
    67         include StarFrame::Renderable 
    68         render :after, :name do 
    69         end 
    70       end 
    71     end 
    72   end 
    73   def test_render_hook_with_unknown_type_raised_type_error 
    74     assert_raise TypeError do 
    75       klass = Class.new do 
    76         include StarFrame::Renderable 
    77         render :no_type do 
    78         end 
    79       end 
    80     end 
    81   end 
    8248   
    8349   
     
    8652  end 
    8753   
    88   def test_renderable_object_should_respond_to_render 
     54  def test_updatable_object_should_respond_to_rendered 
     55    assert_respond_to UnOverwriteRenderableObject.new, :rendered 
     56  end 
     57  def test_updatable_object_should_respond_to_render 
    8958    assert_respond_to UnOverwriteRenderableObject.new, :render 
    9059  end 
    9160   
    92   def test_renderable_object_should_have_renderable_methods 
    93     actual = RenderableObject.instance_variable_get(:@_renderable_methods) 
    94     expected = {:before => [], :after => []} 
    95     assert_equal expected, actual 
     61  def test_updatable_object_rendered_should_return_nil 
     62    assert_equal nil, UnOverwriteRenderableObject.new.rendered 
    9663  end 
    97    
    98   def test_renderable_object_render_should_return_nil 
     64  def test_updatable_object_render_should_return_nil 
    9965    assert_equal nil, UnOverwriteRenderableObject.new.render 
    10066  end 
     
    10470    render do 
    10571      :rendered 
     72    end 
     73  end 
     74  class RenderableObjectSub < RenderableObject 
     75    render do 
     76      :rendered_sub 
    10677    end 
    10778  end 
     
    11485  end 
    11586   
    116    
    117    
    118   class HookedRenderableObject 
    119     include StarFrame::Renderable 
    120      
    121     attr_reader :called 
    122     def initialize 
    123       @called = [] 
    124     end 
    125      
    126     render do 
    127       @called << :main 
    128     end 
    129      
    130     render :before do 
    131       @called << :before 
    132       :before 
    133     end 
    134     render :after do 
    135       @called << :after 
    136       :after 
    137     end 
    138      
    139     render :before, :before_with_name 
    140     def before_with_name 
    141        @called << :before2 
    142       :before2 
    143     end 
    144     render :after, :after_with_name 
    145     def after_with_name 
    146       @called << :after2 
    147       :after2 
    148     end 
     87  def test_sub_rendered_event_should_return_block 
     88    assert_equal :rendered_sub, RenderableObjectSub.new.rendered 
    14989  end 
    150   class HookedRenderableObjectSub < HookedRenderableObject 
    151     render :before do 
    152       @called << :before3 
    153       :before3 
    154     end 
    155     render :after do 
    156       @called << :after3 
    157       :after3 
    158     end 
    159   end 
    160    
    161   def test_rendered_hook_should_register_renderable_methods 
    162     actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    163     assert_equal 2, actual[:before].size 
    164     assert_equal 2, actual[:after].size 
    165   end 
    166   def test_rendered_hook_should_define_methods 
    167     hooked_object = HookedRenderableObject.new 
    168     actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    169     assert_equal true, actual[:before].all?{ |method_name| hooked_object.respond_to? method_name } 
    170     assert_equal true, actual[:after].all?{ |method_name| hooked_object.respond_to? method_name } 
    171   end 
    172    
    173   def test_rendered_before_hook_should_return_block 
    174     actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    175     assert_equal :before, HookedRenderableObject.new.__send__(actual[:before][-1]) 
    176   end 
    177   def test_rendered_after_hook_should_return_block 
    178     actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    179     assert_equal :after, HookedRenderableObject.new.__send__(actual[:after][0]) 
    180   end 
    181    
    182   def test_rendered_before_hook_with_method_name_should_return_method 
    183     actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    184     assert_equal :before2, HookedRenderableObject.new.__send__(actual[:before][-2]) 
    185   end 
    186   def test_rendered_after_hook_with_method_name_should_return_method 
    187     actual = HookedRenderableObject.instance_variable_get(:@_renderable_methods) 
    188     assert_equal :after2, HookedRenderableObject.new.__send__(actual[:after][1]) 
    189   end 
    190    
    191   def test_hooked_render_should_call_method_chain 
    192     hooked_object = HookedRenderableObject.new 
    193     hooked_object.render 
    194     assert_equal [:before2, :before, :main, :after, :after2], hooked_object.called 
    195   end 
    196    
    197    
    198   def test_hooked_sub_render_should_call_method_chain 
    199     hooked_object = HookedRenderableObjectSub.new 
    200     hooked_object.render 
    201     assert_equal [:before3, :before2, :before, :main, :after, :after2, :after3], hooked_object.called 
    202   end 
    203    
    204    
    205   def test_register_render_hook 
    206     klass = Class.new(HookedRenderableObject) do 
    207       def before3 
    208         @called << :before3 
    209         :before3 
    210       end 
    211       def after3 
    212         @called << :after3 
    213         :after3 
    214       end 
    215     end 
    216     klass.register_render_hook :before, :before3 
    217     klass.register_render_hook :after, :after3 
    218     hooked_object = klass.new 
    219     hooked_object.render 
    220     assert_equal [:before3, :before2, :before, :main, :after, :after2, :after3], hooked_object.called 
     90  def test_sub_render_should_send_rendered_event 
     91    assert_equal :rendered_sub, RenderableObjectSub.new.render 
    22192  end 
    22293end 
  • lang/ruby/starframe/test/starframe/test_updatable.rb

    r28021 r28046  
    1111    end 
    1212  end 
    13   def test_update_with_method_name_raised_arg_error 
    14     assert_raise ArgumentError do 
    15       klass = Class.new do 
    16         include StarFrame::Updatable 
    17         update nil, :method_name 
    18       end 
    19     end 
    20   end 
    21    
    22   def test_update_hook_without_method_name_and_block_raised_arg_error 
    23     assert_raise ArgumentError do 
    24       klass = Class.new do 
    25         include StarFrame::Updatable 
    26         update :after 
    27       end 
    28     end 
    29   end 
    30   def test_update_hook_with_method_name_and_block_raised_arg_error 
    31     assert_raise ArgumentError do 
    32       klass = Class.new do 
    33         include StarFrame::Updatable 
    34         update :after, :name do 
    35         end 
    36       end 
    37     end 
    38   end 
    39   def test_update_hook_with_unknown_type_raised_type_error 
    40     assert_raise TypeError do 
    41       klass = Class.new do 
    42         include StarFrame::Updatable 
    43         update :no_type do 
    44         end 
    45       end 
    46     end 
    47   end 
    4813   
    4914   
     
    5217  end 
    5318   
     19  def test_updatable_object_should_respond_to_updated 
     20    assert_respond_to UnOverwriteUpdatableObject.new, :updated 
     21  end 
    5422  def test_updatable_object_should_respond_to_update 
    5523    assert_respond_to UnOverwriteUpdatableObject.new, :update 
     
    5927  end 
    6028   
    61   def test_updatable_object_should_have_updatable_methods 
    62     actual = UpdatableObject.instance_variable_get(:@_updatable_methods) 
    63     expected = {:before => [], :after => []} 
    64     assert_equal expected, actual 
     29  def test_updatable_object_updated_should_return_nil 
     30    assert_equal nil, UnOverwriteUpdatableObject.new.updated 
    6531  end 
    66    
    6732  def test_updatable_object_update_should_return_nil 
    6833    assert_equal nil, UnOverwriteUpdatableObject.new.update 
     
    7843    end 
    7944  end 
     45  class UpdatableObjectSub < UpdatableObject 
     46    update do 
     47      :updated_sub 
     48    end 
     49  end 
    8050   
    8151  def test_updated_event_should_return_block 
     
    8959  end 
    9060   
    91    
    92    
    93   class HookedUpdatableObject 
    94     include StarFrame::Updatable 
    95      
    96     attr_reader :called 
    97     def initialize 
    98       @called = [] 
    99     end 
    100      
    101     update do 
    102       @called << :main 
    103     end 
    104      
    105     update :before do 
    106       @called << :before 
    107       :before 
    108     end 
    109     update :after do 
    110       @called << :after 
    111       :after 
    112     end 
    113      
    114     update :before, :before_with_name 
    115     def before_with_name 
    116        @called << :before2 
    117       :before2 
    118     end 
    119     update :after, :after_with_name 
    120     def after_with_name 
    121       @called << :after2 
    122       :after2 
    123     end 
     61  def test_sub_updated_event_should_return_block 
     62    assert_equal :updated_sub, UpdatableObjectSub.new.updated 
    12463  end 
    125   class HookedUpdatableObjectSub < HookedUpdatableObject 
    126     update :before do 
    127       @called << :before3 
    128       :before3 
    129     end 
    130     update :after do 
    131       @called << :after3 
    132       :after3 
    133     end 
     64  def test_sub_update_should_send_updated_event 
     65    assert_equal :updated_sub, UpdatableObjectSub.new.update 
    13466  end 
    135    
    136   def test_updated_hook_should_register_updatable_methods 
    137     actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    138     assert_equal 2, actual[:before].size 
    139     assert_equal 2, actual[:after].size 
    140   end 
    141   def test_updated_hook_should_define_methods 
    142     hooked_object = HookedUpdatableObject.new 
    143     actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    144     assert_equal true, actual[:before].all?{ |method_name| hooked_object.respond_to? method_name } 
    145     assert_equal true, actual[:after].all?{ |method_name| hooked_object.respond_to? method_name } 
    146   end 
    147    
    148   def test_updated_before_hook_should_return_block 
    149     actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    150     assert_equal :before, HookedUpdatableObject.new.__send__(actual[:before][-1]) 
    151   end 
    152   def test_updated_after_hook_should_return_block 
    153     actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    154     assert_equal :after, HookedUpdatableObject.new.__send__(actual[:after][0]) 
    155   end 
    156    
    157   def test_updated_before_hook_with_method_name_should_return_method 
    158     actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    159     assert_equal :before2, HookedUpdatableObject.new.__send__(actual[:before][-2]) 
    160   end 
    161   def test_updated_after_hook_with_method_name_should_return_method 
    162     actual = HookedUpdatableObject.instance_variable_get(:@_updatable_methods) 
    163     assert_equal :after2, HookedUpdatableObject.new.__send__(actual[:after][1]) 
    164   end 
    165    
    166   def test_hooked_update_should_call_method_chain 
    167     hooked_object = HookedUpdatableObject.new 
    168     hooked_object.update 
    169     assert_equal [:before2, :before, :main, :after, :after2], hooked_object.called 
    170   end 
    171   def test_hooked_call_should_call_method_chain 
    172     hooked_object = HookedUpdatableObject.new 
    173     hooked_object.call 
    174     assert_equal [:before2, :before, :main, :after, :after2], hooked_object.called 
    175   end 
    176    
    177    
    178   def test_hooked_sub_update_should_call_method_chain 
    179     hooked_object = HookedUpdatableObjectSub.new 
    180     hooked_object.update 
    181     assert_equal [:before3, :before2, :before, :main, :after, :after2, :after3], hooked_object.called 
    182   end 
    183   def test_hooked_sub_call_should_call_method_chain 
    184     hooked_object = HookedUpdatableObjectSub.new 
    185     hooked_object.call 
    186     assert_equal [:before3, :before2, :before, :main, :after, :after2, :after3], hooked_object.called 
    187   end 
    188    
    189    
    190   def test_register_update_hook 
    191     klass = Class.new(HookedUpdatableObject) do 
    192       def before3 
    193         @called << :before3 
    194         :before3 
    195       end 
    196       def after3 
    197         @called << :after3 
    198         :after3 
    199       end 
    200     end 
    201     klass.register_update_hook :before, :before3 
    202     klass.register_update_hook :after, :after3 
    203     hooked_object = klass.new 
    204     hooked_object.update 
    205     assert_equal [:before3, :before2, :before, :main, :after, :after2, :after3], hooked_object.called 
     67  def test_sub_call_should_send_updated_event 
     68    assert_equal :updated_sub, UpdatableObjectSub.new.call 
    20669  end 
    20770end