hotcocoa 0.5.1 → 0.6.0pre

data/lib/hotcocoa/mvc.rb

@@ -1,122 +1,132 @@
 require 'hotcocoa'
 
 class HotCocoaApplication
-  attr_accessor :shared_application, :application_controller, :controllers
-  
   include HotCocoa
-  
-  def self.instance=(instance)
-    @instance = instance
-  end
-  
-  def self.instance
-    @instance
+
+  # @return [NSApplication]
+  attr_accessor :shared_application
+
+  # @return []
+  attr_accessor :application_controller
+
+  # @return []
+  attr_accessor :controllers
+
+  class << self
+    ##
+    # The singleton instance of the application.
+    #
+    # @return [HotCocoaApplication]
+    attr_accessor :instance
   end
-  
-  def initialize(application_file)
+
+  def initialize application_file
     HotCocoaApplication.instance = self
+
     @controllers = {}
     load_controllers_and_views(directory_of(application_file))
+
     @shared_application = application(ApplicationView.options[:application])
     @shared_application.load_application_menu
     @application_controller = controller(:application_controller)
+
     shared_application.delegate_to(application_controller)
   end
-  
+
   def start
     @shared_application.run
   end
-  
-  def controller(controller_name)
+
+  def controller controller_name
     controller_name_string = controller_name.to_s
-    controller_class = Object.const_get(controller_name_string !~ /_/ && controller_name_string =~ /[A-Z]+.*/ ? controller_name_string : controller_name_string.split('_').map{|e| e.capitalize}.join)
+
+    controller_class = if Object.const_get(controller_name_string !~ /_/ && controller_name_string =~ /[A-Z]+.*/)
+      controller_name_string
+    else
+      controller_name_string.split('_').map { |e| e.capitalize }.join
+    end
+
     @controllers[controller_name] || create_controller_instance(controller_name, controller_class)
   end
-  
+
   private
-  
-    def create_controller_instance(controller_name, controller_class)
-      controller_instance = controller_class.new(self)
-      @controllers[controller_name] = controller_instance
-      controller_instance.application_window
-      controller_instance
-    end
-    
-    def directory_of(application_file)
-      File.dirname(File.expand_path(application_file))
+
+  def create_controller_instance controller_name, controller_class
+    controller_instance = controller_class.new self
+
+    @controllers[controller_name] = controller_instance
+
+    controller_instance.application_window
+    controller_instance
+  end
+
+  def directory_of application_file
+    File.dirname(File.expand_path(application_file))
+  end
+
+  def load_controllers_and_views directory
+    Dir.glob(File.join(directory, 'controllers/**/*.rb')).each do |controller_file|
+      load(controller_file)
     end
-    
-    def load_controllers_and_views(directory)
-      Dir.glob(File.join(directory, 'controllers', '**', '*.rb')).each do |controller_file|
-        load(controller_file)
-      end
-      Dir.glob(File.join(directory, 'views', '**', '*.rb')).each do |view_file|
-        load(view_file)
-      end
+    Dir.glob(File.join(directory, 'views/**/*.rb')).each do |view_file|
+      load(view_file)
     end
-  
+  end
 end
 
 class HotCocoaController
-  
-  def self.view_instances
-    @view_instances ||= {}
+
+  class << self
+    attr_reader :view_instances
   end
-  
+  @view_instances = {}
+
   attr_reader :application
-  
-  def initialize(application)
+
+  def initialize application
     @application = application
   end
-  
+
   def application_window
     @application.application_controller.application_window
   end
-
 end
 
 class HotCocoaApplicationController < HotCocoaController
-  
-  def initialize(application)
-    super(application)
-  end
-  
   def application_window
     @application_window ||= ApplicationWindow.new(self).application_window
   end
-
 end
 
 class HotCocoaWindow
-  
-  attr_reader :application_controller, :application_window
-  
-  def initialize(application_controller)
+  attr_reader :application_controller
+  attr_reader :application_window
+
+  def initialize application_controller
     @application_controller = application_controller
     render
   end
-  
+
   def render
     @application_window = HotCocoa.window(ApplicationView.options[:window])
     @application_window.delegate_to(application_controller)
     @application_window.view << application_controller.application_view
   end
-  
 end
 
 class HotCocoaView < HotCocoa::LayoutView
-  
-  DefaultLayoutOptions = {:expand => [:width, :height]}
-  
+  DefaultLayoutOptions = { expand: [:width, :height] }
+
   module ClassMethods
-    def controller(name=nil)
+    def controller name = nil
       if name
         @name = name
       else
         @name || :application_controller
       end
     end
-    def options(options=nil)
+
+    def options options = nil
       if options
         @options = options
       else
@@ -124,22 +134,23 @@ class HotCocoaView < HotCocoa::LayoutView
       end
     end
   end
