wagons 0.0.1 → 0.0.9

data/lib/wagons/installer.rb

@@ -0,0 +1,313 @@
+module Wagons
+  
+  # Helper class to install wagons into the current application.
+  # Wagons are searched for in the system gem repository.
+  #
+  # If you want to use the #install method, add "gem 'open4'" to
+  # your Gemfile.
+  class Installer
+    
+    attr_accessor :include_version_in_wagonfile
+    
+    def initialize
+      @include_version_in_wagonfile = true
+    end
+    
+    # Gem specifications of all installed wagons.
+    def installed
+      @installed ||= Wagons.all.collect(&:gemspec)
+    end
+
+    # Most recent gem specifications of all wagons available in GEM_HOME.
+    def available
+      return @available if defined?(@available)
+
+      # only keep most recent version in @available
+      @available = []
+      load_available_specs.each do |spec|
+        if prev = @available.find {|w| w.name == spec.name }
+          if prev.version < spec.version
+          @available.delete(prev)
+          @available << spec
+          end
+        else
+        @available << spec
+        end
+      end
+      @available
+    end
+
+
+    # Most recent gem specifications of available, but not installed (in any version) wagons.
+    def not_installed
+      exclude_specs(available, installed)
+    end
+
+    # Most recent gem specifications of available and installed (in an older version) wagons.
+    def updates
+      available.select do |spec|
+        if wagon = installed_spec(spec.name)
+          wagon.version < spec.version
+        end
+      end
+    end
+
+    # Install or update the wagons with the given names. I.e., adds the given
+    # wagon names to the Wagonfile and runs rake wagon:setup.
+    # After that, the application MUST be restarted to load the new wagons.
+    # Returns nil if everything is fine or a string with error messages.
+    # This method requires open4.
+    def install(names)
+      change_internal(names, :check_dependencies) do |specs|
+        content = File.read(wagonfile) rescue ""
+        wagonfile_update(specs)
+        
+        begin
+          setup_wagons(specs)
+        rescue => e
+          wagonfile_write(content)
+          raise e
+        end
+      end
+    end
+
+    # Remove the wagons with the given names. I.e., reverts the migrations
+    # of the given wagon names if the wagon is not protected 
+    # and removes the entries from the Wagonfile.
+    # Returns nil if everything is fine or a string with error messages.
+    def uninstall(names)
+      change_internal(names, :check_uninstalled_dependencies, :check_protected) do |specs|
+        remove_wagons(specs)
+        wagonfile_remove(specs)
+      end
+    end
+
+    # Get the gem specification of the installed wagon with the given name.
+    # Return nil if not found.
+    def installed_spec(name)
+      installed.find {|s| s.name == name }
+    end
+
+    # Get the gem specification of an available wagon with the given name.
+    # Return nil if not found.
+    def available_spec(name)
+      available.find {|s| s.name == name}
+    end
+    
+    # Update the Wagonfile with the given gem specifications.
+    def wagonfile_update(specs)
+      wagonfile_edit(specs) do |spec, content|
+        declaration = "gem '#{spec.name}'"
+        declaration += ", '#{spec.version.to_s}'" if include_version_in_wagonfile
+        unless content.sub!(gem_declaration_regexp(spec.name), declaration)
+          content += "\n#{declaration}"
+        end
+        content
+      end
+    end
+
+    # Remove the given gem specifications from the Wagonfile.
+    def wagonfile_remove(specs)
+      wagonfile_edit(specs) do |spec, content|
+        content.sub(gem_declaration_regexp(spec.name), '')
+      end
+    end
+    
+    # Check if all wagon dependencies of the given gem specifications
+    # are met by the installed wagons.
+    # Returns nil if everything is fine or a string with error messages.
+    def check_dependencies(specs)
+      missing = check_app_requirement(specs)
+
+      present = exclude_specs(installed, specs)
+      future = present + specs
+
+      check_all_dependencies(specs, future, missing)
+    end
+    
+    # Check if the app requirement of the given gem specifications
+    # are met by the current app version.
+    # Returns nil if everything is fine or a array with error messages.
+    def check_app_requirement(specs)
+      missing = []
+      specs.each do |spec|
+        if wagon = wagon_class(spec)
+          unless wagon.app_requirement.satisfied_by?(Wagons.app_version)
+            missing << "#{spec} requires application version #{wagon.app_requirement}"
+          end
+        end
+      end
+
+      missing
+    end
+    
+    # Check if the wagon dependencies of the remaining wagons
+    # would still be met after the given gem specifications are uninstalled.
+    # Returns nil if everything is fine or a string with error messages.
+    def check_uninstalled_dependencies(specs)
+      present = exclude_specs(installed, specs)
+      check_all_dependencies(present, present)
+    end
+
+    # Checks if the wagons for given gem specifications are protected.
+    # Returns nil if everything is fine or a string with error messages.
+    def check_protected(specs)
+      protected = []
+      specs.each do |spec|
+        msg = Wagons.find(spec.name).protect?
+        protected << msg if msg.is_a?(String)
+      end
+      protected.join("\n").presence
+    end
+
+    # List of available gem specifications with the given names.
+    # Raises an error if a name cannot be found.
+    def specs_from_names(names)
+      names.collect do |name| 
+        spec = available_spec(name)
+        raise "#{name} was not found" if spec.nil?
+        spec
+      end
+    end
+    
+    # Removes all gem specifications with the same name in to_be_excluded from full.
+    # Versions are ignored.
+    def exclude_specs(full, to_be_excluded)
+      full.clone.delete_if {|s| to_be_excluded.find {|d| s.name == d.name } }
+    end
+    
+    # Wagonfile
+    def wagonfile
+      Rails.root.join("Wagonfile")
+    end
+    
+    # The wagon class of the given spec.
+    def wagon_class(spec)
+      @wagon_classes ||= {}
+      return @wagon_classes[spec] if @wagon_classes.has_key?(spec)
+      
+      clazz = nil
+      file = File.join(spec.gem_dir, 'lib', spec.name, 'wagon.rb')
+      if File.exists?(file)
+        require file
+        clazz = "#{spec.name.camelize}::Wagon".constantize
+      else
+        raise "#{spec.name} wagon class not found in #{file}"
+      end
+      @wagon_classes[spec] = clazz
+    end
+
+    private
+    
+    def load_available_specs
+      paths = [ENV['GEM_HOME']]
+      paths += (ENV['GEM_PATH'] || "").split(File::PATH_SEPARATOR)
+      paths.collect(&:presence).compact.collect do |path|
+        Dir[File.join(path, 'specifications', "#{Wagons.app_name}_*.gemspec")].collect do |gemspec|
+          Gem::Specification.load(gemspec)
+        end
+      end.flatten
+    end
+
+    def perform_checks(specs, checks)
+      checks.each do |check|
+        if msg = send(check, specs)
+          return msg
+        end
+      end
+      nil
+    end
+
+    def check_all_dependencies(to_check, all, missing = [])
+      to_check.each do |spec|
+        spec.runtime_dependencies.each do |dep|
+          if dep.name.start_with?("#{Wagons.app_name}_") &&
+          all.none? {|s| dep.matches_spec?(s) }
+            missing << "#{spec.name} requires #{dep.name} #{dep.requirement}"
+          end
+        end
+      end
+
+      missing.join("\n").presence
+    end
+    
+    def gem_declaration_regexp(name)
+      /^.*gem\s+('|")#{name}('|").*$/
+    end
+        
+    def wagonfile_edit(specs)
+      content = File.read(wagonfile) rescue ""
+
+      specs.each do |spec|
+        content = yield spec, content
+      end
+      content.gsub!(/(\n\s*\n\s*)+/, "\n") # remove empty lines
+
+      wagonfile_write(content.strip)
+    end
+    
+    def wagonfile_write(content)
+      File.open(wagonfile, 'w') do |f|
+        f.puts content
+      end
+    end
+    
+    def setup_wagons(specs)
+      require 'open4'
+      
+      env = Rails.env
+      cmd = setup_command(specs)
+      Rails.logger.info(cmd)
+      
+      Bundler.with_clean_env do
+        ENV['RAILS_ENV'] = env
+        execute_setup(cmd)
+      end
+    end
+    
+    def remove_wagons(specs)
+      Wagons.all.reverse.each do |wagon|
+        if specs.find {|spec| wagon.gem_name == spec.name }
+          wagon.unload_seed
+          wagon.revert
+        end
+      end
+    end
+        
+    def setup_command(specs)
+      wagons = specs.collect {|s| s.name.sub(/^#{Wagons.app_name}_/, '') }.join(',')
+      "cd #{Rails.root} && bundle exec rake wagon:setup WAGON=#{wagons} -t"
+    end
+    
+    def execute_setup(cmd)
+      msg = nil
+      status = Open4.popen4(cmd) do |pid, input, output, errors|
+        msg = errors.read
+      end
+      
+      if status.exitstatus.to_i != 0
+        raise msg.presence || "Unknown error while running wagon:setup"
+      end
+    end
+    
+    def change_internal(names, *checks)
+      specs = specs_from_names(names)
+      
+      if msg = perform_checks(specs, checks)
+        msg
+      else
+        yield specs
+        nil
+      end
+    rescue Exception => e
+      handle_exception(e, names)
+    end
+    
+    def handle_exception(e, names)
+      msg = e.message
+      Rails.logger.error msg + "\n\t" + e.backtrace.join("\n\t")
+      msg
+    end
+
+  end
+end

data/lib/wagons/railtie.rb

@@ -1,6 +1,6 @@
 module Wagons
   # Integrate tasks into Rails.
-  class Railtie < Rails::Railtie
+  class Railtie < Rails::Railtie #:nodoc:
     rake_tasks do
       load "tasks/wagons.rake"
     end

data/lib/wagons/version.rb

@@ -1,3 +1,3 @@
 module Wagons
-  VERSION = "0.0.1"
+  VERSION = "0.0.9"
 end

data/lib/wagons/view_helper.rb

@@ -0,0 +1,58 @@
+module Wagons
+  module ViewHelper
+     
+    # Renders all partials with names that match "_[ key ]_*.[ format ].[ handler ]"
+    # in alphabetical order.
+    # Accepts an additional option :folder to pass an additional folder to search
+    # extension partials in.
+    def render_extensions(key, options = {})
+      extensions = find_extension_partials(key, options.delete(:folder)).collect do |partial|
+        render options.merge(:partial => partial) 
+      end
+      safe_join(extensions)
+    end
+    
+    # The view folders relative to app/views in which extensions are searched for.
+    # Uses the folder of the current template.
+    def extension_folders
+      [current_template_folder]
+    end
+    
+    # The folder of the current partial relative to app/views
+    def current_template_folder
+      @virtual_path[/(.+)\/.*/, 1]
+    end
+    
+    private
+    
+    def find_extension_partials(key, folder = nil)
+      folders = extension_folders.dup
+      folders << folder if folder
+      
+      files = find_extension_files(key, folders).sort_by { |f| File.basename(f) }
+      files_to_partial_names(files)
+    end
+    
+    def find_extension_files(key, folders)
+      view_paths.collect do |path|
+        folders.collect do |folder|
+          lookup_context.formats.collect do |format|
+            lookup_context.handlers.collect do |handler|
+              Dir.glob(File.join(path, folder, "_#{key}_*.#{format}.#{handler}"))
+            end
+          end
+        end
+      end.flatten
+    end
+    
+    def files_to_partial_names(files)
+      files.collect do |f|
+        m = f.match(/views.(.+?[\/\\])_(.+)\.\w+\.\w+$/)
+        m[1] + m[2]
+      end
+    end
+      
+  end
+end
+
+ActionView::Base.send(:include, Wagons::ViewHelper) if defined?(ActionView::Base)

data/lib/wagons/wagon.rb

@@ -1,112 +1,128 @@
-# A wagon is an extension to your application train running on Rails.
-# 
-# Wagons are built on Rails Engines. To change an engine to a wagon,
-# simply include this module into your own Engine.
-module Wagon
-  
-  # All wagons installed in the current Rails application.
-  def self.all
-    Rails.application.railties.all.select {|r| r.is_a?(Wagon) }
-  end
-  
-  # The name of the main Rails application.
-  def self.app_name
-    Rails.application.class.name.split('::').first.underscore
-  end
-  
-  # Find a wagon by its name.
-  def self.find(name)
-    name = name.to_s
-    all.find {|wagon| wagon.wagon_name == name || wagon.gem_name == name }
-  end
-  
-  # Version from the gemspec.
-  def version
-    gemspec.version
-  end
-  
-  # Human readable name.
-  def label
-    gemspec.summary
-  end
-  
-  # Simple system name, without application prefix.
-  def wagon_name
-    gem_name.sub(/^#{Wagon.app_name}_/, '')
-  end
-  
-  # Name of the gem.
-  def gem_name
-    class_name = self.class.name.demodulize.underscore
-    engine_name.sub(/_#{class_name}$/, '')
-  end
-  
-  # Description from the gemspec.
-  def description
-    gemspec.description
-  end
-  
-  # Direct dependencies on other wagons.
-  def dependencies
-    gemspec.dependencies.collect(&:name).
-                         select {|dep| dep =~ /\A#{Wagon.app_name}_/ }.
-                         collect { |dep| Wagon.find(dep) || raise("No wagon #{dep} found") }
-  end
-  
-  # Recursive depdencies on other wagons.
-  def all_dependencies
-    dependencies.collect {|dep| dep.all_dependencies + [dep] }.flatten.uniq
-  end
-  
-  # Gem Specification.
-  def gemspec
-    Gem::Specification.find_by_name(gem_name)
-  end
-  
-  # If true, this wagon may not be removed. Override as required.
-  def protect?
-    false
-  end
-  
-  # Run the migrations.
-  def migrate(version = nil)
-    ActiveRecord::Migrator.migrate(migrations_paths, version)
-  end
-  
-  # Revert the migrations.
-  def revert
-    ActiveRecord::Migrator.migrate(migrations_paths, 0)
-  end
-  
-  # Load seed data in db/fixtures.
-  def load_seed
-    SeedFu.seed seed_fixtures
-  end
-  
-  # Unload seed data in db/fixtures.
-  def unload_seed
-    SeedFuNdo.unseed seed_fixtures
-  end
-  
-  # Paths for migration files.
-  def migrations_paths
-    paths['db/migrate'].existent
-  end
-  
-  # Loads tasks into the main Rails application.
-  # Overwritten to only load own rake tasks, without install:migrations task from Rails::Engine
-  def load_tasks(app=self)
-    railties.all { |r| r.load_tasks(app) }
-    extend Rake::DSL if defined? Rake::DSL
-    self.class.rake_tasks.each { |block| self.instance_exec(app, &block) }
-    paths["lib/tasks"].existent.sort.each { |ext| load(ext) }
-  end
-  
-  private
-  
-  def seed_fixtures
-    fixtures = root.join('db', 'fixtures')
-    [fixtures, File.join(fixtures, Rails.env)]
+require 'active_support/concern'
+
+module Wagons
+  
+  # A wagon is an extension to your application train running on Rails.
+  # 
+  # Wagons are built on Rails Engines. To change an engine to a wagon,
+  # simply include this module into your own Engine.
+  module Wagon
+    extend ActiveSupport::Concern
+    
+    # Version from the gemspec.
+    def version
+      gemspec.version
+    end
+    
+    # Human readable name.
+    def label
+      gemspec.summary
+    end
+    
+    # Simple system name, without application prefix.
+    def wagon_name
+      gem_name.sub(/^#{Wagons.app_name}_/, '')
+    end
+    
+    # Name of the gem.
+    def gem_name
+      class_name = self.class.name.demodulize.underscore
+      engine_name.sub(/_#{class_name}$/, '')
+    end
+    
+    # Description from the gemspec.
+    def description
+      gemspec.description
+    end
+    
+    # Direct dependencies on other wagons.
+    def dependencies
+      gemspec.dependencies.collect(&:name).
+                           select {|dep| dep =~ /\A#{Wagons.app_name}_/ }.
+                           collect { |dep| Wagons.find(dep) || raise("No wagon #{dep} found") }
+    end
+    
+    # Recursive depdencies on other wagons.
+    def all_dependencies
+      dependencies.collect {|dep| dep.all_dependencies + [dep] }.flatten.uniq
+    end
+    
+    # Gem Specification.
+    def gemspec
+      Gem::Specification.find_by_name(gem_name)
+    end
+    
+    # If true, this wagon may not be removed. Override as required.
+    # May return a string with a message, why the wagon must not be removed.
+    def protect?
+      false
+    end
+    
+    # Run the migrations.
+    def migrate(version = nil)
+      ActiveRecord::Migrator.migrate(migrations_paths, version)
+    end
+    
+    # Revert the migrations.
+    def revert
+      ActiveRecord::Migrator.migrate(migrations_paths, 0)
+    end
+    
+    # Load seed data in db/fixtures.
+    def load_seed
+      SeedFu.seed seed_fixtures
+    end
+    
+    # Unload seed data in db/fixtures.
+    def unload_seed
+      SeedFuNdo.unseed seed_fixtures
+    end
+    
+    # Hash of the seed models to their existing records.
+    def existing_seeds
+      silence_stream(STDOUT) do
+        SeedFuNdo.existing_seeds seed_fixtures
+      end
+    end
+    
+    # The version requirement for the main application.
+    def app_requirement
+      self.class.app_requirement
+    end
+    
+    # Paths for migration files.
+    def migrations_paths
+      paths['db/migrate'].existent
+    end
+    
+    # Loads tasks into the main Rails application.
+    # Overwritten to only load own rake tasks, without install:migrations task from Rails::Engine
+    def load_tasks(app=self)
+      railties.all { |r| r.load_tasks(app) }
+      extend Rake::DSL if defined? Rake::DSL
+      self.class.rake_tasks.each { |block| self.instance_exec(app, &block) }
+      paths["lib/tasks"].existent.sort.each { |ext| load(ext) }
+    end
+    
+    private
+    
+    def seed_fixtures
+      fixtures = root.join('db', 'fixtures')
+      ENV['NO_ENV'] ? [fixtures] : [fixtures, File.join(fixtures, Rails.env)]
+    end
+    
+    module ClassMethods
+      # Get or set a version requirement for the main application.
+      # Set the application version in config/initializers/wagon_app_version.rb.
+      # Gem::Requirement syntax is supported.
+      def app_requirement(requirement = nil)
+        if requirement
+          @app_requirement = Gem::Requirement.new(requirement)
+        else
+          @app_requirement ||= Gem::Requirement.new
+        end
+      end
+    end
   end
 end
 

data/lib/wagons/wagon_tasks.rake

@@ -1,6 +1,5 @@
 # These are the tasks included by the specific wagons
 
-
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -99,6 +98,8 @@ namespace :db do
   
   desc "Display status of migrations"
   app_task "migrate:status"
+  
+  app_task "test:prepare"
 end
 
 
@@ -106,12 +107,12 @@ Rake.application.invoke_task(:load_app)
 
 
 namespace :app do
-  task :environment do
-    # set migrations paths only to core to have db:test:prepare work as desired
-    ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
-  end
-    
   namespace :db do
+    task :load_config do
+      # set migrations paths to core only to have db:test:prepare work as desired
+      ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
+    end
+    
     namespace :test do
       # for sqlite, make sure to delete the test.sqlite3 from the main application
       task :purge do 
@@ -123,7 +124,8 @@ namespace :app do
         end
       end
       
-      # run wagon migrations and load seed data
+      # run wagon migrations and load seed data.
+      # append this to the regular app:db:test:prepare task.
       task :prepare do
         Rails.env = 'test'
         dependencies = (wagon.all_dependencies + [wagon])