rucola 0.0.3 → 0.5.0

data/test/test_fsevents.rb

@@ -0,0 +1,152 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'rucola/fsevents'
+
+describe "FSEvents initialization" do
+  before do
+    @path = File.dirname(__FILE__)
+    @paths = [@path]
+  end
+
+  it "should raise an ArgumentError if a non existing path is specified" do
+    lambda { Rucola::FSEvents.new('/non/existing/path') {|events| 'nothing' } }.should.raise ArgumentError
+  end
+  
+  it "should raise an ArgumentError if no block was passed" do
+    lambda { Rucola::FSEvents.new(@paths) }.should.raise ArgumentError
+  end
+  
+  it "should take at minimum an array of paths and a block" do
+    fsevents = Rucola::FSEvents.new(@paths) { |events| 'nothing' }
+    fsevents.should.be.an.instance_of Rucola::FSEvents
+    fsevents.paths.first.should.be @path
+  end
+  
+  it "should have some default values" do
+    fsevents = Rucola::FSEvents.new(@paths) { |events| 'nothing' }
+    fsevents.allocator.should.be OSX::KCFAllocatorDefault
+    fsevents.context.should.be nil
+    fsevents.since.should.be OSX::KFSEventStreamEventIdSinceNow
+    fsevents.latency.should == 0.0
+    fsevents.flags.should == 0
+    fsevents.stream.should.be nil
+  end
+
+  it "should be possible to create and start a stream with one call" do
+    fsevents = mock('FSEvents')
+    Rucola::FSEvents.expects(:new).with(@paths).returns(fsevents)
+    fsevents.expects(:create_stream)
+    fsevents.expects(:start)
+    
+    result = Rucola::FSEvents.start_watching(@path) {|events| 'nothing' }
+    result.should.be(fsevents)
+  end
+  
+  it "should accept options to tweak event parameters" do
+    fsevents = Rucola::FSEvents.new(@paths,
+      :latency => 5.2,
+      :since => 24051980
+    ) { |events| 'nothing' }
+    fsevents.since.should.be 24051980
+    fsevents.latency.should == 5.2
+  end
+end
+
+describe "FSEvents when setting up the stream" do
+  before do
+    @path = File.dirname(__FILE__)
+    @paths = [@path]
+    @fsevents = Rucola::FSEvents.new(@paths) { |events| 'nothing' }
+  end
+  
+  it "should create a real FSEvents stream" do
+    @fsevents.create_stream
+    @fsevents.stream.should.be.an.instance_of OSX::ConstFSEventStreamRef
+  end
+  
+  it "should raise a Rucola::FSEvents::StreamError if the stream could not be created" do
+    OSX.expects(:FSEventStreamCreate).returns(nil)
+    lambda { @fsevents.create_stream }.should.raise Rucola::FSEvents::StreamError
+  end
+  
+  it "should register the stream with the current runloop" do
+    stream_mock = mock('Stream')
+    OSX.expects(:FSEventStreamCreate).returns(stream_mock)
+    runloop_mock = mock('Runloop')
+    OSX.expects(:CFRunLoopGetCurrent).returns(runloop_mock)
+    OSX.expects(:FSEventStreamScheduleWithRunLoop).with(stream_mock, runloop_mock, OSX::KCFRunLoopDefaultMode)
+    @fsevents.create_stream
+  end
+  
+  it "should start the stream" do
+    stream_mock = mock('Stream')
+    @fsevents.instance_variable_set(:@stream, stream_mock)
+    OSX.expects(:FSEventStreamStart).with(stream_mock).returns(true)
+    @fsevents.start
+  end
+  
+  it "should raise a Rucola::FSEvents::StreamError if the stream could not be started" do
+    OSX.expects(:FSEventStreamStart).returns(false)
+    lambda { @fsevents.start }.should.raise Rucola::FSEvents::StreamError
+  end
+end
+
+describe "FSEvents when started the stream" do
+  before do
+    @paths = [TMP_PATH]
+  end
+  
+  def touch_file
+    sleep 0.25
+    `touch #{@paths.first}/test.txt`
+    sleep 1.5
+    `rm #{@paths.first}/test.txt`
+  end
+  
+  def start(fsevents)
+    fsevents.create_stream
+    fsevents.start
+    Thread.new { OSX.CFRunLoopRun }
+  end
+  
+  xit "should run the user specified block when one of the paths that was specified is modified" do
+    some_mock = mock
+    some_mock.expects(:call!)
+    
+    fsevents = Rucola::FSEvents.new(@paths) do |events|
+      some_mock.call!
+      
+      events.length.should == 1
+      event = events.first
+      event.should.be.an.instance_of Rucola::FSEvents::FSEvent
+      event.path.should == @paths.first
+    end
+    p fsevents
+    start(fsevents)
+    touch_file
+    fsevents.stop
+  end
+end
+
+describe "FSEvent" do
+  before do
+    @tmp_path = TMP_PATH
+    @new_file, @old_file = "#{@tmp_path}/new_file", "#{@tmp_path}/old_file"
+
+    `touch #{@old_file}`
+    sleep 1
+    `touch #{@new_file}`
+  end
+
+  after do
+    `rm #{@old_file}`
+    `rm #{@new_file}`
+  end
+  
+  it "should return an array of file entries in the path that the event occurred in, sorted by modification time (first element = last mod.)" do
+    Rucola::FSEvents::FSEvent.new(nil, 666, @tmp_path).files.should == [@new_file, @old_file]
+  end
+  
+  it "should return the last modified file" do
+    Rucola::FSEvents::FSEvent.new(nil, 999, @tmp_path).last_modified_file.should == @new_file
+  end
+end

