rugui 1.3.0 → 1.3.1

data/Changelog

@@ -1,3 +1,12 @@
+1.3.1
+- Added a DSL to detect when observable properties were changed.
+- Silencing logs when running in test environment unless a level is defined in test environment configuration file.
+- Added refresh method to be used when testing GUI parts (views) of applications.
+- Conventionally named views are now registered automatically (i.e., for a controller named MyController, a view named MyView will be registered automatically)
+- Added a new style registering of controllers, views and models, with option for registering main models (models which are already registered in the main controller)
+- Connecting signals for widget types only if the widget isn't destroyed
+- Fixed a bug which happened when copying properties from a observable when the destination observable property value was nil
+
 1.3.0
 - Added support to upload RuGUI to rubyforge.
 - Updated README docs with new instructions for installation.

data/lib/packing/release.rb

@@ -9,8 +9,8 @@ begin
     gemspec.authors = ["Vicente Mundim", "Felipe Mesquita", "Claudio Escudero"]
     gemspec.add_dependency(%q<activesupport>, [">= 2.1.1"])
     gemspec.add_dependency(%q<rubigen>, [">= 1.5.1"])
-    gemspec.version = "1.3.0"
-    gemspec.date = %q{2009-04-01}
+    gemspec.version = "1.3.1"
+    gemspec.date = %q{2009-06-16}
     gemspec.rubyforge_project = "rugui"
     gemspec.executables = ['rugui']
     gemspec.files = FileList["bin/*", "lib/**/*", "rugui_generators/**/*", "script/*", "spec/**/*", "Changelog", "LICENSE", "Rakefile", "README"].to_a

data/lib/rugui/base_controller.rb

@@ -6,14 +6,17 @@ module RuGUI
     include RuGUI::PropertyObserver
     include RuGUI::LogSupport
     include RuGUI::SignalSupport
+    include RuGUI::EntityRegistrationSupport
 
     attr_accessor :models
+    attr_accessor :main_models
     attr_accessor :views
     attr_accessor :controllers
     attr_accessor :parent_controller
 
     def initialize(parent_controller = nil)
       @models = {}
+      @main_models = {}
       @views = {}
       @controllers = {}
 
@@ -23,9 +26,18 @@ module RuGUI
         @parent_controller = parent_controller
       end
 
+      register_all :model
       setup_models
+
+      register_default_view if should_register_default_view?
+      register_all :view
       setup_views
+
+      register_all :controller
       setup_controllers
+
+      register_all :main_model
+      setup_main_models
     end
 
     # This is included here so that the initialize method is properly updated.
@@ -43,13 +55,19 @@ module RuGUI
     # a new instance of the model class will be created.
     #
     def register_model(model, name = nil)
-      model = create_instance(model) if model.is_a?(String) or model.is_a?(Symbol)
-      name ||= model.class.to_s.underscore
-      model.register_observer(self, name)
-      @models[name.to_sym] = model
-      create_model_attribute_reader(name)
+      register(:model, model, name)
+    end
 
-      model.post_registration(self)
+    #
+    # Registers a main model for this controller.
+    #
+    # Only model names (as string or symbol) should be passed. Optionally a
+    # different name may be given. If the main controller doesn't have a model
+    # registered or if this is the main controller a NoMethodError exception
+    # will be raised.
+    #
+    def register_main_model(model_name, name = nil)
+      register(:main_model, model_name, name)
     end
 
     #
@@ -59,13 +77,7 @@ module RuGUI
     # instance of the view class will be created.
     #
     def register_view(view, name = nil)
-      view = create_instance(view) if view.is_a?(String) or view.is_a?(Symbol)
-      name ||= view.class.to_s.underscore
-      view.register_controller(self)
-      @views[name.to_sym] = view
-      create_view_attribute_reader(name)
-
-      view.post_registration(self)
+      register(:view, view, name)
     end
 
     #
@@ -75,13 +87,7 @@ module RuGUI
     # a new instance of the controller class will be created.
     #
     def register_controller(controller, name = nil)
