wagons 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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/README.rdoc

@@ -0,0 +1,21 @@
+= Here be Wagons!
+
+Wagons are extensions to your application train running on Rails. You can see them as plugins that extend the behavior of your specific Rails application. This framework makes it easy to create and manage them.
+
+== Setup
+
+As always, add this declaration to your application's Gemfile
+
+  gem 'wagons'
+  
+If you do not have one yet, create a .gemspec file for your application. This allows Rubygems to see your application as a (virtual) gem, so your wagons can define a dependency on it. As with all gems, move your (production) dependencies to this gemspec (+add_dependency+) and simply call +gemspec+ inside your Gemfile.
+
+Now you are ready for your first wagon. Generate it with
+
+  rails generate wagon [name]
+
+== Under the hood
+
+TODO:
+* Wagonfile
+* Rake Tasks

data/Rakefile

@@ -0,0 +1,36 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Here be Wagons'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+task :test do
+  puts "Testing wagons is a bit weird. So far, please run the following command directly in your shell:"
+  puts "(cd test/dummy/vendor/wagons/superliner && rake)"
+end
+
+
+task :default => :test

data/lib/generators/wagon/USAGE

@@ -0,0 +1,7 @@
+Description:
+    Generates a new wagon
+
+Example:
+    rails generate wagon superliner
+
+    This will create a brand new wagon in vendor/wagons/superliner.

data/lib/generators/wagon/templates/%singular_name%.gemspec.tt

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your wagon's version:
+require "<%= singular_name %>/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "<%= singular_name %>"
+  s.version     = <%= class_name %>::VERSION
+  s.authors     = ["TODO: Your name"]
+  s.email       = ["TODO: Your email"]
+  #s.homepage    = "TODO"
+  s.summary     = "<%= wagon_name.humanize.titleize %>"
+  s.description = "TODO: description"
+
+  s.files = Dir["{app,config,db,lib}/**/*"] + ["Rakefile"]
+  s.test_files = Dir["test/**/*"]
+
+  s.add_dependency "<%= application_name %>"
+  
+end

data/lib/generators/wagon/templates/Gemfile.tt

@@ -0,0 +1,20 @@
+<%= app_root_initializer %>
+
+source "http://rubygems.org"
+
+# Declare your gem's dependencies in <%= singular_name %>.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+group :development, :test do
+  gem '<%= application_name %>', :path => ENV['APP_ROOT']
+end
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'ruby-debug'

data/lib/generators/wagon/templates/Rakefile.tt

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+ENGINE_PATH = File.expand_path('..', __FILE__)
+<%= app_root_initializer %>
+
+load 'wagons/wagon_tasks.rake'

data/lib/generators/wagon/templates/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  
+end

data/lib/generators/wagon/templates/lib/%singular_name%/version.rb.tt

@@ -0,0 +1,3 @@
+module <%= class_name %>
+  VERSION = "0.0.1"
+end

data/lib/generators/wagon/templates/lib/%singular_name%/wagon.rb.tt

@@ -0,0 +1,13 @@
+module <%= class_name %>
+  class Wagon < Rails::Engine
+    include ::Wagon
+    
+    # Add a load path for this specific Wagon
+    #config.autoload_paths += %W( #{config.root}/lib )
+
+    config.to_prepare do
+      # extend application classes here
+    end 
+  
+  end
+end

data/lib/generators/wagon/templates/lib/%singular_name%.rb.tt

@@ -0,0 +1,7 @@
+require 'wagons'
+# require 'your_wagon_dependencies'
+require '<%= singular_name %>/wagon'
+
+module <%= class_name %>
+end
+

data/lib/generators/wagon/templates/script/rails.tt

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('Gemfile', ENGINE_ROOT)
+ENGINE_PATH = File.expand_path('lib/<%= singular_name %>/engine', ENGINE_ROOT)
+
+<%= app_root_initializer %>
+
+load File.expand_path('script/rails', ENV["APP_ROOT"])

data/lib/generators/wagon/templates/test/%singular_name%_test.rb.tt

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class <%= class_name %>Test < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, <%= class_name %>
+  end
+end

data/lib/generators/wagon/templates/test/test_helper.rb.tt

@@ -0,0 +1,10 @@
+# Configure Rails Environment
+<%= app_root_initializer %>
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+
+require File.join(ENV["APP_ROOT"], 'test', 'test_helper.rb')
+
+
+class ActiveSupport::TestCase  
+  self.reset_fixture_path File.expand_path("../fixtures", __FILE__)
+end

data/lib/generators/wagon/wagon_generator.rb

