ext 1.0.3 → 1.0.4

data/lib/externals/test/rails_app_svn_repository.rb

@@ -0,0 +1,106 @@
+require 'externals/test/repository'
+require 'externals/test/git_repository_from_internet'
+require 'externals/test/svn_repository_from_dump'
+require 'externals/test/svn_repository_helper'
+require 'externals/test/fake_rails_repository'
+require 'externals/test/modules_svn_repository'
+require 'externals/test/rails_app_unmanaged'
+require 'externals/test/engines'
+
+module Externals
+  module Test
+    class RailsAppSvnRepository < Repository
+      include SvnRepositoryHelper
+
+      def initialize
+        super "rails_app", "svn2"
+        dependents.merge!(
+          :acts_as_list => GitRepositoryFromInternet.new("acts_as_list.git"),
+          :ssl_requirement => GitRepositoryFromInternet.new("ssl_requirement.git"),
+          :engines => Engines.new,
+          :redhillonrails_core => SvnRepositoryFromDump.new("redhillonrails_core"),
+          :empty_plugin => SvnRepositoryFromDump.new("empty_plugin"),
+          #fkm seems to cause problems when running tests, concerning a corrupt repository.
+          #commenting out for now.
+          #:foreign_key_migrations => SvnRepositoryFromDump.new("foreign_key_migrations", ""),
+          :rails => FakeRailsRepository.new,
+          :modules => ModulesSvnRepository.new,
+          :rails_app_unmanaged => RailsAppUnmanaged.new
+        )
+
+        dependents[:ssl_requirement].attributes[:revision] =
+          "aa2dded823f8a9b378c22ba0159971508918928a"
+      end
+
+      def build_here
+        puts `svnadmin create #{name}`
+        raise unless $? == 0
+
+        mkdir_p "workdir"
+        Dir.chdir 'workdir' do
+          rm_rf_ie name
+
+          cmd = "svn checkout \"#{clean_url}\""
+          puts `#{cmd}`
+          raise unless $? == 0
+
+          Dir.entries(dependents[:rails_app_unmanaged].clean_dir).each do |file|
+            unless %w(.. .).include? file.to_s
+              cp_a File.join(dependents[:rails_app_unmanaged].clean_dir, file), name
+            end
+          end
+
+          Dir.chdir name do
+            SvnProject.add_all
+            puts `svn commit -m "created initial project"`
+            raise unless $? == 0
+
+            `svn up`
+            raise unless $? == 0
+
+            Ext.run "init"
+            raise " could not create .externals"  unless File.exists? '.externals'
+
+            # this line is necessary as ext can't perform the necessary
+            # ignores otherwise if vendor and vendor/plugins haven't been added
+            SvnProject.add_all
+            #            puts `svn commit -m "added .externals file"`
+            #            raise unless $? == 0
+
+            #install some git subprojects
+            Ext.run "install", dependents[:acts_as_list].clean_dir
+            #we have to use file:// to test export, because without that
+            #git clone optimizes by copying and igores --depth
+            Ext.run "install", "file://#{dependents[:rails].clean_dir}"
+
+            #install a couple svn managed subprojects
+            [
+              #:foreign_key_migrations,
+              :redhillonrails_core
+            ].each do |proj|
+              Ext.run "install", "--svn", dependents[proj].clean_url
+            end
+
+            #install project with a git branch
+            Ext.run "install", dependents[:engines].clean_dir, "-b", "edge"
+
+            #install project with a non-default path
+            Ext.run "install", "--svn",
+              "#{dependents[:modules].clean_url}",
+              "modules"
+
+            SvnProject.add_all
+
+            puts `svn commit -m "created empty rails app with some subprojects"`
+            unless $? == 0
+              raise
+            end
+          end
+
+          rm_rf "workdir"
+        end
+      end
+    end
+
+  end
+end

data/lib/externals/test/rails_app_unmanaged.rb

@@ -0,0 +1,25 @@
+require 'externals/test/repository'
+
+module Externals
+  module Test
+    class RailsAppUnmanaged < Repository
+      def initialize
+        super "rails_app", "unmanaged"
+      end
+
+      def build_here
+        rm_rf name
+        if rails_version =~ /^3([^\d]|$)/
+          puts `#{rails_exe} new #{name}`
+          raise unless $? == 0
+        elsif rails_version =~ /^2([^\d]|$)/
+          puts `#{rails_exe} #{name}`
+          raise unless $? == 0
+        else
+          raise "can't determine rails version"
+        end
+      end
+
+    end
+  end
+end