-      controller = create_instance(controller, self) if controller.is_a?(String) or controller.is_a?(Symbol)
-      name ||= controller.class.to_s.underscore
-      controller.parent_controller = self
-      @controllers[name.to_sym] = controller
-      create_controller_attribute_reader(name)
-
-      controller.post_registration
+      register(:controller, controller, name)
     end
 
     #
@@ -102,54 +108,97 @@ module RuGUI
       @main_controller ||= find_main_controller
     end
 
+    class << self
+      def models(*names)
+        register(:model, *names)
+      end
+
+      def main_models(*names)
+        register(:main_model, *names)
+      end
+
+      def views(*names)
+        register(:view, *names)
+      end
+
+      def controllers(*names)
+        register(:controller, *names)
+      end
+    end
+
     protected
       #
-      # Subclasses should reimplement this to register models.
+      # Subclasses should reimplement this to register or initialize models.
       #
       def setup_models
       end
 
       #
-      # Subclasses should reimplement this to register views.
+      # Subclasses should reimplement this to register or initialize main models.
+      #
+      def setup_main_models
+      end
+
+      #
+      # Subclasses should reimplement this to register or initialize views.
       #
       def setup_views
       end
 
       #
-      # Subclasses should reimplement this to register controllers.
+      # Subclasses should reimplement this to register or initialize controllers.
       #
       def setup_controllers
       end
 
     private
-      def create_instance(klass_name, *args)
-        klass_name.to_s.camelize.constantize.new(*args)
+      def after_register_model(model, name)
+        model.register_observer(self, name)
+        model.post_registration(self)
+      end
+
+      def after_register_main_model(model, name)
+        after_register_model(model, name)
       end
 
-      # Creates an attribute reader for the model.
-      def create_model_attribute_reader(name)
-        create_attribute_reader(:models, name)
+      def after_register_view(view, name)
+        view.register_controller(self)
+        view.post_registration(self)
       end
 
-      # Creates an attribute reader for the view.
-      def create_view_attribute_reader(name)
-        create_attribute_reader(:views, name)
+      def after_register_controller(controller, name)
+        controller.parent_controller = self
+        controller.post_registration
       end
 
-      # Creates an attribute reader for the controller.
-      def create_controller_attribute_reader(name)
-        create_attribute_reader(:controllers, name)
+      def create_instance_arguments_for_controller
+        [self]
       end
 
-      # Creates an attribute reader for the some entity.
-      def create_attribute_reader(entity, name)
-        self.class.class_eval <<-class_eval
-          def #{name}
-            @#{entity}[:#{name}]
-          end
-        class_eval
+      def get_instance_for_main_model(name)
+        main_controller.send(name) # should raise an error if main_controller doesn't have that main model.
       end
-      
+
+      def register_default_view
+        default_view_name.camelize.constantize # Check if we can constantize view name, if this fails a NameError exception is thrown.
+        register_view default_view_name
+      rescue NameError
+        # No default view for this controller, nothing to do.
+      end
+
+      def default_view_name
+        "#{controller_name}_view"
+      end
+
+      def controller_name
+        match = self.class.name.underscore.match(/([\w_]*)_controller/)
+        match ? match[1] : self.class.name
+      end
+
+      def should_register_default_view?
+        RuGUI.configuration.automatically_register_conventionally_named_views
+      end
+
       # Navigates through the controllers hierarchy trying to find the main
       # controller (i.e., a class that extends RuGUI::BaseMainController).
       def find_main_controller
@@ -182,6 +231,16 @@ module RuGUI
       self.framework_adapter.run
     end
 
+    #
+    # Refreshes the GUI application, running just one event loop.
+    #
+    # This method is mostly useful when writing tests. It shouldn't be used
+    # in normal applications.
+    #
+    def refresh
+      self.framework_adapter.refresh
+    end
+
     #
     # Exits from the application.
     #

data/lib/rugui/base_model.rb

@@ -2,7 +2,7 @@ module RuGUI
   class BaseModel < BaseObject
     include RuGUI::ObservablePropertySupport
     include RuGUI::LogSupport
-    
+
     def initialize(observable_properties_values = {})
       initialize_observable_property_support(observable_properties_values)
     end

data/lib/rugui/base_view.rb

@@ -36,7 +36,7 @@ module RuGUI
     attr_accessor :controllers
     attr_reader :widgets
     attr_reader :unnamed_widgets
