rucola 0.0.1

data/lib/rucola/nib.rb

@@ -0,0 +1,99 @@
+require 'osx/cocoa'
+require 'fileutils'
+
+module Rucola
+  module Nib
+    
+    def self.backup(path)
+      nib = File.dirname(path)
+      nib_name = File.basename(nib)
+      backup = "/tmp/#{nib_name}.bak"
+      unless $TESTING
+        puts "\n========================================================================="
+        puts "Backing up #{nib} to #{backup}"
+        puts "Please retrieve that one if for some reason the nib was damaged!"
+        puts "=========================================================================\n\n"
+      end
+      FileUtils.rm_rf(backup) if File.exists?(backup)
+      FileUtils.cp_r(nib, backup)
+    end
+    
+    class Classes
+      attr_reader :data
+      
+      def self.open(classes_nib_path)
+        new(classes_nib_path)
+      end
+      
+      def initialize(classes_nib_path)
+        @path = File.expand_path(classes_nib_path)
+        @data = OSX::NSDictionary.dictionaryWithContentsOfFile(@path)
+      end
+      
+      def classes
+        @data['IBClasses']
+      end
+      
+      def add_class(class_name)
+        classes.push({
+          'CLASS' => class_name,
+          'SUPERCLASS' => 'NSObject',
+          'LANGUAGE' => 'ObjC'
+        })
+      end
+      
+      def has_class?(class_name)
+        classes.any? { |klass| klass['CLASS'] == class_name }
+      end
+      
+      def save
+        Rucola::Nib.backup(@path)
+        @data.writeToFile_atomically(@path, true)
+      end
+      
+    end
+    
+    class KeyedObjects
+      attr_reader :data
+      
+      def self.open(path)
+        new(path)
+      end
+      
+      def initialize(path)
+        @path = path
+        @data, format, error = OSX::NSPropertyListSerialization.propertyListFromData_mutabilityOption_format_errorDescription(
+          OSX::NSData.dataWithContentsOfFile(@path),
+          OSX::NSPropertyListMutableContainersAndLeaves
+        )
+      end
+      
+      def files_owner_class
+        @data['$objects'][3]
+      end
+      
+      # Changes the custom class of the File's Owner.
+      def change_files_owner_class(new_class)
+        # With a fresh nib the name of the custom class always appears as the 4th object
+        # in the $objects array. But this might not always be the case. At least for
+        # setting the initial custom class with a known nib, such as the one we use
+        # as a template, will work.
+        @data['$objects'][3] = new_class
+      end
+      
+      # Save the keyedobjects.nib back to the original path.
+      # Or alternatively pass it a new path.
+      def save(new_path = nil)
+        new_data, new_error = OSX::NSPropertyListSerialization.dataFromPropertyList_format_errorDescription(@data, OSX::NSPropertyListBinaryFormat_v1_0)
+
+        Rucola::Nib.backup(@path)
+
+        path = (new_path.nil? ? @path : new_path)
+        dirname = File.dirname(path)
+        FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+
+        new_data.writeToFile_atomically(path, true)
+      end
+    end
+  end
+end

data/lib/rucola/rucola_support.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rucola_support/rc_app'
+require 'rucola_support/initialize_hooks'
+require 'rucola_support/core_ext'
+require 'rucola_support/controllers'
+require 'rucola_support/models'
+require 'rucola/rucola_support/notifications'

data/lib/rucola/rucola_support/controllers.rb

@@ -0,0 +1,2 @@
+require 'rucola_support/controllers/rc_controller'
+require 'rucola_support/controllers/rc_window_controller'

data/lib/rucola/rucola_support/controllers/rc_controller.rb

@@ -0,0 +1,7 @@
+require 'osx/cocoa'
+
+module Rucola
+  class RCController < OSX::NSObject
+    include Rucola::RCApp
+  end
+end

data/lib/rucola/rucola_support/controllers/rc_window_controller.rb

@@ -0,0 +1,12 @@
+require 'osx/cocoa'
+
+module Rucola
+  class RCWindowController < OSX::NSWindowController
+    # Loads the nib that corresponds to this subclass.
+    # So for instance a class PreferencesWindowController,
+    # will look for a nib in: app/views/Preferences.nib
+    def init
+      self if self.initWithWindowNibPath_owner(Rucola::RCApp.path_for_view(self), self)
+    end
+  end
+end

