hotcocoa 0.5

data/lib/hotcocoa/mappings.rb

@@ -0,0 +1,109 @@
+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
+      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
+  
+end

data/lib/hotcocoa/mvc.rb

@@ -0,0 +1,175 @@
+require 'hotcocoa'
+
+class HotCocoaApplication
+  attr_accessor :shared_application, :application_controller, :controllers
+  
+  include HotCocoa
+  
+  def self.instance=(instance)
+    @instance = instance
+  end
+  
+  def self.instance
+    @instance
+  end
+  
+  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)
+    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)
+    @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))
+    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
+    end
+  
+end
+
+class HotCocoaController
+  
+  def self.view_instances
+    @view_instances ||= {}
+  end
+  
+  attr_reader :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)
+    @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]}
+  
+  module ClassMethods
+    def controller(name=nil)
+      if name
+        @name = name
+      else
+        @name || :application_controller
+      end
+    end
+    def options(options=nil)
+      if options
+        @options = options
+      else
+        @options
+      end
+    end
+  end
+  
+  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
+    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}].setup_view
+        end
+        HotCocoaController.view_instances[:#{class_name}]
+      end
+    }, __FILE__, __LINE__
+  end
+  
+  attr_reader :controller
+
+  def setup_view
+    unless @controller
+      @controller = class_controller
+      self.layout = layout_options
+      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
+    
+end
+
+class ApplicationWindow < HotCocoaWindow
+  
+end
+
+class Application < HotCocoaApplication
+  
+end

data/lib/hotcocoa/notification_listener.rb

@@ -0,0 +1,62 @@
+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)
+    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
+    
+    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)
+  end
+end

data/lib/hotcocoa/object_ext.rb

@@ -0,0 +1,22 @@
+# Object.full_const_get was taken from the ‘extlib’ project:
+# http://github.com/sam/extlib which is released under a MIT License and
+# copyrighted by Sam Smoot (2008).
+
+class Object
+
+  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
+  #
+  # @return <Object> The constant corresponding to the name.
+  def full_const_get(name)
+    list = name.split("::")
+    list.shift if list.first.empty?
+    obj = self
+    list.each do |x|
+      # This is required because const_get tries to look for constants in the
+      # ancestor chain, but we only want constants that are HERE
+      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+    end
+    obj
+  end
+
+end

data/lib/hotcocoa/plist.rb

@@ -0,0 +1,45 @@
+module HotCocoa
+  def read_plist(data, mutability=:all)
+    mutability = case mutability
+      when :none
+        NSPropertyListImmutable
+      when :containers_only
+        NSPropertyListMutableContainers
+      when :all
+        NSPropertyListMutableContainersAndLeaves
+      else
+        raise ArgumentError, "invalid mutability `#{mutability}'"
+    end
+    if data.is_a?(String)
+      data = data.dataUsingEncoding(NSUTF8StringEncoding)
+      if data.nil?
+        raise ArgumentError, "cannot convert string `#{data}' to data"
+      end
+    end
+    # TODO retrieve error description and raise it if there is an error.
+    NSPropertyListSerialization.propertyListFromData(data,
+      mutabilityOption:mutability,
+      format:nil,
+      errorDescription:nil)
+  end
+end
+
+class Object
+  def to_plist(format=:xml)
+    format = case format
+      when :xml
+        NSPropertyListXMLFormat_v1_0 
+      when :binary
+        NSPropertyListBinaryFormat_v1_0
+      when :open_step
+        NSPropertyListOpenStepFormat 
+      else
+        raise ArgumentError, "invalid format `#{format}'"
+    end
+    # TODO retrieve error description and raise it if there is an error.
+    data = NSPropertyListSerialization.dataFromPropertyList(self,
+      format:format,
+      errorDescription:nil)
+    NSMutableString.alloc.initWithData(data, encoding:NSUTF8StringEncoding) 
+  end
+end

data/lib/hotcocoa/standard_rake_tasks.rb

@@ -0,0 +1,17 @@
+AppConfig = HotCocoa::ApplicationBuilder::Configuration.new("config/build.yml")
+
+task :deploy => [:clean] do
+  HotCocoa::ApplicationBuilder.build(AppConfig, :deploy => true)
+end
+
+task :build do
+  HotCocoa::ApplicationBuilder.build(AppConfig)
+end
+
+task :run => [:build] do
+  `"./#{AppConfig.name}.app/Contents/MacOS/#{AppConfig.name.gsub(/ /, '')}"`
+end
+
+task :clean do
+  `/bin/rm -rf "#{AppConfig.name}.app"`
+end

data/lib/hotcocoa/template.rb

