rubigen 1.0.0

data/lib/rubigen/generators/applications/ruby_app/ruby_app_generator.rb

@@ -0,0 +1,78 @@
+require 'rbconfig'
+
+class RubyAppGenerator < RubiGen::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options   :shebang => DEFAULT_SHEBANG
+  
+  attr_accessor :app_name
+  attr_accessor :module_name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = args.shift
+    self.app_name     = File.basename(File.expand_path(@destination_root))
+    self.module_name  = app_name.camelize
+  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] }
+    windows            = (RUBY_PLATFORM =~ /dos|win32|cygwin/i) || (RUBY_PLATFORM =~ /(:?mswin|mingw)/)
+
+    record do |m|
+      # Root directory and all subdirectories.
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      # Root
+      m.file "fresh_rakefile", "Rakefile"
+      m.file "README.txt",     "README.txt"
+
+     # Scripts
+      %w( generate ).each do |file|
+        m.file     "script/#{file}",        "script/#{file}", script_options
+        m.template "script/win_script.cmd", "script/#{file}.cmd", 
+          :assigns => { :filename => file } if windows
+      end
+      
+      # Default module for app
+      m.template "module.rb",         "lib/#{app_name}.rb", script_options
+      
+      # Test helper
+      m.template "test_helper.rb",    "test/test_helper.rb", script_options
+
+      %w(debug).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 }
+    end
+    
+
+  # Installation skeleton.  Intermediate directories are automatically
+  # created so don't sweat their absence here.
+  BASEDIRS = %w(
+    doc
+    lib
+    log
+    script
+    test
+    tmp
+  )
+end

data/lib/rubigen/generators/applications/ruby_app/templates/README.txt

@@ -0,0 +1 @@
+README

data/lib/rubigen/generators/applications/ruby_app/templates/fresh_rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+begin
+  require 'rake'
+rescue LoadError
+  puts 'This script should only be accessed via the "rake" command.'
+  puts 'Installation: gem install rake -y'
+  exit
+end
+require 'rake/clean'
+

data/lib/rubigen/generators/applications/ruby_app/templates/module.rb

@@ -0,0 +1,5 @@
+$:.unshift File.dirname(__FILE__)
+
+module <%= module_name %>
+  
+end

data/lib/rubigen/generators/applications/ruby_app/templates/script/generate

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Scripts::Generate.new.run(ARGV)

data/lib/rubigen/generators/applications/ruby_app/templates/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/<%= app_name %>'

data/lib/rubigen/generators/components/test_unit/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Stubs out a new test (using Test::Unit). Pass the model name, either 
+    CamelCased or under_scored.
+
+    This generates a unit test in /test.
+
+Examples:
+    `./script/generate test_unit account_receiver`
+
+        creates an Account test:
+            Test:       test/test_account_receiver.rb
+
+    The same result will occur for:
+      `./script/generate test_unit AccountReceiver`

data/lib/rubigen/generators/components/test_unit/templates/test

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

data/lib/rubigen/generators/components/test_unit/test_unit_generator.rb

@@ -0,0 +1,26 @@
+class TestUnitGenerator < RubiGen::Base
+  
+  attr_reader :name, :test_name, :class_name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name           = args.shift
+    @test_name      = "test_#{name}".underscore
+    @class_name     = test_name.camelize
+  end
+  
+  def manifest
+    record do |m|
+      m.directory 'test'
+
+      # Model class, unit test, and fixtures.
+      m.template 'test',  "test/#{test_name}.rb"
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} #{spec.name} NameOfTest"
+    end
+end

data/lib/rubigen/helpers/generator_test_helper.rb

