sprout 0.7.246 → 1.0.0.pre

data/test/unit/fake_executable_task.rb

@@ -0,0 +1,22 @@
+
+class FakeExecutableTask
+  attr_accessor :output
+  attr_accessor :default_prefix
+  attr_accessor :default_short_prefix
+
+  def initialize
+    super
+    @output = 'fake_tool'
+    @default_prefix = '-'
+    @default_short_prefix = '--'
+  end
+
+  def default_file_expression
+    @default_file_expression ||= '/**/**/*'
+  end
+
+  def prerequisites
+    @prerequisites ||= []
+  end
+end
+

data/test/unit/fake_other_executable.rb

@@ -0,0 +1,20 @@
+
+class CustomFakeParameter < Sprout::Executable::StringParam; end
+
+class FakeOtherExecutableTask
+  include Sprout::Executable
+
+  add_param :boolean_param, Boolean
+  add_param :custom_param,  CustomFakeParameter
+  add_param :file_param,    File
+  add_param :files_param,   Files
+  add_param :number_param,  Number
+  add_param :path_param,    Path
+  add_param :paths_param,   Paths
+  add_param :string_param,  String
+  add_param :strings_param, Strings
+  add_param :urls_param,    Urls
+
+  add_param_alias :sp, :strings_param
+end
+

data/test/unit/fake_process_runner.rb

@@ -0,0 +1,29 @@
+
+class FakeProcessRunner
+
+  attr_accessor :command
+
+  def initialize
+    @r = FakeIO.new
+    @w = FakeIO.new
+    @e = FakeIO.new
+  end
+
+  def execute_open4 *command
+    @command = command
+  end
+
+  def read
+    @r
+  end
+
+  def read_err
+    @e
+  end
+
+  def write value
+    @w.write value
+  end
+
+end
+

data/test/unit/file_param_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FileParamTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "a new FileParam" do
+
+    setup do
+      @input_with_spaces = File.join(fixtures, "executable", "path with spaces", "input.as")
+      @input_with_spaces.gsub!(Dir.pwd + File::SEPARATOR, '')
+      @input_with_escaped_spaces = @input_with_spaces.gsub(' ', '\ ')
+      @input_with_quoted_spaces = "#{@input_with_spaces.gsub('/', '\\')}"
+
+      @input = File.join(fixtures, "executable", "params", "input.as")
+
+      @tool = FakeExecutableTask.new
+
+      @param = Sprout::Executable::FileParam.new
+      @param.belongs_to = @tool
+      @param.name = 'input'
+      @param.value = @input
+    end
+
+    should "clean the path for each system" do
+      as_each_system do |sys|
+        @param.expects(:validate)
+        # Ensure that system.clean_path is called
+        @param.value = @input_with_spaces
+        @param.prepare
+        assert_equal "-input=#{sys.clean_path(@input_with_spaces)}", @param.to_shell
+      end
+    end
+
+    should "include file path in shell output" do
+      as_each_system do |sys|
+        assert_equal "-input=#{sys.clean_path(@input)}", @param.to_shell
+      end
+    end
+
+    should "add file as prerequisite to parent" do
+      assert_equal 0, @tool.prerequisites.size
+      @param.prepare
+      assert_equal 1, @tool.prerequisites.size
+    end
+
+    should "not add prerequisite that matches output of parent" do
+      @tool.output = :abcd
+      @param.value = "abcd"
+      @param.prepare
+      assert_equal 0, @tool.prerequisites.size
+    end
+
+    should "raise if the file doesn't exist when asked for output" do
+      @param.value = 'unknown file'
+      assert_raises Sprout::Errors::InvalidArgumentError do
+        @param.to_shell
+      end
+    end
+  end
+end
+

