rucola 0.0.1 → 0.0.2

data/rucola_generators/document_model/templates/test_document_model_template.rb.erb

@@ -1,10 +1,23 @@
 require File.expand_path('../../test_helper', __FILE__)
 
-class Test<%= name.camel_case %> < Test::Unit::TestCase
-  
-  def test_<%= name.snake_case %>_initialization
-    <%= name.snake_case %> = <%= name.camel_case %>.alloc.init
-    assert_instance_of(<%= name.camel_case %>, <%= name.snake_case %>)
+describe '<%= name.camel_case %>' do
+  before do
+    @document = <%= name.camel_case %>.alloc.init
+  end
+
+  it "should initialize" do
+    @document.should.be.an.instance_of <%= name.camel_case %>
+    
+    # You can also test if your attributes were set correctly in #after_init.
+    # @document.some_attr.should == 'default'
   end
   
+  it "should do stuff when a document is opened" do
+    # Some example code of testing your #readFromFile_ofType method.
+    # The same goes for the alternative open/write methods.
+    #
+    # path = '/some/path/to/a/textfile.txt'
+    # File.expects(:read).with(path).returns('foo')
+    # @document.readFromFile_ofType(path, '????')
+  end
 end

data/rucola_generators/rucola_plugin/USAGE

@@ -0,0 +1,6 @@
+Description:
+
+Running this command will create the plugin structure and an init.rb in vendor/plugins/<name>. 
+
+You can specify -r if you prefer rspec to test/unit or test/spec. This will create a spec dir instead of a test dir.  
+  

data/rucola_generators/rucola_plugin/rucola_plugin_generator.rb

@@ -0,0 +1,63 @@
+require 'rucola/rucola_support'
+
+class RucolaPluginGenerator < RubiGen::Base
+  
+  default_options :author => nil
+  
+  attr_reader :name, :plugin_name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift.snake_case
+    @plugin_name = @name.camel_case
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      plugin_dir = "vendor/plugins/#{name}"
+      # Ensure appropriate folder(s) exists
+      m.directory plugin_dir
+      m.directory "#{plugin_dir}/generators"
+      m.directory "#{plugin_dir}/lib"
+      m.directory "#{plugin_dir}/tasks"
+      if @rspec
+        m.directory "#{plugin_dir}/spec"
+      else
+        m.directory "#{plugin_dir}/test"
+      end
+
+      # Create stubs
+      m.template "init.rb.erb",  "#{plugin_dir}/init.rb"
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a Rucola plugin in your apps vendor/plugins directory.
+
+!!! NOTE: Rucola is still very young, and we may (will probably) modify how plugins work.
+!!!       Please give feedback on the mailing list or in #ruby-osx on freenode
+
+USAGE: #{$0} #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      opts.on("-r", "--rspec", "Create spec directory rather than test") { |v| options[:rspec] = v }
+      # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      @rspec = options[:rspec]
+    end
+end

data/rucola_generators/rucola_plugin/templates/init.rb.erb

@@ -0,0 +1,25 @@
+require 'osx/cocoa'
+require 'rucola/plugin'
+
+module Rucola
+  class <%= plugin_name %> < Plugin
+    def before_boot
+    end
+    
+    def after_boot
+    end
+  
+    def before_process(initializer)
+    end
+    
+    def after_process(initializer)
+    end
+    
+    def after_launch
+    end
+  end
+  
+  class Configuration
+    # Add anything you need to the configuration here.
+  end
+end

data/rucola_generators/window_controller/templates/test_window_controller_template.rb.erb

@@ -1,10 +1,26 @@
 require File.expand_path('../../test_helper', __FILE__)
 
-class Test<%= name.camel_case %>Controller < Test::Unit::TestCase
-  
-  def test_<%= name.snake_case %>_controller_initialization
-    <%= name.snake_case %>_controller = <%= name.camel_case %>Controller.alloc.init
-    assert_instance_of(<%= name.camel_case %>Controller, <%= name.snake_case %>_controller)
+describe '<%= name.camel_case %>Controller' do
+  before do
+    @controller = <%= name.camel_case %>Controller.alloc.init
+    
+    # If this is a window controller belonging to a document model,
+    # then this will allow you to mock the document.
+    #
+    # @document = mock('Document')
+    # @controller.stubs(:document).returns(@document)
+  end
+
+  it "should initialize" do
+    @controller.should.be.an.instance_of <%= name.camel_case %>Controller
   end
   
