rucola 0.0.1

data/app_generators/rucola/templates/script/plugin

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'net/http'
+
+RUCOLA_PLUGINS_URL = 'http://rucola.rubyforge.org/svn/extras/plugins/'
+PLUGIN_DIR = 'vendor/plugins'
+
+def get_plugin_index
+  return @rucola_plugins unless @rucola_plugins.nil?
+
+  rucola_plugin_index = Net::HTTP.get(URI.parse(RUCOLA_PLUGINS_URL + "plugin_index"))
+  
+  @rucola_plugins = {}
+  rucola_plugin_index.each_line do |line|
+    next if line.chomp.empty?
+    plugin_name, plugin_description = line.chomp.split("\t")
+    @rucola_plugins[plugin_name] = plugin_description
+  end
+  @rucola_plugins
+end
+
+def list_plugins
+  rucola_plugins = get_plugin_index
+  puts "Available plugins from #{RUCOLA_PLUGINS_URL} are:\n\n"
+  puts "- " << rucola_plugins.map { |name, desc| "#{name}: #{desc}" }.sort.join("\n\n- ") << "\n\n"
+  exit
+end
+
+def install_plugin(plugin)
+  if plugin.nil?
+    puts "Please specify the name of the plugin or the url to install from.", ''
+    banner
+  end
+  
+  unless plugin =~ /^[\w\+]+:\/\//
+    rucola_plugins = get_plugin_index
+    if rucola_plugins.has_key? plugin
+      url = RUCOLA_PLUGINS_URL + plugin
+      name = plugin
+    else
+      puts "No plugin was found for: #{plugin}", ''
+      list_plugins
+    end
+  else
+    url = plugin
+    name = url.split('/').last
+  end
+  
+  # do a checkout
+  FileUtils.mkdir_p PLUGIN_DIR unless File.exists? PLUGIN_DIR
+  IO.popen("svn co #{url} #{PLUGIN_DIR}/#{name}") do |process|
+    process.each_line { |line| puts line }
+  end
+  
+  # run install.rb if it exists
+  install_script = File.join(PLUGIN_DIR, name, 'install.rb')
+  if File.exists? install_script
+    puts "\n======================================================================================\n\n"
+    IO.popen("ruby #{install_script}") do |process|
+      process.each_line { |line| puts line }
+    end
+    puts ''
+  end
+end
+
+def banner
+  puts %{
+Usage: #{__FILE__} [options]
+Options:
+  list                        Lists all plugins from the Rucola plugin repository.
+  install PLUGIN              Installs PLUGIN from the Rucola plugins repository or a specific svn url.
+  }.strip
+  exit
+end
+
+banner if ARGV.empty?
+case ARGV[0]
+when 'list' then list_plugins
+when 'install' then install_plugin(ARGV[1])
+else
+  puts "Unknown option: #{ARGV[0]}", ''
+  banner
+end

data/app_generators/rucola/templates/test/controllers/test_application_controller.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class TestApplicationController < Test::Unit::TestCase
+  
+  def test_application_controller_initialization
+    application_controller = ApplicationController.alloc.init
+    assert_instance_of(ApplicationController, application_controller)
+  end
+  
+end

data/app_generators/rucola/templates/test/test_helper.rb

@@ -0,0 +1,10 @@
+ENV['RUBYCOCOA_ENV'] = 'test'
+ENV['RUBYCOCOA_ROOT'] = File.expand_path('../../', __FILE__)
+
+require 'rubygems'
+require "test/unit"
+require "mocha"
+require 'rucola'
+require 'rucola/test_helper'
+
+require File.expand_path('../../config/boot', __FILE__)

data/bin/rucola

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rubigen'
+
+if %w(-v --version).include? ARGV.first
+  require 'newgem/version'
+  puts "#{File.basename($0)} #{Newgem::VERSION::STRING}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+RubiGen::Base.use_application_sources! :rucola
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'rucola')

data/config/hoe.rb

@@ -0,0 +1,71 @@
+require 'rucola/version'
+
+AUTHOR = ['Eloy Duran', 'Justin Palmer']  # can also be an array of Authors 
+EMAIL = "e.duran@superalloy.nl"
+DESCRIPTION = "Rucola is an extension for RubyCocoa. It has a application skeleton generator and builds an \"opinionated\" application layout, like the one known from rails. And comes with RubyCocoa specific rake tasks."
+GEM_NAME = 'rucola' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'rucola' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Rucola::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'rucola documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\\n\\n")
+  p.extra_deps = ['rubigen', 'rubynode']     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'rucola'

data/lib/rucola.rb