-    
+
     class_inheritable_accessor :configured_builder_file
     class_inheritable_accessor :configured_builder_file_usage
     class_inheritable_accessor :configured_builder_file_extension
@@ -67,7 +67,7 @@ module RuGUI
     # Reimplement this method to create widgets by hand.
     def setup_widgets
     end
-    
+
     # Reimplement this method to setup view helpers.
     def setup_view_helpers
     end

data/lib/rugui/configuration.rb

@@ -41,6 +41,9 @@ module RuGUI
     # The timeout for queued calls. Useful when performing long tasks.
     attr_accessor :queue_timeout
 
+    # Automatically register conventionally named views. Defaults to true.
+    attr_accessor :automatically_register_conventionally_named_views
+
     # A hash of application specific configurations.
     attr_accessor :application
 
@@ -61,6 +64,7 @@ module RuGUI
       self.builder_files_paths = default_builder_files_paths
       self.styles_paths = default_styles_paths
       self.queue_timeout = default_queue_timeout
+      self.automatically_register_conventionally_named_views = default_automatically_register_conventionally_named_views
       self.gems = default_gems
       self.logger = {}
       self.application = {}
@@ -129,6 +133,10 @@ module RuGUI
         50
       end
 
+      def default_automatically_register_conventionally_named_views
+        true
+      end
+
       def default_gems
         []
       end

data/lib/rugui/entity_registration_support.rb

@@ -0,0 +1,94 @@
+module RuGUI
+  module EntityRegistrationSupport
+    module ClassMethods
+      def register(entity, *names)
+        names.each do |name|
+          register_entity entity, name
+        end
+      end
+
+      private
+        def register_entity(entity, name)
+          self.entity_registrations[entity] ||= []
+          self.entity_registrations[entity] << name
+        end
+    end
+
+    def self.included(base)
+      base.class_inheritable_accessor :entity_registrations
+      base.entity_registrations = {}
+      base.extend(ClassMethods)
+    end
+
+    protected
+      def register_all(entity)
+        if self.entity_registrations.has_key?(entity)
+          self.entity_registrations[entity].each do |name|
+            register(entity, name)
+          end
+        end
+      end
+
+      def register(entity, object_or_name, name = nil)
+        name = register_name_for(object_or_name, name)
+        if should_register?(name)
+          object = create_or_get_instance_for(entity, object_or_name)
+          setup_instance(entity, name, object)
+          call_after_register_for(entity, object, name)
+          object
+        end
+      end
+
+    private
+      def register_name_for(object_or_name, name)
+        if object_or_name.is_a?(String) or object_or_name.is_a?(Symbol)
+          name || object_or_name.to_s.underscore
+        else
+          name || object_or_name.class.to_s.underscore
+        end
+      end
+
+      def should_register?(name)
+        not respond_to?(name) or send(name).nil?
+      end
+
+      def create_or_get_instance_for(entity, object_or_name)
+        if object_or_name.is_a?(String) or object_or_name.is_a?(Symbol)
+          args = create_instance_arguments_for(entity) || []
+          get_instance_for(entity, object_or_name) or create_instance(object_or_name, *args)
+        else
+          object_or_name
+        end
+      end
+
+      def create_instance_arguments_for(entity)
+        send("create_instance_arguments_for_#{entity}") if respond_to?("create_instance_arguments_for_#{entity}", true)
+      end
+
+      def get_instance_for(entity, name)
+        send("get_instance_for_#{entity}", name) if respond_to?("get_instance_for_#{entity}", true)
+      end
+
+      def create_instance(klass_name, *args)
+        klass_name.to_s.camelize.constantize.new(*args)
+      end
+
+      def setup_instance(entity, name, object)
+        send("#{entity}s")[name.to_sym] = object
+        create_attribute_reader(entity, name)
+      end
+
+      def call_after_register_for(entity, object, name)
+        send("after_register_#{entity}", object, name) if respond_to?("after_register_#{entity}", true)
+      end
+
+      # Creates an attribute reader for the some entity.
+      def create_attribute_reader(type, name)
+        self.class.class_eval <<-class_eval
+          def #{name}
+            @#{type}s[:#{name}]
+          end
+        class_eval
+      end
+  end
+end

