sprout 0.7.246 → 1.0.0.pre

data/lib/sprout/system/java_system.rb

@@ -0,0 +1,9 @@
+
+module Sprout::System
+
+  # The concrete system for the JRuby environment
+  class JavaSystem < BaseSystem
+
+  end
+end
+

data/lib/sprout/system/osx_system.rb

@@ -0,0 +1,26 @@
+
+module Sprout::System
+
+  class OSXSystem < UnixSystem
+    LIBRARY = 'Library'
+
+    def library
+      lib = File.join(home, LIBRARY)
+      if(File.exists?(lib))
+        return lib
+      else
+        return super
+      end
+    end
+
+    def format_application_name(name)
+      return name.capitalize
+    end
+
+    def can_execute? platform
+      [:mac, :osx, :macosx, :darwin].include?(platform) || super
+    end
+
+  end
+end
+

data/lib/sprout/system/unix_system.rb

@@ -0,0 +1,72 @@
+
+module Sprout::System
+
+  class UnixSystem < BaseSystem
+
+    def clean_path path
+      return if path.nil?
+      if(path.include? '../')
+        path = File.expand_path path
+      end
+
+      if(path.index(' '))
+        return path.split(' ').join('\ ')
+      end
+      return path
+    end
+
+    def execute(tool, options='')
+      attempt_to_repair_executable tool
+      super(tool, options)
+    end
+
+    ##
+    # Ensure Application +name+ String begins with a dot (.), and does
+    # not include spaces.
+    #
+    def format_application_name(name)
+      if(name.index('.') != 0)
+        name = '.' + name
+      end
+      return name.split(" ").join("_").downcase
+    end
+
+    def can_execute? platform
+      [:unix, :linux].include?(platform) || super
+    end
+
+    ##
+    # Repair Windows Line endings
+    # found in non-windows executables
+    # (Flex SDK is regularly published
+    # with broken CRLFs)
+    #
+    # +path+ String path to the executable file.
+    #
+    def attempt_to_repair_executable path
+      repair_executable(path) if should_repair_executable(path)
+    end
+
+    def repair_executable path
+      content = File.read(path)
+      if(content.match(/\r\n/))
+        Sprout::Log.puts "[WARNING] Sprouts is about to replace invalid Windows line endings on an executable at: (#{path})"
+        content.gsub!(/\r\n/, "\n")
+        File.open(path, 'w+') do |f|
+          f.write content
+        end
+      end
+    end
+
+    ##
+    # Determine if we should call +repair_executable+
+    # for the file at the provided +path+ String.
+    #
+    # Will this corrupt binaries?
+    def should_repair_executable path
+      return (File.exists?(path) && !File.directory?(path) && File.read(path).match(/^\#\!/))
+    end
+
+  end
+end
+

data/lib/sprout/system/vista_system.rb

@@ -0,0 +1,16 @@
+
+module Sprout::System
+
+  class VistaSystem < WinSystem
+
+    def find_home
+      return env_userprofile unless env_userprofile.nil?
+      super
+    end
+
+    def env_userprofile
+      ENV['USERPROFILE']
+    end
+  end
+end
+

data/lib/sprout/system/win_nix_system.rb

@@ -0,0 +1,41 @@
+
+module Sprout::System
+
+  # The concrete system for Cygwin and Mingw
+  # We can't quite treat these users like
+  # a typical *nix system, but we can't quite
+  # treat them like Windows users either.
+  #
+  # One great thing about these users,
+  # is that we get to use real processes,
+  # rather than the broken processes that
+  # windows normally offers.
+  class WinNixSystem < WinSystem
+
+    def clean_path(path)
+      return nil if path.nil?
+      if(path.index(' '))
+        return %{'#{path}'}
+      end
+      return path
+    end
+
+    def win_home
+      @win_home ||= ENV['HOMEDRIVE'] + ENV['HOMEPATH']
+    end
+
+    def home
+      @home ||= win_nix_home
+    end
+
+    def win_nix_home
+      path  = win_home.split('\\').join("/")
+      path  = path.split(":").join("")
+      parts = path.split("/")
+      path  = parts.shift().downcase + "/" + parts.join("/")
+      "/cygdrive/" + path
+    end
+
+  end
+end
+

data/lib/sprout/system/win_system.rb

@@ -0,0 +1,76 @@
+
+module Sprout::System
+
+  # The default Windows system.
+  # This is the system type for all
+  # major versions and flavors of Windows
+  # (except Cygwin and Mingw).
+  class WinSystem < BaseSystem
+    LOCAL_SETTINGS = "Local\ Settings"
+    APPLICATION_DATA = "Application\ Data"
+
+    def home
+      path = super
+      if(path.include? "My Documents")
+        path = File.dirname(path)
+      end
+      return path
+    end
+
+    def get_paths
+      return env_path.split(';')
+    end
+
+    def library
+      # For some reason, my homepath returns inside 'My Documents'...
+      application_data = File.join(home, LOCAL_SETTINGS, APPLICATION_DATA)
+      if(File.exists?(application_data))
+        return application_data
+      else
+        return super
+      end
+    end
+
+    def clean_path(path)
+      path = path.split('/').join("\\")
+      if(path.index(' '))
+        return %{"#{path}"}
+      end
+      return path
+    end
+
+    def format_application_name(name)
+      return name.capitalize
+    end
+
+    def can_execute? platform
+      [:windows, :win32].include?(platform) || super
+    end
+
+    protected
+
+    ##
+    # Gets the process runner and calls
+    # platform-specific execute method
+    def get_and_execute_process_runner tool, options=nil
+      tool = find_tool tool
+      runner = get_process_runner
+      runner.execute_win32 "\"#{tool}\" #{options}"
+      runner
+    end
+
+    private
+
+    def find_tool tool
+      return "#{tool}.bat" if File.exists?("#{tool}.bat")
+      return "#{tool}.exe" if File.exists?("#{tool}.exe")
+      tool
+    end
+
+    def env_path
+      ENV['PATH']
+    end
+
+  end
+end
+

data/lib/sprout/test/sprout_test_case.rb

@@ -0,0 +1,211 @@
+
+# Had to make this a module instead of a base class
+# because the ruby test suite kept complaining that 
+# the abstract test case didn't have any test mehods
+# or assertions
+module SproutTestCase # :nodoc:[all]
+  FIXTURES_NAME = 'fixtures'
+
+  # Gives us the ability to hide RubyGem output from
+  # our test results...
+  include Gem::DefaultUserInteraction
+
+  def fixtures from=nil
+    @fixtures ||= find_fixtures(from || Sprout.file_from_caller(caller.first))
+  end
+
+  def setup
+    super
+    @start_path = Dir.pwd
+  end
+
+  def teardown
+    super
+    clear_tasks
+    Sprout::Executable.clear_entities!
+    Sprout::Library.clear_entities!
+    Sprout::Generator.clear_entities!
+
+    remove_file @temp_path
+    remove_file @temp_cache
+
+    @temp_path  = nil
+    @temp_cache = nil
+
+    if(@start_path && Dir.pwd != @start_path)
+      puts "[WARNING] >> SproutTestCase changing dir from #{Dir.pwd} back to: #{@start_path} - Did you mean to leave your working directory in a new place?"
+      Dir.chdir @start_path
+    end
+
+  end
+
+  def temp_path
+    caller_file = Sprout.file_from_caller caller.first
+    @temp_path ||= make_temp_folder File.dirname(caller_file)
+  end
+
+  def make_temp_folder from
+    dir = File.join(fixtures(from), 'tmp')
+    FileUtils.mkdir_p dir
+    dir
+  end
+
+  def run_task(name)
+    t = Rake.application[name]
+    t.invoke
+    return t
+  end
+  
+  def get_task(name)
+    return Rake.application[name]
+  end
+
+  def clear_tasks
+    Rake::Task.clear
+    Rake.application.clear
+  end
+
+  def create_file path
+    dir = File.dirname path
+    FileUtils.mkdir_p dir
+    FileUtils.touch path
+  end
+
+  def remove_file(path=nil)
+    if(path && File.exists?(path))
+      FileUtils.rm_rf(path)
+    end
+  end
+
+  def assert_file(path, message=nil)
+    message ||= "Expected file not found at #{path}"
+    assert(File.exists?(path), message)
+    yield File.read(path) if block_given?
+  end
+
+  def assert_directory(path, message=nil)
+    message ||= "Expected directory not found at #{path}"
+    assert(File.directory?(path), message)
+  end
+
+  def assert_not_empty(path, message=nil)
+    assert_file path, message
+    files = FileList["#{path}/*"]
+    message ||= " - Expected #{path} to not be empty, but it was"
+    assert files.size > 0, message
+  end
+  
+  def assert_matches(expression, string, message='')
+    if(expression.is_a?(String))
+      expresion = /#{expression}/
+    end
+    if(!string.match(expression))
+      fail "#{message} - '#{string}' should include '#{expression}'"
+    end
+  end
+
+  ##
+  # Add the skip method that was introduced in Ruby 1.9.1 Test::Unit
+  # This doesn't really work all that well...
+  if(RUBY_VERSION == '1.8.7')
+    def skip message=""
+      puts
+      puts ">> SproutTestCase.skip called from: #{caller[0]} ( #{message} )"
+    end
+  end
+
+  def temp_cache
+    dir = File.dirname(Sprout.file_from_caller(caller.first))
+    @temp_cache ||= File.join(fixtures(dir), 'sprout', 'cache')
+  end
+
+  def as_each_system
+    [
+     Sprout::System::VistaSystem.new,
+     Sprout::System::WinNixSystem.new,
+     Sprout::System::WinSystem.new,
+     Sprout::System::JavaSystem.new,
+     Sprout::System::OSXSystem.new,
+     Sprout::System::UnixSystem.new
+    ].each do |sys|
+      expectation = Sprout::System.stubs(:create).returns sys
+      yield sys if block_given?
+      # Ugh - This is way too greedy... We're killing all mocks in here
+      # Doing it anyway b/c we need to get Windows support in place...
+      # TODO: Implement this feature without clobbering all stubs/mocks
+      Mocha::Mockery.instance.teardown
+    end
+  end
+
+=begin
+  def as_a_unix_system
+    sys = Sprout::System::UnixSystem.new
+    expectation = Sprout::System.stubs(:create).returns sys
+    yield sys if block_given?
+    # Ugh - This is way too greedy... We're killing all mocks in here
+    # Doing it anyway b/c we need to get Windows support in place...
+    # TODO: Implement this feature without clobbering all stubs/mocks
+    Mocha::Mockery.instance.teardown
+  end
+
+  def as_a_mac_system
+    sys = Sprout::System::OSXSystem.new
+    Sprout::System.stubs(:create).returns sys
+    yield sys if block_given?
+    # Ugh - This is way too greedy... We're killing all mocks in here
+    # Doing it anyway b/c we need to get Windows support in place...
+    # TODO: Implement this feature without clobbering all stubs/mocks
+    Mocha::Mockery.instance.teardown
+  end
+  
+  def as_a_windows_system
+    sys = Sprout::System::WinSystem.new
+    Sprout::System.stubs(:create).returns sys
+    yield sys if block_given?
+    # Ugh - This is way too greedy... We're killing all mocks in here
+    # Doing it anyway b/c we need to get Windows support in place...
+    # TODO: Implement this feature without clobbering all stubs/mocks
+    Mocha::Mockery.instance.teardown
+  end
+=end
+
+  
+  private
+
+  # Find the nearest fixtures folder to the provided
+  # path by checking each parent directory.
+  def find_fixtures path
+    # Return nil if path is nil or is not a file:
+    return nil if(path.nil? || !File.exists?(path))
+    # Get the parent directory if path is a file:
+    path = File.dirname(path) if !File.directory? path
+    # Check for a folder at "#{path}/fixtures":
+    fixture_path = File.join(path, FIXTURES_NAME)
+    # Return the fixtures folder if found:
+    return fixture_path if File.directory? fixture_path
+    # Move up one directory and try again:
+    return find_fixtures File.dirname(path)
+  end
+
+end
+
+  # TODO: Consider adding these:
+  # Some generator-related assertions:
+  #   assert_generated_file(name, &block) # block passed the file contents
+  #   assert_directory_exists(name)
+  #   assert_generated_class(name, &block)
+  #   assert_generated_module(name, &block)
+  #   assert_generated_test_for(name, &block)
+  # The assert_generated_(class|module|test_for) &block is passed the body of the class/module within the file
+  #   assert_has_method(body, *methods) # check that the body has a list of methods (methods with parentheses not supported yet)
+  #
+  # Other helper methods are:
+  #   app_root_files - put this in teardown to show files generated by the test method (e.g. p app_root_files)
+  #   bare_setup - place this in setup method to create the app_root folder for each test
+  #   bare_teardown - place this in teardown method to destroy the TMP_ROOT or app_root folder after each test
+
+
+# Prevent log messages from interrupting the test output:
+Sprout::Log.debug = true
+Sprout::ProgressBar.debug = true
+