rucola 0.0.1

data/lib/rucola/tasks/freeze.rake

@@ -0,0 +1,44 @@
+namespace :rc do
+  
+  namespace :freeze do
+    
+    RUBYCOCOA_FRAMEWORK_PATH_CURRENT = 'vendor/rubycocoa'
+    desc "Freezes the current used version of RubyCocoa in #{RUBYCOCOA_FRAMEWORK}"
+    task :current do
+      mkdir_p RUBYCOCOA_FRAMEWORK_PATH_CURRENT unless File.exist? RUBYCOCOA_FRAMEWORK_PATH_CURRENT
+      puts "Copying framework."
+      cp_r RUBYCOCOA_FRAMEWORK, RUBYCOCOA_FRAMEWORK_PATH_CURRENT
+      # add the new RubyCocoa framework to the project and bundle it when building the application
+      Rake::Task['rc:freeze:bundle'].invoke
+    end
+    
+    RUBYCOCOA_FRAMEWORK_PATH_EDGE = 'vendor/rubycocoa/framework/build/Default'
+    desc 'Freezes the current edge version of RubyCocoa'
+    task :edge do
+      if File.exist? 'vendor/rubycocoa'
+        sh 'cd vendor/rubycocoa && svn up'
+      else
+        mkdir 'vendor' unless File.exist? 'vendor'
+        sh 'cd vendor && svn co https://rubycocoa.svn.sourceforge.net/svnroot/rubycocoa/trunk/src rubycocoa'
+      end
+      sh 'cd vendor/rubycocoa && rake'
+      
+      # add the new RubyCocoa framework to the project and bundle it when building the application
+      Rake::Task['rc:freeze:bundle'].invoke
+    end
+    
+    desc 'Bundle the frozen RubyCocoa framework with the application'
+    task :bundle do
+      if File.exist? RUBYCOCOA_FRAMEWORK_PATH_EDGE
+        framework_location = RUBYCOCOA_FRAMEWORK_PATH_EDGE
+      else
+        framework_location = RUBYCOCOA_FRAMEWORK_PATH_CURRENT
+      end
+      project = Rucola::Xcode.new File.join(SOURCE_ROOT, "#{APPNAME}.xcodeproj")
+      project.change_rubycocoa_framework_location "#{framework_location}/RubyCocoa.framework"
+      project.bundle_rubycocoa_framework
+      project.save
+    end
+  end
+  
+end

data/lib/rucola/tasks/interface_builder.rake

@@ -0,0 +1,80 @@
+require 'yaml'
+
+namespace :ib do
+  RB_NIB_TOOL = "#{RUBYCOCOA_FRAMEWORK}/Versions/Current/Tools/rb_nibtool.rb"
+  
+  def helper_file
+    "/tmp/#{APPNAME}_helper.rb.tmp"
+  end
+  
+  def create_tmp_helper_file
+    # get all the Rucola controller class definition files
+    class_defs = FileList["#{File.expand_path('../../rucola_support/controllers', __FILE__)}/*.rb"]
+    
+    # get the optional ib_external_class_defs.yml file in which a user can specify any other
+    # classes that might need to be incuded for IB to recognize them.
+    user_class_def_string = ''
+    user_class_def_file = File.join(SOURCE_ROOT, 'config/ib_external_class_defs.yml')
+    user_class_defs = YAML.load_file(user_class_def_file)
+    if user_class_defs
+      user_class_def_string = create_class_stubs(user_class_defs)
+    end
+    
+    # write the Rucola controllers and the optional ib_external_class_defs.yml to a tmp file
+    File.open(helper_file, 'w') do |file|
+      file.write class_defs.map{ |class_def| File.read(class_def) }.join("\n\n") << user_class_def_string
+    end
+  end
+  
+  def create_class_stubs(klasses, prev_super = '')
+    class_defs = ''
+    klasses.each do |klass, subklass|
+      unless prev_super == ''
+        class_defs += "class #{klass} < #{prev_super}; end\n"
+      end
+      if subklass.is_a?(Array)
+        subklass.each do |sub|
+          if sub.is_a?(Hash)
+            create_class_stubs(sub, klass)
+          else
+            class_defs += "class #{sub} < #{klass}; end\n"
+          end
+        end
+      end
+    end
+    return class_defs
+  end
+  
+  def create_tmp_controller_file(controller_name)
+    tmp_file = "/tmp/#{controller_name.snake_case}.rb.tmp"
+    File.open(tmp_file, 'w') do |file|
+      file.write( File.read(helper_file) + "\n\n" + File.read("app/controllers/#{controller_name.snake_case}.rb") )
+    end
+    tmp_file
+  end
+  
+  def name_for_controller(controller_path)
+    File.basename(controller_path)[0..-4].camel_case
+  end
+  
+  desc 'Updates the nibs from their corresponding ruby source files'
+  task :update do
+    create_tmp_helper_file
+    
+    controllers = FileList["#{SOURCE_ROOT}/app/controllers/*.rb"]
+    nibs = FileList["#{SOURCE_ROOT}/app/views/*.nib", "#{SOURCE_ROOT}/misc/English.lproj/MainMenu.nib"].reject {|file| File.extname(file) != '.nib' or file.include? '~' }
+    
+    controllers.each do |controller_path|
+      controller_name = name_for_controller(controller_path)
+      nibs.each do |nib|
+        if Rucola::Nib::Classes.open("#{nib}/classes.nib").has_class? controller_name
+          @tmp_file ||= create_tmp_controller_file(controller_name)
+          puts "      update  #{nib[(SOURCE_ROOT.length + 1)..-1]}: #{controller_name}"
+          `ruby #{RB_NIB_TOOL} --update --nib #{nib} --file #{@tmp_file}`
+        end
+      end
+      @tmp_file = nil
+    end
+  end
+  
+end