@@ -0,0 +1,21 @@
+class WagonGenerator < Rails::Generators::NamedBase
+  
+  attr_reader :wagon_name, :app_root_initializer
+  
+  source_root File.expand_path('../templates', __FILE__)
+  
+  def initialize(*args)
+    super
+    @wagon_name = name
+    @app_root_initializer = "ENV['APP_ROOT'] ||= File.expand_path(__FILE__).split(\"vendor\#{File::SEPARATOR}wagons\").first"
+    
+    assign_names!("#{application_name}_#{name}")
+  end
+  
+  
+  def copy_templates
+    self.destination_root = "vendor/wagons/#{wagon_name}" 
+    directory('.')
+  end
+  
+end

data/lib/tasks/wagons.rake

@@ -0,0 +1,112 @@
+
+namespace :wagon do
+  desc "Run wagon migrations (options: VERSION=x, WAGON=abc, VERBOSE=false)"
+  task :migrate => [:environment, :'db:load_config'] do
+    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+    wagons.each do |wagon|
+      wagon.migrate(ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    end
+  end
+  
+  desc "Revert wagon migrations (options: WAGON=abc, VERBOSE=false)"
+  task :revert => [:environment, :'db:load_config'] do
+    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+    wagons.reverse.each do |wagon|
+      wagon.revert
+    end
+  end
+  
+  desc "Seed wagon data (options: WAGON=abc)"
+  task :seed => :abort_if_pending_migrations do 
+    wagons.each { |wagon| wagon.load_seed }
+  end
+  
+  desc "Unseed wagon data (options: WAGON=abc)"
+  task :unseed => :abort_if_pending_migrations do
+    wagons.reverse.each { |wagon| wagon.unload_seed }
+  end
+  
+  desc "Migrate and seed wagons"
+  task :setup => [:migrate, :seed]
+  
+  desc "Remove the specified wagon"
+  task :remove do
+    if wagons.size != 1
+      puts "Please specify a WAGON to remove"
+    elsif message = wagons.first.protect?
+      puts message
+    else
+      Rake::Task['wagon:unseed'].invoke
+      Rake::Task['wagon:revert'].invoke
+    end
+  end
+  
+  desc "Creates a Wagonfile for development"
+  task :file do
+    file = Rails.root.join('Wagonfile')
+    unless File.exist?(file)
+      File.open(file, 'w') do |f|
+        f.puts <<FIN
+group :development do
+    # Load all wagons found in vendor/wagons/*
+    Dir[File.expand_path('../vendor/wagons/**/*.gemspec', __FILE__)].each do |spec|
+        gem File.basename(spec, '.gemspec'), :path => File.expand_path('..', spec)
+    end
+end
+FIN
+      end
+    end
+    gemfile = Rails.root.join('Gemfile')
+    content = File.read(gemfile)
+    unless content =~ /wagonfile/
+      File.open(gemfile, 'w') do |f|
+        f.puts content
+        f.puts "\n\n"
+        f.puts "# Include the wagon gems you want attached in Wagonfile. 
+# Do not check Wagonfile into source control.
+#
+# To create a Wagonfile suitable for development, run 'rake wagon:file'
+wagonfile = File.expand_path('../Wagonfile', __FILE__)
+eval(File.read(wagonfile)) if File.exist?(wagonfile)"
+      end
+    end
+  end
+  
+  desc "list the loaded wagons"
+  task :list => :environment do  # depend on environment to get correct order
+    wagons.each {|p| puts p.wagon_name }
+  end
+  
+  namespace :test do
+    desc "Create script to test all wagons at once"
+    task :script => :environment do
+      script = 'vendor/wagons/test_wagons.sh'
+      File.open(script, 'w') do |f|
+        wagons.each do |w|
+          f.puts "(echo && echo '*** TESTING #{w.wagon_name.upcase} ***' && cd #{w.root.to_s[(Rails.root.to_s.size+1)..-1]} && bundle exec rake)"
+        end
+      end
+    end
+  end
+  
+  # desc "Raises an error if there are pending wagon migrations"
+  task :abort_if_pending_migrations => :environment do
+    pending_migrations = ActiveRecord::Migrator.new(:up, wagons.collect(&:migrations_paths).flatten).pending_migrations
+
+    if pending_migrations.any?
+      puts "You have #{pending_migrations.size} pending migrations:"
+      pending_migrations.each do |pending_migration|
+        puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+      end
+      abort %{Run `rake wagon:migrate` to update your database then try again.}
+    end
+  end
+end
+
+# Load the wagons specified by WAGON or all available.
+def wagons
+  to_load = ENV['WAGON'].blank? ? :all : ENV['WAGON'].split(",").map(&:strip)
+  wagons = Wagon.all.select { |wagon| to_load == :all || to_load.include?(wagon.wagon_name) }
+  puts "Please specify at least one valid WAGON" if wagons.blank?
+  wagons
+end

data/lib/wagons/railtie.rb

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

data/lib/wagons/test_case.rb

@@ -0,0 +1,10 @@
+class ActiveSupport::TestCase
+  
+    # Resets the fixtures to the new path
+    def self.reset_fixture_path(path)
+        self.fixture_table_names = []
+        self.fixture_class_names = {}
+        self.fixture_path = path
+        self.fixtures :all  
+    end
+end

data/lib/wagons/version.rb

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

data/lib/wagons/wagon.rb

@@ -0,0 +1,112 @@
+# 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)]
+  end
+end
+

data/lib/wagons/wagon_tasks.rake

@@ -0,0 +1,145 @@
+# These are the tasks included by the specific wagons
+
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake/testtask'
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+task :test => [:'app:db:test:prepare']
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.title    = File.basename(ENGINE_PATH)
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('**/*.rdoc')
+  rdoc.rdoc_files.include('app/**/*.rb')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+
+APP_RAKEFILE = File.join(ENV['APP_ROOT'], "Rakefile")
+
+def app_task(name)
+  task name => [:load_app, "app:db:#{name}"]
+end
+
+def find_engine_path(path)
+  return if path == "/"
+
+  if Rails::Engine.find(path)
+    path
+  else
+    find_engine_path(File.expand_path('..', path))
+  end
+end
+
+def wagon
+  @wagon ||= Rails::Engine.find(ENGINE_PATH)
+end
+
+task "load_app" do
+  namespace :app do
+    load APP_RAKEFILE
+  end
+  task :environment => "app:environment"
+
+  if !defined?(ENGINE_PATH) || !ENGINE_PATH
+    ENGINE_PATH = find_engine_path(APP_RAKEFILE)
+  end
+end
+
+
+namespace :db do
+  desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
+  task :migrate => [:load_app, 'app:environment', 'app:db:load_config'] do
+    wagon.migrate
+  end
+  
+  desc "Revert the database (options: VERSION=x, VERBOSE=false)."
+  task :revert => [:load_app, 'app:environment', 'app:db:load_config'] do
+    wagon.revert
+  end
+
+  desc "Load the seed data"
+  task "seed" => [:load_app, 'app:db:abort_if_pending_migrations'] do
+    wagon.load_seed
+  end
+
+  desc "Unload the seed data"
+  task "unseed" => [:load_app, 'app:db:abort_if_pending_migrations'] do
+    wagon.unload_seed
+  end
+  
+  desc "Run migrations and seed data (use db:reset to also revert the db first)"
+  task :setup => [:migrate, :seed]
+  
+  desc "Revert the database and set it up again"
+  task :reset => [:unseed, :revert, :setup]
+  
+  desc "Display status of migrations"
+  app_task "migrate:status"
+end
+
+
+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
+    namespace :test do
+      # for sqlite, make sure to delete the test.sqlite3 from the main application
+      task :purge do 
+        abcs = ActiveRecord::Base.configurations
+        case abcs['test']['adapter']
+        when /sqlite/
+          dbfile = Rails.application.root.join(abcs['test']['database'])
+          File.delete(dbfile) if File.exist?(dbfile)
+        end
+      end
+      
+      # run wagon migrations and load seed data
+      task :prepare do
+        Rails.env = 'test'
+        dependencies = (wagon.all_dependencies + [wagon])
+        
+        # migrate 
+        dependencies.each { |d| d.migrate }
+        
+        # seed
+        SeedFu.quiet = true unless ENV['VERBOSE']
+        SeedFu.seed([ Rails.root.join('db/fixtures').to_s,
+                      Rails.root.join('db/fixtures/test').to_s ])
+        dependencies.each { |d| d.load_seed }
+      end
+    end
+  end
+end
+
+
+task :default => :test

data/lib/wagons.rb

@@ -0,0 +1,15 @@
+require 'seed-fu-ndo'
+
+require 'wagons/wagon'
+require 'wagons/railtie'
+require 'wagons/test_case'
+
+module Wagons
+end
+
+# Requires the specified argument but silently ignores an LoadErrors.
+def optional_require(*args)
+  require *args
+rescue LoadError
+  # that's fine, it's an optional require
+end

data/test/dummy/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'wagons', :path => '../../'
+
+# Include the wagons you want attached in Wagonfile. 
+# Do not check Wagonfile into source control.
+#
+# To create a Wagonfile suitable for development, run 'rake wagon:file'
+#
+wagonfile = File.expand_path('../Wagonfile', __FILE__)
+eval(File.read(wagonfile)) if File.exist?(wagonfile)