rucola 0.0.3 → 0.5.0

data/lib/rucola/dependencies/exclusions.rb

@@ -0,0 +1,20 @@
+module Rucola
+  class Dependencies
+    class << self
+      def exclusions
+        @exclusions ||= []
+      end
+      
+      def exclude(regexp)
+        exclusions << regexp
+      end
+      
+      def exclude?(name)
+        exclusions.any? { |regexp| name =~ regexp }
+      end
+    end
+    
+    # define libs that should not be resolved here
+    exclude(/osx\//)
+  end
+end

data/lib/rucola/dependencies/override_require_and_gem.rb

@@ -0,0 +1,30 @@
+# These monkey patches are used in a app if it has rucola bundled
+
+# make Gem work
+unless defined? Gem
+  module Gem #:nodoc:
+    class LoadError < StandardError #:nodoc:
+    end
+  end
+end
+
+module Rucola
+  class Dependencies
+    def self.override_require_and_gem!
+      Kernel.module_eval do
+        alias_method :__require_before_rucola_standalone_app, :require
+        def require(name)
+          return if name == 'rubygems' # atm we don't want to allow rubygems
+          # check if there's an exception for this requirement and load it, otherwise load the original
+          exception = Rucola::Dependencies.instance.exceptions[name] if Rucola::Dependencies.respond_to?(:instance) # check if everything is done loading
+          __require_before_rucola_standalone_app(exception || name)
+        end
+
+        def gem(name, version)
+          #puts "Gem required: #{name}"
+          require(name)
+        end
+      end
+    end
+  end
+end

data/lib/rucola/dependencies/resolver.rb

@@ -0,0 +1,68 @@
+require 'yaml'
+require 'osx/cocoa'
+
+require File.expand_path('../exclusions', __FILE__)
+
+class DependencyResolver #:nodoc:
+  class UnableToResolveError < StandardError #:nodoc:
+  end
+
+  def initialize(name, version)
+    @name, @version = name, version
+  end
+
+  def require!
+    verbose_before = $VERBOSE
+    $VERBOSE = nil
+    begin
+      if Kernel.private_methods.include? 'gem_original_require'
+        gem_original_require(@name)
+      else
+        require(@name)
+      end
+    rescue LoadError
+      # unfortunately, rubygems will always require 'etc.bundle' & 'fileutils' so there's no real way of knowing
+      # wether or not it was required by rubygems or the actual library.
+      begin
+        Gem.activate(@name, true, @version)
+        require(@name)
+      rescue NameError
+        raise UnableToResolveError, "Unable to resolve: '#{@name}', '#{@version}'"
+      end
+    end
+    $VERBOSE = verbose_before
+  end
+
+  def difference_in_loaded_features
+    # save this to set it back to what it originally was
+    loaded_features_before_rubygems = $LOADED_FEATURES.dup
+    
+    $LOADED_FEATURES.replace([])
+    require 'rubygems' rescue LoadError
+    
+    Kernel.module_eval do
+      alias_method :__require_before_dependency_resolver, :require
+      def require(name)
+        unless Rucola::Dependencies.exclude?(name)
+          __require_before_dependency_resolver(name)
+        end
+      end
+    end
+    
+    # save this so we can compare what else was added except for rubygems
+    loaded_features_before = $LOADED_FEATURES.dup
+    
+    require!
+    
+    result = ($LOADED_FEATURES - loaded_features_before)
+    $LOADED_FEATURES.replace(loaded_features_before_rubygems)
+    result
+  end
+end
+
+name, version = ARGV[0..1]
+$LOAD_PATH.replace(YAML.load(ARGV[2])) unless ARGV[2].nil?
+
+dr = DependencyResolver.new(name, version)
+# print to stdout the serialized results array
+puts YAML.dump(dr.difference_in_loaded_features)

data/lib/rucola/fsevents.rb

@@ -0,0 +1,108 @@
+OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+
+module Rucola
+  class FSEvents
+    class FSEvent
+      attr_reader :fsevents_object
+      attr_reader :id
+      attr_reader :path
+      def initialize(fsevents_object, id, path)
+        @fsevents_object, @id, @path = fsevents_object, id, path
+      end
+      
+      # Returns an array of the files/dirs in the path that the event occurred in.
+      # The files are sorted by the modification time, the first entry is the last modified file.
+      def files
+        Dir.glob("#{File.expand_path(path)}/*").sort_by {|f| File.mtime(f) }.reverse
+      end
+      
+      # Returns the last modified file in the path that the event occurred in.
+      def last_modified_file
+        files.first
+      end
+    end
+    
+    class StreamError < StandardError; end
+    
+    attr_reader :paths
+    attr_reader :stream
+    
+    attr_accessor :allocator
+    attr_accessor :context
+    attr_accessor :since
+    attr_accessor :latency
+    attr_accessor :flags
+    
+    class << self
+      # Initializes a new FSEvents `watchdog` object,
+      # creates, starts and then returns the stream.
+      #
+      # Pass it a block which will be used as a callback.
+      # The block will receive an array of FSEvent objects.
+      #
+      #   fsevents = Rucola::FSEvents.start_watching('/some/path') do |events|
+      #     events.each do |event|
+      #       p event
+      #     end
+      #   end
+      #   p fsevents
+      def start_watching(*paths, &block)
+        fsevents = new(paths.flatten, &block)
+        fsevents.create_stream
+        fsevents.start
+        fsevents
+      end
+    end
+    
+    # Creates a new FSEvents `watchdog` object.
+    # Pass it an array of paths and a block with your callback. Options allow you to specify in more detail how
+    # the events watcher should behave.
+    #
+    # *:since: The service will report events that have happened after the supplied event ID. Never use 0 because that 
+    #   will cause every fsevent since the "beginning of time" to be reported. Use OSX::KFSEventStreamEventIdSinceNow
+    #   if you want to receive events that have happened after this call. (Default: OSX::KFSEventStreamEventIdSinceNow).
+    # *:latency: Number of seconds to wait until an FSEvent is reported, this allows the service to bundle events. (Default: 0.0)
+    #
+    # For the rest of the options read the Cocoa documentation.
+    def initialize(paths, options={}, &block)
+      raise ArgumentError, 'No callback block was specified.' unless block_given?
+      paths.each { |path| raise ArgumentError, "The specified path (#{path}) does not exist." unless File.exist?(path) }
+      
+      @allocator = options[:allocator] || OSX::KCFAllocatorDefault
+      @context   = options[:context]   || nil
+      @since     = options[:since]     || OSX::KFSEventStreamEventIdSinceNow
+      @latency   = options[:latency]   || 0.0
+      @flags     = options[:flags]     || 0
+      @stream    = options[:stream]    || nil
+      
+      @paths = paths
+      @user_callback = block
+      @callback = Proc.new do |stream, client_callback_info, number_of_events, paths_pointer, event_flags, event_ids|
+        paths_pointer.regard_as('*')
+        events = []
+        number_of_events.times {|i| events << Rucola::FSEvents::FSEvent.new(self, event_ids[i], paths_pointer[i]) }
+        @user_callback.call(events)
+      end
+    end
+    
+    # Create the stream.
+    # Raises a Rucola::FSEvents::StreamError if the stream could not be created.
+    def create_stream
+      @stream = OSX.FSEventStreamCreate(@allocator, @callback, @context, @paths, @since, @latency, @flags)
+      raise(StreamError, 'Unable to create FSEvents stream.') unless @stream
+      OSX.FSEventStreamScheduleWithRunLoop(@stream, OSX.CFRunLoopGetCurrent, OSX::KCFRunLoopDefaultMode)
+    end
+    
+    # Start the stream.
+    # Raises a Rucola::FSEvents::StreamError if the stream could not be started.
+    def start
+      raise(StreamError, 'Unable to start FSEvents stream.') unless OSX.FSEventStreamStart(@stream)
+    end
+    
+    # Stop the stream.
+    # You can resume it by calling `start` again.
+    def stop
+      OSX.FSEventStreamStop(@stream)
+    end
+  end
+end

data/lib/rucola/initializer.rb

@@ -1,39 +1,40 @@
 require 'osx/cocoa'
 require 'pathname'
 
-require 'rucola/rucola_support/rc_app'
-require 'rucola/plugin'
-
-unless ENV['RUBYCOCOA_ENV'].nil?
-  RUBYCOCOA_ENV = ENV['RUBYCOCOA_ENV']
-else
-  unless ENV['DYLD_LIBRARY_PATH'].nil?
-    env = ENV['DYLD_LIBRARY_PATH'].split('/').last.downcase
-    if %(debug release test).include?(env)
-      RUBYCOCOA_ENV = env
+if !defined?(RUBYCOCOA_ENV) or RUBYCOCOA_ENV.nil?
+  if ENV['RUBYCOCOA_ENV']
+    RUBYCOCOA_ENV = ENV['RUBYCOCOA_ENV']
+  else
+    if ENV['DYLD_LIBRARY_PATH']
+      env = ENV['DYLD_LIBRARY_PATH'].split('/').last.downcase
+      if %(debug release test).include?(env)
+        RUBYCOCOA_ENV = env
+      else
+        RUBYCOCOA_ENV = 'debug'
+      end
     else
-      RUBYCOCOA_ENV = 'debug'
+      RUBYCOCOA_ENV = 'release'
     end
-  else
-    RUBYCOCOA_ENV = 'release'
   end
 end
 
-unless ENV['RUBYCOCOA_ROOT'].nil?
-  # rake will set the RUBYCOCOA_ROOT for debugging purpose
-  RUBYCOCOA_ROOT = Pathname.new(ENV['RUBYCOCOA_ROOT'])
-else
-  # We are running in debug from xcode, which doesn't set RUBYCOCOA_ROOT.
-  # Or we are simply running in release.
-  RUBYCOCOA_ROOT = 
-    if RUBYCOCOA_ENV == 'release'
-      Pathname.new(OSX::NSBundle.mainBundle.resourcePath.fileSystemRepresentation)
-    else
-      Pathname.new(ENV['DYLD_LIBRARY_PATH'] + "../../../").cleanpath
-    end
+if !defined?(RUBYCOCOA_ROOT) or RUBYCOCOA_ROOT.nil?
+  if ENV['RUBYCOCOA_ROOT']
+    # rake will set the RUBYCOCOA_ROOT for debugging purpose
+    RUBYCOCOA_ROOT = Pathname.new(ENV['RUBYCOCOA_ROOT'])
+  else
+    # We are running in debug from xcode, which doesn't set RUBYCOCOA_ROOT.
+    # Or we are simply running in release.
+    RUBYCOCOA_ROOT = 
+      if RUBYCOCOA_ENV == 'release'
+        Pathname.new(OSX::NSBundle.mainBundle.resourcePath.fileSystemRepresentation)
+      else
+        Pathname.new(ENV['DYLD_LIBRARY_PATH'] + "../../../").cleanpath
+      end
+  end
 end
 
-$:.unshift(RUBYCOCOA_ROOT)
+$:.unshift(RUBYCOCOA_ROOT.to_s)
 
 module Rucola
   # Are we building and running or just running this application by clicking on 
@@ -44,15 +45,23 @@ module Rucola
 end
 
 
-# Environment initialization scheme ported/derived from Rails' Initializer.
-require 'erb'
+# we need to require everything that would be needed by a standalone application
+require 'erb' # FIXME: this should only be required if we're really gonna use erb (AR project)
+require 'rucola/rucola_support'
+require 'rucola/dependencies'
+require 'rucola/dependencies/exclusions'
+require 'rucola/dependencies/override_require_and_gem'
+require 'rucola/plugin'
+require 'rucola/ruby_debug'
+
 module Rucola
   # Rails-like Initializer responsible for processing configuration.
   class Initializer
-    # The Configuration instance used by this Initializer instance.
-    attr_reader :configuration
-    
     class << self
+      def instance
+        @initializer ||= new
+      end
+      
       # Load the config/boot.rb file.
       def boot
         Rucola::Plugin.before_boot
@@ -64,7 +73,7 @@ module Rucola
       # to alter behaviour before any of the application's files are required
       # and the app is started.
       def do_boot
-        require RUBYCOCOA_ROOT + 'config/boot'
+        Kernel.require Rucola::RCApp.root_path + '/config/boot'
       end
       
       # Returns the path to the plugins root directory. Eg /MyApp/vendor/plugins.
@@ -77,53 +86,71 @@ module Rucola
         root = plugins_root
         if root.exist?
           root.children.each do |plugin|
-            next unless plugin.directory?
-            Kernel.require plugin + 'init.rb'
+            init_rb = plugin + 'init.rb'
+            next unless init_rb.exist?
+            Kernel.require init_rb
           end
         end
       end
       
-      # Run the initializer and start the application.  The #process method is run by default which 
-      # runs all the initialization routines.  You can alternatively specify 
-      # a command to run.
-      # 
-      #    OSX::Initializer.run(:set_load_path)
+      # Run the initializer and start the application.
+      # Pass it a block to set the configuration.
       #
-      def run(command = :process, configuration = Configuration.new)
-        yield configuration if block_given?
-        initializer = new configuration
-        initializer.send(command)
-        start_app
+      #   Rucola::Initializer.run do |config|
+      #     config.use_debugger = true
+      #     # See +Configuration+ for more info on the options.
+      #   end
+      def run
+        if @initializer.nil?
+          @initializer = new
+          
+          yield @initializer.configuration if block_given?
+          @initializer.process
+          
+          start_app
+        else
+          yield @initializer.configuration if block_given?
+        end
       end
       
       # Starts the application's run loop.
       def start_app
-        OSX.NSApplicationMain(0, nil) unless RUBYCOCOA_ENV == 'test' || ENV['DONT_START_RUBYCOCOA_APP']
+        OSX.NSApplicationMain(0, nil) unless Rucola::RCApp.test? || ENV['DONT_START_RUBYCOCOA_APP']
       end
     end
     
-    # Create an initializer instance that references the given 
-    # Configuration instance. 
-    def initialize(configuration)
-      @configuration = configuration
+    # The Configuration instance used by this Initializer instance.
+    attr_reader :configuration
+    
+    # Create an initializer instance.
+    def initialize
+      @configuration = Configuration.new
     end
     
-    # Step through the initialization routines, skipping the active_record 
-    # routines if active_record isnt' being used.
+    # Step through the initialization routines.
     def process
       Rucola::Plugin.before_process(self)
-      unless ENV['DYLD_LIBRARY_PATH'].nil?
-        set_load_path
-        copy_load_paths_for_release
-      end
       
-      require_rucola_support
+      # load the environment config
+      @configuration.load_environment_configuration!
+      
+      Rucola::Debugger.use! if @configuration.use_debugger
+      use_reloader! if @configuration.use_reloader
+      
+      require_dependencies
       require_frameworks
+      require_lib_source_files
       require_ruby_source_files
-      load_environment
+      
       Rucola::Plugin.after_process(self)
     end
     
+    # Requires all the dependencies specified in config/dependencies.rb
+    def require_dependencies
+      deps_file = (RUBYCOCOA_ROOT + 'config/dependencies.rb').to_s
+      Rucola::Dependencies.load(deps_file).require!
+    end
+    
     # Requires all frameworks specified by the Configuration#objc_frameworks
     # list.  This is also responsible for including osx/active_record_proxy if 
     # use_active_record? is true
@@ -131,11 +158,6 @@ module Rucola
       configuration.objc_frameworks.each { |framework| OSX.require_framework(framework) }
     end
     
-    # Loads the Rucola support library
-    def require_rucola_support
-      require Pathname.new(__FILE__).dirname + 'rucola_support'
-    end
-    
     # Recursively requires any ruby source file that it finds.
     def require_ruby_source_files_in_dir_recursive(dir)
       dir.children.each do |child|
@@ -147,6 +169,13 @@ module Rucola
       end
     end
     
+    # Requires any ruby source files in the app/lib/ directory.
+    def require_lib_source_files
+      Dir[RUBYCOCOA_ROOT + 'lib/*.rb'].each do |f|
+        require f
+      end
+    end
+    
     # Loops through the subdirectories of the app/ directory.
     # It requires any ruby file in any of the subdirectories and registers
     # the required file in the hash +@require_ruby_source_files+ with the name
@@ -159,45 +188,26 @@ module Rucola
       end
     end
     
-    def load_application_initializers
-      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
-        load(initializer)
+    # Loads the +Reloader+ lib if +use_reloader+ is set to +true+ on the +Configuration+.
+    def use_reloader!
+      if configuration.use_reloader
+        Kernel.require 'rucola/reloader'
+        Rucola::Reloader.start!
       end
     end
     
-    # Loads the environment specified by Configuration#environment_path, which
-    # can be debug or release
-    def load_environment
-      return if @environment_loaded
-      @environment_loaded = true
-      
-      config = configuration
-      constants = self.class.constants
-      eval(IO.read(configuration.environment_path), binding, configuration.environment_path)
-
-      (self.class.constants - constants).each do |const|
-        Object.const_set(const, self.class.const_get(const))
+    def load_application_initializers
+      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
+        load(initializer)
       end
     end
     
     # Set the paths from which your application will automatically load source files.
-    def set_load_path
-      load_paths = configuration.load_paths
-      load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) } unless RUBYCOCOA_ENV == 'test' # FIXME: why??
+    def set_load_path!
+      load_paths = configuration.load_paths || [] # TODO: from script/console the configuration isn't ran.
+      load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) } unless Rucola::RCApp.test? # FIXME: why??
       $LOAD_PATH.uniq!
     end