data/lib/rucola/rucola_support/core_ext.rb

@@ -0,0 +1,2 @@
+require 'rucola_support/core_ext/ruby'
+require 'rucola_support/core_ext/objc'

data/lib/rucola/rucola_support/core_ext/objc.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/objc/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "rucola_support/core_ext/objc/#{filename}"
+end

data/lib/rucola/rucola_support/core_ext/objc/nsobject.rb

@@ -0,0 +1,22 @@
+require 'osx/cocoa'
+
+class OSX::NSObject
+  class << self
+    alias_method :_inherited_before_rucola, :inherited
+    
+    def inherited(subclass)
+      # First let RubyCocoa do it's magic!
+      _inherited_before_rucola(subclass)
+    
+      # We only want to mixin modules into subclasses of classes
+      # that start with 'Rucola::RC'.
+      class_prefix = subclass.superclass.name.to_s[0..9]
+      if class_prefix == 'Rucola::RC'
+        subclass.class_eval do
+          include Rucola::InitializeHooks
+          include Rucola::Notifications
+        end
+      end
+    end
+  end
+end

data/lib/rucola/rucola_support/core_ext/ruby.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/ruby/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "rucola_support/core_ext/ruby/#{filename}"
+end

data/lib/rucola/rucola_support/core_ext/ruby/string.rb

@@ -0,0 +1,21 @@
+class String
+  # These 2 methods are taken blatently from the Merb string extensions.
+  
+  # "FooBar".snake_case #=> "foo_bar"
+  def snake_case
+    gsub(/\B[A-Z]/, '_\&').downcase
+  end
+
+  # "foo_bar".camel_case #=> "FooBar"
+  def camel_case    
+    if self.include? '_'
+      self.split('_').map{|e| e.capitalize}.join
+    else
+      unless self =~ (/^[A-Z]/)
+        self.capitalize
+      else
+        self
+      end
+    end
+  end
+end

data/lib/rucola/rucola_support/initialize_hooks.rb

@@ -0,0 +1,21 @@
+module Rucola
+  module InitializeHooks
+    module ClassMethods
+      # Adds the given proc to the initialize hooks queue,
+      # which will be ran after object initialization.
+      def _rucola_register_initialize_hook(hook)
+        (@_rucola_initialize_hooks ||= []).push hook
+      end
+    end
+  
+    def initialize
+      # get the hooks, if they exist let them all do their after initialization work.
+      hooks = self.class.instance_variable_get(:@_rucola_initialize_hooks)
+      hooks.each { |hook| self.instance_eval(&hook) } unless hooks.nil?
+    end
+  
+    def self.included(base) # :nodoc
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/rucola/rucola_support/models.rb

@@ -0,0 +1 @@
+require 'rucola_support/models/rc_document'

data/lib/rucola/rucola_support/models/rc_document.rb

@@ -0,0 +1,10 @@
+require 'osx/cocoa'
+
+module Rucola
+  class RCDocument < OSX::NSDocument
+    def makeWindowControllers
+      @@_window_controller ||= Object.const_get("#{self.class.name.to_s.camel_case}Controller")
+      addWindowController @@_window_controller.alloc.init
+    end
+  end
+end

data/lib/rucola/rucola_support/notifications.rb

@@ -0,0 +1 @@
+require 'rucola_support/notifications/notifications'

data/lib/rucola/rucola_support/notifications/notifications.rb