+  it "should do stuff at awakeFromNib" do
+    # Some example code of testing your #awakeFromNib.
+    #
+    # @document.expects(:some_method).returns('foo')
+    # @controller.ib_outlet(:some_text_view).expects(:string=).with('foo')
+    
+    @controller.awakeFromNib
+  end
 end

data/rucola_generators/window_controller/window_controller_generator.rb

@@ -48,7 +48,7 @@ class WindowControllerGenerator < RubiGen::Base
   protected
     def banner
       <<-EOS
-Creates a ...
+Creates a window controller that inherits from NSWindowController.
 
 USAGE: #{$0} #{spec.name} name"
 EOS

data/test/test_document_model_generator.rb

@@ -25,14 +25,20 @@ class TestDocumentModelGenerator < Test::Unit::TestCase
   #   bare_setup - place this in setup method to create the APP_ROOT folder for each test
   #   bare_teardown - place this in teardown method to destroy the TMP_ROOT or APP_ROOT folder after each test
   
-  def test_generator_without_options
+  def test_generator_without_extension
+    name = "MyDocument"
+    proc { run_generator('document_model', [name], sources) }.should.raise RubiGen::UsageError
+  end
+  
+  def test_generator_with_correct_options
     name = "MyDocument"
     extension = 'mydocext'
     
     plist_mock = mock('Info Plist')
     OSX::NSDictionary.expects(:dictionaryWithContentsOfFile).returns(plist_mock)
     doc_types = []
-    plist_mock.expects(:[]).with('CFBundleDocumentTypes').returns(doc_types)
+    plist_mock.expects(:[]=).at_least_once.returns(doc_types)
+    plist_mock.expects(:[]).at_least_once.with('CFBundleDocumentTypes').returns(doc_types)
     plist_mock.expects(:writeToFile_atomically)
     
     run_generator('document_model', [name, extension], sources)

data/test/test_info_plist.rb

@@ -28,4 +28,8 @@ describe "Info" do
     @info_plist.data.expects(:writeToFile_atomically).with(@path, true)
     @info_plist.save
   end
+  
+  it "should be able to return the name of the application" do
+    @info_plist.app_name.should == 'MyApp'
+  end
 end

data/test/test_initializer.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'rucola/initializer'
+
+RUBYCOCOA_ROOT = Pathname.new('/MyApp')
+
+describe "Initializer's Class methods" do
+  # it "should load the plugins directly after loading the initializer file" do
+  #   Rucola::Initializer.expects(:load_plugins)
+  #   load 'rucola/initializer.rb'
+  # end
+  
+  it "should return the path to the plugins root directory" do
+    Rucola::Initializer.plugins_root.to_s.should == '/MyApp/vendor/plugins'
+  end
+  
+  it "should load any plugins by requiring their init.rb files" do
+    plugin_root_mock = mock('Plugin Root')
+    Rucola::Initializer.expects(:plugins_root).returns(plugin_root_mock)
+    plugin_root_mock.expects(:exist?).returns(true)
+    
+    dir_mock, file_mock = mock('Dir'), mock('File')
+    plugin_root_mock.expects(:children).returns([file_mock, dir_mock])
+    
+    file_mock.expects(:directory?).returns(false)
+    dir_mock.expects(:directory?).returns(true)
+    
+    init_rb_path = '/MyApp/vendor/plugins/Foo/init.rb'
+    dir_mock.expects(:+).with('init.rb').returns(init_rb_path)
+    Kernel.expects(:require).with(init_rb_path)
+    
+    Rucola::Initializer.load_plugins
+  end
+  
+  it "should run any before and after boot plugins around the call to do_boot" do
+    Rucola::Plugin.expects(:before_boot)
+    Rucola::Initializer.expects(:do_boot)
+    Rucola::Plugin.expects(:after_boot)
+    Rucola::Initializer.boot
+  end
+  
+  it "should perform the application's specific configuration and start the app" do
+    config_mock = mock('Configuration')
+    Rucola::Configuration.expects(:new).returns(config_mock)
+    initializer_mock = mock('Initializer')
+    Rucola::Initializer.expects(:new).with(config_mock).returns(initializer_mock)
+    initializer_mock.expects(:process)
+    Rucola::Initializer.expects(:start_app)
+    
+    Rucola::Initializer.run
+  end
+  
+  it "should yield the configuration instance for setup purposes (this is used in the environments)" do
+    config_mock = mock('Configuration')
+    Rucola::Configuration.expects(:new).returns(config_mock)
+    Rucola::Initializer.any_instance.expects(:process)
+    Rucola::Initializer.expects(:start_app)
+    
+    Rucola::Initializer.run do |config|
+      config.should.be config_mock
+    end
+  end
+  
+  it "should actually start the main app run loop" do
+    OSX.expects(:NSApplicationMain)
+    Rucola::Initializer.start_app
+  end
+  
+  it "should not start the main app run loop if the RUBYCOCOA_ENV is 'test'" do
+    ::RUBYCOCOA_ENV = 'test'
+    OSX.expects(:NSApplicationMain).times(0)
+    Rucola::Initializer.start_app
+  end
+  
+  it "should not start the main app run loop if ENV['DONT_START_RUBYCOCOA_APP'] has been set" do
+    ::RUBYCOCOA_ENV = 'release'
+    ENV['DONT_START_RUBYCOCOA_APP'] = 'true'
+    OSX.expects(:NSApplicationMain).times(0)
+    Rucola::Initializer.start_app
+  end
+end

