tap 0.7.9 → 0.8.0

data/lib/tap/generator.rb

@@ -1,29 +1,88 @@
-require 'active_record'            # required by rails_generator, for some reason
-require 'rails_generator'
-require 'tap/generator/options'
-require 'tap/generator/usage'
-
-module Tap
-  module Generator 
-    module Generators  # :nodoc:
-    end
-  end
-end
-      
-# These modifications are to make the rails generators work for Tap
-module Rails # :nodoc:
-  module Generator # :nodoc:  
-    class Base # :nodoc:
-      include Tap::Generator::Options
-      
-      # Used to discover generators within tap.  Adapted from code
-      # in 'rails/rails_generator/lookup.rb'
-      def self.use_tap_sources!
-        reset_sources
-        sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generator/generators")
-        sources << PathSource.new(:builtin, Tap::App.instance.filepath(:generators))
-      end
-    end
-  end
-end
-
+require 'rails_generator'
+require 'tap/generator/options'
+require 'tap/generator/usage'
+
+module Tap
+  # stub module definition so generators can use 'module Tap::Generator::Generators' 
+  module Generator # :nodoc:
+    module Generators  # :nodoc:
+    end
+  end
+end
+      
+# These modifications are to make the rails generators work for Tap
+module Rails # :nodoc:
+  module Generator # :nodoc:  
+    class Base # :nodoc:
+      include Tap::Generator::Options
+      
+      # Used to discover generators within tap.  Adapted from code
+      # in 'rails/rails_generator/lookup.rb'
+      def self.use_tap_sources!
+        reset_sources
+        sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generator/generators")
+        sources << PathSource.new(:builtin, Tap::App.instance.filepath(:generators))
+      end
+    end
+    
+    class NamedBase < Base # :nodoc:
+      attr_reader :class_name_without_nesting
+    end
+    
+    module Commands # :nodoc:
+      class Create # :nodoc:
+        
+        #--
+        # Adds a template_option to nest classes, so that "Some::ClassName" can be nested
+        #
+        #   module Some
+        #     class ClassName
+        #     end
+        #   end
+        #
+        # rather than
+        # 
+        #   class Some::ClassName
+        #   end
+        #
+        # The problem is that with the latter representation, errors can be raised if 'Some' 
+        # has not already been defined as a module.
+        #++
+        def template(relative_source, relative_destination, template_options = {})
+          file(relative_source, relative_destination, template_options) do |file|
+            # Evaluate any assignments in a temporary, throwaway binding.
+            vars = template_options[:assigns] || {}
+            b = binding
+            vars.each { |k,v| eval "#{k} = vars[:#{k}] || vars['#{k}']", b }
+
+            # Render the source file with the temporary binding.
+            content = ERB.new(file.read, nil, '-').result(b)
+            
+            # add nesting with two-space indentation
+            if template_options.has_key?(:class_nesting)
+              class_nesting = template_options[:class_nesting]
+              
+              nestings = class_nesting.split(/::/)
+              lines = content.split(/\r?\n/)
+   
+              depth = nestings.length
+              lines.collect! {|line| "  " * depth + line}
+              
+              nestings.reverse_each do |mod_name|
+                depth -= 1
+                lines.unshift("  " * depth + "module #{mod_name}")
+                lines << ("  " * depth + "end")
+              end
+              
+              content = lines.join("\n")
+            end
+            
+            content
+          end
+        end
+        
+      end
+    end
+  end
+end
+

data/lib/tap/generator/generators/config/config_generator.rb

@@ -1,6 +1,6 @@
 module Tap::Generator::Generators
   class ConfigGenerator < Rails::Generator::NamedBase # :nodoc:
-    attr_accessor :default_config
+    attr_accessor :formatted_yaml
 
     def initialize(*args)
       super(*args)    
@@ -12,11 +12,13 @@ module Tap::Generator::Generators
       record do |m|
         task_name = class_path.empty? ? class_name : File.join(class_path, class_name)
         task = @app.task(task_name)
-        self.default_config = task.class.default_config
+        self.formatted_yaml = task.class.configurations.format_yaml
     
         config_path = @app.relative_filepath(:root, @app[:config])
         m.directory File.join(config_path, class_path)
         m.template "config.erb", File.join(config_path, class_name.underscore + ".yml")
