rubigen 1.4.0 → 1.5.0

data/.autotest

@@ -0,0 +1,13 @@
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  
+  at.add_mapping(%r%^test/test_.*.rb$%) do |filename, _| 
+    filename 
+  end
+  at.add_mapping(/lib\/(.*)\.rb/) do |_, m|
+    ["test/test_#{m[1]}.rb"]
+  end
+  # at.add_mapping(/.*_?generators\/(.*)\/(.*)_generator\.rb/) do |_, m|
+  #   ["test/test_#{m[1]}.rb"]
+  # end
+end

data/History.txt

@@ -1,4 +1,17 @@
-== 1.4.0 2008-12-11 NOT RELEASED
+== 1.5.0 2008-12-27
+
+* Preparation for integration back into Rails
+* --git/-g option for generated files to be added via git commands
+* after_generate hook for generators (used as rails' templates mechanism)
+* bumped activesupport requirement to 2.2.2
+* upgraded internal files to support latest newgem (removed config/ folder, moved config to Rakefile)
+* support for RAILS_ROOT as a destination root
+* removed references to Merb which now has its own generator system; can access any merb
+  generators via `rubigen` helper app
+* RubiGen::Base.active can be changed to a RubiGen::Base subclass that will be used
+  for lookups (e.g. RubiGen::Base.active = Rails::Generator::Base)
+
+== 1.4.0 2008-12-11
 
 * rubigen tests now pass against ruby 1.9.0 and ruby 1.9.1(prerelease 2)
 * puts are sent to an explicit #stdout which can be STDOUT or a StringIO passed from tests; test output is now clean!

data/Manifest.txt

@@ -1,7 +1,8 @@
+.autotest
 History.txt
 License.txt
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
 Todo.txt
 app_generators/ruby_app/USAGE
@@ -11,15 +12,20 @@ app_generators/ruby_app/templates/Rakefile
 app_generators/ruby_app/templates/lib/module.rb
 app_generators/ruby_app/templates/test/test_helper.rb.erb
 bin/install_rubigen_scripts
+bin/rubigen
 bin/ruby_app
-config/hoe.rb
-config/requirements.rb
+features/development.feature
+features/help.feature
+features/rubigen_cli.feature
+features/steps/common.rb
+features/steps/env.rb
 generators/install_rubigen_scripts/install_rubigen_scripts_generator.rb
 generators/install_rubigen_scripts/templates/script/destroy
 generators/install_rubigen_scripts/templates/script/generate
 generators/install_rubigen_scripts/templates/script/win_script.cmd
 lib/rubigen.rb
 lib/rubigen/base.rb
+lib/rubigen/cli.rb
 lib/rubigen/commands.rb
 lib/rubigen/generated_attribute.rb
 lib/rubigen/helpers/generator_test_helper.rb
@@ -48,13 +54,10 @@ rubygems_generators/component_generator/templates/readme
 rubygems_generators/component_generator/templates/test.rb
 rubygems_generators/component_generator/templates/test_generator_helper.rb
 rubygems_generators/component_generator/templates/usage
+script/console
 script/destroy
 script/generate
 script/txt2html
-setup.rb
-tasks/deployment.rake
-tasks/environment.rake
-tasks/website.rake
 test/test_application_generator_generator.rb
 test/test_component_generator_generator.rb
 test/test_generate_builtin_application.rb
@@ -63,6 +66,7 @@ test/test_generator_helper.rb
 test/test_helper.rb
 test/test_install_rubigen_scripts_generator.rb
 test/test_lookup.rb
+test/test_rubigen_cli.rb
 test_unit_generators/test_unit/USAGE
 test_unit_generators/test_unit/templates/test.rb
 test_unit_generators/test_unit/test_unit_generator.rb

data/{README.txt → README.rdoc}

@@ -1,5 +1,9 @@
 = RubiGen - Ruby Generator Framework
 
+* http://rubigen.rubyforge.org
+
+== DESCRIPTION:
+
 A framework to allow Ruby applications to generate file/folder stubs 
 (like the `rails` command does for Ruby on Rails, and the 'script/generate'
 command within a Rails application during development).
@@ -15,7 +19,7 @@ and generally assumed it was the only generator framework within the Ruby world
 So, any RubyGem whose name ended with '_generator' was assumed to be a generator for
 a Rails application.
 
-But if you are developing a Merb application, then you may want a different set of generators.
+But if you are developing an Adhearsion application, then you may want a different set of generators.
 If you are developing a RubyGem, then you will want a different set of generators.
 
 RubiGen exists to give different development environments their own generator framework.
@@ -27,15 +31,25 @@ Jeremy Kemper wrote the original Rails Generator, which is 95% of the basis of R
 == Installation
 
 RubiGen is only required at development time, and normally isn't required at deployment time
-(unless your application uses it to generate files etc for its users).
+(unless your application uses it to generate files at runtime).
 
 On your development machine:
 
-    gem install rubigen -y
+    sudo gem install rubigen
     
 == Usage
 
-RubiGen will be normally integrated into another RubyGem, such as `newgem` or `merb` or `camping`,
+RubiGen comes with a stand-alone executable to allow you to invoke generators:
+
+For example, to run the rails' `model` generator:
+
+    rubigen rails model Person name:string
+
+would replace the normal
+
+    script/generate model Person name:string
+
+RubiGen has been traditionally integrated into another project, such as `rails`, `newgem` or `camping`,
 rather than be used on its own.
 
 These frameworks might use RubiGen for two reasons:
@@ -57,9 +71,9 @@ So, there are two steps to integrating RubiGen into your framework:
    generate components/extensions within the framework.
    RubiGen allows you to restrict which generators are available. For example, within
    RubyGem development environment (as generated by `newgem`), the `script/generator`
-   only shows `rubygem`-related generators. Merb could restrict `script/generator`
-   to only show Merb related generators (or perhaps Merb and/or Rails generators)
-2. Your framework RubyGem (e.g. `newgem` or `merb` RubyGems) needs to add `rubigen` as a 
+   only shows `rubygem`-related generators. Rails could restrict `script/generator`
+   to only show Rails related generators
+2. Your framework RubyGem (e.g. `newgem` or `rails`) needs to add `rubigen` as a 
    dependency, so that users of your RubyGem can access the generator framework.
    
 = Creating generators

data/Rakefile

@@ -1,4 +1,21 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
+%w[rubygems rake rake/clean newgem].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/rubigen'
 
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('rubigen', RubiGen::VERSION) do |p|
+  p.developer('Dr Nic Williams', 'drnicwilliams@gmail.com')
+  p.developer('Jeremy Kemper', 'jeremy@bitsweat.net')
+  p.changes        = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps     = [['activesupport','>= 2.2.2']]
+  p.extra_dev_deps = [['newgem', ">= #{::Newgem::VERSION}"]]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+
+task :default => :features

data/Todo.txt

@@ -1,5 +1,7 @@
 = TODO
 
-* Labels for displays based on scope (common, merb, newgem), not rubygems, builtin, etc. Perhaps use one PathSource per scope.
+* default #manifest to clone over any folders + files + apply erb to any *.erb files
+* rspec examples generated for application_generator and component_generator as per newgem
+* Labels for displays based on scope (common, rails, newgem), not rubygems, builtin, etc. Perhaps use one PathSource per scope.
   See RubiGen::Scripts::Base#usage_message
-* Local generators (~/.rubigen) can be scoped (~/.rubigen/merb_generators)
+* Local generators (~/.rubigen) can be scoped (~/.rubigen/rails_generators)

data/bin/rubigen

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-12-27.
+#  Copyright (c) 2008. All rights reserved.
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rubigen")
+
+require "rubigen/cli"
+
+Rubigen::CLI.execute(STDOUT, ARGV, :destination => File.expand_path("."))

data/features/development.feature

@@ -0,0 +1,13 @@
+Feature: Development processes of newgem itself (rake tasks)
+
+  As a Newgem maintainer or contributor
+  I want rake tasks to maintain and release the gem
+  So that I can spend time on the tests and code, and not excessive time on maintenance processes
+    
+  Scenario: Generate RubyGem
+    Given this project is active project folder
+    And 'pkg' folder is deleted
+    When task 'rake gem' is invoked
+    Then folder 'pkg' is created
+    And file with name matching 'pkg/*.gem' is created else you should run "rake manifest" to fix this
+    And gem spec key 'rdoc_options' contains /--mainREADME.rdoc/

data/features/help.feature

@@ -0,0 +1,14 @@
+Feature: Generators offer help/usage details
+  In order to reduce cost of learning about a new generator
+  As a generator user
+  I want help/usage details about generators
+  
+  Scenario: List of visible generators for rubygems
+    Given a safe folder
+    When run local executable 'rubigen rubygems' with arguments ''
+    Then output does match /application_generator/
+    And output does match /component_generator/
+    And output does not match /migration/ # from rails scope
+  
+
+  

data/features/rubigen_cli.feature

@@ -0,0 +1,10 @@
+Feature: rubigen command-line interface to access generators anywhere
+  In order to reduce cost of using rubigen
+  As a Ruby developer
+  I want to execute generators anywhere without a script/generate helper script
+  
+  Scenario: Run a component generator
+    Given a safe folder
+    When run local executable 'rubigen' with arguments 'rubygems component_generator foo bar'
+    Then file 'bar_generators/foo/foo_generator.rb' is created
+  

data/features/steps/common.rb

@@ -0,0 +1,195 @@
+def in_project_folder(&block)
+  project_folder = @active_project_folder || @tmp_root
+  FileUtils.chdir(project_folder, &block)
+end
+
+def in_home_folder(&block)
+  FileUtils.chdir(@home_path, &block)
+end
+
+Given %r{^a safe folder} do
+  FileUtils.rm_rf   @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  FileUtils.mkdir_p @tmp_root
+  FileUtils.mkdir_p @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  Given "env variable $HOME set to '#{@home_path}'"
+end
+
+Given %r{^this project is active project folder} do
+  Given "a safe folder"
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given %r{^env variable \$([\w_]+) set to '(.*)'} do |env_var, value|
+  ENV[env_var] = value
+end
+
+def force_local_lib_override(project_name = @project_name)
+  rakefile = File.read(File.join(project_name, 'Rakefile'))
+  File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+    f << "$:.unshift('#{@lib_path}')\n"
+    f << rakefile
+  end
+end
+
+def setup_active_project_folder project_name
+  @active_project_folder = File.join(@tmp_root, project_name)
+  @project_name = project_name
+end
+
+Given %r{'(.*)' folder is deleted} do |folder|
+  in_project_folder do
+    FileUtils.rm_rf folder
+  end
+end
+
+When %r{^'(.*)' generator is invoked with arguments '(.*)'$} do |generator, arguments|
+  @stdout = StringIO.new
+  FileUtils.chdir(@active_project_folder) do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When %r{run executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{run project executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{run local executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  @stderr = File.expand_path(File.join(@tmp_root, "executable.err"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stderr}"
+  end
+end
+
+When %r{^task 'rake (.*)' is invoked$} do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then %r{^folder '(.*)' (is|is not) created} do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then %r{^file '(.*)' (is|is not) created} do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then %r{^file with name matching '(.*)' is created} do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then %r{gem file '(.*)' and generated file '(.*)' should be the same} do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then %r{^output same as contents of '(.*)'$} do |file|
+  expected_output = File.read(File.join(File.dirname(__FILE__) + "/../expected_outputs", file))
+  actual_output = File.read(File.dirname(__FILE__) + "/../../tmp/#{@stdout}")
+  actual_output.should == expected_output
+end
+
+Then %r{^(does|does not) invoke generator '(.*)'$} do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then %r{help options '(.*)' and '(.*)' are displayed} do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then %r{^output (does|does not) match \/(.*)\/} do |does, regex|
+  actual_output = File.read(@stdout)
+  (does == 'does') ?
+    actual_output.should(match(/#{regex}/)) :
+    actual_output.should_not(match(/#{regex}/)) 
+end
+
+Then %r{^contents of file '(.*)' (does|does not) match \/(.*)\/} do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then %r{^all (\d+) tests pass} do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then %r{^all (\d+) examples pass} do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then %r{^yaml file '(.*)' contains (\{.*\})} do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then %r{^Rakefile can display tasks successfully} do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then %r{^task 'rake (.*)' is executed successfully} do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then %r{^gem spec key '(.*)' contains \/(.*)\/} do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/steps/env.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/../../lib/rubigen"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'

data/lib/rubigen/base.rb

@@ -35,7 +35,7 @@ require File.dirname(__FILE__) + '/generated_attribute'
 # directory.
 #
 # The filenames of the templates don't matter, but choose something that
-# will be self-explatatory since you will be referencing these in the 
+# will be self-explanatory since you will be referencing these in the 
 # +manifest+ method inside your generator subclass.
 #
 # 
@@ -86,6 +86,11 @@ module RubiGen
     # A logger instance available everywhere in the generator.
     cattr_accessor :logger
 
+    # Either RubiGen::Base, or a subclass (e.g. Rails::Generator::Base)
+    # Currently used to determine the lookup paths via the overriden const_missing mechansim
+    # in lookup.rb
+    cattr_accessor :active
+
     # Every generator that is dynamically looked up is tagged with a
     # Spec describing where it was found.
     class_inheritable_accessor :spec
@@ -102,6 +107,8 @@ module RubiGen
         @destination_root = options[:destination]
       elsif defined? ::APP_ROOT
         @destination_root = ::APP_ROOT
+      elsif defined? ::RAILS_ROOT
+        @destination_root = ::RAILS_ROOT
       end
 
       # Silence the logger if requested.
@@ -163,6 +170,9 @@ module RubiGen
       name
     end
     
+    def after_generate
+    end
+
     protected
       # Convenience method for generator subclasses to record a manifest.
       def record

data/lib/rubigen/cli.rb

@@ -0,0 +1,31 @@
+require 'optparse'
+
+module Rubigen
+  class CLI
+    attr_reader :stdout
+    
+    def self.execute(stdout, arguments, runtime_arguments = {})
+      self.new.execute(stdout, arguments, runtime_arguments)
+    end
+
+    def execute(stdout, arguments, runtime_arguments = {})
+      @stdout = stdout
+      main_usage and return unless scope = arguments.shift
+      scopes = scope.split(",").map(&:to_sym)
+      
+      runtime_arguments.merge!(:stdout => stdout, :no_exit => true)
+      RubiGen::Base.logger = RubiGen::SimpleLogger.new(stdout)
+
+      require 'rubigen/scripts/generate'
+      RubiGen::Base.use_component_sources!(scopes)
+      RubiGen::Scripts::Generate.new.run(arguments, runtime_arguments)
+    end
+    
+    def main_usage
+      stdout.puts <<-USAGE.gsub(/^        /, '')
+      Usage: $0 scope generator [options for generator]
+      USAGE
+      true
+    end
+  end
+end