-  
-  def self.inherited(klass)
+
+  def self.inherited klass
     klass.extend(ClassMethods)
     klass.send(:include, HotCocoa::Behaviors)
-    class_name = klass.name.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+    class_name = klass.name.underscore
+
     HotCocoaController.class_eval %{
       def #{class_name}
         unless HotCocoaController.view_instances[:#{class_name}]
-          HotCocoaController.view_instances[:#{class_name}] = #{klass.name}.alloc.initWithFrame([0,0,0,0])
+          HotCocoaController.view_instances[:#{class_name}] = #{klass.name}.alloc.initWithFrame(CGRectZero)
           HotCocoaController.view_instances[:#{class_name}].setup_view
         end
         HotCocoaController.view_instances[:#{class_name}]
       end
     }, __FILE__, __LINE__
   end
-  
+
   attr_reader :controller
 
   def setup_view
@@ -149,27 +160,25 @@ class HotCocoaView < HotCocoa::LayoutView
       render
     end
   end
-  
+
+
   private
-  
-    def class_controller
-      HotCocoaApplication.instance.controller(self.class.controller)
-    end
-  
-    def layout_options
-      options = if self.class.options && self.class.options[:layout]
-        self.class.options[:layout]
-      else
-        DefaultLayoutOptions
-      end
-    end
-    
+
+  def class_controller
+    HotCocoaApplication.instance.controller(self.class.controller)
+  end
+
+  def layout_options
+    options = if self.class.options && self.class.options[:layout]
+                self.class.options[:layout]
+              else
+                DefaultLayoutOptions
+              end
+  end
 end
 
 class ApplicationWindow < HotCocoaWindow
-  
 end
 
 class Application < HotCocoaApplication
-  
 end

data/lib/hotcocoa/notification_listener.rb

@@ -1,62 +1,139 @@
-module HotCocoa
-  
-  class NotificationListener
-    
-    DistributedBehaviors = {
-      :drop                 => NSNotificationSuspensionBehaviorDrop,
-      :coalesce             => NSNotificationSuspensionBehaviorCoalesce,
-      :hold                 => NSNotificationSuspensionBehaviorHold,
-      :deliver_immediately  => NSNotificationSuspensionBehaviorDeliverImmediately
-    }
-    
-    attr_reader :callback, :name, :sender, :suspension_behavior
-    
-    def self.registered_listeners
-      @registered_listeners ||= []
-    end
-    
-    def initialize(options={}, &block)
-      @callback = block
-      @distributed = (options[:distributed] == true)
-      @suspension_behavior = DistributedBehaviors[options[:when_suspended] || :coalesce]
-      @name = options[:named]
-      @sender = options[:sent_by]
-      NotificationListener.registered_listeners << self
-      observe
-    end
-    
-    def distributed?
-      @distributed
-    end
-    
-    def receive(notification)
-      callback.call(notification)
+##
+# Object that can register a block to receive arbitrary notifications from
+# the default NSNotificationCenter or NSDistributedNotificationCenter.
+class HotCocoa::NotificationListener
+
+  ##
+  # Map Ruby-ish names for distributed behaviors.
+  #
+  # @return [Hash{Symbol=>NSNotificationSuspensionBehavior}]
+  DistributedBehaviors = {
+    drop:                NSNotificationSuspensionBehaviorDrop,
+    coalesce:            NSNotificationSuspensionBehaviorCoalesce,
+    hold:                NSNotificationSuspensionBehaviorHold,
+    deliver_immediately: NSNotificationSuspensionBehaviorDeliverImmediately
+  }
+
+  ##
+  # Name of the notification to listen for.
+  #
+  # @return [String]
+  attr_reader :name
+
+  ##
+  # Name of the notification sender.
+  #
+  # @return [String]
+  attr_reader :sender
+
+  # @return [NSNotificationSuspensionBehavior]
+  attr_reader :suspension_behavior
+
+  ##
+  # Whether or not the object is registered with the default distributed
+  # or regular notification center.
+  #
+  # @return [Boolean]
+  attr_reader :distributed
+  alias_method :distributed?, :distributed
+
+  class << self
+    ##
+    # List of all {HotCocoa::NotificationListeners}.
+    #
+    # @return [HotCocoa::NotificationListener]
+    attr_reader :registered_listeners
+  end
+  @registered_listeners = []
+
+  ##
+  # @todo Would be better to use #define_singleton_method to define a new
+  #   {#receive} for each instance?
+  #
+  # @param [Hash] options
+  # @options options [String] :named name of the notification
+  # @options options [nil] :sent_by (nil) the signature of the notification
+  #   poster (i.e. the method to post notifications asks for a
+  #   notificationSender, these values must match up), or set to nil to
+  #   receive notifications from anyone
+  # @options options [NSNotificationSuspensionBehavior] :when_suspended (:coalesce)
+  #   behavior if notification is not set to be being delivered immediately
+  #   by the sender, see {HotCocoa::NotificationListener::DistributedBehaviors}
+  #   for possible values
+  # @options options [Boolean] :distributed (false)
+  #
+  # @yield the block given here will become the callback for the
+  #   notification
+  # @yieldparam [String] notification the name of the notification received
+  def initialize options = {}, &block
+    raise 'You must pass a block to act as the callback' unless block_given?
+    @callback = block
+
+    @name                = options[:named]
+    @sender              = options[:sent_by]
+    @suspension_behavior = DistributedBehaviors[options[:when_suspended] || :coalesce]
+    @distributed         = (options[:distributed] == true)
+    NotificationListener.registered_listeners << self
+    observe
+  end
+
+  ##
+  # Stop the listener from listening to any future notifications. The
+  # options available here are the same as the {#initialize} methods
+  # `:named` and `:sent_by` options.
+  def stop_notifications options = {}
+    if options.has_key?(:named) || options.has_key?(:sent_by)
+      notification_center.removeObserver self,
+                                   name: options[:named],
+                                 object: options[:sent_by]
+    else
+      notification_center.removeObserver self
     end
-    
-    def stop_notifications(options={})
-      if options.has_key?(:named) || options.has_key?(:sent_by)
-        notification_center.removeObserver(self, name:options[:named], object:options[:sender])
-      else
-        notification_center.removeObserver(self)
-      end
+  end
+
+  ##
+  # The callback called when a notification is posted. You should not be
+  # directly calling this yourself.
+  def receive notification
+    @callback.call notification
+  end
+
+
+  private
+
+  ##
+  # Register for the notification.
+  def observe
+    if distributed?
+      notification_center.addObserver self,
+                            selector: 'receive:',
+                                name: name,
+                              object: sender,
+                  suspensionBehavior: suspension_behavior
+
+    else
+      notification_center.addObserver self,
+                            selector: 'receive:',
+                                name: name,
+                              object: sender
     end
-    
-    private
-    
-      def observe
-        if distributed?
-          notification_center.addObserver self, selector:'receive:', name:name, object:sender, suspensionBehavior:suspension_behavior
-        else
-          notification_center.addObserver self, selector:'receive:', name:name, object:sender
-        end
-      end
-      
-      def notification_center
-        @notification_center ||= (distributed? ? NSDistributedNotificationCenter.defaultCenter : NSNotificationCenter.defaultCenter)
-      end
   end
-  
-  def on_notification(options={}, &block)
-    NotificationListener.new(options, &block)
+
+  ##
+  # Returns the notification center to which the listener is registered.
+  #
+  # @return [NSNotificationCenter,NSDistributedNotificationCenter]
+  def notification_center
+    @notification_center ||= (distributed ? NSDistributedNotificationCenter.defaultCenter : NSNotificationCenter.defaultCenter)
   end
-end
+end
+
+##
+# Register for a notification given a block. The options and block given
+# here will be passed to {HotCocoa::NotificationListener#initialize};
+# this method is merely syntactic sugar.
+#
+# @return [HotCocoa::NotificationListener
+def HotCocoa.on_notification options = {}, &block
+  HotCocoa::NotificationListener.new(options, &block)
+end

data/lib/hotcocoa/standard_rake_tasks.rb

@@ -1,21 +1,29 @@
-AppConfig = HotCocoa::ApplicationBuilder::Configuration.new("config/build.yml")
+$stderr.puts <<EOM
+standard_rake_tasks.rb is deprecated in favour of a new app template
+which declares the tasks directly in the template Rakefile.
 
-desc "Build a deployable version of the application"
-task :deploy => [:clean] do
-  HotCocoa::ApplicationBuilder.build(AppConfig, :deploy => true)
+You can update your Rakefile by copying the new tasks from Github at
+https://github.com/ferrous26/hotcocoa/blob/master/template/Rakefile
+EOM
+
+AppConfig = HotCocoa::ApplicationBuilder::Configuration.new( 'config/build.yml' )
+
+desc 'Build a deployable version of the application'
+task :deploy do
+  HotCocoa::ApplicationBuilder.build AppConfig, deploy: true
 end
 
-desc "Build the application"
+desc 'Build the application'
 task :build do
-  HotCocoa::ApplicationBuilder.build(AppConfig)
+  HotCocoa::ApplicationBuilder.build AppConfig
 end
 
-desc "Build and execute the application"
+desc 'Build and execute the application'
 task :run => [:build] do
   `"./#{AppConfig.name}.app/Contents/MacOS/#{AppConfig.name.gsub(/ /, '')}"`
 end
 
-desc "Cleanup build files"
+desc 'Cleanup build files'
 task :clean do
-  `/bin/rm -rf "#{AppConfig.name}.app"`
+  sh "/bin/rm -rf '#{AppConfig.name}.app'"
 end

data/lib/hotcocoa/target_action_convenience.rb

@@ -0,0 +1,39 @@
+##
+# This module should be mixed into mappings that want to support
+# target actions.
+module HotCocoa::Mappings::TargetActionConvenience
+
+  ##
+  # @todo testing
+  #
+  # @param [Proc] behavior
+  def on_action= behavior
+    if target && (
+                  target.instance_variable_get(:@action_behavior) ||
+                  target.instance_variable_get(:@double_action_behavior))
+
+      @object.instance_variable_set(:@action_behavior, behavior)
+      @object = target
+
+    else
+      @object = Object.new
+      @object.instance_variable_set(:@action_behavior, behavior)
+      setTarget(@object)
+    end
+
+    def @object.perform_action sender
+      @action_behavior.call sender
+    end
+
+    setAction('perform_action:')
+  end
+
+  ##
+  # @todo testing
+  #
+  # @yieldparam [id] sender
+  def on_action &behavior
+    self.on_action = behavior
+    self
+  end
+end

data/lib/hotcocoa/template.rb

@@ -1,27 +1,96 @@
 require 'fileutils'
-require 'rbconfig'
 
-module HotCocoa
-  class Template
-    
-    def self.source_directory
-      File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+##
+# This class creates new projects given the directory to put them
+# into and the name for the new project.
+class HotCocoa::Template
+  include FileUtils
+
+  ##
+  # Directories that need to be created for a new app project.
+  #
+  # @return [Array<String>]
+  DIRECTORIES    = [ 'lib', 'resources' ]
+
+  ##
+  # Project files which can be directly copied to a new project.
+  #
+  # @return [Array<String>]
+  COPIED_FILES   = [
+                    'lib/menu.rb',
+                    'resources/HotCocoa.icns'
+                   ]
+
+  ##
+  # Project files which contain tokens that need to be substituted
+  # before being copied to a new project.
+  #
+  # @return [Array<String>]
+  FILTERED_FILES = [
+                    'Rakefile',
+                    '__APPLICATION_NAME__.appspec',
+                    'lib/application.rb',
+                   ]
+
+  ##
+  # The path to the HotCocoa app template in the HotCocoa source files
+  #
+  # @return [String]
+  def self.template_directory
+    file = $LOADED_FEATURES.find { |file| file.match /hotcocoa\/template\.rbo?$/ }
+    File.expand_path(File.join(File.dirname(file), '../../template'))
+  end
+
+  # @param [String] dir where to put the project
+  # @param [String] name name for the project
+  def initialize dir, name
+    @directory = dir
+    @app_name  = name
+  end
+
+  ##
+  # Create the project!
+  def copy!
+    @template = self.class.template_directory
+    make_directories
+    copy_resources
+    copy_sources
+  end
+
+
+  private
+
+  ##
+  # Create the directory structure for a new app.
+  def make_directories
+    mkdir_p @directory
+    DIRECTORIES.each do |dir|
+      mkdir_p File.join(@directory, dir)
+    end
+  end
+
+  ##
+  # Copy all files that do not need to have tokens substituted.
+  def copy_resources
+    COPIED_FILES.each do |file|
+      cp File.join(@template, file), File.join(@directory, file)
     end
-    
-    def self.copy_to(directory, app_name)
-      FileUtils.mkdir_p(directory)
-      Dir.glob(File.join(source_directory, "template", "**/*")).each do |file|
-        short_name = file[(source_directory.length+10)..-1]
-        if File.directory?(file)
-          FileUtils.mkdir_p File.join(directory, short_name)
-        else
-          File.open(File.join(directory, short_name), "w") do |out|
-            input =  File.read(file)
-            input.gsub!(/__APPLICATION_NAME__/, app_name)
-            out.write input
-          end
-        end
-      end
+  end
+
+  ##
+  # Copy all files that need to have tokens substituted.
+  def copy_sources
+    company_name = ENV['USER'] || 'yourcompany'
+
+    FILTERED_FILES.each do |file|
+      input = File.read File.join(@template, file)
+      input.gsub! /__APPLICATION_NAME__/, @app_name
+      input.gsub! /__COMPANY_NAME__/, company_name
+
+      outname = file.gsub /__APPLICATION_NAME__/, @app_name
+      outname = File.join(@directory, outname)
+      File.open(outname, 'w') { |out| out.write input }
     end
   end
+
 end

data/lib/hotcocoa/version.rb

@@ -0,0 +1,3 @@
+module HotCocoa
+  VERSION = '0.6.0pre'
+end