data/test/unit/file_target_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FileTargetTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "a file target" do
+    setup do
+      @asunit_swc = 'bin/AsUnit4-4.1.pre.swc'
+    end
+
+    context "that is created with a constructor block" do
+      should "have the provided values" do
+        target = Sprout::FileTarget.new do |t|
+          t.add_library :swc, @asunit_swc
+        end
+        assert_provided_values target
+      end
+    end
+
+    context "that is created with no constructor block" do
+      should "have the provided values" do
+        target = Sprout::FileTarget.new
+        target.add_library :swc, @asunit_swc
+        assert_provided_values target
+      end
+    end
+
+  end
+
+  private
+
+  def assert_provided_values t
+    assert_equal :universal, t.platform
+    assert_equal 0, t.executables.size
+    assert_equal 1, t.libraries.size
+    library = t.libraries.first
+    assert_equal :swc, library.name
+    assert_equal File.join('.', @asunit_swc), library.path
+  end
+
+end
+

data/test/unit/files_param_test.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FilesParamTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "a new FilesParam" do
+
+    setup do
+      @input1 = File.join(fixtures, "executable", "params", "input.as")
+      @input2 = File.join(fixtures, "executable", "params", "input2.as")
+      @input3 = File.join(fixtures, "executable", "params", "input3.as")
+
+      @input4 = File.join(fixtures, "executable", "path with spaces", "input.as")
+      @input5 = File.join(fixtures, "executable", "path with spaces", "input2.as")
+      @input6 = File.join(fixtures, "executable", "path with spaces", "input3.as")
+
+      @param = Sprout::Executable::Files.new
+      @param.name = 'inputs'
+      @param.belongs_to = FakeExecutableTask.new
+    end
+
+    ['abcd', 1234, true].each do |value|
+      should "throw with non-enumerable assignment of #{value}" do
+        assert_raises Sprout::Errors::ExecutableError do
+          @param.value = value
+        end
+      end
+    end
+
+    should "allow assignment of enumerables" do
+      @param.value = ['abcd', 'efgh']
+    end
+
+    should "allow concatenation on first access" do
+      @param.value << 'abcd'
+    end
+
+    should "clean each path provided" do
+      # Ensure order is retained:
+      @param.value << @input3
+      @param.value << @input2
+      @param.value << @input1
+      
+      as_each_system do |sys|
+        assert_equal "-inputs+=#{sys.clean_path(@input3)} -inputs+=#{sys.clean_path(@input2)} -inputs+=#{sys.clean_path(@input1)}", @param.to_shell, "As a #{sys}"
+      end
+    end
+
+    should "clean paths with spaces" do
+      @param.value << @input6
+      @param.value << @input5
+      @param.value << @input4
+      
+      as_each_system do |sys|
+        assert_equal "-inputs+=#{sys.clean_path(@input6)} -inputs+=#{sys.clean_path(@input5)} -inputs+=#{sys.clean_path(@input4)}", @param.to_shell, "As a #{sys}"
+      end
+    end
+
+    should "defer to to_shell_proc if provided" do
+      @param.to_shell_proc = Proc.new { |param|
+        "proc:#{param.name}:#{param.value.shift}"
+      }
+
+      @param.value << 'abcd'
+
+      assert "Should be visible", @param.visible?
+      assert_equal 'proc:inputs:abcd', @param.to_shell
+    end
+
+  end
+end
+