@@ -0,0 +1,146 @@
+require 'osx/cocoa'
+
+module Rucola
+  module Notifications
+    # This Notifications module will add a class method called +notify_on+, which registers
+    # your object for the given notification and executes the given block when the
+    # notification is posted to the OSX::NSNotificationCenter.defaultCenter.
+    #
+    #   class FooController < OSX::NSObject
+    #
+    #     notify_on OSX::NSApplicationDidFinishLaunchingNotification do |notification|
+    #       puts "Application did finish launching."
+    #       p notification
+    #     end
+    #
+    #     # code
+    #
+    #   end
+    #   
+    #   In addition to notify_on, you also get a method called notify which allows you to specify methods
+    #   to be invoked when a notification is posted.
+    #     
+    #     class FooController < OSX::NSObject
+    #       notify :some_method, :when => :application_did_finish_launching
+    #     
+    #       def some_method(notification)
+    #         puts "Application finished launching"
+    #       end
+    #     end
+
+
+      module ClassMethods
+        # Add prefix shortcuts as a hash.
+        #
+        #   class FooController < OSX::NSObject
+        #     acts_as_notifiable
+        #
+        #     # This will make sure that :win_ is expanded to :window_ in the notifications that you register.
+        #     notification_prefix :win => :window
+        #
+        #     notify_on :win_did_become_key do |notification|
+        #       # code
+        #     end
+        #   end
+        #
+        # By default the shortcut <tt>{ :app => :application }</tt> is registered.
+        def notification_prefix(prefixes)
+          (@_notification_prefixes ||= {}).merge! prefixes
+        end
+        
+        # Registers the object for the given notification and executes the given block when the
+        # notification is posted to the OSX::NSNotificationCenter.defaultCenter.
+        #
+        #   class FooController < OSX::NSObject
+        #
+        #     notify_on OSX::NSApplicationDidFinishLaunchingNotification do |notification|
+        #       puts "Application did finish launching."
+        #       p notification
+        #     end
+        #
+        #     # code
+        #
+        #   end
+        #
+        # You can also pass it a symbol as +notification+ in which case it will be exapnded.
+        # It will first check if the name + 'Notification' exists, if not it will prepend 'NS'.
+        # So :application_did_finish_launching becomes 'NSApplicationDidFinishLaunchingNotification'.
+        #
+        # You can even register shortcut prefixes. See +notification_prefix+.
+        def notify_on(notification, &block)
+          notification_name = notification
+          
+          if notification_name.is_a? Symbol
+            notification_name = notification_name.to_s
+            
+            # first check if this notification_name uses a shortcut prefix
+            splitted_notification_name = notification_name.split('_')
+            prefix = splitted_notification_name.first.to_sym
+            if @_notification_prefixes and @_notification_prefixes.has_key? prefix
+              notification_name = @_notification_prefixes[prefix].to_s << '_' << splitted_notification_name[1..-1].join('_')
+            end
+
+            begin
+              # try with only Notification appended
+              notification_name = notification_name.camel_case << 'Notification'
+              OSX.const_get(notification_name)
+            rescue NameError
+              begin
+                # then try with NS prepended
+                notification_name = 'NS' << notification_name
+                OSX.const_get(notification_name)
+              rescue NameError
+                raise NameError, "Unable to find the notification corresponding to :#{notification}"
+              end
+            end
+          end
+          
+          method_name = "_handle_#{notification_name.snake_case}".to_sym
+          
+          # define the handle method
+          class_eval do
+            define_method(method_name, &block)
+          end
+          
+          @_registered_notifications ||= {}
+          @_registered_notifications[notification_name.to_s] = method_name
+        end
+        
+        # Register a callback when a notification is posted.
+        #
+        #     class FooController < OSX::NSObject
+        #       notify :some_method, :when => :application_did_finish_launching
+        #     
+        #       def some_method(notification)
+        #         puts "Application finished launching"
+        #       end
+        #     end
+        #
+        def notify(method_to_notify, options = {})
+          @_registered_notifications ||= {}
+          @_registered_notifications[options[:when]] = method_to_notify
+        end
+        
+      end
+      
+      def self.included(base) # :nodoc
+        base.extend(ClassMethods)
+        
+        # register the initialize hook which actually registers the notifications for the instance.
+        base._rucola_register_initialize_hook lambda { self._register_notifications }
+        
+        # register default shortcut
+        base.notification_prefix :app => :application
+      end
+      
+      # this instance method is called after object initialization by the initialize hook
+      def _register_notifications # :nodoc:
+        notifications = self.class.instance_variable_get(:@_registered_notifications)
+        return if notifications.nil?
+        center = OSX::NSNotificationCenter.defaultCenter
+        notifications.each do |notification_name, notification_handler|
+          center.addObserver_selector_name_object(self, notification_handler, notification_name, nil)
+        end
+      end
+  end
+end