data/lib/rugui/framework_adapters/GTK.rb

@@ -85,6 +85,10 @@ module RuGUI
           Gtk.main
         end
 
+        def refresh
+          Gtk.main_iteration_do(false) while Gtk.events_pending?
+        end
+
         def quit
           Gtk.main_quit
         end
@@ -188,7 +192,7 @@ module RuGUI
       widgets.concat(@unnamed_widgets.select { |widget| widget.kind_of?(widget_type) }) unless @unnamed_widgets.empty?
 
       widgets.each do |widget|
-        widget.signal_connect(signal, &block)
+        widget.signal_connect(signal, &block) unless widget.destroyed?
       end
     end
 

data/lib/rugui/framework_adapters/Qt4.rb

@@ -27,6 +27,11 @@ module RuGUI
           Qt.application.exec
         end
 
+        def refresh
+          # TODO: Vicente Mundim - 03/06/2009 - Implement this method for Qt.
+          raise NotImplementedError.new("Sorry, refresh is not implemented for Qt yet!")
+        end
+
         def quit
           Qt.application.exit
         end

data/lib/rugui/framework_adapters/base_framework_adapter.rb

@@ -22,6 +22,13 @@ module RuGUI
         def run
         end
 
+        # Refreshes the GUI application, running just one event loop.
+        #
+        # This method is mostly useful when writing tests. It shouldn't be used
+        # in normal applications.
+        def refresh
+        end
+
         # Exits the application, freeing any resources used by the framework.
         def quit
         end

data/lib/rugui/log_support.rb

@@ -89,10 +89,12 @@ module RuGUI
       #
       def defined_level
         level = RuGUI.configuration.logger[:level]
-        unless level
-          level = DEFAULT_LEVEL
-        else
+        if level
           level = LEVELS[level]
+        elsif ENV["RUGUI_ENV"] == 'test'
+          level = LEVELS[:fatal] # log nothing at all
+        else
+          level = DEFAULT_LEVEL
         end
         level
       end

data/lib/rugui/observable_property_support.rb

@@ -95,7 +95,10 @@ module RuGUI
         if other_observable.respond_to?(property)
           other_property_value = other_observable.send(property)
           if other_property_value.class.include?(ObservablePropertySupport)
-            send(property).copy_observable_properties_from(other_property_value) if deep
+            if deep
+              send("#{property}=", other_property_value.class.new) if send(property).nil? # Creates an instance of the same class
+              send(property).copy_observable_properties_from(other_property_value)
+            end
           else
             send("#{property}=", other_property_value)
           end

data/lib/rugui/property_changed_support.rb