data/test/test_helper.rb

@@ -4,10 +4,39 @@ require "test/spec"
 require "mocha"
 require 'osx/cocoa'
 
+# suppress all the warnings about contsants being re-initialized when re-requiring the same lib
+$VERBOSE = nil
+
 $:.unshift File.expand_path('../../lib', __FILE__)
 
 FIXTURES = File.expand_path('../fixtures/', __FILE__)
 $TESTING = true
 
+require 'pathname'
+RUBYCOCOA_ROOT = Pathname.new(File.expand_path(File.dirname(__FILE__)))
+RUBYCOCOA_ENV = 'test'
+TMP_PATH = File.expand_path('../../tmp/', __FILE__)
+
 require 'rucola/rucola_support'
-require 'rucola/test_helper'
+require 'rucola/test_helper'
+
+# Don't know if this is good enough yet to add to the helpers for apps.
+# Need to see what assert_difference does.
+module Test::Spec::Rucola
+  module ShouldChange
+    def change(string, difference = 1, obj = nil)
+      initial_value = (obj.nil? ? eval(string) : obj.instance_eval(string))
+      @object.call
+      (obj.nil? ? eval(string) : obj.instance_eval(string)).should == initial_value + difference
+    end
+  end
+  module ShouldNotChange
+    def change(string, obj = nil)
+      initial_value = (obj.nil? ? eval(string) : obj.instance_eval(string))
+      @object.call
+      (obj.nil? ? eval(string) : obj.instance_eval(string)).should == initial_value
+    end
+  end
+end
+Test::Spec::Should.send(:include, Test::Spec::Rucola::ShouldChange)
+Test::Spec::ShouldNot.send(:include, Test::Spec::Rucola::ShouldNotChange)

data/test/test_initializer.rb

@@ -3,12 +3,18 @@ require 'rucola/initializer'
 
 RUBYCOCOA_ROOT = Pathname.new('/MyApp')
 
+module Rucola::Reloader; end
+
 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
   
+  after do
+    Rucola::Initializer.instance_variable_set(:@initializer, nil)
+  end
+  
   it "should return the path to the plugins root directory" do
     Rucola::Initializer.plugins_root.to_s.should == '/MyApp/vendor/plugins'
   end
@@ -18,15 +24,17 @@ describe "Initializer's Class methods" do
     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])
+    dir_with_initrb_mock, dir_without_initrb_mock = mock('Dir'), mock('Dir without init.irb')
+    plugin_root_mock.expects(:children).returns([dir_with_initrb_mock, dir_without_initrb_mock])
     
-    file_mock.expects(:directory?).returns(false)
-    dir_mock.expects(:directory?).returns(true)
+    initrb_for_dir_with_initrb_mock = mock('init.rb does exist')
+    dir_with_initrb_mock.expects(:+).with('init.rb').returns(initrb_for_dir_with_initrb_mock)
+    initrb_for_dir_with_initrb_mock.expects(:exist?).returns(true)
+    Kernel.expects(:require).with(initrb_for_dir_with_initrb_mock)
     