data/lib/rucola/tasks/main.rake

@@ -0,0 +1,29 @@
+require 'rake/testtask'
+
+require 'osx/cocoa'
+require 'rucola/xcode'
+require 'rucola/nib'
+require 'rucola/rucola_support'
+
+# set the env, default to debug if we are running a rake task.
+RUBYCOCOA_ENV = ENV['RUBYCOCOA_ENV'].nil? ? 'debug' : ENV['RUBYCOCOA_ENV']
+RUBYCOCOA_ROOT = ENV['RUBYCOCOA_ROOT'].nil? ? SOURCE_ROOT : ENV['RUBYCOCOA_ROOT']
+puts "RUNNING IN MODE: #{RUBYCOCOA_ENV.upcase}\n\n"
+
+# FIXME: We also need to check if the user uses a frozen rc framework
+RUBYCOCOA_FRAMEWORK = OSX::NSBundle.bundleWithIdentifier('com.apple.rubycocoa').bundlePath.to_s
+
+# TASKS
+
+# Get all the tasks
+Dir["#{File.dirname(__FILE__)}/*.rake"].each {|file| load file unless File.basename(file) == 'main.rake' }
+
+task :default => 'xcode:build'
+
+desc 'Runs all the clean tasks'
+task :clean => 'xcode:clean'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*/test_*.rb']
+  t.verbose = true
+end

data/lib/rucola/tasks/xcode.rake

@@ -0,0 +1,43 @@
+namespace :xcode do
+  
+  def config
+    RUBYCOCOA_ENV.capitalize
+  end
+  
+  def build_dir
+    # get the users build dir
+    prefs = OSX::NSUserDefaults.standardUserDefaults
+    prefs.addSuiteNamed 'com.apple.xcode'
+    prefs['PBXApplicationwideBuildSettings']['SYMROOT'] || './build'
+  end
+  
+  def build_root
+    File.expand_path("#{build_dir}/#{config}/#{TARGET}")
+  end
+  
+  desc 'Builds the application'
+  task :build do
+    executable = "#{build_root}/Contents/MacOS/#{APPNAME}"
+    
+    unless File.exists?(executable)
+      sh "xcodebuild -configuration #{config}"
+    else
+      puts "Build already exists, skipping. (Use clean if you really really want a new build.)\n\n"
+    end
+    
+    # Make sure the app is brought to the front once launched.
+    Thread.new do
+      sleep 0.025 until OSX::NSWorkspace.sharedWorkspace.launchedApplications.any? {|dict| dict['NSApplicationName'] == APPNAME }
+      `osascript -e 'tell application "#{executable}" to activate'`
+    end
+    
+    # launch app with the correct env set
+    sh "RUBYCOCOA_ENV='#{RUBYCOCOA_ENV}' RUBYCOCOA_ROOT='#{RUBYCOCOA_ROOT}' #{executable}"
+  end
+  
+  desc 'Removes the build'
+  task :clean do
+    puts "Removing #{build_root}"
+    FileUtils.rm_rf build_root
+  end
+end

data/lib/rucola/test_helper.rb