data/lib/externals/test/repository.rb

@@ -0,0 +1,188 @@
+require 'fileutils'
+
+module Externals
+  module Test
+
+    # repositories used for testing live in
+    #
+    # test/tmp/cleanreps
+    #
+    # and a backup is made in
+    #
+    # test/tmp/pristinereps
+    #
+    # reps in pristinereps are never written to, but a test can write to
+    # a rep in cleanreps.  When this happens, the test needs to reset
+    # the rep in cleanreps.  This can be done by simply deleting it.  It
+    # will then be copied back over from pristinereps.
+    #
+    # a file is placed in these directories named .working_#{repname}
+    # when they are being built or copied.  If present, Repository will not use
+    # that folder, and will instead delete it and recreate it.
+    #
+    class Repository
+      include ExtTestCase
+
+      attr_accessor :name, :subpath, :dependents, :attributes
+
+      def initialize name, subpath = ""
+        self.subpath = subpath
+        self.name = name
+        self.dependents ||= {}
+        self.attributes ||= {}
+
+        [
+          clean_dir_parent,
+          pristine_dir_parent
+        ].each do |p|
+          FileUtils.mkdir_p p
+        end
+      end
+
+      # the root location under which all clean repositories are stored for testing.
+      def clean_dir_root
+        File.join(root_dir, "test", "tmp", "cleanreps")
+      end
+
+      # One level up from the directory in which this repository's clean version is stored
+      def clean_dir_parent
+        if subpath.empty?
+          clean_dir_root
+        else
+          File.join clean_dir_root, subpath
+        end
+      end
+
+      # The directory in which this repository's clean version is stored
+      def clean_dir
+        File.join clean_dir_parent, name
+      end
+
+      # the root location under which all pristine repositories are stored for testing.
+      def pristine_dir_root
+        File.join(root_dir, "test", "tmp", "pristinereps")
+      end
+
+      # One level up from the directory in which this repository's pristine version is stored
+      def pristine_dir_parent
+        if subpath.empty?
+          pristine_dir_root
+        else
+          File.join pristine_dir_root, subpath
+        end
+      end
+
+      # The directory in which this repository's pristine version is stored
+      def pristine_dir
+        File.join pristine_dir_parent, name
+      end
+
+      # builds/copies the test repository if needed
+      def prepare
+        #let's mark ourselves as dirty if any of our dependents are dirty
+        if dependents.values.detect(&:'dirty?')
+          mark_dirty
+        end
+        dependents.values.each {|child| child.prepare}
+
+        if dirty?
+          delete_clean_dir
+        end
+
+        #if the directory is there, we don't need to do anything
+        if !File.exists? clean_dir
+          Dir.chdir clean_dir_parent do
+            mark_dirty
+            if pristine_exists? && !pristine_dirty?
+              copy_pristine_here
+            else
+              build_here
+            end
+            unmark_dirty
+
+            copy_clean_to_pristine
+          end
+        end
+      end
+
+      def copy_clean_to_pristine
+        if pristine_exists? && pristine_dirty?
+          delete_pristine_dir
+        end
+
+        # if it exists, it's already done
+        if !File.exists? pristine_dir
+          pristine_mark_dirty
+          Dir.chdir pristine_dir_parent do
+            cp_a clean_dir, "."
+          end
+          pristine_unmark_dirty
+        end
+      end
+
+      def copy_pristine_here
+        cp_a pristine_dir, "."
+      end
+
+      def pristine_exists?
+        File.exists? pristine_dir
+      end
+
+      def delete_clean_dir
+        Dir.chdir clean_dir_parent do
+          rm_rf_ie name
+        end
+      end
+
+      def delete_pristine_dir
+        Dir.chdir pristine_dir_parent do
+          rm_rf_ie name
+        end
+      end
+
+      def dirty?
+        Dir.chdir clean_dir_parent do
+          File.exists? working_file_name
+        end
+      end
+
+      def mark_dirty
+        Dir.chdir clean_dir_parent do
+          File.open working_file_name, "w" do |file|
+            file.puts "dirty"
+          end
+        end
+      end
+
+      def unmark_dirty
+        Dir.chdir clean_dir_parent do
+          File.delete working_file_name
+        end
+      end
+
+      def pristine_dirty?
+        Dir.chdir pristine_dir_parent do
+          File.exists? working_file_name
+        end
+      end
+
+      def pristine_mark_dirty
+        Dir.chdir pristine_dir_parent do
+          File.open working_file_name, "w" do |file|
+            file.puts "dirty"
+          end
+        end
+      end
+
+      def pristine_unmark_dirty
+        Dir.chdir pristine_dir_parent do
+          File.delete working_file_name
+        end
+      end
+
+      def working_file_name
+        ".working_#{name}"
+      end
+    end
+  end
+end

