hotcocoa 0.5.1 → 0.6.0pre

data/lib/hotcocoa/mappings/foundation/net_service_browser.rb

@@ -0,0 +1,27 @@
+HotCocoa::Mappings.map bonjour_browser: NSNetServiceBrowser do
+
+  ##
+  # There are no values that need to be set at initialization
+  def init_with_options browser, opts
+    browser.init
+  end
+
+  custom_methods do
+    def search_for_services type, domain = ''
+      searchForServicesOfType type, inDomain: domain
+    end
+
+    def search_for_domains
+      searchForBrowsableDomains
+    end
+  end
+
+  delegating 'netServiceBrowser:didFindDomain:moreComing:',     to: 'did_find_domain',     parameters: ['didFindDomain',    'moreComing']
+  delegating 'netServiceBrowser:didRemoveDomain:moreComing:',   to: 'did_remove_domain',   parameters: ['didRemoveDomain',  'moreComing']
+  delegating 'netServiceBrowser:didFindService:moreComing:',    to: 'did_find_service',    parameters: ['didFindService',   'moreComing']
+  delegating 'netServiceBrowser:didRemoveService:moreComing:',  to: 'did_remove_service',  parameters: ['didRemoveService', 'moreComing']
+  delegating 'netServiceBrowserWillSearch:',                    to: 'will_search'
+  delegating 'netServiceBrowser:didNotSearch:',                 to: 'did_not_search',      parameters: ['didNotSearch']
+  delegating 'netServiceBrowserDidStopSearch:',                 to: 'did_stop_search'
+
+end

data/lib/hotcocoa/mappings/foundation/notification.rb

@@ -0,0 +1,24 @@
+HotCocoa::Mappings.map notification: NSNotification do
+
+  defaults post: true, distributed: false
+
+  def alloc_with_options options
+    if options.delete :post
+      if options.delete :distributed
+        NSDistributedNotificationCenter.defaultCenter.postNotificationName options.delete(:name),
+                                                                   object: options.delete(:object),
+                                                                 userInfo: options.delete(:info),
+                                                       deliverImmediately: (options.delete(:immediately) == true)
+      else
+        NSNotificationCenter.defaultCenter.postNotificationName options.delete(:name),
+                                                        object: options.delete(:object),
+                                                      userInfo: options.delete(:info)
+      end
+    else
+      NSNotification.notificationName options.delete(:name),
+                              object: options.delete(:object),
+                            userInfo: options.delete(:info)
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/foundation/sort_descriptor.rb

@@ -0,0 +1,17 @@
+HotCocoa::Mappings.map sort_descriptor: NSSortDescriptor do
+
+  defaults ascending: true
+
+  def init_with_options sort_descriptor, opts
+    if opts.has_key? :selector
+      sort_descriptor.initWithKey opts.delete(:key),
+                       ascending: opts.delete(:ascending)
+
+    else
+      sort_descriptor.initWithKey opts.delete(:key),
+                       ascending: opts.delete(:ascending),
+                        selector: opts.delete(:selector)
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/foundation/timer.rb

@@ -0,0 +1,38 @@
+HotCocoa::Mappings.map timer: NSTimer do
+
+  defaults scheduled: true, repeats: false
+
+  def alloc_with_options options
+    raise ArgumentError, 'timer requires :interval' unless options.has_key? :interval
+
+    target   = options.delete :target
+    selector = options.delete :selector
+    unless target && selector
+      raise ArgumentError, 'timer requires either :target and :selector or :on_action' unless options.has_key? :on_action
+
+      target = Object.new
+      target.instance_variable_set(:@block, options.delete(:on_action))
+
+      def target.fire timer
+        @block.call(timer)
+      end
+
+      selector = 'fire:'
+    end
+
+    if options.delete :scheduled
+      NSTimer.scheduledTimerWithTimeInterval options.delete(:interval),
+                                     target: target,
+                                   selector: selector,
+                                   userInfo: options.delete(:info),
+                                    repeats: options.delete(:repeats)
+    else
+      NSTimer.timerWithTimeInterval options.delete(:interval),
+                            target: target,
+                          selector: selector,
+                          userInfo: options.delete(:info),
+                           repeats: options.delete(:repeats)
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/foundation/user_defaults.rb