-    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)
+    initrb_for_dir_without_initrb_mock = mock('init.rb does not exist')
+    dir_without_initrb_mock.expects(:+).with('init.rb').returns(initrb_for_dir_without_initrb_mock)
+    initrb_for_dir_without_initrb_mock.expects(:exist?).returns(false)
     
     Rucola::Initializer.load_plugins
   end
@@ -39,10 +47,8 @@ describe "Initializer's Class methods" do
   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)
+    Rucola::Initializer.expects(:new).returns(initializer_mock)
     initializer_mock.expects(:process)
     Rucola::Initializer.expects(:start_app)
     
@@ -50,31 +56,58 @@ describe "Initializer's Class methods" do
   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.any_instance.stubs(:process)
     
     Rucola::Initializer.run do |config|
-      config.should.be config_mock
+      config.should.be.instance_of Rucola::Configuration
+      
+      Rucola::Initializer.run do |same_config|
+        same_config.should.be config
+      end
     end
   end
   
   it "should actually start the main app run loop" do
-    OSX.expects(:NSApplicationMain)
-    Rucola::Initializer.start_app
+    with_env('release') { should_start_app(1) }
   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
+    with_env('test') { should_start_app(0) }
   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)
+    should_start_app(0)
+    ENV['DONT_START_RUBYCOCOA_APP'] = nil
+  end
+  
+  private
+  
+  def should_start_app(times = 0)
+    OSX.expects(:NSApplicationMain).times(times)
     Rucola::Initializer.start_app
   end
-end
+end
+
+describe "Initializer's instance methods" do
+  
+  it "should not start the Reloader if that's set in the config" do
+    initializer = Rucola::Initializer.new
+    initializer.configuration.use_reloader = false
+    
+    Kernel.expects(:require).times(0)
+    Rucola::Reloader.expects(:start!).times(0)
+    initializer.use_reloader!
+  end
+  
+  it "should start the Reloader if that's set in the config" do
+    initializer = Rucola::Initializer.new
+    initializer.configuration.use_reloader = true
+    
+    Kernel.expects(:require).with('rucola/reloader')
+    Rucola::Reloader.expects(:start!)
+    initializer.use_reloader!
+  end
+end
+
+# TODO: test dependencies.

data/test/test_log.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'rucola/log'
+
+describe "Log" do
+  it "should be a singleton class" do
+    Rucola::Log.instance.object_id.should == Rucola::Log.instance.object_id
+  end
+end
+
+describe "A Log instance" do
+  class LogCall < Exception; end
+  
+  before do
+    @log = Rucola::Log.instance
+    OSX.stubs(:NSLog).raises(LogCall)
+  end
+  
+  after do
+    @log.level = @log.level_for_env
+  end
+  
+  it "should return the default level for a certain env" do
+    with_env('test') { @log.level_for_env.should == Rucola::Log::SILENT }
+    with_env('debug') { @log.level_for_env.should == Rucola::Log::DEBUG }
+    with_env('release') { @log.level_for_env.should == Rucola::Log::ERROR }
+  end
+  
+  it "should only log messages of the right level" do
+    @log.level = Rucola::Log::SILENT
+    lambda { @log.debug('-') }.should.not.raise(LogCall)
+    lambda { @log.error('-') }.should.not.raise(LogCall)
+    @log.level = Rucola::Log::DEBUG
+    lambda { @log.debug('-') }.should.raise(LogCall)
+    lambda { @log.error('-') }.should.raise(LogCall)
+    @log.level = Rucola::Log::ERROR
+    lambda { @log.debug('-') }.should.not.raise(LogCall)
+    lambda { @log.error('-') }.should.raise(LogCall)
+  end
+  
+  it "should allow a change of log level" do
+    @log.level = Rucola::Log::DEBUG
+    @log.level.should == Rucola::Log::DEBUG
+  end
+end

data/test/test_objc_core_ext.rb

@@ -34,4 +34,27 @@ describe "NSObject default mixins" do
   it "should not mixin the initialize hooks if it's a subclass of a class that starts with anything else but 'Rucola::RC'" do
     NotSubClassOfRC.methods.should.not.include '_rucola_register_initialize_hook'
   end