@@ -0,0 +1,119 @@
+module RuGUI
+  module PropertyChangedSupport
+    module ClassMethods
+      # Invoked when a property was changed.
+      #
+      # Example:
+      # <tt>
+      # when_property_changed :name do |observable, new_value, old_value|
+      #   puts "Hey! The property 'name' of the #{observable.class.name} was changed from #{old_value} to #{new_value}."
+      # end
+      # </tt>
+      #
+      # Or you can inform the observable:
+      # <tt>
+      # when_property_changed :name, :observable => :rabbit do |observable, new_value, old_value|
+      #   puts "Hey! The property 'name' of the 'rabbit' was changed from #{old_value} to #{new_value}."
+      # end
+      # </tt>
+      #
+      # If you can inform a method to be called:
+      # <tt>
+      # when_property_changed :name, :puts_anything
+      #
+      # def puts_anything(observable, new_value, old_value)
+      #   puts "Hey! The property 'name' of the #{observable.class.name} was changed from #{old_value} to #{new_value}."
+      # end
+      # </tt>
+      #
+      # Or you can inform the observable and a method to be called.
+      # <tt>
+      # when_property_changed :name, :observable => :rabbit, :call => :puts_anything
+      #
+      # def puts_anything(observable, new_value, old_value)
+      #   puts "Hey! The property 'name' of the 'rabbit' was changed from #{old_value} to #{new_value}."
+      # end
+      # </tt>
+      # </tt>
+      #
+      def when_property_changed(property, method_or_options = {}, &block)
+        property_changed_block = RuGUI::PropertyChangedSupport::PropertyChangedBlock.new
+        property_changed_block.property = property
+        property_changed_block.set_options(method_or_options)
+        property_changed_block.block = block if block_given?
+        self.property_changed_blocks << property_changed_block
+      end
+    end
+
+    def self.included(base)
+      base.class_inheritable_accessor :property_changed_blocks
+      base.property_changed_blocks = []
+      base.extend(ClassMethods)
+    end
+
+    class PropertyChangedBlock
+      attr_accessor :property
+      attr_accessor :options
+      attr_accessor :block
+      attr_accessor :observer
+
+      # Call the block configurated for the property changed if a block exists for the one.
+      def call_property_changed_block_if_exists(observer, observable, property, new_value, old_value)
+        self.observer = observer
+        call_property_changed_block(observable, new_value, old_value) if block_exists?(observable, property, new_value, old_value)
+      end
+
+      # Set the options given the args.
+      def set_options(method_or_options)
+        case method_or_options
+        when String, Symbol
+          self.options = { :call => prepared(method_or_options) }
+        when Hash
+          self.options = method_or_options
+        end
+      end
+
+      protected
+        # Check if a block exists for the property changed
+        def block_exists?(observable, property, new_value, old_value)
+          if self.options.has_key?(:observable)
+            return same_observable_and_property?(observable, property)
+          else
+            return same_property?(property)
+          end
+        end
+
+        # Call the block configurated for the property changed.
+        def call_property_changed_block(observable, new_value, old_value)
+          return if not self.options.has_key?(:call) and self.block.blank?
+          if self.options.has_key?(:call)
+            method = self.options[:call]
+            self.observer.send(method, observable, new_value, old_value) if self.observer.respond_to?(method)
+          else
+            self.block.call(observable, new_value, old_value) unless self.block.blank?
+          end
+        end
+
+      private
+        def same_property?(property)
+          prepared(self.property) == prepared(property)
+        end
+
+        def same_observable?(observable)
+          prepared(self.options[:observable]) == prepared(observable.class.name)
+        end
+
+        def same_observable_and_property?(observable, property)
+          same_observable?(observable) and same_property?(property)
+        end
+
+        def prepared(param)
+          param.to_s.downcase.underscore
+        end
+
+        def logger
+          @logger ||= RuGUILogger.logger
+        end
+    end
+  end
+end

data/lib/rugui/property_observer.rb

@@ -1,13 +1,13 @@
 module RuGUI
   # Adds observer functionality for any class which has support for observable
   # properties.
-  # 
+  #
   # The observer class should implement a method name
   # 'property_property_name_changed', where 'property_name' is
   # the name of the observable property, that will be called whenever that
   # property value has changed. If it does not declare a method with this
   # name, it will be silently ignored.
-  # 
+  #
   # The method signature is:
   #
   #   property_foo_changed(model, new_value, old_value)
@@ -33,15 +33,22 @@ module RuGUI
   module PropertyObserver
     include RuGUI::FrameworkAdapters::FrameworkAdapterSupport
 
+    def self.included(base)
+      base.send(:include, RuGUI::PropertyChangedSupport)
+    end
+
     def property_updated(observable, property, new_value, old_value)
       queue_method_call_if_exists("property_#{property}_changed", observable, new_value, old_value)
       queue_method_call_if_exists("property_#{observable.class.name.underscore}_#{property}_changed", observable, new_value, old_value)
+      self.property_changed_blocks.each do |property_changed_block|
+        property_changed_block.call_property_changed_block_if_exists(self, observable, property, new_value, old_value)
+      end
     end
-    
+
     def named_observable_property_updated(observable_name, observable, property, new_value, old_value)
       queue_method_call_if_exists("property_#{observable_name}_#{property}_changed", observable, new_value, old_value) unless named_observable_collides_with_class_name?(observable_name, observable)
     end
-    
+
     private
       def queue_method_call_if_exists(method_name, *args)
         if respond_to?(method_name)
@@ -50,7 +57,7 @@ module RuGUI
           end
         end
       end
