adaptation 0.0.1

data/lib/rails_generator/generators/applications/app/app_generator.rb

@@ -0,0 +1,133 @@
+require 'rbconfig'
+
+class AppGenerator < Rails::Generator::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  DATABASES = %w(mysql oracle postgresql sqlite2 sqlite3 frontbase)
+
+  default_options   :db => "mysql", :shebang => DEFAULT_SHEBANG, :freeze => false
+  mandatory_options :source => "#{File.dirname(__FILE__)}/../../../../.."
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    usage("Databases supported for preconfiguration are: #{DATABASES.join(", ")}") if (options[:db] && !DATABASES.include?(options[:db]))
+    @destination_root = args.shift
+    @app_name = File.basename(File.expand_path(@destination_root))
+  end
+
+  def manifest
+    # Use /usr/bin/env if no special shebang was specified
+    script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
+    dispatcher_options = { :chmod => 0755, :shebang => options[:shebang] }
+
+    record do |m|
+      # Root directory and all subdirectories.
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      # Root
+      m.file "README", "README"
+
+      # Application
+      m.file "helpers/test_helper.rb", "test/test_helper.rb"
+      m.file "helpers/publish.rb", "test/mocks/test/publish.rb"
+
+      # database.yml 
+      m.template "configs/databases/#{options[:db]}.yml", "config/database.yml", :assigns => {
+        :app_name => @app_name,
+        :socket   => options[:db] == "mysql" ? mysql_socket_location : nil
+      }
+
+      # mom.yml
+      m.template "configs/mom.yml", "config/mom.yml"
+
+      # boot.rb, needed by some scripts
+      m.file "configs/boot.rb", "config/boot.rb"
+
+      # Environments
+      #m.file "environments/boot.rb",    "config/boot.rb"
+      #m.template "environments/environment.rb", "config/environment.rb", :assigns => { :freeze => options[:freeze] }
+      #m.file "environments/production.rb",  "config/environments/production.rb"
+      #m.file "environments/development.rb", "config/environments/development.rb"
+      #m.file "environments/test.rb",        "config/environments/test.rb"
+
+      # Scripts
+      %w( mom generate destroy about subscribe ).each do |file|
+        m.file "bin/#{file}", "script/#{file}", script_options
+      end
+
+      # Dispatches
+      m.file "dispatches/dispatch.rb", "public/dispatch.rb", script_options
+      m.file "dispatches/publish.rb", "public/publish.rb", script_options
+
+      # Docs
+      m.file "doc/README_FOR_APP", "doc/README_FOR_APP"
+
+      # Logs
+      %w(server production development test).each { |file|
+        m.file "configs/empty.log", "log/#{file}.log", :chmod => 0666
+      }
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} /path/to/your/app [options]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("-r", "--ruby=path", String,
+             "Path to the Ruby binary of your choice (otherwise scripts use env, dispatchers current path).",
+             "Default: #{DEFAULT_SHEBANG}") { |v| options[:shebang] = v }
+
+      opt.on("-d", "--database=name", String,
+            "Preconfigure for selected database (options: mysql/oracle/postgresql/sqlite2/sqlite3).",
+            "Default: mysql") { |v| options[:db] = v }
+
+      #opt.on("-f", "--freeze",
+      #      "Freeze Rails in vendor/rails from the gems generating the skeleton",
+      #      "Default: false") { |v| options[:freeze] = v }
+    end
+
+    def mysql_socket_location
+      MYSQL_SOCKET_LOCATIONS.find { |f| File.exists?(f) } unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
+    end
+
+
+  # Installation skeleton.  Intermediate directories are automatically
+  # created so don't sweat their absence here.
+  BASEDIRS = %w(
+    app/adaptors
+    app/messages
+    app/models
+    config/environments
+    db
+    doc
+    lib
+    lib/tasks
+    log
+    public
+    script
+    test/fixtures
+    test/functional
+    test/mocks/development
+    test/mocks/test
+    test/unit
+  )
+
+  MYSQL_SOCKET_LOCATIONS = [
+    "/tmp/mysql.sock",                        # default
+    "/var/run/mysqld/mysqld.sock",            # debian/gentoo
+    "/var/tmp/mysql.sock",                    # freebsd
+    "/var/lib/mysql/mysql.sock",              # fedora
+    "/opt/local/lib/mysql/mysql.sock",        # fedora
+    "/opt/local/var/run/mysqld/mysqld.sock",  # mac + darwinports + mysql
+    "/opt/local/var/run/mysql4/mysqld.sock",  # mac + darwinports + mysql4
+    "/opt/local/var/run/mysql5/mysqld.sock",  # mac + darwinports + mysql5
+    "/opt/lampp/var/mysql/mysql.sock"         # xampp for linux
+  ]
+end