+        
+        # TODO -- add versioning
       end
     end
   end

data/lib/tap/generator/generators/config/templates/config.erb

@@ -1,2 +1 @@
-# Configurations for <%= class_name %>
-<%= default_config.stringify_keys.to_yaml %>
+<%= formatted_yaml %>

data/lib/tap/generator/generators/file_task/file_task_generator.rb

@@ -1,21 +1,6 @@
-module Tap::Generator::Generators
-  class FileTaskGenerator < Rails::Generator::NamedBase # :nodoc:
-    def initialize(*args)
-      super(*args)    
-      @destination_root  = Tap::App.instance[:root]
-      @app = Tap::App.instance
-  	end
+require 'tap/generator/generators/task/task_generator'
 
-    def manifest
-      record do |m|
-        lib_path = @app.relative_filepath(:root, @app[:lib])
-        m.directory File.join(lib_path, class_path)
-        m.template "task.erb", File.join(lib_path, class_name.underscore + ".rb")
-     
-        test_path = @app.relative_filepath(:root, @app[:test])
-        m.directory File.join(test_path, class_path)
-        m.template "test.erb", File.join(test_path, class_name.underscore + "_test.rb")
-      end
-    end
+module Tap::Generator::Generators
+  class FileTaskGenerator < TaskGenerator # :nodoc:
   end
 end

data/lib/tap/generator/generators/file_task/templates/task.erb

@@ -1,25 +1,32 @@
-# == Documentation
+# == Description
+# Replace with a description for <%= class_name_without_nesting %>
+# === Usage
+# Replace with usage instructions
 #
-# === Command Line Usage
-# Replace with your command line usage instructions
-#
-class <%= class_name %> < Tap::FileTask
+class <%= class_name_without_nesting %> < Tap::FileTask
+  # uncomment to:
+  # - pass all inputs to process at once 
+  # - define a task that takes no inputs
+  
+  #do_not_iterate
+  
+  # use config to set task configurations
+  # configs have accessors by default
+  
+  #config :key, 'value'          # config documentation
 
   def process(input)
-    # The process logic goes here.  You don't have to use transform.  
-    # Do whatever works!
-    output = infer_filepath(:data, input)
+    # The process logic goes here.
+    output = filepath(:data, input)
 
-    make(output) 
+    # prepare ensures the parent directory for
+    # output exists, and marks it for rollback
+    # in the event of an error
+    prepare(output) 
 
     File.open(input) do |source|
       File.open(output, "w") do |target|
-        target.write "<root>\n"
-        while line = source.gets
-          next unless line =~ /(\w+): (\w+)/
-          target.write "  <#{$1}>#{$2}</#{$1}>\n"
-        end
-        target.write "</root>"
+        # ... do something ...
       end
     end
   end

data/lib/tap/generator/generators/file_task/templates/test.erb

@@ -1,12 +1,23 @@
 require File.join(File.dirname(__FILE__), '<%= '../' * class_nesting_depth %>tap_test_helper.rb') 
 require '<%= class_path.empty? ? file_name : File.join(class_path, file_name) %>'
 
-class <%= class_name %>Test < Test::Unit::TestCase
+class <%= class_name_without_nesting %>Test < Test::Unit::TestCase
   acts_as_tap_test 
   
   def test_<%= file_name.underscore %>
+    # this test will make input/expected directories for the
+    # test_<%= file_name.underscore %> the first time it is
+    # run.  assert_expected_result_files runs t with all the 
+    # input files and returns true only if the expected and 
+    # output files are equal
+    #
+    # output files are cleaned up by default.  to preserve
+    # them use:
+    #
+    #   % tap run test keep_outputs=true
+    
     t = <%= class_name %>.new 
-    file_task_test(t, :quiet => true)
+    assert_expected_result_files(t)
   end
   
 end

data/lib/tap/generator/generators/generator/generator_generator.rb