-      
+
       def named_observable_collides_with_class_name?(observable_name, observable)
         observable_name == observable.class.name.underscore
       end

data/lib/rugui/version.rb

@@ -2,7 +2,7 @@ module RuGUI
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 3
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rugui.rb

@@ -27,11 +27,13 @@ require 'rugui/log_support'
 require 'rugui/plugin/loader'
 require 'rugui/framework_adapters/framework_adapter_support'
 require 'rugui/base_object'
+require 'rugui/property_changed_support'
 require 'rugui/observable_property_support'
 require 'rugui/property_observer'
 require 'rugui/initialize_hooks'
 require 'rugui/signal_support'
+require 'rugui/entity_registration_support'
 require 'rugui/base_controller'
 require 'rugui/base_model'
 require 'rugui/base_view_helper'
-require 'rugui/base_view'
+require 'rugui/base_view'

data/spec/framework/base_controller_spec.rb

@@ -15,6 +15,14 @@ describe RuGUI::BaseController do
       @controller.my_view.should be_an_instance_of(MyView)
       @controller.views[:my_view].should == @controller.my_view
     end
+
+    describe "with conventionally named controllers and views" do
+      it "should automatically register a conventionally named view if it exists" do
+        @conventionally_named_controller = ConventionallyNamedController.new
+        @conventionally_named_controller.respond_to?(:conventionally_named_view).should be_true
+        @conventionally_named_controller.conventionally_named_view.should be_an_instance_of(ConventionallyNamedView)
+      end
+    end
   end
   
   describe "with model registering" do
@@ -38,6 +46,83 @@ describe RuGUI::BaseController do
     end
   end
 
+  describe "with new style registering" do
+    before :all do
+      RuGUI.configuration.automatically_register_conventionally_named_views = false
+    end
+
+    after :all do
+      RuGUI.configuration.automatically_register_conventionally_named_views = true
+    end
+
+    describe "of views" do
+      before :each do
+        NewStyleController.views :new_style_view
+        @controller = NewStyleController.new
+      end
+
+      it "should have the new_style_view registered when instantiated" do
+        @controller.views[:new_style_view].should be_an_instance_of(NewStyleView)
+        @controller.new_style_view.should be_an_instance_of(NewStyleView)
+        @controller.views[:new_style_view].should == @controller.new_style_view
+      end
+    end
+
+    describe "of models" do
+      before :each do
+        NewStyleController.models :new_style_model
+        @controller = NewStyleController.new
+      end
+
+      it "should have the new_style_model registered when instantiated" do
+        @controller.models[:new_style_model].should be_an_instance_of(NewStyleModel)
+        @controller.new_style_model.should be_an_instance_of(NewStyleModel)
+        @controller.models[:new_style_model].should == @controller.new_style_model
+      end
+    end
+
+    describe "of main models" do
+      before :each do
+        NewStyleController.main_models :new_style_model
+        
+        @main_controller = RuGUI::BaseMainController.new
+        @main_controller.register_model :new_style_model
+        @main_controller.register_controller :new_style_controller
+
+        @controller = @main_controller.new_style_controller
+      end
+
+      it "should have the new_style_model registered when instantiated" do
+        @controller.main_models[:new_style_model].should be_an_instance_of(NewStyleModel)
+        @controller.new_style_model.should be_an_instance_of(NewStyleModel)
+        @controller.main_models[:new_style_model].should == @controller.new_style_model
+      end
+
+      it "should use the same instance that was registered in the main controller" do
+        @controller.new_style_model.object_id.should == @main_controller.new_style_model.object_id # object ids should be equals here
+      end
+
+      it "should raise an error if we register a main model which aren't register in the main controller" do
+        lambda {
+          @controller.register_main_model(:some_inexistent_model)
+        }.should raise_error(NoMethodError)
+      end
+    end
+
+    describe "of controllers" do
+      before :each do
+        NewStyleController.controllers :new_style_child_controller
+        @controller = NewStyleController.new
+      end
+
+      it "should have the new_style_child_controller registered when instantiated" do
+        @controller.controllers[:new_style_child_controller].should be_an_instance_of(NewStyleChildController)
+        @controller.new_style_child_controller.should be_an_instance_of(NewStyleChildController)
+        @controller.controllers[:new_style_child_controller].should == @controller.new_style_child_controller
+      end
+    end
+  end
+
   describe "with initialization hooks" do
     it "should call before initialize and after initialize methods" do
       controller = MyController.new