data/lib/rails_generator/generators/components/adaptor/USAGE

@@ -0,0 +1,25 @@
+Description:
+    The adaptor generator creates stubs for a new adaptor.
+
+    The generator takes an adaptor name.
+    The adaptor name may be given in CamelCase or under_score and should
+    not be suffixed with 'Adaptor'.  To create an adaptor within a
+    module, specify the adaptor name as 'module/adaptor'.
+
+    The generator creates an adaptor class in app/adaptors
+    and a functional test suite in test/functional.
+
+Example:
+    ./script/generate adaptor AddClient
+
+    Add client adaptor.
+        Adaptor:    app/adaptors/add_client_adaptor.rb
+        Test:       test/functional/add_client_adaptor_test.rb
+
+Modules Example:
+    ./script/generate adaptor 'admin/add_client'
+
+    Add client adaptor.
+        Adaptor:    app/adaptors/admin/add_client_adaptor.rb
+        Test:       test/functional/admin/add_client_adaptor.rb
+

data/lib/rails_generator/generators/components/adaptor/adaptor_generator.rb

@@ -0,0 +1,21 @@
+class AdaptorGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, "#{class_name}Adaptor", "#{class_name}AdaptorTest"
+
+      # Adaptors and test directories.
+      m.directory File.join('app/adaptors', class_path)
+      m.directory File.join('test/functional', class_path)
+      # Adaptor class and functional test.
+      m.template 'adaptor.rb',
+                  File.join('app/adaptors',
+                            class_path,
+                            "#{file_name}_adaptor.rb")
+      m.template 'functional_test.rb',
+                  File.join('test/functional',
+                            class_path,
+                            "#{file_name}_adaptor_test.rb")
+    end
+  end
+end

data/lib/rails_generator/generators/components/adaptor/templates/adaptor.rb

@@ -0,0 +1,6 @@
+class <%= class_name %>Adaptor < Adaptation::Adaptor
+  
+  def process
+  end
+
+end

data/lib/rails_generator/generators/components/adaptor/templates/functional_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+require '<%= file_path %>_adaptor'
+
+class <%= class_name %>AdaptorTest < Test::Unit::TestCase
+
+  fixtures :<%= table_name %>
+
+  def setup
+    @adaptor = <%= class_name %>Adaptor.new
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/lib/rails_generator/generators/components/message/USAGE

@@ -0,0 +1,16 @@
+Description:
+    The message generator creates stubs for a new message.
+
+    The generator takes a message name as its argument.  The message name may be given in CamelCase or under_score and
+    should not be suffixed with 'Message'.
+
+    The generator creates a message class in app/messages, a test suite in test/unit and test fixtures in
+    test/fixtures/singular_name.xml.
+
+Examples:
+    ./script/generate message add_client
+
+        This will create an AddClient message:
+            Message:    app/messages/add_client.rb
+            Test:       test/unit/add_client_test.rb
+            Fixtures:   test/fixtures/add_client.xml

data/lib/rails_generator/generators/components/message/message_generator.rb

@@ -0,0 +1,28 @@
+class MessageGenerator < Rails::Generator::NamedBase
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name, "#{class_name}Test"
+
+      # Model, test, and fixture directories.
+      m.directory File.join('app/mmessages', class_path)
+      m.directory File.join('test/unit', class_path)
+      m.directory File.join('test/fixtures', class_path)
+
+      # Model class, unit test, and fixtures.
+      m.template 'message.rb',    File.join('app/messages', class_path, "#{file_name}.rb")
+      m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
+      m.template 'fixtures.xml',  File.join('test/fixtures', class_path, "#{file_name}.xml")
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} generate MessageName [field:type, field:type]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+    end
+end