-    
-    # Copy the default load paths to the resource directory for the application if 
-    # we are building a release, otherwise we do nothing. When in debug or test mode,
-    # the files are loaded directly from your working directory.
-    #
-    # TODO: Remove debug database from released app if it exists.
-    def copy_load_paths_for_release
-      return unless configuration.environment == 'release'
-      configuration.load_paths.each do |path|
-        `cp -R #{path} #{RUBYCOCOA_ROOT}/#{File.basename(path)}` if File.directory?(path)
-      end
-    end
   end
   
   class Configuration
@@ -215,37 +225,59 @@ module Rucola
     # all +models+, +config+, +controllers+ and +db+ paths are included in this list.
     attr_accessor :load_paths
     
-    def initialize
-      set_root_path!
-      set_application_support_path!
-      
-      self.objc_frameworks              = []
-      self.load_paths                   = default_load_paths
-    end
+    # Defines wether or not you want to use the +Reloader+.
+    #
+    # Turning on the reloader will start a fsevent loop which watches the files in app/ for changes
+    # and try to reload any classes that have been saved while the app is running.
+    #
+    # It could however lead to erratic behaviour so use it with caution.
+    attr_accessor :use_reloader
     
-    def set_root_path!
-      @root_path = Pathname.new(::RUBYCOCOA_ROOT).realpath.to_s
-    end
+    # Defines wether or not you want to use the +debugger+.
+    #
+    # The debugger allows you to easily set breakpoints and debug them.
+    # See the documentation from ruby-debug for its usage:
+    # http://www.datanoise.com/ruby-debug/
+    attr_accessor :use_debugger
     