data/lib/externals/test/svn_repository_from_dump.rb

@@ -0,0 +1,27 @@
+require 'externals/test/repository'
+require 'externals/test/svn_repository_helper'
+
+module Externals
+  module Test
+    class SvnRepositoryFromDump < Repository
+      include SvnRepositoryHelper
+
+      def initialize name, subpath = nil
+        super name, subpath || "svn"
+      end
+
+      #builds the test repository in the current directory
+      def build_here
+        cp_a File.join(root_dir, "test", "setup", "#{name}.svn.gz"), "."
+
+        puts `gzip -f -d #{name}.svn.gz`
+        raise unless $? == 0
+        puts `svnadmin create #{name}`
+        raise unless $? == 0
+        puts `svnadmin load #{name} < #{name}.svn`
+        raise unless $? == 0
+      end
+
+    end
+  end
+end

data/lib/externals/test/svn_repository_helper.rb

@@ -0,0 +1,10 @@
+module Externals
+  module Test
+    module SvnRepositoryHelper
+      def clean_url
+        url = File.join 'file://', clean_dir
+        url.gsub(/^\s*file:(\/[^\/])/, "file://\\1")
+      end
+    end
+  end
+end

data/lib/externals/test_case.rb

@@ -1,198 +1,35 @@
 require 'test/unit'
+require 'fileutils'
 
 module Externals
   TestCase = Test::Unit::TestCase
   module ExtTestCase
-    protected
-
-    def initialize_test_git_repository
-      scm = 'git'
-      Dir.chdir(File.join(File.dirname(__FILE__), '..', '..', 'test')) do
-        `mkdir repositories` unless File.exists? 'repositories'
-        Dir.chdir 'repositories' do
-          `mkdir #{scm}repo`
-          Dir.chdir("#{scm}repo") do
-            `git init`
-            open 'readme.txt', 'w' do |f|
-              f.write "readme.txt Line 1
-            Line 2
-            Line 3"
-            end
-
-            `git add .`
-            `git commit -m "added readme.txt"`
-
-            open 'readme.txt', 'a' do |f|
-              f.write "line 4"
-            end
-
-            `git add .`
-            `git commit -m "added a line to readme.txt"`
-          end
-        end
-      end
-    end
-
-    def initialize_test_svn_repository
-      scm = 'svn'
-      Dir.chdir(File.join(File.dirname(__FILE__), '..', '..', 'test')) do
-        `mkdir repositories` unless File.exists? 'repositories'
-        Dir.chdir 'repositories' do
-          puts `svnadmin create #{scm}repo`
-        end
-      end
-    end
-
-    def destroy_test_repository scm
-      puts(rmcmd = "rm -rf #{repository_dir(scm)}")
-      puts `#{rmcmd}`
-    end
-
-    def repository_dir scm = nil
-      if scm.nil?
-        File.join(File.dirname(__FILE__), '..', '..', 'test', 'repositories')
-      else
-        File.expand_path(File.join(repository_dir, "#{scm}repo"))
-      end
-    end
-
-    def create_test_modules_repository scm
-      Dir.chdir(File.join(File.dirname(__FILE__), '..', '..', 'test')) do
-        `mkdir repositories` unless File.exists? 'repositories'
-        Dir.chdir 'repositories' do
-          puts `svnadmin create #{scm}modulesrepo`
-        end
-
-        cmd = "svn checkout \"file:///#{File.expand_path(File.join('repositories', "#{scm}modulesrepo"))}\""
-        puts "about to run #{cmd}"
-        puts `#{cmd}`
-        Dir.chdir "#{scm}modulesrepo" do
-          if !File.exists? 'modules.txt'
-            open("modules.txt", "w") do |f|
-              f.write "line1 of modules.txt\n"
-            end
-
-            SvnProject.add_all
-            puts `svn commit -m "created modules.txt"`
-          end
-        end
-        `rm -rf #{scm}modulesrepo`
-      end
-    end
-
-    def with_svn_branches_modules_repository_dir
-      File.expand_path(File.join(repository_dir, with_svn_branches_modules_repository_name))
-    end
-    def with_svn_branches_modules_repository_url
-      url = "file:///#{with_svn_branches_modules_repository_dir}"
-      if windows?
-        url.gsub!(/\\/, "/")
-      end
-      url.gsub("file:////", 'file:///')
-    end
-    def with_svn_branches_repository_url
-      url = "file:///#{with_svn_branches_repository_dir}"
-      if windows?
-        url.gsub!(/\\/, "/")
-      end
-      url.gsub("file:////", 'file:///')
-    end
-
-    def with_svn_branches_modules_repository_name
-      'svnmodulesbranchesrepo'
-    end
-    def with_svn_branches_repository_dir
-      File.expand_path(File.join(repository_dir, with_svn_branches_repository_name))
-    end
-    def with_svn_branches_repository_name
-      'svnbranchesrepo'
-    end
-
-    def destroy_with_svn_branches_modules_repository
-      Dir.chdir repository_dir do
-        `rm -rf #{with_svn_branches_modules_repository_name}`
-      end
-    end
-
-    def destroy_with_svn_branches_repository
-      Dir.chdir repository_dir do
-        `rm -rf #{with_svn_branches_repository_name}`
-      end
-    end
-
-    def create_with_svn_branches_modules_repository
-      Dir.chdir(File.join(root_dir, 'test')) do
-        `mkdir repositories` unless File.exists? 'repositories'
-        Dir.chdir repository_dir do
-          puts `svnadmin create #{with_svn_branches_modules_repository_name}`
-        end
-
-        `mkdir workdir` unless File.exists? 'workdir'
-        Dir.chdir 'workdir' do
-          cmd = "svn checkout \"#{with_svn_branches_modules_repository_url}\""
-          puts "about to run #{cmd}"
-          puts `#{cmd}`
-          raise unless $? == 0
-
-          Dir.chdir with_svn_branches_modules_repository_name do
-            `mkdir branches`
-            `mkdir current`
+    include FileUtils
 
