rucola 0.0.3 → 0.5.0

data/lib/rucola/version.rb

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

data/lib/rucola/xcode.rb

@@ -2,9 +2,7 @@ require 'osx/cocoa'
 require 'pathname'
 
 module Rucola
-  class Xcode
-    # FIXME: We should probably generate random id keys!
-    
+  class Xcode #:nodoc:
     attr_reader :project
     attr_reader :project_path
     attr_reader :project_data
@@ -86,7 +84,41 @@ module Rucola
       build_phase['files'].push(object_id) unless build_phase['files'].include?(object_id)
     end
     
-    NEW_COPY_FRAMEWORKS_BUILD_PHASE = ['519A79DB0CC8AE6B00CBE85D', {
+    # Returns an array of framework objects that are in the project.
+    def frameworks
+      objects.select {|obj| obj.last['name'].include?('framework') unless obj.last['name'].nil? }
+    end
+    
+    # Adds a framework to a project.
+    # Returns [framework_obj, fileref_obj].
+    def add_framework(name, path)
+      source_tree = path[0, 1] == '/' ? '<absolute>' : '<group>'
+      framework_obj = [generate_object_id, { 'isa' => 'PBXFileReference', 'lastKnownFileType' => 'wrapper.framework', 'name' => name, 'path' => path, 'sourceTree' => source_tree }.to_ns]
+      add_object(*framework_obj)
+      
+      fileref_obj = [generate_object_id, { 'fileRef' => framework_obj.first, 'isa' => 'PBXBuildFile'}.to_ns]
+      add_object(*fileref_obj)
+      
+      linked_frameworks_group = object_for_name('Linked Frameworks')
+      linked_frameworks_group.last['children'].push(framework_obj.first)
+      
+      [framework_obj, fileref_obj]
+    end
+    
+    def generate_uuid
+      ("%04x%04x%04x%04x%04x%04x" % [rand(0x0010000),rand(0x0010000),rand(0x0010000),rand(0x0010000),rand(0x0010000),rand(0x0010000)]).upcase
+    end
+    
+    # Makes sure that an unique object UUID is returned
+    def generate_object_id
+      uuids = objects.keys
+      begin
+       uuid = generate_uuid
+      end while uuids.include?(uuid)
+      uuid
+    end
+    
+    NEW_COPY_FRAMEWORKS_BUILD_PHASE = {
       'name' => 'Copy Frameworks',
       'isa' => 'PBXCopyFilesBuildPhase',
       'buildActionMask' => '2147483647',
@@ -94,14 +126,12 @@ module Rucola
       'dstSubfolderSpec' => 10, # TODO: is 10 the number for the location popup choice: Frameworks
       'runOnlyForDeploymentPostprocessing' => 0,
       'files' => [].to_ns
-    }]
+    }
     # Creates a new framework copy build phase.
     # It does not add it to the objects nor the build phases,
     # do this with +add_object+ and +add_build_phase_to_project_target+.
-    #
-    # FIXME: Need to generate the id's instead of static.
     def new_framework_copy_build_phase
-      NEW_COPY_FRAMEWORKS_BUILD_PHASE
+      [generate_object_id, NEW_COPY_FRAMEWORKS_BUILD_PHASE]
     end
     
     # Changes the path of the framework +framework_name+ to the path +new_path_to_framework+.
@@ -121,7 +151,7 @@ module Rucola
       framework_id, framework_values = object_for_name(framework_name)
       
       # create a new file wrapper for in the copy build phase