data/lib/rails_generator/generators/components/message/templates/fixtures.xml

@@ -0,0 +1,3 @@
+<<%= file_name %>> 
+# put your xml here
+</<%= file_name %>> 

data/lib/rails_generator/generators/components/message/templates/message.rb

@@ -0,0 +1,2 @@
+class <%= class_name %> < Adaptation::Message
+end

data/lib/rails_generator/generators/components/message/templates/unit_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  fixtures :<%= file_name %>
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+
+  # assert messages with unexpected parts are detected
+  #def test_not_parsed
+  #  assert_parsed :<%= file_name %>
+  #  assert_not_parsed :<%= file_name %>_with_unknown_element
+  #  assert_not_parsed :<%= file_name %>_with_unknown_attribute
+  #end
+
+  # assert message passes our validations
+  #def test_validates
+  #  assert_validates :<%= file_name %>
+  #  assert_not_validates :<%= file_name %>_without_gid
+  #end
+
+
+end

data/lib/rails_generator/generators/components/model/USAGE

@@ -0,0 +1,26 @@
+Description:
+    The model generator creates stubs for a new model.
+
+    The generator takes a model name as its argument.  The model name may be given in CamelCase or under_score and
+    should not be suffixed with 'Model'.
+
+    As additional parameters, the generator will take attribute pairs described by name and type. These attributes will
+    be used to prepopulate the migration to create the table for the model and give you a set of predefined fixture.    
+    You don't have to think up all attributes up front, but it's a good idea of adding just the baseline of what's 
+    needed to start really working with the resource.
+
+    The generator creates a model class in app/models, a test suite in test/unit, test fixtures in
+    test/fixtures/singular_name.yml, and a migration in db/migrate.
+
+Examples:
+    ./script/generate model account
+
+        This will create an Account model:
+            Model:      app/models/account.rb
+            Test:       test/unit/account_test.rb
+            Fixtures:   test/fixtures/accounts.yml
+            Migration:  db/migrate/XXX_add_accounts.rb
+
+    ./script/generate model post title:string created_on:date body:text published:boolean
+    
+        Creates post model with predefined attributes.

data/lib/rails_generator/generators/components/model/model_generator.rb