@@ -0,0 +1,133 @@
+module RubiGen
+  module GeneratorTestHelper
+    # Runs the create command (like the command line does)
+    def run_generator(name, params, sources, options = {})
+      silence_generator do
+        build_generator(name, params, sources, options).command(:create).invoke!
+      end
+    end
+
+    # Instatiates the Generator
+    def build_generator(name, params, sources, options)
+      # if !options.first
+      #   type, sources = :component, []
+      # elsif options.first.is_a?(Symbol)
+      #   type, sources = options.first, []
+      # else
+      #   type, sources = :component, options.select { |s| s.is_a?(Source) }
+      # end
+      if sources.is_a?(Symbol)
+        if sources == :app
+          RubiGen::Base.use_application_sources!
+        else
+          RubiGen::Base.use_component_sources!
+        end
+      else
+        RubiGen::Base.reset_sources
+        RubiGen::Base.append_sources(*sources) unless sources.blank?
+      end
+      # generator_options = options.find { |o| o.is_a?(Hash) } || {}
+      RubiGen::Base.instance(name, params, options)
+    end
+
+    # Silences the logger temporarily and returns the output as a String
+    def silence_generator
+      logger_original=RubiGen::Base.logger
+      myout=StringIO.new
+      RubiGen::Base.logger=RubiGen::SimpleLogger.new(myout)
+      yield if block_given?
+      RubiGen::Base.logger=logger_original
+      myout.string
+    end
+
+    # asserts that the given file was generated.
+    # the contents of the file is passed to a block.
+    def assert_generated_file(path)
+      assert_file_exists(path)
+      File.open("#{APP_ROOT}/#{path}") do |f|
+        yield f.read if block_given?
+      end
+    end
+
+    # asserts that the given file exists
+    def assert_file_exists(path)
+      assert File.exists?("#{APP_ROOT}/#{path}"),"The file '#{path}' should exist"
+    end
+
+    # asserts that the given directory exists
+    def assert_directory_exists(path)
+      assert File.directory?("#{APP_ROOT}/#{path}"),"The directory '#{path}' should exist"
+    end
+
+    # asserts that the given class source file was generated.
+    # It takes a path without the <tt>.rb</tt> part and an optional super class.
+    # the contents of the class source file is passed to a block.
+    def assert_generated_class(path,parent=nil)
+      path=~/\/?(\d+_)?(\w+)$/
+      class_name=$2.camelize
+      assert_generated_file("#{path}.rb") do |body|
+        assert body=~/class #{class_name}#{parent.nil? ? '':" < #{parent}"}/,"the file '#{path}.rb' should be a class"
+        yield body if block_given?
+      end
+    end
+
+    # asserts that the given module source file was generated.
+    # It takes a path without the <tt>.rb</tt> part.
+    # the contents of the class source file is passed to a block.
+    def assert_generated_module(path)
+      path=~/\/?(\w+)$/
+      module_name=$1.camelize
+      assert_generated_file("#{path}.rb") do |body|
+        assert body=~/module #{module_name}/,"the file '#{path}.rb' should be a module"
+        yield body if block_given?
+      end
+    end
+
+    # asserts that the given unit test was generated.
+    # It takes a name or symbol without the <tt>test_</tt> part and an optional super class.
+    # the contents of the class source file is passed to a block.
+    def assert_generated_test_for(name, parent="Test::Unit::TestCase")
+      assert_generated_class "test/test_#{name.to_s.underscore}",parent do |body|
+        yield body if block_given?
+      end
+    end
+
+    # asserts that the given methods are defined in the body.
+    # This does assume standard rails code conventions with regards to the source code.
+    # The body of each individual method is passed to a block.
+    def assert_has_method(body,*methods)
+      methods.each do |name|
+        assert body=~/^  def #{name.to_s}\n((\n|   .*\n)*)  end/,"should have method #{name.to_s}"
+        yield( name, $1 ) if block_given?
+      end
+    end
+    
+    def app_root_files
+      Dir[APP_ROOT + '/**/*']
+    end
+
+    def rubygem_folders
+      %w[bin examples lib test]
+    end
+  
+    def rubygems_setup
+      bare_setup
+      rubygem_folders.each do |folder|
+        Dir.mkdir("#{APP_ROOT}/#{folder}") unless File.exists?("#{APP_ROOT}/#{folder}")
+      end
+    end
+  
+    def rubygems_teardown
+      bare_teardown
+    end
+  
+    def bare_setup
+      FileUtils.mkdir_p(APP_ROOT)
+    end
+  
+    def bare_teardown
+      FileUtils.rm_rf TMP_ROOT || APP_ROOT
+    end
+  
+  end
+end

data/lib/rubigen/lookup.rb