@@ -0,0 +1,43 @@
+HotCocoa::Mappings.map user_defaults: NSUserDefaults do
+
+  defaults defaults: {}
+
+  def alloc_with_options options
+    user_defaults = NSUserDefaults.standardUserDefaults
+
+    unless options[:defaults].nil?
+      defs = {}
+      # force all keys to be strings, doesn't seem to like symbols
+      options.delete(:defaults).each_pair { |key, value| defs[key.to_s] = value }
+      user_defaults.registerDefaults(defs)
+    end
+
+    user_defaults
+  end
+
+  custom_methods do
+    def []= key, value
+      if value.nil?
+        delete key.to_s
+      else
+        setObject value, forKey: key.to_s
+      end
+      sync
+    end
+
+    def [] key
+      objectForKey key.to_s
+    end
+
+    def delete key
+      removeObjectForKey key.to_s
+      sync
+    end
+
+    # @todo Perhaps we should be making a an alert instead of printing to the log?
+    def sync
+      puts 'Failed to synchronize' unless synchronize
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/foundation/xml_parser.rb

@@ -0,0 +1,44 @@
+HotCocoa::Mappings.map xml_parser: NSXMLParser do
+
+  def alloc_with_options options
+    if options[:url]
+      url = options.delete :url
+      url = NSURL.URLWithString url if url.is_a? String
+      NSXMLParser.alloc.initWithContentsOfURL url
+
+    elsif options[:file]
+      NSXMLParser.alloc.initWithData NSData.dataWithContentsOfFile options.delete :file
+
+    elsif options[:data]
+      NSXMLParser.alloc.initWithData options.delete :data
+
+    else
+      raise 'Must provide either :url, :file, or :data when constructing an NSXMLParser'
+    end
+  end
+
+  delegating 'parserDidStartDocument:',                                                       to: :on_start_document
+  delegating 'parserDidEndDocument:',                                                         to: :on_end_document
+  delegating 'parser:didStartElement:namespaceURI:qualifiedName:attributes:',                 to: :on_start_element,               parameters: [:didStartElement, :namespaceURI, :qualifiedName, :attributes]
+  delegating 'parser:didEndElement:namespaceURI:qualifiedName:',                              to: :on_end_element,                 parameters: [:didEndElement, :namespaceURI, :qualifiedName]
+  delegating 'parser:didStartMappingPrefix:toURI:',                                           to: :on_start_mapping_prefix,        parameters: [:didStartMappingPrefix, :toURI]
+  delegating 'parser:didEndMappingPrefix:',                                                   to: :on_end_mapping_prefix,          parameters: [:didEndMappingPrefix]
+
+  delegating 'parser:foundAttributeDeclarationWithName:forElement:type:defaultValue:',        to: :on_attribute_declaration,       parameters: [:foundAttributeDeclarationWithName, :forElement, :type, :defaultValue]
+  delegating 'parser:foundCDATA:',                                                            to: :on_cdata,                       parameters: [:foundCDATA]
+  delegating 'parser:foundCharacters:',                                                       to: :on_characters,                  parameters: [:foundCharacters]
+  delegating 'parser:foundComment:',                                                          to: :on_comment,                     parameters: [:foundComment]
+  delegating 'parser:foundElementDeclarationWithName:model:',                                 to: :on_element_declaration,         parameters: [:foundElementDeclarationWithName, :model]
+  delegating 'parser:foundExternalEntityDeclarationWithName:publicID:systemID:',              to: :on_external_entity_declaration, parameters: [:foundExternalEntityDeclarationWithName, :publicID, :systemID]
+  delegating 'parser:foundIgnorableWhitespace:',                                              to: :on_ignorable_whitespace,        parameters: [:foundIgnorableWhitespace]
+  delegating 'parser:foundInternalEntityDeclarationWithName:value:',                          to: :on_internal_entity_declaration, parameters: [:foundInternalEntityDeclarationWithName, :value]
+  delegating 'parser:foundNotationDeclarationWithName:publicID:systemID:',                    to: :on_notation_declaration,        parameters: [:foundNotationDeclarationWithName, :data]
+  delegating 'parser:foundProcessingInstructionWithTarget:data:',                             to: :on_processing_instruction,      parameters: [:foundProcessingInstructionWithTarget, :data]
+  delegating 'parser:foundUnparsedEntityDeclarationWithName:publicID:systemID:notationName:', to: :on_unparsed_entity_declaration, parameters: [:foundUnparsedEntityDeclarationWithName, :publicID, :systemID, :notationName]
+
+  delegating 'parser:resolveExternalEntityName:systemID:',                                    to: :resolve_external_entity_name,   parameters: [:resolveExternalEntityName, :systemID]
+
+  delegating 'parser:parseErrorOccurred:',                                                    to: :on_parse_error,                 parameters: [:parseErrorOccurred]
+  delegating 'parser:validationErrorOccurred:',                                               to: :on_validation_error,            parameters: [:validationErrorOccurred]
+
+end