data/lib/rucola/rucola_support/rc_app.rb

@@ -0,0 +1,101 @@
+module Rucola
+  module RCApp
+    # Returns the path to the current source root of the application.
+    #
+    # So in debug & test mode this will point to your development source root.
+    #
+    # In release however this will point to the equivalent of:
+    # <tt>NSBundle.mainBundle.resourcePath</tt>
+    def root_path
+      RUBYCOCOA_ROOT.to_s
+    end
+    module_function :root_path
+    
+    # Returns the path to the current used app/controllers dir.
+    #
+    # So in debug & test mode this will point to your development
+    # source_root/app/controllers.
+    #
+    # In release however this will point to the equivalent of:
+    #   NSBundle.mainBundle.resourcePath + 'app/controllers'
+    def controllers_path
+      (RUBYCOCOA_ROOT + 'app/controllers').to_s
+    end
+    module_function :controllers_path
+    
+    # Returns the path to the current used app/models dir.
+    #
+    # So in debug & test mode this will point to your development
+    # source_root/app/models.
+    #
+    # In release however this will point to the equivalent of:
+    #   NSBundle.mainBundle.resourcePath + 'app/models'
+    def models_path
+      (RUBYCOCOA_ROOT + 'app/models').to_s
+    end
+    module_function :models_path
+    
+    # Returns the path to the current used app/assets dir.
+    #
+    # So in debug & test mode this will point to your development
+    # source_root/app/assets.
+    #
+    # In release however this will point to the equivalent of:
+    #   NSBundle.mainBundle.resourcePath + 'app/assets'
+    def assets_path
+      (RUBYCOCOA_ROOT + 'app/assets').to_s
+    end
+    module_function :assets_path
+    
+    # Returns the path to the current used app/views dir.
+    #
+    # So in debug & test mode this will point to your development
+    # source_root/app/views.
+    #
+    # In release however this will point to the equivalent of:
+    #   NSBundle.mainBundle.resourcePath + 'app/views'
+    def views_path
+      (RUBYCOCOA_ROOT + 'app/views').to_s
+    end
+    module_function :views_path
+    
+    # Returns the path to a +controller+ file.
+    #
+    #   Rucola::RCApp.path_for_controller(ApplicationController) #=> 'root/app/controllers/application_controller.rb'
+    def path_for_controller(controller)
+      "#{controllers_path}/#{controller.name.to_s.snake_case}.rb"
+    end
+    module_function :path_for_controller
+    
+    # Returns the path to a +model+ file.
+    #
+    #   Rucola::RCApp.path_for_model(Person) #=> 'root/app/models/person.rb'
+    def path_for_model(model)
+      "#{models_path}/#{model.name.to_s.snake_case}.rb"
+    end
+    module_function :path_for_model
+    
+    # Returns the path to a +view+ file.
+    #
+    #   Rucola::RCApp.path_for_controller('preferences') #=> 'root/app/views/Preferences.nib'
+    #   Rucola::RCApp.path_for_controller('Preferences') #=> 'root/app/views/Preferences.nib'
+    #
+    #   Rucola::RCApp.path_for_controller(PreferencesController) #=> 'root/app/views/Preferences.nib'
+    #   Rucola::RCApp.path_for_controller(PreferencesController.alloc.init) #=> 'root/app/views/Preferences.nib'
+    def path_for_view(view)
+      view = view.class unless view.is_a?(String) or view.is_a?(Class)
+      view = view.name.to_s.sub(/Controller$/, '') if view.is_a? Class
+      "#{views_path}/#{view.camel_case}.nib"
+    end
+    module_function :path_for_view
+    
+    # Returns the path to an +asset+ file.
+    #
+    #   Rucola::RCApp.path_for_asset('somefile.png') #=> 'root/app/assets/somefile.png'
+    def path_for_asset(asset)
+      "#{assets_path}/#{asset}"
+    end
+    module_function :path_for_asset
+
+  end
+end