@@ -0,0 +1,57 @@
+require 'osx/cocoa'
+
+module OSX
+  # Allows methods to be overriden with a different arity.
+  #
+  # TODO: Check with Laurent if this is bad?
+  # Otherwise we should maybe override the stub method to set this to true
+  # when the object is a subclass of OSX::NSObject and set it to false again after the stubbing.
+  def self._ignore_ns_override; true; end
+
+  class NSObject
+    # A Mocha helper method which allows to stub alloc.init and return a mock.
+    #
+    #   it "should init and return an instance" do
+    #     obj_mock = mock("NSObject mock")
+    #     OSX::NSObject.expects_alloc_init_returns(obj_mock) # performs 2 assertions
+    #     OSX::NSObject.alloc.init.should == obj_mock
+    #   end
+    #
+    # Results in:
+    # 1 tests, 3 assertions, 0 failures, 0 errors
+    def self.expects_alloc_init_returns(mock)
+      mock.expects(:init).returns(mock)
+      self.expects(:alloc).returns(mock)
+    end
+    
+    # A Mocha helper method which allocs an instance, yields it and then calls init.
+    #
+    #   class Monkey < OSX::NSObject
+    #     def init
+    #       if super_init
+    #         self.foo
+    #         self.bar
+    #         return self
+    #       end
+    #     end
+    #   end
+    #
+    #   it "should alloc, yield and return an instance" do
+    #     obj = OSX::Monkey.during_init do |instance|
+    #       instance.expects(:foo)
+    #       instance.expects(:bar)
+    #     end
+    #     p obj # => #<Monkey:0x1a7566 class='Monkey' id=0x1b30a70>
+    #   end
+    #
+    # Results in:
+    # 1 tests, 2 assertions, 0 failures, 0 errors
+    def self.during_init(&block)
+      obj = self.alloc
+      yield obj
+      res = obj.init
+      warn " warning: #{self.class.name}#init did not return an instance." if res.nil?
+      res
+    end
+  end
+end

data/lib/rucola/version.rb

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

data/lib/rucola/xcode.rb

@@ -0,0 +1,148 @@
+require 'osx/cocoa'
+require 'pathname'
+
+module Rucola
+  class Xcode
+    # FIXME: We should probably generate random id keys!
+    
+    attr_reader :project
+    attr_reader :project_path
+    attr_reader :project_data
+    
+    def initialize(project_path)
+      @project_path = Pathname.new(project_path)
+      @project = @project_path.basename.to_s.sub(/\.xcodeproj$/, '')
+      @project_path_data = @project_path + 'project.pbxproj'
+      @project_data = OSX::NSDictionary.dictionaryWithContentsOfFile(@project_path_data.to_s)
+    end
+    
+    # Saves the project data atomically.
+    # Returns +false+ if it failed.
+    def save
+      # FIXME: Because we use non generated id's atm (which is bad!)
+      # we should first make a bakup of the project.
+      unless $TESTING
+        puts "\n========================================================================="
+        puts "Backing up project #{@project}.xcodeproj to /tmp/#{@project}.xcodeproj.bak"
+        puts "Please retrieve that one if for some reason the project was damaged!\n"
+      end
+      backup = "/tmp/#{@project}.xcodeproj.bak"
+      Kernel.system("rm -rf #{backup}") if File.exists?(backup)
+      Kernel.system("cp -R #{project_path} #{backup}")
+      
+      # this writes the plist as a new xml style plist,
+      # but luckily xcode recognizes it as well and
+      # writes it back out as an old style plist.
+      @project_data.writeToFile_atomically(@project_path_data.to_s, true)
+    end
+    
+    def nil_if_empty(result)
+      result.empty? ? nil : result
+    end
+    private :nil_if_empty
+    
+    # Get's the id & values for a object which name is the one passed to this method.
+    # Returns an array: [id, values]
+    def object_for_name(name)
+      nil_if_empty @project_data['objects'].select { |object| object.last['name'] == name }.flatten
+    end
+    
+    # Get's the id & values for a object which type and name is the one passed to this method.
+    # Returns an array: [id, values]
+    def object_for_type_and_name(type, name)
+      nil_if_empty @project_data['objects'].select { |object| object.last['isa'] == type and object.last['name'] == name }.flatten
+    end
+    
+    # Returns the object that represents this projects target.
+    # Returns an array: [id, values]
+    def object_for_project_target
+      nil_if_empty object_for_type_and_name('PBXNativeTarget', @project)
+    end
+    
+    # Returns the object for a given name.
+    # Returns an array: [id, values]
+    def object_for_id(object_id)
+      @project_data['objects'][object_id].nil? ? nil : [object_id, @project_data['objects'][object_id]]
+    end
+    
+    # Adds an object to the objects.
+    def add_object(object_id, object_values)
+      @project_data['objects'][object_id] = object_values
+    end
+    
+    # Adds a build phase specified by +object_id+ to the build phases of the project target.
+    def add_build_phase_to_project_target(object_id)
+      # Add the new build phase to the main project target if it doesn't already exist
+      build_target_id, build_target_values = object_for_project_target
+      build_target_values['buildPhases'].push(object_id) unless build_target_values['buildPhases'].include?(object_id)
+    end
+    
+    def add_object_to_build_phase(object_id, build_phase_id)
+      build_phase = object_for_id(build_phase_id).last
+      build_phase['files'].push(object_id) unless build_phase['files'].include?(object_id)
+    end
+    
+    NEW_COPY_FRAMEWORKS_BUILD_PHASE = ['519A79DB0CC8AE6B00CBE85D', {
+      'name' => 'Copy Frameworks',
+      'isa' => 'PBXCopyFilesBuildPhase',
+      'buildActionMask' => '2147483647',
+      'dstPath' => '',
+      'dstSubfolderSpec' => 10, # TODO: is 10 the number for the location popup choice: Frameworks
+      'runOnlyForDeploymentPostprocessing' => 0,
+      'files' => []
+    }]
+    # 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
+    end
+    
+    # Changes the path of the framework +framework_name+ to the path +new_path_to_framework+.
+    def change_framework_location(framework_name, new_path_to_framework)
+      framework_id, framework_values = object_for_name(framework_name)
+      framework_values['path'] = new_path_to_framework
+      framework_values['sourceTree'] = '<group>'
+    end
+    
+    # Changes the path of the RubyCocoa framework to +new_path_to_framework+.
+    def change_rubycocoa_framework_location(new_path_to_framework)
+      change_framework_location 'RubyCocoa.framework', new_path_to_framework
+    end
+    
+    # Bundles the given framework in the application.
+    def bundle_framework(framework_name)
+      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_values = {
+        'isa' => 'PBXBuildFile',
+        'fileRef' => framework_id
+      }
+      add_object(framework_in_build_phase_id, framework_in_build_phase_values)
+      
+      # get or define the Copy Frameworks build phase
+      build_phase = object_for_name('Copy Frameworks')
+      if build_phase.nil?
+        build_phase_id, build_phase_values = new_framework_copy_build_phase
+        # add the new build phase to the objects
+        add_object(build_phase_id, build_phase_values)
+        
+        # add the new build phase to the project target
+        add_build_phase_to_project_target(build_phase_id)
+      else
+        build_phase_id, build_phase_values = build_phase
+      end
+      # add the framework to the build phase
+      add_object_to_build_phase(framework_in_build_phase_id, build_phase_id)
+    end
+    
+    # Bundles the RubyCocoa framework in the application.
+    def bundle_rubycocoa_framework
+      bundle_framework 'RubyCocoa.framework'
+    end
+  end
+end