data/lib/hotcocoa/mappings/qtkit/movie.rb

@@ -0,0 +1,15 @@
+HotCocoa::Mappings.map movie: QTMovie do
+
+  def alloc_with_options options
+    if options.has_key? :file
+      QTMovie.movieWithFile options.delete(:file), error:options.delete(:error)
+
+    elsif options.has_key? :url
+      QTMovie.movieWithURL NSURL.URLWithString(options.delete :url), error:options.delete(:error)
+
+    else
+      raise 'Can only allocate a movie from a file or a url'
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/qtkit/movie_view.rb

@@ -0,0 +1,28 @@
+HotCocoa::Mappings.map movie_view: QTMovieView do
+
+  defaults layout: {}, frame: CGRectZero
+
+  def init_with_options movie_view, options
+    movie_view.initWithFrame(options.delete :frame)
+  end
+
+  custom_methods do
+    def controller_visible= value
+      setControllerVisible value
+    end
+
+    ##
+    # @todo Change this method to use varargs in the future when we
+    #       start deprecating things
+    def controller_buttons= buttons
+      setBackButtonVisible      buttons.include? :back
+      setCustomButtonVisible    buttons.include? :custom
+      setHotSpotButtonVisible   buttons.include? :hot_spot
+      setStepButtonsVisible     buttons.include? :step
+      setTranslateButtonVisible buttons.include? :translate
+      setVolumeButtonVisible    buttons.include? :volume
+      setZoomButtonsVisible     buttons.include? :zoom
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/webkit/web_view.rb

@@ -0,0 +1,20 @@
+HotCocoa::Mappings.map web_view: WebView do
+
+  defaults layout: {}, frame: CGRectZero
+
+  def init_with_options web_view, options
+    web_view.initWithFrame options.delete :frame
+  end
+
+  custom_methods do
+    def url= url
+      url = NSURL.URLWithString(url) if url.kind_of? String
+      mainFrame.loadRequest NSURLRequest.requestWithURL url
+    end
+
+    def auto_size
+      setAutoresizingMask(NSViewHeightSizable|NSViewWidthSizable)
+    end
+  end
+
+end

data/lib/hotcocoa/mappings.rb

