rugui 1.2.0

data/lib/rugui/property_observer.rb

@@ -0,0 +1,58 @@
+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)
+  #
+  # for a property named 'foo'.
+  #
+  # If the observer class declares a method with this signature:
+  #
+  #   property_my_class_foo_changed(model, new_value, old_value)
+  #
+  # it will be called whenever the property _foo_ of an observable of the
+  # class <code>MyClass</code> has changed.
+  #
+  # Also, if the observer class declares a method with this signature:
+  #
+  #   property_my_named_observable_foo_changed(model, new_value, old_value)
+  #
+  # it will be called whenever the property _foo_ of the observable named
+  # _my_named_observable_ has changed. To declare named observers, you must
+  # register the observer passing a name to the
+  # ObservablePropertySupport#register_observer method.
+  #
+  module PropertyObserver
+    include RuGUI::FrameworkAdapters::FrameworkAdapterSupport
+
+    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)
+    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)
+          self.framework_adapter.queue do
+            send(method_name, *args)
+          end
+        end
+      end
+      
+      def named_observable_collides_with_class_name?(observable_name, observable)
+        observable_name == observable.class.name.underscore
+      end
+  end
+end

data/lib/rugui/signal_support.rb

@@ -0,0 +1,57 @@
+module RuGUI
+  module SignalSupport
+    module ClassMethods
+      # Declares a signal handler for the given signal of the widget. The
+      # handler may be a method of this class or a block, which will be run with
+      # the instance of this class as context.
+      #
+      # If the signal has arguments they are passed to the receiver method or
+      # the block.
+      def on(widget_name, signal_name, receiver_method_name = nil, &block)
+        if receiver_method_name.nil? and not block_given?
+          logger.warn "Either a block or a receiver_method_name must be given to on(#{widget_name}, #{signal_name}), ignoring call."
+          return
+        end
+
+        signal_connection = RuGUI::SignalSupport::SignalConnection.new
+        signal_connection.widget_name = widget_name
+        signal_connection.signal_name = signal_name
+        signal_connection.receiver_method_name = receiver_method_name
+        signal_connection.receiver_block = block if block_given?
+        signal_connection.receiver_class = self
+
+        self.signal_connections << signal_connection
+      end
+    end
+
+    # Autoconnects declared signal handlers for the widgets in the sender to
+    # methods in this instance, or to blocks which have this instance as context.
+    def autoconnect_declared_signals(sender)
+      self.signal_connections.each do |signal_connection|
+        if sender.respond_to?(signal_connection.widget_name)
+          widget = sender.send(signal_connection.widget_name)
+
+          if (not signal_connection.receiver_block.nil?) and self.is_a?(signal_connection.receiver_class)
+            sender.framework_adapter.connect_declared_signal_block(widget, signal_connection.signal_name, self, signal_connection.receiver_block)
+          elsif not signal_connection.receiver_method_name.nil? and self.respond_to?(signal_connection.receiver_method_name)
+            sender.framework_adapter.connect_declared_signal(widget, signal_connection.signal_name, self, signal_connection.receiver_method_name)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.class_inheritable_accessor :signal_connections
+      base.signal_connections = []
+      base.extend(ClassMethods)
+    end
+
+    class SignalConnection
+      attr_accessor :widget_name
+      attr_accessor :signal_name
+      attr_accessor :receiver_method_name
+      attr_accessor :receiver_block
+      attr_accessor :receiver_class
+    end
+  end
+end

data/lib/rugui/tasks/gems_application.rake