data/test/test_nib.rb

@@ -34,6 +34,15 @@ describe 'Nib::Classes' do
     @nib.classes.last.to_ruby.should == { 'CLASS' => 'FooController', "LANGUAGE"=>"ObjC", "SUPERCLASS"=>"NSObject" }
   end
   
+  it "should be able to add a subclass of a specific class" do
+    before = @nib.classes.length
+    @nib.add_class('JoesController', 'MomsController')
+    @nib.classes.length.should.be before + 1
+    
+    @nib.classes.last.to_ruby.should == { 'CLASS' => 'JoesController', "LANGUAGE"=>"ObjC", "SUPERCLASS"=>"MomsController" }
+    
+  end
+  
   it "should be able to save the classes.nib" do
     Rucola::Nib.expects(:backup).with(@path)
     @nib.data.expects(:writeToFile_atomically).with(@path, true)

data/test/test_notifications.rb

@@ -1,14 +1,17 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
 class FooNotifiable < Rucola::RCController; end
-class BarNotifiable < Rucola::RCController; end
-class BazNotifiable < Rucola::RCController; end
-class BlaNotifiable < Rucola::RCController; end
-class FuNotifiable < Rucola::RCController; end
-class KungNotifiable < Rucola::RCController; end
 class Person < Rucola::RCController; end
+class Shipping < Rucola::RCController
+  notify :update_shipping, :when => :address_was_changed
+  def update_shipping(notification); end
+end
 
 describe 'Rucola::Notifications' do
+  after do
+    OSX::NSNotificationCenter.defaultCenter.removeObserver(@instance)
+  end
+  
   it "should handle notifications when included" do
     FooNotifiable.instance_variable_get(:@_registered_notifications).should.be.nil
     
@@ -26,50 +29,66 @@ describe 'Rucola::Notifications' do
   end
   
   it "should be able to handle the original string representations of the notifications" do
-    BarNotifiable.notify_on 'NSApplicationDidFinishLaunchingNotification' do |notification|
+    FooNotifiable.notify_on 'NSApplicationDidFinishLaunchingNotification' do |notification|
       app_finished_launching
     end
     
-    BarNotifiable.alloc.init.expects(:app_finished_launching)
+    @instance = FooNotifiable.alloc.init
+    @instance.expects(:app_finished_launching)
     OSX::NSNotificationCenter.defaultCenter.postNotificationName_object(OSX::NSApplicationDidFinishLaunchingNotification, self)
   end
   
   it "should also be able to handle the abbreviated symbol representation of a notification" do
-    BazNotifiable.notify_on :application_did_become_active do |notification|
+    FooNotifiable.notify_on :application_did_become_active do |notification|
       app_did_become_active
     end
     