@@ -1,115 +1,61 @@
-module HotCocoa
-  module Mappings
-    
-    def self.reload
-      Dir.glob(File.join(File.dirname(__FILE__), "mappings", "*.rb")).each do |mapping|
-        require mapping
-      end
-    end
-    
-    DefaultEmptyRect = [0,0,0,0]
-    
-    module TargetActionConvenience
-      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
-     
-      def on_action(&behavior)
-        self.on_action = behavior
-        self
-      end
-    end
-    
-    # TODO: Needs docs for all possible invocations and examples!
-    def self.map(options, &block)
-      framework = options.delete(:framework)
-      mapped_name = options.keys.first
-      mapped_value = options.values.first
-      args = [mapped_name, mapped_value]
-      
-      if mapped_value.kind_of?(Class)
-        add_mapping(*args, &block)
-      else
-        if framework.nil? || loaded_framework?(framework)
-          add_constant_mapping(*args, &block)
-        else
-          on_framework(framework) do
-            add_constant_mapping(*args, &block)
-          end
-        end
-      end
-    end
-    
-    # Registers +mapped_name+ as a Mapper#builder_method for the given
-    # +mapped_value+. The +block+ is used as the Mapper#builder_method's body.
-    def self.add_mapping(mapped_name, mapped_value, &block)
-      m = Mapper.map_instances_of(mapped_value, mapped_name, &block)
-      mappings[m.builder_method] = m
-    end
-    
-    # Registers +mapped_name+ as a Mapper#builder_method for the given
-    # +constant+ string which will be looked up. The +block+ is used as the
-    # Mapper#builder_method's body.
-    def self.add_constant_mapping(mapped_name, constant, &block)
-      add_mapping(mapped_name, Object.full_const_get(constant), &block)
-    end
-    
-    # Returns the Hash of mappings.
-    def self.mappings
-      @mappings ||= {}
-    end
-    
-    # Registers a callback for after the specified framework has been loaded.
-    def self.on_framework(name, &block)
-      (frameworks[name.to_s] ||= []) << block
-    end
-    
-    # Returns the Hash of mapped frameworks.
-    def self.frameworks
-      @frameworks ||= {}
-    end
-    
-    # Returns the Set of loaded frameworks.
-    def self.loaded_frameworks
-      @loaded_frameworks ||= Set.new
-    end
-    
-    # Registers a given framework as being loaded.
-    def self.framework_loaded
-      frameworks.keys.each do |key|
-        if loaded_framework?(key)
-          frameworks[key].each do |mapper|
-            mapper.call
-          end
-          frameworks.delete(key)
-        end
+module HotCocoa::Mappings
+  # needs to be initialized
+  @mappings = {}
+
+  ##
+  # This is a hack to work around a MacRuby issue with compiled files.
+  #
+  # Return the absolute path to `lib/hotcocoa`.
+  #
+  # @return [String]
+  file = $LOADED_FEATURES.find { |file| file.match /hotcocoa\/mappings\.rbo?$/ }
+  @path = File.expand_path(File.join(File.dirname(file), 'mappings'))
+end
+
+class << HotCocoa::Mappings
+
+  ##
+  # The cache of mappers for available mappings.
+  #
+  # @return [Hash{Symbol=>HotCocoa::Mappings::Mapper}]
+  attr_reader :mappings
+
+  ##
+  # Load mappings for every loaded framework.
+  def reload
+    $LOADED_FRAMEWORKS.each do |framework| load framework end
+  end
+
+  ##
+  # Load mappings for a given framework.
+  #
+  # @param [String] framework
+  def load framework
+    framework = framework.downcase
+    dir       = File.join(@path, framework)
+    if Dir.exists? dir
+      Dir.glob(File.join(dir, '**/*.rb')).each do |mapping|
+        require mapping.chomp! '.rb'
       end
     end
-    
-    # Returns whether or not the framework has been loaded yet.
-    def self.loaded_framework?(name)
-      NSBundle.allFrameworks.map { |bundle|
-        bundle.bundlePath.split("/").last
-      }.select { |framework|
-        framework.split(".")[1] == 'framework'
-      }.map { |framework|
-        framework.split(".")[0]
-      }.include?(name.to_s)
-    end
-    
   end
-  
+
+  ##
+  # Create a new mapping by registering `mapped_name` as a builder
+  # method for `mapped_class`.
+  #
+  # @example
+  #
+  #   HotCocoa::Mappings.map( window: NSWindow ) do
+  #     # define your mapping
+  #   end
+  #
+  # @param [Symbol] mapped_name
+  # @param [Class]  mapped_class
+  def map name, &block
+    mapped_name, mapped_class = name.first
+    mappings[mapped_name] =
+      HotCocoa::Mappings::Mapper.map_instances_of mapped_class, mapped_name, &block
+  end
+
 end