@@ -0,0 +1,71 @@
+task :rake_environment do
+  $rails_rake_task = true
+  require(File.join(APPLICATION_ROOT, 'config', 'environment'))
+  RuGUI.configuration.logger[:level] = :error
+end
+
+desc "List the gems that this RuGUI application depends on"
+task :gems => 'gems:base' do
+  RuGUI.configuration.gems.each do |gem|
+    print_gem_status(gem)
+  end
+  puts
+  puts "I = Installed"
+  puts "F = Frozen"
+  puts "R = Framework (loaded before RuGUI starts)"
+end
+
+namespace :gems do
+  task :base do
+    $gems_rake_task = true
+    require 'rubygems'
+    require 'rubygems/gem_runner'
+    Rake::Task[:rake_environment].invoke
+  end
+
+  desc "Build any native extensions for unpacked gems"
+  task :build do
+    $gems_build_rake_task = true
+    Rake::Task['gems:unpack'].invoke
+    current_gems.each &:build
+  end
+
+  desc "Installs all required gems."
+  task :install => :base do
+    current_gems.each &:install
+  end
+
+  desc "Unpacks all required gems into vendor/gems."
+  task :unpack => :install do
+    current_gems.each &:unpack
+  end
+
+  namespace :unpack do
+    desc "Unpacks all required gems and their dependencies into vendor/gems."
+    task :dependencies => :install do
+      current_gems.each { |gem| gem.unpack(:recursive => true) }
+    end
+  end
+
+  desc "Regenerate gem specifications in correct format."
+  task :refresh_specs => :base do
+    current_gems.each &:refresh
+  end
+end
+
+def current_gems
+  gems = RuGUI.configuration.gems
+  gems = gems.select { |gem| gem.name == ENV['GEM'] } unless ENV['GEM'].blank?
+  gems
+end
+
+def print_gem_status(gem, indent=1)
+  code = case
+    when gem.framework_gem? then 'R'
+    when gem.frozen?        then 'F'
+    when gem.installed?     then 'I'
+    else                         ' '
+  end
+  puts "   "*(indent-1)+" - [#{code}] #{gem.name} #{gem.requirement.to_s}"
+  gem.dependencies.each { |g| print_gem_status(g, indent+1) }
+end

data/lib/rugui/tasks/rugui.rb