@@ -0,0 +1,3 @@
+$:.unshift File.dirname(__FILE__)
+require 'rucola/version'
+require 'rucola/initializer'

data/lib/rucola/info_plist.rb

@@ -0,0 +1,37 @@
+require 'osx/cocoa'
+
+module Rucola
+  class InfoPlist
+    def self.open(path)
+      new(path)
+    end
+    
+    attr_reader :data
+    
+    def initialize(path)
+      @path = path
+      @data = OSX::NSDictionary.dictionaryWithContentsOfFile(@path)
+    end
+    
+    def document_types
+      @data['CFBundleDocumentTypes'] ||= []
+      @data['CFBundleDocumentTypes']
+    end
+    
+    def add_document_type(name, extension, role, icon = '????', os_type = '????')
+      document_types.push({
+        'NSDocumentClass' => name,
+        'CFBundleTypeExtensions' => [extension],
+        'CFBundleTypeRole' => role,
+        'CFBundleTypeIconFile' => icon,
+        'CFBundleTypeOSTypes' => [os_type],
+        'CFBundleTypeName' => 'DocumentType'
+      })
+    end
+    
+    def save
+      @data.writeToFile_atomically(@path, true)
+    end
+    
+  end
+end

data/lib/rucola/initializer.rb

@@ -0,0 +1,313 @@
+require 'osx/cocoa'
+require 'pathname'
+
+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).include?(env)
+      RUBYCOCOA_ENV = env
+    else
+      RUBYCOCOA_ENV = 'debug'
+    end
+  else
+    RUBYCOCOA_ENV = 'release'
+  end
+end
+
+# ActiveRecord uses RAILS_ENV internally to figure out which environment key to parse in 
+# database.yml.  Since we use the non-standard release and debug environments, we need to 
+# set this here
+RAILS_ENV = RUBYCOCOA_ENV
+
+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 == 'debug'
+      Pathname.new(ENV['DYLD_LIBRARY_PATH'] + "../../../").cleanpath
+    else
+      Pathname.new(OSX::NSBundle.mainBundle.resourcePath.fileSystemRepresentation)
+    end
+end
+
+$:.unshift(RUBYCOCOA_ROOT)
+
+module Rucola
+  # Are we building and running or just running this application by clicking on 
+  # an executable.
+  def building_application?
+    ENV['DYLD_LIBRARY_PATH']
+  end
+end
+
+
+# Environment initialization scheme ported/derived from Rails' Initializer.
+require 'erb'
+module Rucola
+  # Rails-like Initializer responsible for processing configuration.
+  class Initializer
+    # The Configuration instance used by this Initializer instance.
+    attr_reader :configuration
+    
+    # Load the config/boot.rb file.
+    def self.boot
+      require RUBYCOCOA_ROOT + 'config/boot'
+    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)
+    #
+    def self.run(command = :process, configuration = Configuration.new)
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer.send(command)
+      start_app unless RUBYCOCOA_ENV == 'test'
+    end
+    
+    # Starts the application.
+    def self.start_app
+      OSX.NSApplicationMain(0, nil)
+    end
+    
+    # Create an initializer instance that references the given 
+    # Configuration instance. 
+    def initialize(configuration)
+      @configuration = configuration
+    end
+    
+    # Step through the initialization routines, skipping the active_record 
+    # routines if active_record isnt' being used.
+    def process
+      unless ENV['DYLD_LIBRARY_PATH'].nil?
+        set_load_path
+        copy_load_paths_for_release
+      end
+      
+      require_rucola_support
+      require_frameworks
+      require_ruby_source_files
+      load_environment
+      
+      if configuration.use_active_record?
+        initialize_database_directories
+        initialize_database
+        initialize_active_record_settings
+      end
+    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
+    def require_frameworks
+      configuration.objc_frameworks.each { |framework| OSX.require_framework(framework) }
+      if configuration.use_active_record?
+        require 'active_support'
+        configuration.active_record = OrderedOptions.new
+        require 'active_record'        
+        require 'osx/active_record_proxy'
+      end
+    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|
+        if child.directory?
+          require_ruby_source_files_in_dir_recursive(child)
+          next
+        end
+        require child if child.basename.to_s =~ /\.rb$/
+      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
+    # of the subdirectory as it's key.
+    #
+    # require_ruby_source_files # => {:models=>[], :views=>[], :controllers=>[#<Pathname:/src/SampleApp/app/controllers/ApplicationController.rb>]}
+    def require_ruby_source_files
+      Dir[RUBYCOCOA_ROOT + 'app/**/*.rb'].each do |f|
+        require f
+      end
+    end
+    
+    def initialize_database_directories
+      return if configuration.environment == 'debug'
+      `mkdir -p '#{configuration.application_support_path}'` unless File.exists?(configuration.application_support_path)
+    end
+    
+    def initialize_database
+      ActiveRecord::Base.configurations = configuration.database_configuration
+      ActiveRecord::Base.logger = Logger.new($stderr)
+      ActiveRecord::Base.colorize_logging = false
+      ActiveRecord::Base.establish_connection
+      ActiveRecord::Base.connection.initialize_schema_information
+    end
+    
+    # Initializes active_record settings. The available settings map to the accessors
+    # of the  ActiveRecord::Base class.
+    def initialize_active_record_settings
+      configuration.send('active_record').each do |setting, value|
+        ActiveRecord::Base.send("#{setting}=", value)
+      end
+    end
+
+    def load_application_initializers
+      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
+        load(initializer)
+      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))
+      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??
+      $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 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 if configuration.environment == 'debug'
+      configuration.load_paths.each do |path|
+        `cp -R #{path} #{RUBYCOCOA_ROOT}/#{File.basename(path)}` if File.directory?(path)
+      end
+    end
+    
+    # Now is a good time to load the plugins, because
+    # this will give them the chance to alter the
+    # behaviour of Rucola before it starts.
+    RUBYCOCOA_PLUGINS_ROOT = RUBYCOCOA_ROOT + 'vendor/plugins'
+    @@required_plugins = [] # TODO: isn't used yet
+    if RUBYCOCOA_PLUGINS_ROOT.exist?
+      RUBYCOCOA_PLUGINS_ROOT.children.each do |plugin|
+        next unless plugin.directory?
+        @@required_plugins.push plugin
+        require plugin + 'init.rb'
+      end
+    end
+  end
+  
+  class Configuration
+    # The applications base directory
+    attr_reader :root_path
+    
+    # The path to the applications support directory
+    # <tt>~/Library/Application Support/AppName</tt>
+    attr_accessor :application_support_path
+    
+    # List of Objective-C frameworks that should be required
+    attr_accessor :objc_frameworks
+    
+    #Stub for setting options on ActiveRecord::Base
+    attr_accessor :active_record
+    
+    # Should the active_record framework be loaded. 
+    attr_accessor :use_active_record
+    
+    # An array of additional paths to prepend to the load path. By default,
+    # all +models+, +config+, +controllers+ and +db+ paths are included in this list.
+    attr_accessor :load_paths
+    
+    # The path to the database configuration file to use. (Defaults to
+    # <tt>config/database.yml</tt>.)
+    attr_accessor :database_configuration_file
+    
+    
+    def initialize
+      set_root_path!
+      set_application_support_path!
+      
+      self.objc_frameworks              = []
+      self.load_paths                   = default_load_paths
+      self.database_configuration_file  = default_database_configuration_file
+    end
+    
+    def set_root_path!
+      @root_path = Pathname.new(::RUBYCOCOA_ROOT).realpath.to_s
+    end
+    
+    def set_application_support_path!
+      # TODO: we might want to set this to something in test mode.
+      return if RUBYCOCOA_ENV == 'test'
+      
+      app_name = OSX::NSBundle.mainBundle.bundleIdentifier.to_s.scan(/\w+$/).first
+      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, app_name)
+    end
+    
+    # Returns the value of @use_active_record
+    def use_active_record?
+      @use_active_record
+    end
+    
+    # Returns the value of RUBYCOCOA_ENV
+    def environment
+      ::RUBYCOCOA_ENV
+    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"
+    end
+    
+    # Loads and returns the contents of the #database_configuration_file. The
+    # contents of the file are processed via ERB before being sent through
+    # YAML::load.
+    def database_configuration
+      db_config = YAML::load(ERB.new(IO.read(database_configuration_file)).result)
+      db = db_config[environment]['database']
+      db_config[environment]['database'] = environment == 'release' ? "#{application_support_path}/#{db.split('/').last}" : "#{RUBYCOCOA_ROOT}/db/#{db.split('/').last}"
+      db_config
+    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 
+      # root, instead we need the path to the working directory.
+      def default_load_paths
+        return if ENV['DYLD_LIBRARY_PATH'].nil?
+        paths = %w(
+          models
+          controllers
+          db
+        ).map {|dir| "#{Pathname.new(ENV['DYLD_LIBRARY_PATH'] + "../../../").cleanpath}/#{dir}" }.select { |dir| File.directory?(dir) }
+      end
+      
+      def default_database_configuration_file
+        File.join(root_path, 'config', 'database.yml')
+      end
+  end
+end