-    def set_application_support_path!
-      # TODO: we might want to set this to something in test mode.
-      return if RUBYCOCOA_ENV == 'test'
-      
-      user_app_support_path = File.join(OSX::NSSearchPathForDirectoriesInDomains(OSX::NSLibraryDirectory, OSX::NSUserDomainMask, true)[0].to_s, "Application Support")
-      @application_support_path = File.join(user_app_support_path, Rucola::RCApp.app_name)
-    end
+    # Defines wether or not you want to allow the use of RubyGems.
+    #
+    # You can completely disable the usage of RubyGems by setting this to false.
+    #
+    # Unless you're using gems which are installed on a system by default, it's
+    # better to set it to false. This will enable you to debug wether or not your
+    # application has been bundled succesfully, PLUS not using rubygems will improve
+    # the performance of your application.
+    attr_accessor :use_rubygems
     
-    # Returns the value of RUBYCOCOA_ENV
-    def environment
-      ::RUBYCOCOA_ENV
+    # Declare which dependency types should be bundled with a release build.
+    # Most of the times you would probably only bundle gems if you're targeting
+    # a ruby which is compatible and contains the right site libs.
+    #
+    #   # Only bundles gems
+    #   config.dependency_types = :gem
+    #
+    #   # Bundles gems and site libs
+    #   config.dependency_types = :gem, :site
+    #
+    #   # Bundles site and other libs, where other are libs outside any of the default load paths.
+    #   config.dependency_types = :site, :other
+    attr_accessor :dependency_types
+    
+    def initialize
+      @objc_frameworks  = []
+      @load_paths       = default_load_paths
+      @dependency_types = []
+      @use_reloader = @use_debugger = @use_debugger = false
     end
     
-    # The path to the current environment's file (development.rb, etc.). By
-    # default the file is at <tt>config/environments/#{environment}.rb</tt>.
-    def environment_path
-      "#{root_path}/config/environments/#{environment}.rb"
+    # Loads the current environment's file (debug.rb, release.rb, test.rb).
+    # By default the file is at <tt>config/environments/#{environment}.rb</tt>.
+    def load_environment_configuration!
+      root = defined?(SOURCE_ROOT) ? SOURCE_ROOT : RCApp.root_path
+      require "#{root}/config/environments/#{RCApp.env}.rb"
     end
-        
+    
     private
       # Set the load paths, which specifies what directories should be copied over on release.
       # We can't use RUBYCOCOA_ROOT here because when building for release the .app file is the