data/spec/framework/observable_property_support_spec.rb

@@ -210,6 +210,12 @@ describe RuGUI::ObservablePropertySupport do
       @parent.my_own_observable_property.should == @another_parent.my_own_observable_property
       @parent.child_observable_property.should_not == @another_parent.child_observable_property
     end
+
+    it "should create an instance of the same class and copy observable properties to it if destination object has a nil observable property while source object doesn't" do
+      @parent.child_observable_property = nil
+      @parent.copy_observable_properties_from(@another_parent)
+      @parent.child_observable_property.should == @another_parent.child_observable_property
+    end
   end
 
   describe "with observable properties mapped for an instance" do

data/spec/helpers/controllers.rb

@@ -7,10 +7,6 @@ class MyController < RuGUI::BaseController
 
   attr_accessor :message
   
-  def setup_views
-    register_view :my_view
-  end
-  
   def setup_models
     register_model :my_model
     register_model :my_model, :my_other_model_instance
@@ -26,4 +22,13 @@ class MyController < RuGUI::BaseController
 end
 
 class MyChildController < RuGUI::BaseController
-end
+end
+
+class ConventionallyNamedController < RuGUI::BaseController
+end
+
+class NewStyleController < RuGUI::BaseController
+end
+
+class NewStyleChildController < RuGUI::BaseController
+end

data/spec/helpers/models.rb

@@ -7,3 +7,6 @@ class MyModel < RuGUI::BaseModel
   
   observable_property :my_property
 end
+
+class NewStyleModel < RuGUI::BaseModel
+end

data/spec/helpers/views.rb

@@ -69,4 +69,10 @@ class MyOtherView < RuGUI::BaseView
 end
 
 class NoBuilderView < RuGUI::BaseView
+end
+
+class ConventionallyNamedView < RuGUI::BaseView
+end
+
+class NewStyleView < RuGUI::BaseView
 end

data/spec/resource_files/my_other_view.glade

@@ -3,7 +3,7 @@
 <!--Generated with glade3 3.4.5 on Thu Aug 28 14:02:01 2008 -->
 <glade-interface>
   <widget class="GtkWindow" id="top_window">
-    <property name="visible">True</property>
+    <property name="visible">False</property>
     <signal name="delete_event" handler="on_top_window_delete_event"/>
     <child>
       <widget class="GtkHBox" id="horizontal_container">

data/spec/resource_files/my_view.glade

@@ -3,7 +3,7 @@
 <!--Generated with glade3 3.4.5 on Thu Aug 28 14:02:07 2008 -->
 <glade-interface>
   <widget class="GtkWindow" id="top_window">
-    <property name="visible">True</property>
+    <property name="visible">False</property>
     <signal name="delete_event" handler="on_top_window_delete_event"/>
     <child>
       <widget class="GtkVBox" id="vertical_container">

data/spec/spec.opts

@@ -2,3 +2,4 @@
 --format progress
 --loadby mtime
 --reverse
+--debugger

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rugui
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors: 
 - Vicente Mundim
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-24 00:00:00 -03:00
+date: 2009-07-08 00:00:00 -03:00
 default_executable: rugui
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,6 +61,7 @@ files:
 - lib/rugui/base_view.rb
 - lib/rugui/base_view_helper.rb
 - lib/rugui/configuration.rb
+- lib/rugui/entity_registration_support.rb
 - lib/rugui/framework_adapters/GTK.rb
 - lib/rugui/framework_adapters/Qt4.rb
 - lib/rugui/framework_adapters/base_framework_adapter.rb
@@ -73,6 +74,7 @@ files:
 - lib/rugui/observable_property_proxy.rb
 - lib/rugui/observable_property_support.rb
 - lib/rugui/plugin/loader.rb
+- lib/rugui/property_changed_support.rb
 - lib/rugui/property_observer.rb
 - lib/rugui/signal_support.rb
 - lib/rugui/tasks/gems_application.rake