@@ -0,0 +1,21 @@
+module Tap::Generator::Generators
+  class GeneratorGenerator < Rails::Generator::NamedBase # :nodoc:
+    def initialize(*args)
+      super(*args)    
+      @destination_root  = Tap::App.instance[:root]
+      @app = Tap::App.instance
+      
+      raise "Sorry - generator names cannot be nested.  Try '#{file_name}' by itself." unless class_path.empty?
+  	end
+
+    def manifest
+      record do |m|
+        generators_root = @app.relative_filepath(:root, @app[:generators])
+        m.directory File.join(generators_root, file_name, "templates")
+        
+        m.template "generator.erb", File.join(generators_root,  file_name, file_name + "_generator.rb")
+        m.template "usage.erb",  File.join(generators_root, file_name, "USAGE")
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/generator/templates/generator.erb

@@ -0,0 +1,23 @@
+class <%= class_name_without_nesting %>Generator < Rails::Generator::NamedBase 
+  def initialize(*args)
+    super(*args)    
+    @destination_root  = Tap::App.instance[:root]
+    @app = Tap::App.instance
+  end
+
+  def manifest
+    record do |m|
+      # Use statements like these to make directories you need.
+      # Note directories will be created relative to @destination_root
+      # (ie @app[:root]) so the target dir must be a relative filepath
+      #target_dir = @app.relative_filepath(:root, @app[:target])
+      #m.directory target_dir
+      
+      # These statements would create the following files:
+      #   templates/ruby_file.erb =>  target_dir/class_name.rb
+      #   tempaltes/text_file.erb  =>  target_dir/class_name.txt
+      #m.template "ruby_file.erb", File.join(target_dir, class_name.underscore + ".rb"), :class_nesting => class_nesting
+      #m.template "text_file.erb",  File.join(target_dir, class_name.underscore + ".txt")
+    end
+  end
+end

data/lib/tap/generator/generators/generator/templates/usage.erb

@@ -0,0 +1 @@
+<%= class_name %> Usage

data/lib/tap/generator/generators/package/package_generator.rb

@@ -0,0 +1,38 @@
+require 'shellwords'
+require 'pp'
+
+module Tap::Generator::Generators
+  class PackageGenerator < Rails::Generator::NamedBase # :nodoc:
+    include Shellwords
+    
+    attr_accessor :config, :argv, :package_file
+    
+    def initialize(*args)
+      super(*args)    
+      @destination_root  = Tap::App.instance[:root]
+      @app = Tap::App.instance
+  	end
+
+    def manifest
+      record do |m|
+        # read the config for the current root
+        @config = File.read Tap::Script.config_filepath(@app[:root])
+        
+        # at this point ARGV still includes the package name, 
+        # ie the commands should be argument 1  
+        # Note: it's important to setup argv this way, from a single argument,
+        # so that options can be included in the packaged arguments:
+        #   generate package raw_to_mgf "run --debug some/task"
+        # vs
+        #   generate package raw_to_mgf run --debug some/task
+        # where '--debug' is applied to generate rather than run
+        @argv = PP.singleline_pp(shellwords(ARGV[1].to_s), '')
+        
+        @package_file = class_path.empty? ? file_name : File.join(class_path, file_name)
+        filepath = "pkg/#{@package_file}.rb"
+        m.directory File.dirname(filepath)
+        m.template "package.erb", filepath
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/package/templates/package.erb