@@ -0,0 +1,38 @@
+class ModelGenerator < Rails::Generator::NamedBase
+  default_options :skip_migration => false
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name, "#{class_name}Test"
+
+      # Model, test, and fixture directories.
+      m.directory File.join('app/models', class_path)
+      #m.directory File.join('test/unit', class_path)
+      m.directory File.join('test/fixtures', class_path)
+
+      # Model class, unit test, and fixtures.
+      m.template 'model.rb',      File.join('app/models', class_path, "#{file_name}.rb")
+      #m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
+      #m.template 'fixtures.yml',  File.join('test/fixtures', class_path, "#{table_name}.yml")
+
+      #unless options[:skip_migration]
+      #  m.migration_template 'migration.rb', 'db/migrate', :assigns => {
+      #    :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+      #  }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+      #end
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} generate ModelName [field:type, field:type]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("--skip-migration", 
+             "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
+    end
+end

data/lib/rails_generator/generators/components/model/templates/fixtures.yml

@@ -0,0 +1,11 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+one:
+  id: 1
+<% for attribute in attributes -%>
+  <%= attribute.name %>: <%= attribute.default %>
+<% end -%>
+two:
+  id: 2
+<% for attribute in attributes -%>
+  <%= attribute.name %>: <%= attribute.default %>
+<% end -%>

data/lib/rails_generator/generators/components/model/templates/migration.rb

@@ -0,0 +1,13 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+<% for attribute in attributes -%>
+      t.column :<%= attribute.name %>, :<%= attribute.type %>
+<% end -%>
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/lib/rails_generator/generators/components/model/templates/model.rb

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/lib/rails_generator/generators/components/model/templates/unit_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  fixtures :<%= table_name %>
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/lib/rails_generator/lookup.rb

@@ -0,0 +1,209 @@
+require File.dirname(__FILE__) + '/spec'
+
+class Object
+  class << self
+    # Lookup missing generators using const_missing.  This allows any
+    # generator to reference another without having to know its location:
+    # RubyGems, ~/.rails/generators, and RAILS_ROOT/generators.
+    def lookup_missing_generator(class_id)
+      if md = /(.+)Generator$/.match(class_id.to_s)
+        name = md.captures.first.demodulize.underscore
+        Rails::Generator::Base.lookup(name).klass
+      else
+        const_missing_before_generators(class_id)
+      end
+    end
+
+    unless respond_to?(:const_missing_before_generators)
+      alias_method :const_missing_before_generators, :const_missing
+      alias_method :const_missing, :lookup_missing_generator
+    end
+  end
+end
+
+# User home directory lookup adapted from RubyGems.
+def Dir.user_home
+  if ENV['HOME']
+    ENV['HOME']
+  elsif ENV['USERPROFILE']
+    ENV['USERPROFILE']
+  elsif ENV['HOMEDRIVE'] and ENV['HOMEPATH']
+    "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+  else
+    File.expand_path '~'
+  end
+end
+
+
+module Rails
+  module Generator
+
+    # Generator lookup is managed by a list of sources which return specs
+    # describing where to find and how to create generators.  This module
+    # provides class methods for manipulating the source list and looking up
+    # generator specs, and an #instance wrapper for quickly instantiating
+    # generators by name.
+    #
+    # A spec is not a generator:  it's a description of where to find
+    # the generator and how to create it.  A source is anything that
+    # yields generators from #each.  PathSource and GemSource are provided.
+    module Lookup
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.use_component_sources!
+      end
+
+      # Convenience method to instantiate another generator.
+      def instance(generator_name, args, runtime_options = {})
+        self.class.instance(generator_name, args, runtime_options)
+      end
+
+      module ClassMethods
+        # The list of sources where we look, in order, for generators.
+        def sources
+          read_inheritable_attribute(:sources) or use_component_sources!
+        end
+
+        # Add a source to the end of the list.
+        def append_sources(*args)
+          sources.concat(args.flatten)
+          invalidate_cache!
+        end
+
+        # Add a source to the beginning of the list.
+        def prepend_sources(*args)
+          write_inheritable_array(:sources, args.flatten + sources)
+          invalidate_cache!
+        end
+
+        # Reset the source list.
+        def reset_sources
+          write_inheritable_attribute(:sources, [])
+          invalidate_cache!
+        end
+
+        # Use application generators (app, ?).
+        def use_application_sources!
+          reset_sources
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/applications")
+        end
+
+        # Use component generators (model, controller, etc).
+        # 1.  Rails application.  If RAILS_ROOT is defined we know we're
+        #     generating in the context of a Rails application, so search
+        #     RAILS_ROOT/generators.
+        # 2.  User home directory.  Search ~/.rails/generators.
+        # 3.  RubyGems.  Search for gems named *_generator.
+        # 4.  Builtins.  Model, controller, mailer, scaffold.
+        def use_component_sources!
+          reset_sources
+          if defined? ::RAILS_ROOT
+            sources << PathSource.new(:lib, "#{::RAILS_ROOT}/lib/generators")
+            sources << PathSource.new(:vendor, "#{::RAILS_ROOT}/vendor/generators")
+            sources << PathSource.new(:plugins, "#{::RAILS_ROOT}/vendor/plugins/**/generators")
+          end
+          sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
+          sources << GemSource.new if Object.const_defined?(:Gem)
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
+        end
+
+        # Lookup knows how to find generators' Specs from a list of Sources.
+        # Searches the sources, in order, for the first matching name.
+        def lookup(generator_name)
+          @found ||= {}
+          generator_name = generator_name.to_s.downcase
+          @found[generator_name] ||= cache.find { |spec| spec.name == generator_name }
+          unless @found[generator_name] 
+            chars = generator_name.scan(/./).map{|c|"#{c}.*?"}
+            rx = /^#{chars}$/
+            gns = cache.select{|spec| spec.name =~ rx }
+            @found[generator_name] ||= gns.first if gns.length == 1
+            raise GeneratorError, "Pattern '#{generator_name}' matches more than one generator: #{gns.map{|sp|sp.name}.join(', ')}" if gns.length > 1
+          end
+          @found[generator_name] or raise GeneratorError, "Couldn't find '#{generator_name}' generator"
+        end
+
+        # Convenience method to lookup and instantiate a generator.
+        def instance(generator_name, args = [], runtime_options = {})
+          lookup(generator_name).klass.new(args, full_options(runtime_options))
+        end
+
+        private
+          # Lookup and cache every generator from the source list.
+          def cache
+            @cache ||= sources.inject([]) { |cache, source| cache + source.map }
+          end
+
+          # Clear the cache whenever the source list changes.
+          def invalidate_cache!
+            @cache = nil
+          end
+      end
+    end
+
+    # Sources enumerate (yield from #each) generator specs which describe
+    # where to find and how to create generators.  Enumerable is mixed in so,
+    # for example, source.collect will retrieve every generator.
+    # Sources may be assigned a label to distinguish them.
+    class Source
+      include Enumerable
+
+      attr_reader :label
+      def initialize(label)
+        @label = label
+      end
+
+      # The each method must be implemented in subclasses.
+      # The base implementation raises an error.
+      def each
+        raise NotImplementedError
+      end
+
+      # Return a convenient sorted list of all generator names.
+      def names
+        map { |spec| spec.name }.sort
+      end
+    end
+
+
+    # PathSource looks for generators in a filesystem directory.
+    class PathSource < Source
+      attr_reader :path
+
+      def initialize(label, path)
+        super label
+        @path = path
+      end
+
+      # Yield each eligible subdirectory.
+      def each
+        Dir["#{path}/[a-z]*"].each do |dir|
+          if File.directory?(dir)
+            yield Spec.new(File.basename(dir), dir, label)
+          end
+        end
+      end
+    end
+
+
+    # GemSource hits the mines to quarry for generators.  The latest versions
+    # of gems named *_generator are selected.
+    class GemSource < Source
+      def initialize
+        super :RubyGems
+      end
+
+      # Yield latest versions of generator gems.
+      def each
+        Gem::cache.search(/_generator$/).inject({}) { |latest, gem|
+          hem = latest[gem.name]
+          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+          latest
+        }.values.each { |gem|
+          yield Spec.new(gem.name.sub(/_generator$/, ''), gem.full_gem_path, label)
+        }
+      end
+    end
+
+  end
+end

data/lib/rails_generator/manifest.rb

@@ -0,0 +1,53 @@
+module Rails
+  module Generator
+
+    # Manifest captures the actions a generator performs.  Instantiate
+    # a manifest with an optional target object, hammer it with actions,
+    # then replay or rewind on the object of your choice.
+    #
+    # Example:
+    #   manifest = Manifest.new { |m|
+    #     m.make_directory '/foo'
+    #     m.create_file '/foo/bar.txt'
+    #   }
+    #   manifest.replay(creator)
+    #   manifest.rewind(destroyer)
+    class Manifest
+      attr_reader :target
+
+      # Take a default action target.  Yield self if block given.
+      def initialize(target = nil)
+        @target, @actions = target, []
+        yield self if block_given?
+      end
+
+      # Record an action.
+      def method_missing(action, *args, &block)
+        @actions << [action, args, block]
+      end
+
+      # Replay recorded actions.
+      def replay(target = nil)
+        send_actions(target || @target, @actions)
+      end
+
+      # Rewind recorded actions.
+      def rewind(target = nil)
+        send_actions(target || @target, @actions.reverse)
+      end
+
+      # Erase recorded actions.
+      def erase
+        @actions = []
+      end
+
+      private
+        def send_actions(target, actions)
+          actions.each do |method, args, block|
+            target.send(method, *args, &block)
+          end
+        end
+    end
+
+  end
+end