@@ -0,0 +1,296 @@
+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, ~/.rubigen/generators, and APP_ROOT/generators.
+    def lookup_missing_generator(class_id)
+      if md = /(.+)Generator$/.match(class_id.to_s)
+        name = md.captures.first.demodulize.underscore
+        RubiGen::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 RubiGen
+
+  # 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 GemGeneratorSource 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
+        if read_inheritable_attribute(:sources).blank?
+          if superclass == RubiGen::Base
+            superclass_sources = superclass.sources
+            diff = superclass_sources.inject([]) do |mem, source|
+              found = false
+              application_sources.each { |app_source| found ||= true if app_source == source}
+              mem << source unless found
+              mem
+            end
+            write_inheritable_attribute(:sources, diff)
+          end
+          use_component_sources! if read_inheritable_attribute(:sources).blank?
+        end
+        read_inheritable_attribute(: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!(*filters)
+        reset_sources
+        write_inheritable_attribute(:sources, application_sources(filters))
+      end
+      
+      def application_sources(filters = [])
+        filters.unshift 'app'
+        app_sources = []
+        app_sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/applications")
+        app_sources << filtered_sources(filters)
+        app_sources.flatten
+      end
+        
+      # Use component generators (test_unit, etc).
+      # 1.  Current application.  If APP_ROOT is defined we know we're
+      #     generating in the context of this application, so search
+      #     APP_ROOT/generators.
+      # 2.  User home directory.  Search ~/.rubigen/generators.
+      # 3.  RubyGems.  Search for gems containing /generators folder.
+      # 4.  Builtins.  test_unit.
+      #
+      # Search can be filtered by passing one or more prefixes.
+      # e.g. use_component_sources!(:rubygems) means it will also search in the following 
+      # folders:
+      # 5.  User home directory.  Search ~/.rubigen/rubygems_generators.
+      # 6.  RubyGems.   Search for gems containing /rubygems_generators folder.
+      def use_component_sources!(*filters)
+        reset_sources
+        new_sources = []
+        if defined? ::APP_ROOT
+          new_sources << PathSource.new(:root, "#{::APP_ROOT}/generators")
+          new_sources << PathSource.new(:vendor, "#{::APP_ROOT}/vendor/generators")
+          new_sources << PathSource.new(:plugins, "#{::APP_ROOT}/vendor/plugins/*/**/generators")
+        end
+        new_sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
+        new_sources << filtered_sources(filters)
+        write_inheritable_attribute(:sources, new_sources.flatten)
+      end
+      
+      def filtered_sources(filters)
+        new_sources = []
+        new_sources << PathFilteredSource.new(:user, "#{Dir.user_home}/.rubigen/", *filters)
+        if Object.const_defined?(:Gem)
+          new_sources << GemPathSource.new(*filters)
+        end
+        new_sources
+      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 = File.expand_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
+    
+    def ==(source)
+      self.class == source.class && path == source.path
+    end
+  end
+  
+  class PathFilteredSource < PathSource
+    attr_reader :filters
+    
+    def initialize(label, path, *filters)
+      super label, File.join(path, "#{filter_str(filters)}generators")
+    end
+    
+    def filter_str(filters)
+      @filters = filters.first.is_a?(Array) ? filters.first : filters
+      return "" if @filters.blank?
+      filter_str = @filters.map {|filter| "#{filter}_"}.join(",")
+      "{#{filter_str}}"
+    end
+
+    def ==(source)
+      self.class == source.class && path == source.path && filters == source.filters
+    end
+  end
+
+  class AbstractGemSource < Source
+    def initialize
+      super :RubyGems
+    end
+  end
+
+  # GemPathSource looks for generators within any RubyGem's /{filter_}generators/**/<generator_name>_generator.rb file.
+  class GemPathSource < AbstractGemSource
+    attr_accessor :filters
+    
+    def initialize(*filters)
+      super()
+      @filters = filters
+    end
+    
+    # Yield each generator within rails_generator subdirectories.
+    def each
+      generator_full_paths.each do |generator|
+        yield Spec.new(File.basename(generator).sub(/_generator.rb$/, ''), File.dirname(generator), label)
+      end
+    end
+
+    def ==(source)
+      self.class == source.class && filters == source.filters
+    end
+
+    private
+      def generator_full_paths
+        @generator_full_paths ||=
+          Gem::cache.inject({}) do |latest, name_gem|
+            name, gem = name_gem
+            hem = latest[gem.name]
+            latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+            latest
+          end.values.inject([]) do |mem, gem|
+            Dir[gem.full_gem_path + "/#{filter_str}generators/**/*_generator.rb"].each do |generator|
+              mem << generator
+            end
+            mem
+          end
+      end
+      
+      def filter_str
+        @filters = filters.first.is_a?(Array) ? filters.first : filters
+        return "" if filters.blank?
+        filter_str = filters.map {|filter| "#{filter}_"}.join(",")
+        "{#{filter_str}}"
+      end
+  end
+end

data/lib/rubigen/manifest.rb

@@ -0,0 +1,51 @@
+module RubiGen
+
+  # 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