data/test/unit/generator_generator_test.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+require 'sprout/generators/generator/generator_generator'
+
+class GeneratorGeneratorTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "A new generator generator" do
+
+    setup do
+      @temp             = File.join(fixtures, 'generators', 'tmp')
+      FileUtils.mkdir_p @temp
+      @generator        = Sprout::GeneratorGenerator.new
+      @generator.path   = @temp
+      @generator.logger = StringIO.new
+    end
+
+    teardown do
+      remove_file @temp
+    end
+
+    should "generate a new generator" do
+      @generator.input = 'fwee'
+      @generator.execute
+
+      lib_dir = File.join(@temp, 'lib')
+      assert_directory lib_dir
+      
+      test_dir = File.join(@temp, 'test')
+      assert_directory test_dir
+      
+      #TODO: This should be generated by the library creator
+      # vendor_dir = File.join(@temp, 'vendor')
+      # assert_directory vendor_dir
+      
+      fixtures_dir = File.join(test_dir, 'fixtures', 'generators')
+      assert_directory fixtures_dir
+      
+      test_file = File.join(test_dir, 'unit', 'fwee_generator_test.rb')
+      assert_file test_file do |content|
+        assert_matches /FweeGeneratorTest/, content
+      end
+      
+      test_helper_file = File.join(test_dir, 'unit', 'test_helper.rb')
+      assert_file test_helper_file
+      
+      generators_dir = File.join(lib_dir, 'generators')
+      assert_directory generators_dir
+      
+      generator_file = File.join(generators_dir, 'fwee_generator.rb')
+      assert_file generator_file
+      
+      templates_dir = File.join(generators_dir, 'templates')
+      assert_directory templates_dir
+      
+      template_file = File.join(templates_dir, 'fwee.as')
+      assert_file template_file
+      
+      bin_dir = File.join(@temp, 'bin')
+      assert_directory bin_dir
+      
+      executable_file = File.join(bin_dir, 'fwee')
+      assert_file executable_file
+    
+    end
+    
+    should  'generate a new generator in a namespaced directory' do
+      @generator.input = 'fwi'
+      @generator.namespace = 'sigmund'
+      @generator.execute
+
+      lib_dir = File.join(@temp, 'lib')
+      assert_directory lib_dir
+      
+      namespace_dir = File.join(lib_dir, 'sigmund')
+      assert_directory namespace_dir
+      
+      generator_dir = File.join(namespace_dir, 'generators')
+      assert_directory generator_dir
+      
+    end
+
+  end
+end
+

data/test/unit/generator_test.rb