-    BazNotifiable.alloc.init.expects(:app_did_become_active)
+    @instance = FooNotifiable.alloc.init
+    @instance.expects(:app_did_become_active)
     OSX::NSNotificationCenter.defaultCenter.postNotificationName_object(OSX::NSApplicationDidBecomeActiveNotification, self)
   end
   
-  it "should raise a NameError exception if the abbreviated notification wasn't found" do
-    lambda { BlaNotifiable.notify_on :does_not_exist do |notification|; end }.should.raise NameError
-  end
-  
   it "should also allow the user to define shortcuts" do
-    FuNotifiable.notification_prefix :win => :window
+    FooNotifiable.notification_prefix :win => :window
     
-    FuNotifiable.notify_on :win_did_become_key do |notification|
+    FooNotifiable.notify_on :win_did_become_key do |notification|
       window_did_become_key
     end
-  
-    FuNotifiable.alloc.init.expects(:window_did_become_key)
+    
+    @instance = FooNotifiable.alloc.init
+    @instance.expects(:window_did_become_key)
     OSX::NSNotificationCenter.defaultCenter.postNotificationName_object(OSX::NSWindowDidBecomeKeyNotification, self)
   end
   
   it "should by default have the shortcut app => application" do
-    KungNotifiable.notify_on :app_will_terminate do |notification|
+    FooNotifiable.notify_on :app_will_terminate do |notification|
       app_will_terminate_called!
     end
     
-    KungNotifiable.alloc.init.expects(:app_will_terminate_called!)
+    @instance = FooNotifiable.alloc.init
+    @instance.expects(:app_will_terminate_called!)
     OSX::NSNotificationCenter.defaultCenter.postNotificationName_object(OSX::NSApplicationWillTerminateNotification, self)
   end
   
+  it "should also work with `once` instead of `notify_on`" do
+    FooNotifiable.once :app_did_become_active do |notification|
+      app_did_become_active!
+    end
+    
+    @instance = FooNotifiable.alloc.init
+    @instance.expects(:app_did_become_active!)
+    OSX::NSNotificationCenter.defaultCenter.postNotificationName_object(OSX::NSApplicationDidBecomeActiveNotification, self)
+  end
+  
   it "should call a given method when a certain notification is called" do
     Person.notify :method_to_notify, :when => 'MyNotification'
     Person.alloc.init.expects(:method_to_notify)
     OSX::NSNotificationCenter.defaultCenter.postNotificationName_object("MyNotification", nil)
   end
+  
+  it "should fire notifications" do
+    shipping = Shipping.alloc.init
+    shipping.expects(:update_shipping)
+    Shipping.fire_notification(:address_was_changed, nil)
+  end
 end

data/test/test_plugin.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'rucola/plugin'
+
+include Rucola
+
+class FooPlugin < Rucola::Plugin
+end
+
+describe 'Plugin' do
+  before do
+    @plugin = Rucola::Plugin.plugins.first
+    @initializer_mock = mock('Initializer')
+  end
+  
+  it "contains list of plugin subclasses" do
+    Rucola::Plugin.plugins.map { |p| p.class }.should == [FooPlugin]
+  end
+  
+  it "should run before boot plugins" do
+    @plugin.expects(:before_boot)
+    Rucola::Plugin.before_boot
+  end
+  
+  it "should run after boot plugins" do
+    @plugin.expects(:after_boot)
+    Rucola::Plugin.after_boot
+  end
+  
+  it "should run before process plugins" do
+    @plugin.expects(:before_process).with(@initializer_mock)
+    Rucola::Plugin.before_process(@initializer_mock)
+  end
+  
+  it "should run after process plugins" do
+    @plugin.expects(:after_process).with(@initializer_mock)
+    Rucola::Plugin.after_process(@initializer_mock)
+  end
+  
+  it "should be able to run after launch plugins" do
+    @plugin.expects(:after_launch)
+    Rucola::Plugin.after_launch
+  end
+  
+  it "should run after launch plugins when the app has started" do
+    @plugin.expects(:after_launch)
+    OSX::NSNotificationCenter.defaultCenter.postNotificationName_object(OSX::NSApplicationDidFinishLaunchingNotification, self)
+  end
+end