@@ -0,0 +1,186 @@
+#############################################
+# HOW TO PACKAGE YOUR SCRIPT:
+# 1. Attend to the parts marked TODO
+# 2. Run rubyscript2exe as described below:
+#
+#   % rubyscript2exe <%= package_file %>.rb
+#
+# NOTES:
+# The 'rubyscript2exe' gem is required for packaging -- install using:
+#    % gem install rubyscript2exe
+#
+# The inputs you used when creating this script will supplied before 
+# the inputs you provide to the executable.  Hence if you used:
+#    % tap generate package "run --quiet some/task"
+#
+# These will be equivalent commands:
+#    % tap run --quiet some/task INPUT1 INPUT2
+#    % <%= package_file %>.exe INPUT1 INPUT2
+#
+# Feel free to adjust this script to behave as you like -- whatever this 
+# script does will be packaged into the executable. 
+#
+#############################################
+#
+# = Prompt Instructions
+# Enter an empty line to continue.
+
+require "tap"
+require "tap/script"
+
+# = TODO: add script requires
+#
+# Only what this script does will be packaged into the executable.
+# You MUST specify tasks and other files that are not loaded during
+# the 'rubyscript2exe' execution of this script.  Usually this means
+# require-ing any tasks that may get used.
+# 
+# require 'some/task'
+
+app = Tap::App.instance
+script = Tap::Script.instance
+
+# = TODO: check arguments
+# Make sure these are what you want later in this script they're unshifted
+# onto ARGV, ie they'll be hard-coded into the executable.
+script_argv = <%= argv %>
+
+# = TODO: check configurations
+#
+# This configures the packaged app the same as the current tap.yml
+# Check that the configurations look the way you want them to, or
+# set the executable to load it's own configurations, as by:
+#   config_file = Tap::Script.config_filepath(Dir.pwd)
+#   config = Tap::Script.read_config(config_file)  
+#
+app_config = %Q{<%= config.gsub(/^\s*$|^#.*$/m, '') %>}
+
+# = TODO: decide if you want to prompt when you get no inputs
+# This can be handy if you want to be able to interact with the 
+# packaged script.
+if ARGV.select {|arg| arg !~ /^-|^--/ }.empty?
+  puts Tap::Script.usage(__FILE__, "Prompt Instructions", :keep_headers => false)
+
+  while true
+    print "glob: "
+    line = gets.strip
+    break if line.empty?
+    
+    line = line[1..-2] if line =~ /^".*"$/
+    ARGV << line
+  end
+  puts
+end
+
+# nice give the user a second before you exit, especially if you have a prompt
+def exit(*args)
+	puts 
+	puts "Hit enter to exit."
+  ARGV.clear
+	gets
+	super
+end
+
+#############################################
+# These sections generally needs far less customization
+#############################################
+
+#
+# configure the app
+#
+begin
+  config = YAML.load(app_config)
+  config = {} if config == false
+  script.configure_app(config)
+rescue(Exception)
+  # catch errors and exit gracefully
+  # (errors usu from gem loading errors)
+  puts "Configuration error: #{$!.message}"
+  exit(1)
+end
+
+#
+# add modifications for rubyscript2exe 
+#
+require "rubyscript2exe"
+if RUBYSCRIPT2EXE.is_compiling?
+module Kernel
+  def exit_with_load_path_rewriting
+    [$", REQUIRE2LIB::LOADED].each do |loaded_files|
+      loaded_files.collect! do |load_path|
+        if File.expand_path(load_path) == load_path
+          $:.each do |root|
+            relative_load_path = Tap::Root.relative_filepath(File.expand_path(root), load_path, false)
+            unless relative_load_path == load_path
+              load_path = relative_load_path
+              break
+            end
+          end
+        end
+
+        load_path
+      end
+    end
+    exit_without_load_path_rewriting
+  end
+  
+  alias exit_without_load_path_rewriting exit
+  alias exit exit_with_load_path_rewriting
+end
+
+else
+  script.config.script_paths.unshift RUBYSCRIPT2EXE.appdir("../lib/script")
+  Dependencies.load_paths.unshift RUBYSCRIPT2EXE.appdir("../lib")
+  Dir.chdir(RUBYSCRIPT2EXE.exedir)
+end
+
+#
+# run before script
+#
+begin
+  eval(script.config.before.to_s)
+rescue
+  puts "Error in before script."
+  if app.options.debug
+    raise 
+  else
+    puts $!.message
+    exit(1)
+  end
+end
+
+# This is where the inputs used to create this script are unshifted
+# onto ARGV, ahead of the user inputs.  
+script_argv.reverse_each  {|arg| ARGV.unshift arg}
+  
+#
+# run the script -- note that the first argument
+# to ARGV is the script that gets run.
+#
+begin
+  load script.config.scripts[ARGV.shift]
+rescue
+  if app.options.debug
+    raise 
+  else
+    puts "Error."
+    puts $!.message
+  end
+end
+
+#
+# run after script
+#
+begin
+  eval(script.config.after.to_s) 
+rescue
+  puts "Error in after script."
+  if app.options.debug
+    raise 
+  else
+    puts $!.message
+    exit(1)
+  end
+end
+
+exit(0)