bowline 0.1.6 → 0.3.9

data/lib/bowline/commands/run.rb

@@ -1,11 +1,4 @@
-require "config/environment"
-exec_path = File.join(APP_ROOT, 'build', 'osx', "#{APP_NAME}.app")
-
-unless File.exist?(exec_path)
-  require 'rake'
-  require 'bowline/tasks/bowline'
-  Rake::Task['app:bundle'].invoke
-end
-
-# Debug view
-`open #{File.join(exec_path, 'Contents', 'MacOS', APP_NAME)}`
+require 'rake'
+require 'bowline/tasks/bowline'
+ENV['TIRUN'] = 'true'
+Rake::Task['app'].invoke

data/lib/bowline/dependencies/FAQ.markdown

@@ -0,0 +1,6 @@
+FAQ
+===
+
+1. gem install or uninstall fails with gem >= 0 message
+  > gems/gems/ directory is likely dirty, remove any specifications, cache, doc, gems, or bin folders beneath it.
+

data/lib/bowline/dependencies/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/bowline/dependencies/README.markdown

@@ -0,0 +1,51 @@
+Dependencies
+============
+
+A port of Merb's dependency system to a Rails plugin.
+
+Usage
+=====
+
+1. Install the plugin
+
+        script/plugin install git://github.com/ddollar/dependencies.git
+
+2. Add the following line to your config/environment.rb
+
+        config.plugins = [:dependencies, :all]
+
+3. Add the following line to your .gitignore
+
+        gems
+
+4. Create a config/dependencies.rb file that looks like:
+
+        dependency 'gem'
+        dependency 'gem', '1.0.1'
+        dependency 'gem', :require_as => 'Gem'
+        dependency 'gem', :only => %w(test staging)
+        dependency 'gem', :except => 'production'
+
+        with_options(:only => 'test') do |test|
+          test.dependency 'tester-gem'
+        end
+
+5. Remove or comment out any config.gem lines from config/environment.rb or config/environments/*.rb
+
+6. Install the gems into your project and keep them up to date using:
+
+        rake dependencies:sync
+
+7. Alternatively you can use the following rake task to read your existing config.gem declarations and output a file suitable for this plugin. This task will appropriately handle any gems that you are currently loading on a per-environment basis as well.
+
+        rake dependencies:import
+
+
+About
+=====
+
+Initial idea and Rubygems extension code from [Merb](http://merbivore.com/)
+
+Rewritten for Rails by [David Dollar](http://daviddollar.org) ([@ddollar](http://twitter.com/ddollar))
+
+Documentation, testing, ideas by Steven Soroka ([@ssoroka](http://twitter.com/ssoroka))

data/lib/bowline/dependencies/Rakefile

@@ -0,0 +1,10 @@
+require 'spec/rake/spectask'
+require 'rcov'
+
+task :default => :spec
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', 'spec/spec.opts']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/lib/bowline/dependencies/TODO.markdown

@@ -0,0 +1,4 @@
+To Do
+=====
+
+* Better handling of gems that depend on Rails to load.

data/lib/bowline/dependencies/init.rb

@@ -0,0 +1,41 @@
+unless $block_dependencies_plugin_init
+
+  require File.join(File.dirname(__FILE__), 'lib', 'dependencies')
+
+  Gem.clear_paths
+  Gem.path.unshift(File.join(Rails.root, 'gems'))
+
+  deps = ::Dependencies::Reader.read_file(File.join(Rails.root, 'config', 'dependencies.rb'))
+
+  deps.each do |dep|
+    current_environment = ENV['RAILS_ENV'] || 'development'
+
+    options = {
+      :only       => [current_environment],
+      :except     => [],
+      :require_as => dep.name
+    }.merge(dep.options)
+
+    # swap their :only and :except to an array if they used a not-Array
+    [ :only, :except ].each do |option|
+      options[option] = [options[option].to_s] unless options[option].is_a?(Array)
+    end
+
+    # don't run if require_as is nil or false
+    next if [nil, false].include?(options[:require_as])
+
+    # don't run if the dependency wants an env that is not the current one
+    next unless options[:only].include?(current_environment)
+
+    # don't run if the dependency does not want to load in the current env
+    next if options[:except].include?(current_environment)
+
+    begin
+      require options[:require_as]
+    rescue LoadError => e
+      puts "was unable to require #{dep.name} as '#{options[:require_as]}'
+      Reason: #{e.class.name} error raised with message: #{e.message}"
+    end
+  end
+
+end

data/lib/bowline/dependencies/lib/dependencies.rb

@@ -0,0 +1,9 @@
+module Dependencies; end
+
+Dir[File.join(File.dirname(__FILE__), 'ext', '*.rb')].each do |file|
+  require file
+end
+
+Dir[File.join(File.dirname(__FILE__), 'dependencies', '*.rb')].each do |file|
+  require file
+end

data/lib/bowline/dependencies/lib/dependencies/dependency.rb

@@ -0,0 +1,12 @@
+class Dependencies::Dependency
+  attr_accessor :name, :versions, :options
+  
+  def initialize(name, *options)
+    opts = options.last.is_a?(Hash) ? options.pop : {}
+    vers = options
+
+    @name     = name
+    @versions = vers
+    @options  = opts
+  end
+end

data/lib/bowline/dependencies/lib/dependencies/reader.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/option_merger'
+
+class Dependencies::Reader
+
+  attr_reader :dependencies
+
+  def self.read(definitions)
+    reader = new
+    reader.instance_eval(definitions)
+    reader.dependencies
+  end
+
+  def self.read_file(filename)
+    self.read(File.read(filename))
+  end
+
+  def initialize
+    @dependencies = []
+  end
+
+  def dependency(name, *options)
+    @dependencies << ::Dependencies::Dependency.new(name, *options)
+  end
+
+  def with_options(options)
+    yield ActiveSupport::OptionMerger.new(self, options)
+  end
+
+end

data/lib/bowline/dependencies/lib/dependencies/repository.rb

@@ -0,0 +1,64 @@
+class Dependencies::Repository
+
+  def initialize(base)
+    @paths = {
+      :gems  => File.join(base),
+      :bin   => File.join(base, 'bin'),
+      :specs => File.join(base, 'specifications')
+    }
+  end
+
+  def index
+    @index ||= reload_index!
+  end
+
+  def reload_index!
+    @index = ::Gem::SourceIndex.new.load_gems_in(@paths[:specs])
+  end
+
+  def gem(name, versions=[])
+    ::Gem::Dependency.new(name, versions)
+  end
+
+  def search(gem)
+    index.search(gem)
+  end
+
+  def install(gem)
+    reload_index!
+    return if index.search(gem).last
+    
+    installer = ::Gem::DependencyInstaller.new(
+      :bin_dir => @paths[:bin],
+      :install_dir => @paths[:gems],
+      :user_install => false)
+
+    begin
+      installer.install gem.name, gem.version_requirements
+    rescue ::Gem::GemNotFoundException => e
+      puts "Cannot find #{gem.name} #{gem.version_requirements}"
+    rescue ::Gem::RemoteFetcher::FetchError => e
+      puts "Problem with fetch, retrying..."
+      retry
+    end
+  end
+
+  def uninstall(name, version)
+    uninstaller = ::Gem::Uninstaller.new(name,
+      :version => version,
+      :bin_dir => @paths[:bin],
+      :install_dir => @paths[:gems],
+      :ignore => true,
+      :executables => true
+    )
+    uninstaller.uninstall
+  end
+  
+  def installed
+    Dir[File.join(@paths[:gems], 'gems', '*')].map! { |n| File.basename(n) }
+  end
+
+  def gems
+  end
+
+end

data/lib/bowline/dependencies/lib/ext/rubygems.rb

@@ -0,0 +1,125 @@
+require 'erb'
+require 'rubygems'
+require 'rubygems/dependency_installer'
+
+Gem.pre_install_hooks.push(proc do |installer|
+  unless File.file?(File.join(installer.bin_dir, "common.rb"))
+    FileUtils.mkdir_p(installer.bin_dir)
+    FileUtils.cp(File.join(File.dirname(__FILE__), "common.rb"),
+                 File.join(installer.bin_dir,      "common.rb"))
+  end
+
+  name = installer.spec.name
+
+  puts "+ #{name}"
+
+  if $GEMS && versions = ($GEMS.assoc(name) || [])[1]
+    dep = Gem::Dependency.new(name, versions)
+    unless dep.version_requirements.satisfied_by?(installer.spec.version)
+      raise "Cannot install #{installer.spec.full_name} " \
+            "for #{$INSTALLING}; " \
+            "you required #{dep}"
+    end
+  end
+end)
+
+class ::Gem::Uninstaller
+  def self._with_silent_ui
+
+    ui = Gem::DefaultUserInteraction.ui
+    def ui.say(str)
+      puts "- #{str}"
+    end
+
+    yield
+
+    class << Gem::DefaultUserInteraction.ui
+      remove_method :say
+    end
+  end
+
+  def self._uninstall(source_index, name, op, version)
+    unless source_index.find_name(name, "#{op} #{version}").empty?
+      uninstaller = Gem::Uninstaller.new(
+        name,
+        :version => "#{op} #{version}",
+        :install_dir => Dir.pwd / "gems",
+        :all => true,
+        :ignore => true,
+        :executables => true
+      )
+      _with_silent_ui { uninstaller.uninstall }
+    end
+  end
+
+  def self._uninstall_others(source_index, name, version)
+    _uninstall(source_index, name, "<", version)
+    _uninstall(source_index, name, ">", version)
+  end
+end
+
+Gem.post_install_hooks.push(proc do |installer|
+  source_index = installer.instance_variable_get("@source_index")
+  ::Gem::Uninstaller._uninstall_others(
+    source_index, installer.spec.name, installer.spec.version
+  )
+end)
+
+class ::Gem::DependencyInstaller
+  alias old_fg find_gems_with_sources
+
+  def find_gems_with_sources(dep)
+    if @source_index.any? { |_, installed_spec|
+      installed_spec.satisfies_requirement?(dep)
+    }
+      return []
+    end
+
+    old_fg(dep)
+  end
+end
+
+class ::Gem::SpecFetcher
+  alias old_fetch fetch
+  def fetch(*args) # in rubygems 1.3.2 fetch takes 4 parameters
+    dependency, all, matching_platform, prerelease = *args
+    idx = Gem::SourceIndex.from_installed_gems
+
+    reqs = dependency.version_requirements.requirements
+
+    if reqs.size == 1 && reqs[0][0] == "="
+      dep = idx.search(dependency).sort.last
+    end
+
+    if dep
+      file = dep.loaded_from.dup
+      file.gsub!(/specifications/, "cache")
+      file.gsub!(/gemspec$/, "gem")
+      spec = ::Gem::Format.from_file_by_path(file).spec
+      [[spec, file]]
+    else
+      old_fetch(*args)
+    end
+  end
+end
+
+class ::Gem::Installer
+  def app_script_text(bin_file_name)
+    template = File.read(File.join(File.dirname(__FILE__), '..', 'template' , "app_script.rb"))
+    erb = ERB.new(template)
+    erb.result(binding)
+  end
+end
+
+class ::Gem::Specification
+  def recursive_dependencies(from, index = Gem.source_index)
+    specs = self.runtime_dependencies.map do |dep|
+      spec = index.search(dep).last
+      unless spec
+        raise "Needed #{dep} for #{from}, but could not find it"
+      end
+      spec
+    end
+    specs + specs.map {|s| s.recursive_dependencies(self, index)}.flatten.uniq
+  end
+end

data/lib/bowline/dependencies/lib/template/app_script.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+# This was added by Merb's bundler
+
+require "rubygems"
+require File.join(File.dirname(__FILE__), "common")
+
+gems_dir = File.join(File.dirname(__FILE__), '..', 'gems')
+
+if File.directory?(gems_dir)
+  $BUNDLE = true
+  Gem.clear_paths
+  Gem.path.replace([File.expand_path(gems_dir)])
+  ENV["PATH"] = "#{File.dirname(__FILE__)}:#{ENV["PATH"]}"
+  
+  gem_file = File.join(gems_dir, "specifications", "<%= spec.name %>-*.gemspec")
+  
+  if local_gem = Dir[gem_file].last
+    version = File.basename(local_gem)[/-([\.\d]+)\.gemspec$/, 1]
+  end
+end
+
+version ||= "<%= Gem::Requirement.default %>"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '<%= @spec.name %>', version
+load '<%= bin_file_name %>'

data/lib/bowline/dependencies/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/lib/bowline/dependencies/tasks/dependencies.rake

@@ -0,0 +1,164 @@
+require "rubygems"
+require "rubygems/source_index"
+require "rubygems/dependency_installer"
+require "rubygems/uninstaller"
+require "fileutils"
+
+# there has got to be a better way to do this
+unless ARGV.first == 'dependencies:import'
+  Gem.clear_paths
+  Gem.path.unshift(File.join(RAILS_ROOT, 'gems'))
+end
+
+namespace :dependencies do
+
+  task :setup do
+    # avoid requiring environment by working up from vendor/plugins/dependencies/tasks
+    rails_root = File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. .. ..)))
+
+    # Dependencies isn't loaded when running from rake.  This is a good place to load it.
+    require File.expand_path(File.join(File.dirname(__FILE__), %w(.. lib dependencies))) unless defined?(Dependencies)
+
+    SETTINGS = {
+      :dependencies_file => File.join(rails_root, 'config', 'dependencies.rb'),
+      :gem_dir           => File.join(rails_root, 'gems')
+    }
+    FileUtils.mkdir(SETTINGS[:gem_dir]) unless File.exists?(SETTINGS[:gem_dir])
+  end
+
+  task :load => :setup do
+    SETTINGS[:dependencies] = ::Dependencies::Reader.read_file(SETTINGS[:dependencies_file])
+  end
+
+  namespace :transaction do
+    task :setup do
+      SETTINGS[:gem_original_dir] = SETTINGS[:gem_dir]
+      SETTINGS[:gem_dir] = SETTINGS[:gem_dir] + '.install'
+    end
+
+    task :begin => :setup do
+      FileUtils.rm_rf(SETTINGS[:gem_dir])
+      FileUtils.cp_r(SETTINGS[:gem_original_dir], SETTINGS[:gem_dir])
+    end
+
+    task :commit => :setup do
+      FileUtils.rm_rf(SETTINGS[:gem_original_dir])
+      FileUtils.mv(SETTINGS[:gem_dir], SETTINGS[:gem_original_dir])
+    end
+
+    task :rollback => :setup do
+      FileUtils.rm_rf(SETTINGS[:gem_dir])
+    end
+  end
+
+  desc 'synchronize the stuff'
+  task :sync => [ :setup, :load ] do
+    Rake::Task['dependencies:transaction:begin'].invoke
+
+    begin
+      repo = Dependencies::Repository.new(SETTINGS[:gem_dir])
+
+      SETTINGS[:dependencies].each do |dep|
+        gem = repo.gem(dep.name, dep.versions)
+        next unless repo.search(gem).empty?
+        repo.install(gem)
+      end
+
+      repo.reload_index!
+
+      full_list = SETTINGS[:dependencies].map do |dep|
+        gem = repo.gem(dep.name, dep.versions)
+        spec = repo.index.search(gem).last
+        unless spec
+          # Rake::Task['dependencies:transaction:rollback'].invoke # gets run on rescue below.
+          raise Exception.new("A required dependency #{gem} was not found")
+        end
+        deps = spec.recursive_dependencies(gem, repo.index)
+        [spec] + deps
+      end.flatten.uniq.map do |spec|
+        "#{spec.name}-#{spec.version}"
+      end
+
+      (repo.installed - full_list).each do |g|
+        /^(.*)\-(.*)$/ =~ g
+        repo.uninstall($1, $2)
+      end
+
+      #confirm(gems)
+
+      Rake::Task['dependencies:transaction:commit'].invoke
+
+    rescue Exception => ex
+      puts ex.message
+      puts ex.backtrace
+      Rake::Task['dependencies:transaction:rollback'].invoke
+    end
+  end
+
+  desc 'Build a dependencies.rb from old config.gem style declarations'
+  task :import do
+
+    # gross
+    $block_dependencies_plugin_init = true
+    $gems_rake_task                 = true
+    $gems_build_rake_task           = true
+
+    Rake::Task['environment'].invoke
+    environments = %w( development test production )
+
+    gems = environments.inject({}) do |memo, environment|
+      begin
+        ENV['RAILS_ENV'] = environment
+        RAILS_ENV = environment
+        load File.join(RAILS_ROOT, 'config', 'environment.rb')
+      rescue StandardError => ex
+        puts "Something went wrong: #{ex.message}"
+        exit 1
+      end
+
+      Rails.configuration.gems.each do |gem|
+        signature = [gem.name, gem.requirement.to_s]
+        memo[signature] ||= {
+          :name         => gem.name,
+          :version      => gem.requirement.to_s,
+          :require_as   => gem.lib,
+          :environments => []
+        }
+        memo[signature][:environments] << environment
+      end
+
+      memo
+    end
+
+    all_environments, some_environments = gems.values.partition do |gem|
+      gem[:environments].sort == environments.sort
+    end
+
+    all_environments.each do |gem|
+      puts dependency_declaration_from_hash(gem)
+    end
+
+    environments.each do |environment|
+      gems = some_environments.select do |gem|
+        gem[:environments].include?(environment)
+      end
+
+      unless gems.length.zero?
+        puts
+        puts "with_options(:only => '#{environment}') do |#{environment}|"
+        gems.each do |gem|
+          puts "  #{environment}." + dependency_declaration_from_hash(gem)
+        end
+        puts 'end'
+      end
+    end
+  end
+end
+
+def dependency_declaration_from_hash(gem)
+  declaration  = []
+  declaration << "dependency '#{gem[:name]}'"
+  declaration << "'#{gem[:version]}'"            unless gem[:version].blank?
+  declaration << ":require_as => '#{gem[:lib]}'" unless gem[:lib] == nil
+  declaration.join(', ')
+end