-      framework_in_build_phase_id = '511E98590CC8C5940003DED9'
+      framework_in_build_phase_id = generate_object_id
       framework_in_build_phase_values = {
         'isa' => 'PBXBuildFile',
         'fileRef' => framework_id

data/rucola_generators/controller/templates/test_controller_template.rb.erb

@@ -1,19 +1,31 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 describe '<%= name.camel_case %>Controller' do
-  before do
-    @controller = <%= name.camel_case %>Controller.alloc.init
-  end
-
+  tests <%= name.camel_case %>Controller
+  
+  # If necessary, you can setup custom objects for the ib_outlets defined in the class.
+  # Note however that by using 'tests <%= name.camel_case %>Controller' all the outlets will get stubbed
+  # with stubs that respond to every message with nil.
+  #
+  # def after_setup
+  #   ib_outlets :window => mock("Main Window"),
+  #              :tableView => OSX::NSTableView.alloc.init,
+  #              :searchField => OSX::NSSearchField.alloc.init
+  # 
+  #   window.stubs(:title => 'Main Window')
+  #   tableView.addTableColumn OSX::NSTableColumn.alloc.init
+  #   searchField.stringValue = "foo"
+  # end
+  
   it "should initialize" do
-    @controller.should.be.an.instance_of <%= name.camel_case %>Controller
+    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.
     #
-    # @controller.ib_outlet(:some_text_view).expects(:string=).with('foo')
+    # controller.ib_outlet(:some_text_view).expects(:string=).with('foo')
     
-    @controller.awakeFromNib
+    controller.awakeFromNib
   end
 end

data/rucola_generators/simple_model/USAGE

@@ -0,0 +1,5 @@
+Description:
+  Generates a model which is simply a subclass of OSX::NSObject.
+  
+Usage:
+  script/generate simple_model foo_bar

data/rucola_generators/simple_model/simple_model_generator.rb

@@ -0,0 +1,54 @@
+require 'rucola/rucola_support'
+
+class SimpleModelGenerator < RubiGen::Base
+  
+  default_options :author => nil
+  
+  attr_reader :name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory 'app/models'
+      m.directory 'test/models'
+
+      # Create stubs
+      m.template "simple_model.rb.erb",  "app/models/#{@name.snake_case}.rb"
+      m.template "test_simple_model.rb.erb",  "test/models/test_#{@name.snake_case}.rb"
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a model that inherits from NSObject.
+
+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("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      # 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.
+      # @author = options[:author]
+    end
+end

data/rucola_generators/simple_model/templates/simple_model.rb.erb

@@ -0,0 +1,2 @@
+class <%= name.camel_case %> < OSX::NSObject
+end

data/rucola_generators/simple_model/templates/test_simple_model.rb.erb

@@ -0,0 +1,11 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe '<%= name.camel_case %>' do
+  before do
+    @model = <%= name.camel_case %>.alloc.init
+  end
+
+  it "should initialize" do
+    @model.should.be.an.instance_of <%= name.camel_case %>
+  end
+end

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

@@ -1,26 +1,37 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 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
-
+  tests <%= name.camel_case %>Controller
+  
+  # If necessary, you can setup custom objects for the ib_outlets defined in the class.
+  # Note however that by using 'tests <%= name.camel_case %>Controller' all the outlets will get stubbed
+  # with stubs that respond to every message with nil.
+  #
+  # def after_setup
+  #   ib_outlets :window => mock("Main Window"),
+  #              :tableView => OSX::NSTableView.alloc.init,
+  #              :searchField => OSX::NSSearchField.alloc.init
+  # 
+  #   window.stubs(:title => 'Main Window')
+  #   tableView.addTableColumn OSX::NSTableColumn.alloc.init
+  #   searchField.stringValue = "foo"
+  #
+  #   # If this is a window controller belonging to a document model,
+  #   # then this will allow you to mock the document.
+  #   # 
+  #   # @document = mock('Document')
+  # end
+  
   it "should initialize" do
-    @controller.should.be.an.instance_of <%= name.camel_case %>Controller
+    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.ib_outlet(:some_text_view).expects(:string=).with('foo')
     
-    @controller.awakeFromNib
+    controller.awakeFromNib
   end
 end

data/test/fixtures/dependencies/foo.rb

@@ -0,0 +1,2 @@
+require 'foo/bar'
+require File.expand_path('../foo/baz.rb', __FILE__)

data/test/fixtures/dependencies/requires_fileutils.rb

@@ -0,0 +1 @@
+require 'fileutils'

data/test/fixtures/some_reloadable_class.rb

@@ -0,0 +1,4 @@
+class SomeReloadableClass
+  def self.a_new_class_method; end
+  def a_new_instance_method; end
+end

data/test/test_core_ext.rb

@@ -1,5 +1,51 @@
 require File.dirname(__FILE__) + '/test_helper'
 
+class FooBar
+  def self.a_original_class_method
+  end
+end
+
+module Baz
+  def a_new_class_method; end
+end
+FooBar.extend(Baz)
+
+class FooBarSubclass < FooBar
+  def self.a_original_class_method_in_a_subclass
+  end
+end
+
+# Object ext. specs
+
+describe "Object: class methods" do
+  it "should return the metaclass of a class" do
+    class << FooBar
+      self.should.be FooBar.metaclass
+    end
+  end
+  
+  it "should return an array of class methods that have been added by extending the class" do
+    FooBar.extended_class_methods.should.include 'a_new_class_method'
+    FooBar.extended_class_methods.should.not.include 'a_original_class_method'
+  end
+  
+  it "should return an array of all the class methods that were defined in this class without the ones that were defined in superclasses" do
+    FooBarSubclass.own_class_methods.should.include 'a_original_class_method_in_a_subclass'
+    FooBarSubclass.own_class_methods.should.not.include 'a_original_class_method'
+  end
+  
+  it "should return an array of all the class methods that were defined in only this class, so not from it's superclasses or from extending" do
+    FooBar.original_class_methods.should.include 'a_original_class_method'
+    FooBar.original_class_methods.should.not.include 'a_new_class_method'
+    
+    FooBarSubclass.original_class_methods.should.include 'a_original_class_method_in_a_subclass'
+    FooBarSubclass.original_class_methods.should.not.include 'a_original_class_method'
+    FooBarSubclass.original_class_methods.should.not.include 'a_new_class_method'
+  end
+end
+
+# String ext. specs
+
 describe 'String#camel_case' do
   it "should return foo_bar as FooBar" do
     "foo_bar".camel_case.should == 'FooBar'
@@ -13,3 +59,37 @@ describe 'String#camel_case' do
     'foo'.camel_case.should == 'Foo'
   end
 end
+
+describe "String#to_const" do
+  it "should return the constant FooBar for string 'foo_bar'" do
+    "foo_bar".to_const.should.be FooBar
+  end
+  
+  it "should return the constant FooBar for string 'FooBar'" do
+    "FooBar".to_const.should.be FooBar
+  end
+end
+
+# File ext. specs
+
+describe "File.to_const" do
+  it "should return the constant FooBar for file '/some/path/foo_bar.rb'" do
+    File.to_const('/some/path/foo_bar.rb').should.be FooBar
+  end
+  
+  it "should return the constant FooBar for file 'foo_bar.rb'" do
+    File.to_const('foo_bar.rb').should.be FooBar
+  end
+end
+
+# Kernel ext. specs
+
+describe "Kernel.logger" do
+  it "should return a Rucola Log class instance" do
+    Kernel.log.kind_of?(Rucola::Log).should == true
+  end
+  
+  it "should return the same logger instance on multiple calls" do
+    Kernel.log.object_id.should == Kernel.log.object_id
+  end
+end

data/test/test_dependencies.rb

@@ -0,0 +1,205 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'rucola/dependencies'
+
+Rucola::Dependencies.verbose = false
+$LOAD_PATH.unshift(File.join(FIXTURES, 'dependencies/'))
+
+module DependenciesSpecHelper
+  def self.included(klass)
+    klass.class_eval do
+      after do
+        @dep = nil
+        FileUtils.rm_rf(copied_deps_path)
+      end
+    end
+  end
+  
+  private
+  
+  def deps_path(file = '')
+    File.join(FIXTURES, 'dependencies', file)
+  end
+  
+  def copied_deps_path(file = '')
+    File.join(TMP_PATH, 'copied_dependencies', file)
+  end
+  
+  def stubbed_equal_required_files
+    klass = Rucola::Dependencies::RequiredFile
+    klass.any_instance.stubs(:resolve_relative_and_full_path).returns(['path/foo.rb', '/full/path/foo.rb'])
+    [klass.new(''), klass.new('')]
+  end
+end
+
+describe "Dependencies::Dependency" do
+  include DependenciesSpecHelper
+  
+  before do
+    @dep = Rucola::Dependencies::Dependency.new('foo')
+  end
+  
+  after do
+    @dep = nil
+    FileUtils.rm_rf(copied_deps_path)
+  end
+  
+  it "should initialize" do
+    @dep.should.be.instance_of Rucola::Dependencies::Dependency
+    @dep.name.should == 'foo'
+  end
+  
+  it "should be able to require it" do
+    Kernel.expects(:require).with('foo')
+    @dep.require!
+  end
+  
+  it "should activate a specific gem if a version is specified" do
+    Kernel.stubs(:require)
+    @dep.instance_variable_set(:@version, '1.1.1')
+    Gem.expects(:activate).with('foo', '1.1.1')
+    @dep.require!
+  end
+  
+  it "should be able to resolve the files it needs" do
+    lambda { @dep.resolve! }.should.not.change('$LOADED_FEATURES.dup')
+    required_files = @dep.required_files.map {|f| f.full_path }.sort
+    required_files.should == [deps_path('foo.rb'), deps_path('foo/bar.rb'), deps_path('foo/baz.rb')]
+  end
+  
+  # FIXME: For some reason running this in the complete test suite will fail.
+  # But in practice or by only running this test it works :/
+  xit "should be able to copy to the specified destination path" do
+    @dep.resolve!
+    @dep.copy_to(copied_deps_path)
+    %w{ foo.rb foo/bar.rb foo/baz.rb }.each do |file|
+      File.exist?(copied_deps_path(file)).should.be true
+    end
+  end
+  
+  it "should be possible to only copy `gem` lib files" do
+    should_copy_types(:gem)
+    @dep.copy_to(copied_deps_path, :types => [:gem])
+  end
+  
+  it "should be possible to only copy `standard` lib files" do
+    should_copy_types(:standard)
+    @dep.copy_to(copied_deps_path, :types => [:standard])
+  end
+  
+  it "should be possible to only copy `gem` libs" do
+    should_copy_types(:other)
+    @dep.copy_to(copied_deps_path, :types => [:other])
+  end
+  
+  it "should be possible to combine the types of libs to be copied" do
+    should_copy_types(:other, :gem)
+    @dep.copy_to(copied_deps_path, :types => [:other, :gem])
+  end
+  
+  it "should be possible to get a list of required files of only certain types" do
+    dep = Rucola::Dependencies::Dependency.new('requires_fileutils')
+    dep.resolve!
+    dep.required_files_of_types(:other).all? {|f| f.should.be.other_lib }
+    dep.required_files_of_types(:standard).all? {|f| f.should.be.standard_lib }
+  end
+  
+  private
+  
+  def should_copy_types(*types)
+    keys = [:gem, :other, :standard]
+    files = []
+    keys.each do |type|
+      file = mock(type.to_s)
+      file.stubs({ :full_path => '/some/path', :gem_lib? => false, :standard_lib? => false, :other_lib? => false }.merge({ "#{type}_lib?".to_sym => true }))
+      if types.include?(type)
+        file.expects(:copy_to).times(1).with(copied_deps_path)
+      else
+        file.expects(:copy_to).times(0)
+      end
+      files << file
+    end
+    @dep.instance_variable_set(:@required_files, files)
+  end
+end
+
+describe "Dependencies" do
+  include DependenciesSpecHelper
+  
+  before do
+    @deps = Rucola::Dependencies.new
+    @deps.dependency 'foo'
+    @deps.dependency 'rubynode', '>=0.1.3'
+    @deps.dependency 'fileutils'
+    @deps.resolve!
+  end
+  
+  it "should create a Dependency instance when a dependency is specified" do
+    lambda { @deps.dependency('hpricot') }.should.change("@deps.dependencies.length", +1, self)
+  end
+  
+  it "should be able to require all the dependencies" do
+    @deps.dependencies.each { |dep| dep.expects(:require!) }
+    @deps.require!
+  end
+  
+  it "should be able to resolve all the files needed by the dependencies" do
+    @deps.dependencies.each do |dep|
+      dep.required_files.should.not.be.empty
+    end
+  end
+  
+  it "should be able to copy to the specified destination path" do
+    @deps.copy_to(copied_deps_path)
+    %w{ foo.rb rubynode.rb fileutils.rb }.each do |file|
+      File.exist?(copied_deps_path(file)).should.be true
+    end
+  end
+  
+  it "should be possible to only copy specific types of files" do
+    @deps.dependencies.each do |dep|
+      dep.expects(:copy_to).with(copied_deps_path, { :types => [:gem, :other]})
+    end
+    @deps.copy_to(copied_deps_path, :types => [:gem, :other])
+  end
+  
+  it "should be able to return a complete list of unique required files" do
+    files = stubbed_equal_required_files
+    @deps.dependencies.stubs(:collect).returns([[files.first], [files.last]])
+    
+    @deps.required_files.length.should.be 1
+  end
+end
+
+describe "Dependencies::Dependency::RequiredFile" do
+  include DependenciesSpecHelper
+  
+  it "should be able to compare to another instance" do
+    files = stubbed_equal_required_files
+    files.first.should == files.last
+  end
+end
+
+describe "Dependencies, with problematic dependencies" do
+  before do
+    @deps = Rucola::Dependencies.new
+  end
+  
+  # FIXME: resolving activesupport works, but combined with stubbing resolve_relative_and_full_path it breaks...
+  xit "should not break with activesupport" do
+    @deps.dependency 'activesupport'
+    @deps.resolve!
+    @deps.dependencies.first.required_files.should.not.be.empty
+  end
+  
+  it "should not break with osx/cocoa (excluded)" do
+    @deps.dependency 'osx/cocoa'
+    @deps.resolve!
+    @deps.dependencies.first.required_files.should.be.empty
+  end
+  
+  it "should not break with osx/foundation (excluded)" do
+    @deps.dependency 'osx/foundation'
+    @deps.resolve!
+    @deps.dependencies.first.required_files.should.be.empty
+  end
+end