@@ -0,0 +1,8 @@
+$VERBOSE = nil
+
+# Load RuGUI rakefile extensions
+Dir["#{File.dirname(__FILE__)}/*_application.rake"].each { |ext| load ext }
+
+# Load any custom rakefile extensions
+Dir["#{APPLICATION_ROOT}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+Dir["#{APPLICATION_ROOT}/vendor/plugins/*/**/tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/rugui/tasks/rugui_framework.rb

@@ -0,0 +1,4 @@
+$VERBOSE = nil
+
+# Load RuGUI framework rakefile extensions
+Dir["#{File.dirname(__FILE__)}/*_framework.rake"].each { |ext| load ext }

data/lib/rugui/tasks/runner_application.rake

@@ -0,0 +1,4 @@
+desc 'Runs the application.'
+task :run do
+  require 'main'
+end

data/lib/rugui/tasks/spec_application.rake

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"#{APPLICATION_ROOT}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs in spec directory with RCov (excluding plugin specs)"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_opts = ['--options', "\"#{APPLICATION_ROOT}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = lambda do
+      IO.readlines("#{APPLICATION_ROOT}/spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+    end
+  end
+
+  desc "Print Specdoc for all specs (excluding plugin specs)"
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.spec_opts = ["--format", "specdoc", "--dry-run"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  desc "Print Specdoc for all plugin specs"
+  Spec::Rake::SpecTask.new(:plugin_doc) do |t|
+    t.spec_opts = ["--format", "specdoc", "--dry-run"]
+    t.spec_files = FileList['vendor/plugins/**/spec/**/*_spec.rb'].exclude('vendor/plugins/rspec/*')
+  end
+
+  [:models, :controllers, :views, :view_helpers, :lib].each do |sub|
+    desc "Run the specs under spec/#{sub}"
+    Spec::Rake::SpecTask.new(sub) do |t|
+      t.spec_opts = ['--options', "\"#{APPLICATION_ROOT}/spec/spec.opts\""]
+      t.spec_files = FileList["spec/#{sub}/**/*_spec.rb"]
+    end
+  end
+
+  desc "Run the specs under vendor/plugins (except RSpec's own)"
+  Spec::Rake::SpecTask.new(:plugins) do |t|
+    t.spec_opts = ['--options', "\"#{APPLICATION_ROOT}/spec/spec.opts\""]
+    t.spec_files = FileList['vendor/plugins/**/spec/**/*_spec.rb'].exclude('vendor/plugins/rspec/*')
+  end
+
+  # Setup specs for stats
+  task :statsetup do
+    require 'code_statistics'
+    ::STATS_DIRECTORIES << %w(Model\ specs spec/models) if File.exist?('spec/models')
+    ::STATS_DIRECTORIES << %w(View\ specs spec/views) if File.exist?('spec/views')
+    ::STATS_DIRECTORIES << %w(Controller\ specs spec/controllers) if File.exist?('spec/controllers')
+    ::STATS_DIRECTORIES << %w(ViewHelper\ specs spec/helpers) if File.exist?('spec/view_helpers')
+    ::STATS_DIRECTORIES << %w(Library\ specs spec/lib) if File.exist?('spec/lib')
+    ::CodeStatistics::TEST_TYPES << "Model specs" if File.exist?('spec/models')
+    ::CodeStatistics::TEST_TYPES << "View specs" if File.exist?('spec/views')
+    ::CodeStatistics::TEST_TYPES << "Controller specs" if File.exist?('spec/controllers')
+    ::CodeStatistics::TEST_TYPES << "ViewHelper specs" if File.exist?('spec/view_helpers')
+    ::CodeStatistics::TEST_TYPES << "Library specs" if File.exist?('spec/lib')
+    ::STATS_DIRECTORIES.delete_if {|a| a[0] =~ /test/}
+  end
+end

data/lib/rugui/tasks/spec_framework.rake

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+RUGUI_ROOT = File.join(File.expand_path(File.dirname(__FILE__)), '..', '..', '..')
+
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"#{RUGUI_ROOT}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Print Specdoc for all specs"
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.spec_opts = ["--format", "specdoc", "--dry-run"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  # Setup specs for stats
+  task :statsetup do
+    require 'code_statistics'
+    ::STATS_DIRECTORIES << %w(RuGUI\ specs) if File.exist?('spec')
+    ::CodeStatistics::TEST_TYPES << "RuGUI specs" if File.exist?('spec')
+  end
+end

data/lib/rugui/tasks/test_application.rake

@@ -0,0 +1,77 @@
+TEST_CHANGES_SINCE = Time.now - 600
+
+# Look up tests for recently modified sources.
+def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
+  FileList[source_pattern].map do |path|
+    if File.mtime(path) > touched_since
+      tests = []
+      source_dir = File.dirname(path).split("/")
+      source_file = File.basename(path, '.rb')
+      
+      # Support subdirs in app/models and app/controllers
+      modified_test_path = source_dir.length > 2 ? "#{test_path}/" << source_dir[1..source_dir.length].join('/') : test_path
+
+      # For modified files in app/ run the tests for it. ex. /test/models/account_controller.rb
+      test = "#{modified_test_path}/#{source_file}_test.rb"
+      tests.push test if File.exist?(test)
+
+      # For modified files in app, run tests in subdirs too. ex. /test/functional/account/*_test.rb
+      test = "#{modified_test_path}/#{File.basename(path, '.rb').sub("_controller","")}"
+      FileList["#{test}/*_test.rb"].each { |f| tests.push f } if File.exist?(test)
+		
+      return tests
+
+    end
+  end.flatten.compact
+end
+
+desc 'Run all models, controllers and libs tests'
+task :test do
+  errors = %w(test:models test:controllers test:libs).collect do |task|
+    begin
+      Rake::Task[task].invoke
+      nil
+    rescue => e
+      task
+    end
+  end.compact
+  abort "Errors running #{errors.to_sentence}!" if errors.any?
+end
+
+namespace :test do
+
+  Rake::TestTask.new(:recent) do |t|
+    since = TEST_CHANGES_SINCE
+    touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
+      recent_tests('app/models/**/*.rb', 'test/models', since) +
+      recent_tests('app/controllers/**/*.rb', 'test/controllers', since) + 
+      recent_tests('lib/**/*.rb', 'test/libs', since)
+
+    t.libs << 'test'
+    t.verbose = true
+    t.test_files = touched.uniq
+  end
+  Rake::Task['test:recent'].comment = "Test recent changes"
+  
+  Rake::TestTask.new(:models) do |t|
+    t.libs << "test"
+    t.pattern = 'test/models/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:models'].comment = "Run the models tests in test/models"
+
+  Rake::TestTask.new(:controllers) do |t|
+    t.libs << "test"
+    t.pattern = 'test/controllers/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:controllers'].comment = "Run the controllers tests in test/unit"
+
+  Rake::TestTask.new(:libs) do |t|
+    t.libs << "test"
+    t.pattern = 'test/lib/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:libs'].comment = "Run the libs tests in test/unit"
+
+end

data/lib/rugui/vendor_gem_source_index.rb

@@ -0,0 +1,140 @@
+require 'rubygems'
+require 'yaml'
+
+module RuGUI
+
+  class VendorGemSourceIndex
+    # VendorGemSourceIndex acts as a proxy for the Gem source index, allowing
+    # gems to be loaded from vendor/gems. Rather than the standard gem repository format,
+    # vendor/gems contains unpacked gems, with YAML specifications in .specification in
+    # each gem directory.
+    include Enumerable
+
+    attr_reader :installed_source_index
+    attr_reader :vendor_source_index
+
+    @@silence_spec_warnings = false
+
+    def self.silence_spec_warnings
+      @@silence_spec_warnings
+    end
+
+    def self.silence_spec_warnings=(v)
+      @@silence_spec_warnings = v
+    end
+
+    def initialize(installed_index, vendor_dir=RuGUI::GemDependency.unpacked_path)
+      @installed_source_index = installed_index
+      @vendor_dir = vendor_dir
+      refresh!
+    end
+
+    def refresh!
+      # reload the installed gems
+      @installed_source_index.refresh!
+      vendor_gems = {}
+
+      # handle vendor RuGUI gems - they are identified by having loaded_from set to ""
+      # we add them manually to the list, so that other gems can find them via dependencies
+      Gem.loaded_specs.each do |n, s|
+        next unless s.loaded_from.empty?
+        vendor_gems[s.full_name] = s
+      end
+
+      # load specifications from vendor/gems
+      Dir[File.join(RuGUI::GemDependency.unpacked_path, '*')].each do |d|
+        dir_name = File.basename(d)
+        dir_version = version_for_dir(dir_name)
+        spec = load_specification(d)
+        if spec
+          if spec.full_name != dir_name
+            # mismatched directory name and gem spec - produced by 2.1.0-era unpack code
+            if dir_version
+              # fix the spec version - this is not optimal (spec.files may be wrong)
+              # but it's better than breaking apps. Complain to remind users to get correct specs.
+              # use ActiveSupport::Deprecation.warn, as the logger is not set yet
+              $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems has a mismatched specification file."+
+                           " Run 'rake gems:refresh_specs' to fix this.") unless @@silence_spec_warnings
+              spec.version = dir_version
+            else
+              $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems is not in a versioned directory"+
+                           "(should be #{spec.full_name}).") unless @@silence_spec_warnings
+              # continue, assume everything is OK
+            end
+          end
+        else
+          # no spec - produced by early-2008 unpack code
+          # emulate old behavior, and complain.
+          $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems has no specification file."+
+                       " Run 'rake gems:refresh_specs' to fix this.") unless @@silence_spec_warnings
+          if dir_version
+            spec = Gem::Specification.new
+            spec.version = dir_version
+            spec.require_paths = ['lib']
+            ext_path = File.join(d, 'ext')
+            spec.require_paths << 'ext' if File.exist?(ext_path)
+            spec.name = /^(.*)-[^-]+$/.match(dir_name)[1]
+            files = ['lib']
+            # set files to everything in lib/
+            files += Dir[File.join(d, 'lib', '*')].map { |v| v.gsub(/^#{d}\//, '') }
+            files += Dir[File.join(d, 'ext', '*')].map { |v| v.gsub(/^#{d}\//, '') } if ext_path
+            spec.files = files
+          else
+            $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems not in a versioned directory."+
+                         " Giving up.") unless @@silence_spec_warnings
+            next
+          end
+        end
+        spec.loaded_from = File.join(d, '.specification')
+        # finally, swap out full_gem_path
+        # it would be better to use a Gem::Specification subclass, but the YAML loads an explicit class
+        class << spec
+          def full_gem_path
+            path = File.join installation_path, full_name
+            return path if File.directory? path
+            File.join installation_path, original_name
+          end
+        end
+        vendor_gems[File.basename(d)] = spec
+      end
+      @vendor_source_index = Gem::SourceIndex.new(vendor_gems)
+    end
+
+    def version_for_dir(d)
+      matches = /-([^-]+)$/.match(d)
+      Gem::Version.new(matches[1]) if matches
+    end
+
+    def load_specification(gem_dir)
+      spec_file = File.join(gem_dir, '.specification')
+      YAML.load_file(spec_file) if File.exist?(spec_file)
+    end
+
+    def find_name(*args)
+      @installed_source_index.find_name(*args) + @vendor_source_index.find_name(*args)
+    end
+
+    def search(*args)
+      # look for vendor gems, and then installed gems - later elements take priority
+      @installed_source_index.search(*args) + @vendor_source_index.search(*args)
+    end
+
+    def each(&block)
+      @vendor_source_index.each(&block)
+      @installed_source_index.each(&block)
+    end
+
+    def add_spec(spec)
+      @vendor_source_index.add_spec spec
+    end
+
+    def remove_spec(spec)
+      @vendor_source_index.remove_spec spec
+    end
+
+    def size
+      @vendor_source_index.size + @installed_source_index.size
+    end
+
+  end
+end

data/lib/rugui/version.rb

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

data/lib/rugui.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'activesupport'
+
+module RuGUI
+  class << self
+    # The Configuration instance used to configure the RuGUI environment
+    def configuration
+      @@configuration
+    end
+
+    def configuration=(configuration)
+      @@configuration = configuration
+    end
+
+    def root
+      if defined?(APPLICATION_ROOT)
+        Pathname.new(File.expand_path(APPLICATION_ROOT))
+      else
+        nil
+      end
+    end
+  end
+end
+
+require 'rugui/configuration'
+require 'rugui/log_support'
+require 'rugui/plugin/loader'
+require 'rugui/framework_adapters/framework_adapter_support'
+require 'rugui/base_object'
+require 'rugui/observable_property_support'
+require 'rugui/property_observer'
+require 'rugui/initialize_hooks'
+require 'rugui/signal_support'
+require 'rugui/base_controller'
+require 'rugui/base_model'
+require 'rugui/base_view_helper'
+require 'rugui/base_view'

data/spec/framework/base_controller_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'helpers', 'controllers')
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'helpers', 'views')
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'helpers', 'models')
+
+describe RuGUI::BaseController do
+  before(:each) do
+    @controller = MyController.new
+  end
+  
+  describe "with view registering" do
+    it "should make the view available in a views hash and in an attribute" do
+      @controller.views[:my_view].should be_an_instance_of(MyView)
+      @controller.my_view.should be_an_instance_of(MyView)
+      @controller.views[:my_view].should == @controller.my_view
+    end
+  end
+  
+  describe "with model registering" do
+    it "should make the model available in a models hash and in an attribute" do
+      @controller.models[:my_model].should be_an_instance_of(MyModel)
+      @controller.my_model.should be_an_instance_of(MyModel)
+      @controller.models[:my_model].should == @controller.my_model
+    end
+    
+    it "should be notified using named observable property change calls" do
+      @controller.my_other_model_instance.my_property = 1
+      @controller.message.should == "Property my_property of named observable my_other_model_instance changed from  to 1."
+    end
+  end
+  
+  describe "with controller registering" do
+    it "should make the controller available in a controllers hash and in an attribute" do
+      @controller.controllers[:my_child_controller].should be_an_instance_of(MyChildController)
+      @controller.my_child_controller.should be_an_instance_of(MyChildController)
+      @controller.controllers[:my_child_controller].should == @controller.my_child_controller
+    end
+  end
+
+  describe "with initialization hooks" do
+    it "should call before initialize and after initialize methods" do
+      controller = MyController.new
+      controller.before_initialize_called?.should be_true
+      controller.after_initialize_called?.should be_true
+    end
+  end
+end

data/spec/framework/base_model_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'helpers', 'models')
+
+describe RuGUI::BaseModel do
+  describe "with initialization hooks" do
+    it "should call before initialize and after initialize methods" do
+      model = MyModel.new
+      model.before_initialize_called?.should be_true
+      model.after_initialize_called?.should be_true
+    end
+  end
+end

data/spec/framework/base_view_helper_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'helpers', 'view_helpers')
+
+describe RuGUI::BaseViewHelper do
+  describe "with initialization hooks" do
+    it "should call before initialize and after initialize methods" do
+      view_helper = MyViewHelper.new
+      view_helper.before_initialize_called?.should be_true
+      view_helper.after_initialize_called?.should be_true
+    end
+  end
+end