-            SvnProject.add_all
-            puts `svn commit -m "created branch directory structure"`
-            raise unless $? == 0
+    protected
 
-          end
-          `rm -rf #{with_svn_branches_modules_repository_name}`
-        end
+    def mark_dirty file
+      File.open working_file_name(file), "w" do |file|
+        file.puts "dirty"
       end
     end
-    def create_with_svn_branches_repository
-      Dir.chdir(File.join(root_dir, 'test')) do
-        `mkdir repositories` unless File.exists? 'repositories'
-        Dir.chdir repository_dir do
-          puts `svnadmin create #{with_svn_branches_repository_name}`
-        end
-
-        `mkdir workdir` unless File.exists? 'workdir'
-        Dir.chdir 'workdir' do
-          cmd = "svn checkout \"#{with_svn_branches_repository_url}\""
-          puts "about to run #{cmd}"
-          puts `#{cmd}`
-          raise unless $? == 0
-
-          Dir.chdir with_svn_branches_repository_name do
-            `mkdir branches`
-            `mkdir current`
-
-            SvnProject.add_all
-            puts `svn commit -m "created branch directory structure"`
-            raise unless $? == 0
 
-          end
-          `rm -rf #{with_svn_branches_modules_repository_name}`
-        end
-      end
+    def unmark_dirty file
+      File.delete working_file_name(file)
     end
 
-    def destroy_test_modules_repository scm
-      puts(rmcmd = "rm -rf #{modules_repository_dir(scm)}")
-      puts `#{rmcmd}`
+    def working_file_name file
+      ".working_#{file}"
     end
 
-    def modules_repository_dir scm = nil
-      File.expand_path(File.join(repository_dir, "#{scm}modulesrepo"))
+    def dirty?(file)
+      File.exists? working_file_name(file)
     end
 
-    def create_rails_application
-      Dir.mkdir applications_dir unless File.exists?(applications_dir)
-      Dir.chdir applications_dir do
-        if rails_version =~ /^3([^\d]|$)/
-          puts `#{rails_exe} new rails_app`
-        elsif rails_version =~ /^2([^\d]|$)/
-          puts `#{rails_exe} rails_app`
-        else
-          raise "can't determine rails version"
+    def delete_if_dirty file
+      if File.exists? file
+        if dirty?(file)
+          rm_r file
         end
       end
     end