@@ -0,0 +1,333 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class GeneratorTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "The Sprout::Generator" do
+
+    should "identify a default set of search paths" do
+      File.stubs(:directory?).returns true
+
+      ENV['SPROUT_GENERATORS'] = Dir.pwd
+      paths = Sprout::Generator.search_paths
+      assert_equal File.join('config', 'generators'), paths.shift
+      assert_equal File.join('vendor', 'generators'), paths.shift
+      assert_equal Sprout.generator_cache, paths.shift
+      assert_equal Dir.pwd, paths.shift
+    end
+    
+    should "return empty search paths if no defaults are found" do
+      File.stubs(:directory?).returns false
+      paths = Sprout::Generator.search_paths
+      assert_equal [], paths
+    end
+  end
+
+  context "A new application generator" do
+
+    setup do
+      @fixture          = File.join fixtures, 'generators', 'fake'
+      @templates        = File.join fixtures, 'generators', 'templates'
+      @string_io        = StringIO.new
+      @generator        = configure_generator FakeGenerator.new
+
+      FileUtils.mkdir_p @fixture
+    end
+
+    teardown do
+      remove_file @fixture
+    end
+
+    context "that is asked to execute/create" do
+      should "default path to pwd" do
+        generator = FakeGenerator.new
+        assert_equal Dir.pwd, generator.path
+      end
+
+      should "create outer directory and file" do
+        @generator.input = 'some_project'
+        @generator.execute
+        project = File.join(@fixture, 'some_project')
+        assert_directory project
+        assert_file File.join(project, 'SomeFile')
+        assert_directory File.join(project, 'src')
+        assert_file File.join(project, 'src', 'SomeProject.as') do |content|
+          assert_matches /public class SomeProject/, content
+          assert_matches /public function SomeProject/, content
+        end
+      end
+
+      should "copy templates from the first found template path" do
+        @generator.input = 'some_project'
+        @generator.band_name = 'R.E.M.'
+        @generator.execute
+        assert_file File.join(@fixture, 'some_project', 'SomeFile') do |content|
+          assert_matches /got my Orange Crush - R.E.M./, content
+        end
+      end
+
+      should "respect updates from subclasses" do
+        @generator = configure_generator SubclassedGenerator.new
+        @generator.input = 'some_project'
+        @generator.execute
+        assert_file File.join(@fixture, 'some_project', 'SomeFile') do |content|
+          assert_matches /Living Jest enough for the City and SomeProject/, content
+        end
+      end
+
+      should "use concrete template when provided" do
+        @generator.input = 'some_project'
+        @generator.execute
+        assert_file File.join(@fixture, 'some_project', 'SomeOtherFile') do |content|
+          assert_matches /I've had my fun/, content
+        end
+      end
+
+      should "raise missing template error if expected template is not found" do
+        @generator = configure_generator MissingTemplateGenerator.new
+        assert_raises Sprout::Errors::MissingTemplateError do
+          @generator.execute
+        end
+
+        assert !File.exists?(File.join(@fixture, 'some_project')), "Shouldn't leave half-generated files around"
+      end
+
+      should "notify user of all files created" do
+        @generator.input = 'some_project'
+        @string_io.expects(:puts).with('Created directory: ./some_project')
+        @string_io.expects(:puts).with('Created file:      ./some_project/SomeFile')
+        @string_io.expects(:puts).with('Created file:      ./some_project/SomeOtherFile')
+        @string_io.expects(:puts).with('Created directory: ./some_project/src')
+        @string_io.expects(:puts).with('Created file:      ./some_project/src/SomeProject.as')
+        @generator.execute
+      end
+
+      should "not notify if quiet is true" do
+        @generator.input = 'some_project'
+        @generator.quiet = true
+        @string_io.expects(:puts).never
+        @generator.execute
+      end
+
+      should "only have one param in class definition" do
+        assert_equal 2, FakeGenerator.static_parameter_collection.size
+        assert_equal 2, FakeGenerator.static_default_value_collection.size
+      end
+
+      should "not update superclass parameter collection" do
+        assert_equal 6, Sprout::Generator::Base.static_parameter_collection.size
+        assert_equal 1, Sprout::Generator::Base.static_default_value_collection.size
+      end
+
+      ##
+      # TODO: Add ability to prompt the user if requested files already exist,
+      # and force != true
+    end
+
+    context "that is asked to unexecute/delete" do
+      
+      setup do
+        @generator.input = 'some_project'
+        @generator.execute
+
+        @project = File.join @fixture, 'some_project'
+        @file = File.join @project, 'SomeFile'
+
+        assert_file File.join(@fixture, 'some_project')
+      end
+      
+      should "remove the expected files" do
+        @generator.unexecute
+        assert !File.exists?(@project), "Project should be deleted"
+      end
+
+      should "remove the expected files if destroy == true" do
+        @generator.destroy = true
+        @generator.execute
+        assert !File.exists?(@project), "Project should be deleted"
+      end
+
+      should "not remove files (or their parents) that have been edited" do
+        # Edit the file:
+        File.open @file, 'w+' do |f|
+          f.write "New Content"
+        end
+
+        @generator.unexecute
+        assert !File.exists?(File.join(@project, 'src')), "src dir should be removed"
+        assert_file @file, "Edited files should not be removed"
+      end
+
+      should "remove edited files if force is true" do
+        # Edit the file:
+        File.open @file, 'w+' do |f|
+          f.write "New Content"
+        end
+
+        @generator.force = true
+        @generator.unexecute
+        assert !File.exists?(@project), "Project dir should be removed"
+      end
+
+      should "not remove directories that have files in them" do
+        @file = File.join(@project, 'SomeNewFile.as')
+        File.open(@file, 'w+') do |f|
+          f.write 'New Content'
+        end
+
+        @generator.unexecute
+        assert_file @file, 'New file should not be removed'
+      end
+    end
+
+  end
+
+  private
+  
+  def configure_generator generator
+    generator.input   = 'some_project'
+    generator.logger = @string_io
+    generator.path   = @fixture
+    generator.templates << @templates
+    generator
+  end
+
+  ##
+  # This is a fake Generator that should 
+  # exercise the inputs.
+  class FakeGenerator < Sprout::Generator::Base
+
+    ##
+    # Register this generator by input, type and version
+    #register :application, :fake, '1.0.pre'
+
+    ##
+    # Some argument for the Fake Generator
+    add_param :band_name, String, { :default => 'Styx' }
+
+    ##
+    # Source path
+    add_param :src, String, { :default => 'src' }
+
+    ##
+    # The package (usually Gem) name
+    set :pkg_name, 'generator_test'
+
+    ##
+    # The package version
+    set :pkg_version, '1.0.pre'
+
+    def class_name
+      @class_name ||= input.camel_case
+    end
+
+    def manifest
+      directory input do
+        template 'SomeFile'
+        template 'SomeOtherFile', 'OtherFileTemplate'
+        directory src do
+          template "#{class_name}.as", 'Main.as'
+        end
+      end
+    end
+  end
+
+  context "an unregistered generator" do
+
+    setup do
+      @generators = File.join fixtures, 'generators'
+      @path       = File.join @generators, 'fake'
+      @project    = File.join @path, 'SomeProject'
+      $:.unshift @generators
+    end
+
+    teardown do
+      $:.shift
+      remove_file @path
+    end
+
+    should "fail to find unknown generator" do
+      assert_raises Sprout::Errors::LoadError do
+        generator = Sprout::Generator.load :demo, 'unknown_file', '>= 1.0.pre'
+      end
+    end
+    
+    should "be loadable if it's in the load path" do
+      generator = Sprout::Generator.load :demo, 'temp_generator', '>= 1.0.pre'
+      assert_not_nil generator
+
+      generator.logger = StringIO.new
+      generator.path = @path
+      generator.input = 'SomeProject'
+      generator.execute
+      assert_file @project, "Should have created project folder"
+    end
+  end
+
+  context "a generator that is a subclass of another" do
+    # Require the source files for this context
+    require 'test/fixtures/generators/song_generator'
+    require 'test/fixtures/generators/song_subclass/least_favorite'
+
+    setup do
+      @path = File.join(fixtures, 'generators', 'tmp')
+      FileUtils.mkdir_p @path
+
+      @song_generator = SongGenerator.new
+      @song_generator.logger = StringIO.new
+      @song_generator.path = @path
+
+      @least_favorite = LeastFavorite.new
+      @least_favorite.logger = StringIO.new
+      @least_favorite.path = @path
+    end
+
+    teardown do
+      remove_file @path
+    end
+
+    should "select templates from where it's defined - not it's superclass" do
+      @song_generator.favorite = 'I Feel Better'
+      @song_generator.execute
+      assert_file File.join(@path, 'i_feel_better.txt') do |content|
+        assert_matches /Your favorite song is 'I Feel Better'/, content
+      end
+
+      @least_favorite.favorite = 'I Feel Better'
+      @least_favorite.execute
+      assert_file File.join(@path, 'sucky', 'i_feel_better.txt') do |content|
+        assert_matches /Your LEAST favorite song is 'I Feel Better'/, content
+      end
+    end
+
+  end
+
+  class SubclassedGenerator < FakeGenerator
+
+    add_param :new_param, String, { :default => 'Other' }
+
+    def manifest
+      super
+      directory input do
+        template 'SomeFile', 'SomeSubclassFile'
+      end
+    end
+  end
+
+  ##
+  # This is a broken generator that should fail
+  # with a MissingTemplateError
+  class MissingTemplateGenerator < Sprout::Generator::Base
+
+    def manifest
+      directory input do
+        template 'FileWithNoTemplate'
+      end
+    end
+  end
+
+end
+
+
+
+