+end
+
+describe "NSImage.imageNamed" do
+  before do
+    @image1 = File.join(Rucola::RCApp.assets_path, 'hot_babe.jpg')
+    @image2 = File.join(Rucola::RCApp.assets_path, 'not_so_hot_babe.png')
+    Dir.stubs(:glob).with("#{Rucola::RCApp.assets_path}/*.*").returns(['.', '..', @image2, @image1])
+  end
+  
+  it "should find images without in app/assets" do
+    OSX::NSImage.any_instance.expects(:initWithContentsOfFile).with(@image1)
+    OSX::NSImage.imageNamed('hot_babe')
+  end
+  
+  it "should find images with extension in app/assets" do
+    OSX::NSImage.any_instance.expects(:initWithContentsOfFile).with(@image2)
+    OSX::NSImage.imageNamed('not_so_hot_babe.png')
+  end
+  
+  it "should pass any unfound image name on to the original implementation" do
+    OSX::NSImage.expects(:super_imageNamed).with('whateva')
+    OSX::NSImage.imageNamed('whateva')
+  end
 end

data/test/test_rc_app.rb

@@ -45,6 +45,11 @@ describe 'Rucola::RCApp' do
     RCApp.path_for_model(Person).should == "#{@root_path}/app/models/person.rb"
   end
   
+  it "should return the path to this applications app support dir" do
+    RCApp.stubs(:app_name).returns('FooApp')
+    RCApp.application_support_path.should == File.expand_path('~/Library/Application Support/FooApp')
+  end
+  
   it "should return the path for a given view" do
     view_path = "#{@root_path}/app/views/Preferences.nib"
     RCApp.path_for_view('Preferences').should == view_path

data/test/test_reloader.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'rucola/reloader'
+
+class SomeReloadableClass
+  def self.a_original_class_method; end
+  def a_original_instance_method; end
+end
+
+describe "Reloader" do
+  it "should be able to reload a file/class" do
+    SomeReloadableClass.instance_methods(false).should == ['a_original_instance_method']
+    SomeReloadableClass.own_class_methods.should == ['a_original_class_method']
+    
+    Rucola::Reloader.reload("#{FIXTURES}/some_reloadable_class.rb")
+    
+    SomeReloadableClass.instance_methods(false).should == ['a_new_instance_method']
+    SomeReloadableClass.own_class_methods.should == ['a_new_class_method']
+  end
+  
+  it "should start watching app/controllers and reload a file if it has been modified" do
+    file = '/some/path/some_controller.rb'
+    event = mock('FSEvent')
+    event.expects(:last_modified_file).returns(file)
+    Rucola::FSEvents.expects(:start_watching).with(Rucola::RCApp.controllers_path, Rucola::RCApp.models_path).yields([event])
+    Rucola::Reloader.expects(:reload).with(file)
+    Rucola::Reloader.start!
+  end
+end

data/test/test_rucola_generator.rb

@@ -39,16 +39,21 @@ class TestRucolaGenerator < Test::Unit::TestCase
     assert_directory_exists "app/controllers"
     assert_directory_exists "app/models"
     assert_directory_exists "app/views"
+    assert_directory_exists "app/assets"
+    
     assert_directory_exists "config/environments"
     assert_directory_exists "misc/English.lproj/MainMenu.nib"
     assert_directory_exists "test/controllers"
+    assert_directory_exists "test/lib"
     assert_directory_exists "test/models"
+    assert_directory_exists "lib"
     assert_directory_exists "vendor"
 
     assert_generated_file   "Rakefile"
     
     assert_generated_file   "app/controllers/application_controller.rb"
     assert_generated_file   "config/boot.rb"
+    assert_generated_file   "config/dependencies.rb"
     assert_generated_file   "config/environment.rb"
     assert_generated_file   "config/environments/debug.rb"
     assert_generated_file   "config/environments/release.rb"
@@ -71,7 +76,9 @@ class TestRucolaGenerator < Test::Unit::TestCase
     assert_generated_file   "test/controllers/test_application_controller.rb"
     
     assert_directory_exists "script"
+    assert_generated_file   "script/console"
     assert_generated_file   "script/plugin"
+    assert `ls -l #{File.expand_path('../tmp/myproject/script/console', __FILE__)}`[0..9] == '-rwxr-xr-x'
     assert `ls -l #{File.expand_path('../tmp/myproject/script/plugin', __FILE__)}`[0..9] == '-rwxr-xr-x'
   end