data/rucola_generators/controller/USAGE

@@ -0,0 +1,5 @@
+Description:
+  Generate a controller that inherits from NSObject.
+  
+Usage:
+  script/generate controller articles

data/rucola_generators/controller/controller_generator.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'rucola/rucola_support'
+require 'rucola/nib'
+
+class ControllerGenerator < RubiGen::Base
+  
+  default_options :author => nil
+  
+  attr_reader :name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    @nibs_to_update = args
+    extract_options
+  end
+
+  def add_class_to_classes_nib(controller_name, nib_path)
+    nib = Rucola::Nib::Classes.open(File.expand_path(destination_path(nib_path)))
+    nib.add_class(controller_name)
+    nib.save
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      controller_dir = 'app/controllers'
+      test_dir       = 'test/controllers'
+      
+      m.directory controller_dir
+      m.directory test_dir
+
+      # Create stubs
+      m.template 'controller_template.rb.erb', "#{controller_dir}/#{@name.snake_case}_controller.rb"
+      m.template 'test_controller_template.rb.erb', "#{test_dir}/test_#{@name.snake_case}_controller.rb"
+      
+      # Optionally add the class to a nib
+      controller_name = "#{@name.camel_case}Controller"
+      if @nibs_to_update.empty?
+        print "\nWould you like me to add the class #{controller_name} to MainMenu.nib? [Y/n]: " unless $TESTING
+        result = Kernel.gets.strip
+        if result.empty? or result.downcase == 'y'
+          add_class_to_classes_nib(controller_name, 'misc/English.lproj/MainMenu.nib/classes.nib')
+        end
+      else
+        @nibs_to_update.each do |nib|
+          if nib.camel_case == 'MainMenu'
+            add_class_to_classes_nib(controller_name, 'misc/English.lproj/MainMenu.nib/classes.nib')
+          else
+            add_class_to_classes_nib(controller_name, "app/views/#{nib.camel_case}.nib/classes.nib")
+          end
+        end
+      end
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+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