@@ -210,136 +47,8 @@ module Externals
       ENV['OS'] =~ /^Win/i
     end
 
-    def destroy_rails_application
-      Dir.chdir applications_dir do
-        `rm -rf rails_app`
-      end
-    end
-
     def root_dir
       File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
     end
-
-    def applications_dir
-      File.join(root_dir, 'test', 'applications')
-    end
-
-    def rails_application_dir
-      File.join(applications_dir, 'rails_app')
-    end
-
-    def initialize_with_svn_branches_repository
-      Dir.chdir File.join(root_dir, 'test') do
-        repo_url = with_svn_branches_repository_url
-        
-        Dir.chdir 'workdir' do
-          puts `svn co #{[repo_url, "current"].join("/")} rails_app`
-          raise unless $? == 0
-          Dir.chdir "rails_app" do
-            puts `cp -r #{rails_application_dir}/* .`
-            raise unless $? == 0
-
-            Ext.run "init", "-b", "current"
-
-            # this line is necessary as ext can't perform the necessary
-            # ignores otherwise if vendor and vendor/plugins haven't been added
-            SvnProject.add_all
-
-            raise " could not create .externals"  unless File.exists? '.externals'
-            %w(rails acts_as_list).each do |proj|
-              Ext.run "install", File.join(root_dir, 'test', 'cleanreps', "#{proj}.git")
-            end
-
-            #install a couple svn managed subprojects
-            %w(foreign_key_migrations redhillonrails_core).each do |proj|
-              Ext.run "install", "--svn", "file:///#{File.join(root_dir, 'test', 'cleanreps', proj)}"
-            end
-
-            #install project with a git branch
-            Ext.run "install", File.join(root_dir, 'test', 'cleanreps', 'engines.git'), "-b", "edge"
-
-            #install project with a non-default path and svn branching
-            Ext.run "install", "--svn",
-              "#{with_svn_branches_modules_repository_url}",
-              "-b", "current",
-              "modules"
-
-            SvnProject.add_all
-
-            puts `svn commit -m "created empty rails app with some subprojects"`
-            raise unless $? == 0
-
-            # now let's make a branch in the main project called new_branch
-            `svn copy #{
-            [repo_url, "current"].join("/")
-} #{[repo_url, "branches", "new_branch"].join("/")} -m "creating branch" `
-            raise unless $? == 0
-
-            # let's make a branch in a git subproject:
-            Dir.chdir File.join(%w(vendor plugins engines)) do
-              `git push origin master:branch1`
-              raise unless $? == 0
-            end
-
-            # let's update the .externals file in new_branch to reflect these changes
-            `svn switch #{[repo_url, "branches", "new_branch"].join("/")}`
-            raise unless $? == 0
-
-            # let's remove rails from this branch
-            Ext.run "uninstall", "-f", "rails"
-
-            ext = Ext.new
-            ext.configuration["vendor/plugins/engines"]["branch"] = "branch1"
-            ext.configuration["modules"]["branch"] = "branches/branch2"
-            ext.configuration.write
-
-            SvnProject.add_all
-            `svn commit -m "updated .externals to point to new branches."`
-            raise unless $? == 0
-          end
-
-          `rm -rf rails_app`
-        end
-      end
-    end
-
-    def initialize_with_svn_branches_modules_repository
-      Dir.chdir File.join(root_dir, 'test') do
-        repo_url = with_svn_branches_modules_repository_url
-
-        Dir.chdir 'workdir' do
-          puts `svn co #{[repo_url, "current"].join("/")} modules`
-          raise unless $? == 0
-          Dir.chdir "modules" do
-            if !File.exists? 'modules.txt'
-              open("modules.txt", "w") do |f|
-                f.write "line1 of modules.txt\n"
-              end
-
-              SvnProject.add_all
-              puts `svn commit -m "created modules.txt"`
-              raise unless $? == 0
-            end
-
-            `svn copy #{
-            [repo_url, "current"].join("/")
-} #{[repo_url, "branches", "branch2"].join("/")
-} -m "created branch2"`
-            raise unless $? == 0
-
-            puts `svn switch #{
-            [repo_url, "branches", "branch2"].join("/")
-}`
-            raise unless $? == 0
-            `echo 'line 2 of modules.txt ... this is branch2!' > modules.txt`
-            SvnProject.add_all
-            puts `svn commit -m "changed modules.txt"`
-            raise unless $? == 0
-          end
-        end
-      end
-    end
-
-
   end
 end