@@ -0,0 +1,27 @@
+require 'fileutils'
+require 'rbconfig'
+
+module HotCocoa
+  class Template
+    
+    def self.source_directory
+      File.expand_path(File.join(File.dirname(__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
+  end
+end

data/lib/hotcocoa/virtual_file_system.rb

@@ -0,0 +1,172 @@
+class VirtualFileSystem
+  
+  def self.code_to_load(main_file, password = "\320\302\354\024\215\360P\235\2244\261\214\276:'\274%\270<\350t\212\003\340\t'\004\345\334\256\315\277")
+    <<-VFS
+    module DatabaseRuntime
+
+      class VirtualFilesystem
+
+        attr_reader :password, :encryption_method
+
+        def initialize(password, encryption_method="aes256")
+          @password = password
+          @encryption_method = encryption_method
+        end
+
+        def open_database(main_database)
+          @main_database = main_database
+          begin
+            @db = Marshal.load(File.open(main_database, "rb") {|f| f.read})
+          rescue 
+            puts $!
+            puts $!.backtrace.join("\\n")
+          end
+        end
+
+        def read_file_and_key(filename)
+          data, key = read_file_using_path(filename)
+          if data.nil? && filename[0,1] != "/"
+            $:.each do |loadpath|
+              data, key = read_file_using_path(filename, expand_path(loadpath))
+              break if data
+            end
+          end
+          [data, key]
+        end
+
+        def read_file_using_path(filename, pathname="/")
+          path = expand_path(File.join(pathname, filename))
+          rb_ext = false
+          if has_key?(path)
+            key = filename
+          elsif self.has_key?(path+".rb")
+            key = filename+".rb"
+            rb_ext = true
+          end
+          if key
+            result = rb_ext ? self[path+".rb"] : self[path]
+            if result
+              result.gsub!(/__FILE__/, "'\#{path + (rb_ext ? ".rb" : '')}'")
+              return result, key
+            end
+          end
+          nil
+        end
+
+        def has_key?(key)
+          @db.has_key?(key)
+        end
+
+        def delete(key)
+        end
+
+        def [](key)
+          read(@db, key)
+        end
+
+        def close
+        end
+
+        def keys
+          @db.keys
+        end
+
+        def []=(key, value)
+        end
+
+        def normalize(filename)
+          f = filename.split(File::Separator)
+          f.delete(".")
+          while f.include?("..")
+            f[f.index("..")-1,2] = []
+          end
+          f.join(File::Separator)
+        end
+
+        private 
+
+          def expand_path(filename, dirstring=nil)
+            filename = File.join(dirstring, filename) if dirstring
+            f = filename.split(File::Separator)
+            f.delete(".")
+            f.delete("")
+            while f.include?("..")
+              f[f.index("..")-1,2] = []
+            end
+            "/"+f.join(File::Separator)
+          end
+
+
+          def read(db, key)
+            if db.has_key?(key)
+              #decrypt = OpenSSL::Cipher::Cipher.new(encryption_method)
+              #decrypt.decrypt
+              #decrypt.key = password
+              #data = decrypt.update(db[key])
+              #data << decrypt.final
+              #::Zlib::Inflate.inflate(data)
+              db[key]
+            else
+              nil
+            end
+          end
+
+      end
+
+    end
+
+    $ROOT_BINDING = binding
+
+    module Kernel
+
+      def virtual_filesystems(options)
+        vfs = DatabaseRuntime::VirtualFilesystem.new(options["password"])
+        vfs.open_database(options["database"])
+        Kernel.const_set("VIRTUAL_FILESYSTEM", vfs)
+        vfs
+      end
+
+      alias_method :original_require, :require
+
+      def require(path)
+        path = VIRTUAL_FILESYSTEM.normalize(path)
+        path_loaded =  $".include?(path) || $".include?(path+".rb") || $".include?(path+".so")
+        unless path_loaded
+          data, key = VIRTUAL_FILESYSTEM.read_file_and_key(path)
+          if data
+            $" << key
+            eval(data, $ROOT_BINDING, key, 0)
+            return true
+          else
+            original_require(path)
+          end
+        else
+          return false
+        end
+      end
+
+      alias_method :original_load, :load
+
+      def load(path)
+        path = VIRTUAL_FILESYSTEM.normalize(path)
+        data, key = VIRTUAL_FILESYSTEM.read_file_and_key(path)
+        if data
+          eval(data, $ROOT_BINDING, key, 0)
+          return true
+        else
+          begin
+            original_load(path)
+          rescue LoadError => e
+            raise e
+          end
+        end
+      end
+
+    end
+
+    virtual_filesystems("database"=>File.join(NSBundle.mainBundle.resourcePath.fileSystemRepresentation, 'vfs.db'), "password"=>#{password.inspect})
+    $:.unshift "/lib"
+    load '#{main_file}'
+    VFS
+  end
+end

data/lib/hotcocoa.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+framework 'Cocoa'
+
+module Hotcocoa
+  VERSION = '0.0.1'
+  Views = {}
+end
+
+require 'hotcocoa/object_ext'
+require 'hotcocoa/kernel_ext'
+require 'hotcocoa/mappings'
+require 'hotcocoa/behaviors'
+require 'hotcocoa/mapping_methods'
+require 'hotcocoa/mapper'
+require 'hotcocoa/layout_view'
+require 'hotcocoa/delegate_builder'
+require 'hotcocoa/notification_listener'
+require 'hotcocoa/data_sources/table_data_source'
+require 'hotcocoa/data_sources/combo_box_data_source'
+require 'hotcocoa/plist'
+require 'hotcocoa/kvo_accessors'
+require 'hotcocoa/attributed_string'
+
+HotCocoa::Mappings.reload

data/template/Rakefile

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'hotcocoa/application_builder'
+require 'hotcocoa/standard_rake_tasks'
+
+task :default => [:run]

data/template/config/build.yml

@@ -0,0 +1,8 @@
+name: __APPLICATION_NAME__
+load: lib/application.rb
+version: "1.0"
+icon: resources/HotCocoa.icns
+resources:
+  - resources/**/*.*
+sources: 
+  - lib/**/*.rb