ext 0.0.5

data/MIT_LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Miles Georgi, Azimux.com, nopugs.com Consulting
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,108 @@
+Externals is a project that allows you to use the workflow normally made
+possible by svn:externals in an SCM independent manner.
+
+I was inspired to create this project because I had several projects that had
+a mix of plugins managed by git and by svn.  Git's submodule feature is 
+not exactly like svn:externals.  Basically, I don't like how you have to manually 
+checkout a branch, and I don't like git status not propagating through the 
+submodules.  Also, the branch tip doesn't automatically move with git-submodule.
+Subversion always checks out the branch tip for subprojects when performing a 
+checkout or update.
+
+Externals is designed such that adding support for a new SCM, or new project 
+types is easy.
+
+The externals executable is called ext.  Commands come in a long form and a 
+short form.  The longer form applies the action to the main project.  The short 
+forms apply the action to all sub projects.
+
+The commands and usage are as follows (from 'ext help'):
+
+ext [OPTIONS] <command> [repository[:branch]] [path]
+    -g, --git                        same as '--scm git'  Uses git to checkout/export the main project
+    -s, --svn, --subversion          same as '--scm svn'  Uses subversion to checkout/export the main project
+    -t, --type TYPE                  The type of project the main project is.  For example, 'rails'.
+        --scm SCM                    The SCM used to manage the main project.  For example, '--scm svn'.
+    -w, --workdir DIR                The working directory to execute commands from.  Use this if for some reason you
+        cannot execute ext from the main project's directory (or if it's just inconvenient, such as in a script
+        or in a Capistrano task)
+        --help                       does the same as 'ext help'  If you use this with a command
+        it will ignore the command and run help instead.
+
+
+
+Commands that apply to the main project or the .externals file:
+update_ignore, install, init, touch_emptydirs, help
+
+update_ignore   Adds all paths to subprojects that are
+                registered in .externals to the ignore feature of the
+                main project.  This is automatically performed by install,
+                and so you probably only will run this if you are manually
+                maintaining .externals
+
+install         Usage: ext install <repository[:branch]> [path]
+                Registers <repository> in .externals under the appropriate
+                SCM.  Checks out the project, and also adds it to the ignore
+                feature offered by the SCM of the main project.  If the SCM type
+                is not obvious from the repository URL, use the --scm, --git, 
+                or --svn flags.
+
+init            Creates a .externals file containing only [main]
+                It will try to determine the SCM used by the main project,
+                as well as the project type.  You don't have to specify
+                a project type if you don't want to or if your project type
+                isn't supported.  It just means that when using 'install'
+                that you'll want to specify the path.
+
+touch_emptydirs Recurses through all directories from the
+                top and adds a .emptydir file to any empty directories it
+                comes across.  Useful for dealing with SCMs that refuse to
+                track empty directories (such as git, for example)
+
+help            You probably just ran this command just now.
+
+
+
+Commands that apply to the main project and all subprojects:
+checkout, export, status, update
+
+checkout        Usage: ext checkout <repository>
+                
+                Checks out <repository>, and checks out any subprojects
+                registered in <repository>'s .externals file.
+
+export          Usage: ext export <repository>
+                
+                Like checkout except this command fetches as little
+                history as possible.
+
+status          Usage: ext status
+                
+                Prints out the status of the main project, followed by
+                the status of each subproject.
+
+update          Usage: ext update
+                
+                Brings the main project, and all subprojects, up to the
+                latest version.
+
+
+
+Commands that only apply to the subprojects:
+co, ex, st, up
+
+co              Like checkout, but skips the main project and
+                only checks out subprojects.
+
+ex              Like export, but skips the main project.
+
+st              Like status, but skips the main project.
+
+up              Like update, but skips the main project.
+
+
+The externals project is copyright 2008 by Miles Georgi, nopugs.com, azimux.com
+and is released under the MIT license.  
+
+The license is available in the same directory as this README
+file and is named MIT_LICENSE.txt

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+Rake::TestTask.new('test') do |task|
+  task.libs = [File.expand_path('lib'),File.expand_path('test')]
+  task.pattern = './test/test_*.rb'
+  task.warning = true
+end
+
+gem_specification = Gem::Specification.new do |specification|
+  specification.name = 'ext'
+  specification.version = '0.0.5'
+  specification.platform = Gem::Platform::RUBY
+  specification.rubyforge_project = 'ext'
+  
+  specification.summary = 
+    %{Provides an SCM agnostic way to manage subprojects with a workflow similar 
+to the svn:externals feature of subversion.  It's particularly useful for rails 
+projects that have some plugins managed by svn and some managed by git.}
+  specification.description = 
+    %{Provides an SCM agnostic way to manage subprojects with a workflow similar 
+to the scm:externals feature of subversion.  It's particularly useful for rails 
+projects that have some plugins managed by svn and some managed by git.  
+
+For example, "ext install git://github.com/rails/rails.git" from within a rails 
+application directory will realize that this belongs in the vendor/rails folder.  
+It will also realize that this URL is a git repository and clone it into that 
+folder.  
+
+It will also add the vendor/rails folder to the ignore feature for the SCM of 
+the main project.  Let's say that the main project is being managed by 
+subversion.  In that case it adds "rails" to the svn:ignore property of the 
+vendor folder.  It also adds the URL to the .externals file so that when this 
+project is checked out via "ext checkout" it knows where to fetch the 
+subprojects.  
+
+There are several other useful commands, such as init, touch_emptydirs, add_all, 
+export, status.  I plan to put up a tutorial at http://nopugs.com/ext-tutorial
+
+The reason I made this project is that I was frustrated by two things:
+
+1.  In my opinion, the workflow for svn:externals is far superior to 
+git-submodule.  
+
+2.  Even if git-submodule was as useful as svn:externals, I would still like a 
+uniform way to fetch all of the subprojects regardless of the SCM used to manage 
+the main project.}
+  
+  specification.author = "Miles Georgi"
+  specification.email = "azimux@gmail.com"
+  specification.homepage = "http://nopugs.com/ext-tutorial"
+  
+  specification.test_files = FileList['test/test_*.rb']
+  specification.executables = ['ext', 'ext.bat']
+  specification.files = ['Rakefile', 'README', 'MIT_LICENSE.txt'] + 
+    FileList['lib/**/*.rb']
+  #specification.require_path = 'lib'
+end
+
+Rake::GemPackageTask.new(gem_specification) do |package|
+  package.need_zip = package.need_tar = false
+end

data/bin/ext

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'externals/ext'
+
+Externals::Ext.run(*ARGV)

data/bin/ext.bat

@@ -0,0 +1,6 @@
+@ECHO OFF
+IF NOT "%~f0" == "~f0" GOTO :WinNT
+@"ruby.exe" "ext" %1 %2 %3 %4 %5 %6 %7 %8 %9
+GOTO :EOF
+:WinNT
+@"ruby.exe" "%~dpn0" %*

data/lib/ext/string.rb

@@ -0,0 +1,9 @@
+String.class_eval do
+  def cap_first
+    "#{self[0].chr.upcase}#{self[1..(self.length - 1)]}"
+  end
+  
+  def classify
+    split('_').map(&:cap_first).join
+  end
+end

data/lib/ext/symbol.rb

@@ -0,0 +1,7 @@
+unless Symbol.respond_to? :to_proc
+  class Symbol
+    def to_proc
+      proc { |*args| args[0].send(self, *args[1...args.size]) }
+    end
+  end
+end

data/lib/externals/command.rb

@@ -0,0 +1,35 @@
+module Externals
+  class Command
+    attr_reader :name, :usage, :summary
+    def initialize name, usage, summary = nil
+      @name = name
+      @usage = usage
+      @summary = summary
+      
+      if !@summary
+        @summary, @usage = @usage, @summary
+      end
+    end
+    
+    def to_s
+      retval = StringIO.new
+      retval.printf "%-16s", name
+      if usage
+        retval.printf "Usage: #{usage}\n"
+      else
+        dont_pad_first = true
+      end
+      
+      summary.split(/\n/).each_with_index do |line, index|
+        if index == 0 && dont_pad_first
+          retval.printf "%s\n", line.strip
+        else
+          retval.printf "%16s%s\n", '', line.strip
+        end
+      end
+      
+      retval.printf "\n"
+      retval.string
+    end
+  end
+end

data/lib/externals/configuration/configuration.rb

@@ -0,0 +1,159 @@
+module Externals
+  module Configuration
+    SECTION_TITLE_REGEX = /^\s*\[(\w+)\]\s*$/
+    SECTION_TITLE_REGEX_NO_GROUPS = /^\s*\[(?:\w+)\]\s*$/
+
+
+    class Section
+      attr_accessor :title_string, :body_string, :title, :rows, :scm
+
+      def main?
+        title == 'main'
+      end
+
+      def initialize title_string, body_string, scm = nil
+        self.title_string = title_string
+        self.body_string = body_string
+        self.scm = scm
+
+        self.title = SECTION_TITLE_REGEX.match(title_string)[1]
+        
+        self.scm ||= self.title
+
+        raise "Invalid section title: #{title_string}" unless title
+
+        self.rows = body_string.split(/\n/)
+      end
+
+      def setting key
+        if !main?
+          raise "this isn't a section of the configuration that can contain settings"
+        end
+
+        rows.each do |row|
+          if row =~ /\s*(\w+)\s*=\s*([^#]*)(?:#.*)?$/ && key.to_s == $1
+            return $2
+          end
+        end
+        nil
+      end
+
+      def [] key
+        setting(key)
+      end
+
+
+      def projects
+        return @projects if @projects
+
+        @projects = []
+
+        if main?
+          @projects = [Ext.project_class(self['scm']).new(".", :is_main)]
+        else
+          rows.each do |row|
+            if Project.project_line?(row)
+              @projects << Ext.project_class(title).new(row)
+            end
+          end
+          @projects
+        end
+      end
+
+      def add_row(row)
+        rows << row
+
+        self.body_string = body_string.chomp + "\n#{row}\n"
+        clear_caches
+      end
+
+      def clear_caches
+        @projects = nil
+      end
+
+      def to_s
+        "#{title_string}#{body_string}"
+      end
+    end
+
+    class Configuration
+      attr_accessor :file_string
+
+      def sections
+        @sections ||= []
+      end
+
+      def [] title
+        title = title.to_s
+        sections.detect {|section| section.title == title}
+      end
+      
+      def add_empty_section  title
+        raise "Section already exists" if self[title]
+        sections << Section.new("\n\n[#{title.to_s}]\n", "")
+      end
+      
+      def self.new_empty
+        new nil, true
+      end
+
+      def initialize externals_file = nil, empty = false
+        if empty
+          self.file_string = ''
+          return
+        end
+        
+        if !externals_file && File.exists?('.externals')
+          open('.externals', 'r') do |f|
+            externals_file = f.read
+          end
+        end
+
+        externals_file ||= ""
+
+        self.file_string = externals_file
+
+        titles = externals_file.grep SECTION_TITLE_REGEX
+        bodies = externals_file.split SECTION_TITLE_REGEX_NO_GROUPS
+
+        if titles.size > 0 && bodies.size > 0
+          if titles.size + 1 != bodies.size
+            raise "bodies and sections do not match up"
+          end
+
+          bodies = bodies[1..(bodies.size - 1)]
+
+          (0...(bodies.size)).each do |index|
+            sections << Section.new(titles[index], bodies[index])
+          end
+        end
+      end
+
+      def projects
+        retval = []
+        sections.each do |section|
+          retval += section.projects
+        end
+
+        retval
+      end
+
+      def subprojects
+        retval = []
+        sections.each do |section|
+          retval += section.projects unless section.main?
+        end
+
+        retval
+      end
+
+      def write path = ".externals"
+        open(path, 'w') do |f|
+          sections.each do |section|
+            f.write section.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/externals/ext.rb

@@ -0,0 +1,557 @@
+require 'externals/project'
+require 'externals/configuration/configuration'
+require 'optparse'
+require 'externals/command'
+require 'ext/symbol'
+
+module Externals
+  PROJECT_TYPES_DIRECTORY = File.join(File.dirname(__FILE__), '..', 'externals','project_types')
+
+  # Full commands operate on the main project as well as the externals
+  # short commands only operate on the externals
+  # Main commands only operate on the main project
+  FULL_COMMANDS_HASH = [
+    [:checkout, "ext checkout <repository>", %{
+      Checks out <repository>, and checks out any subprojects
+      registered in <repository>'s .externals file.}],
+    [:export, "ext export <repository>", %{
+      Like checkout except this command fetches as little
+      history as possible.}],
+    [:status, "ext status", %{
+      Prints out the status of the main project, followed by
+      the status of each subproject.}],
+    [:update, "ext update", %{
+      Brings the main project, and all subprojects, up to the
+      latest version.}]
+  ]
+  SHORT_COMMANDS_HASH = [
+    [:co, "Like checkout, but skips the main project and
+          only checks out subprojects."],
+    [:ex, "Like export, but skips the main project."],
+    [:st, "Like status, but skips the main project."],
+    [:up, "Like update, but skips the main project."]
+  ]
+  MAIN_COMMANDS_HASH = [
+    [:update_ignore, "Adds all paths to subprojects that are
+      registered in .externals to the ignore feature of the
+      main project.  This is automatically performed by install,
+      and so you probably only will run this if you are manually
+      maintaining .externals"],
+    [:install, "ext install <repository[:branch]> [path]",
+      "Registers <repository> in .externals under the appropriate
+      SCM.  Checks out the project, and also adds it to the ignore
+      feature offered by the SCM of the main project.  If the SCM 
+      type is not obvious from the repository URL, use the --scm, 
+      --git, or --svn flags."],
+    [:init, "Creates a .externals file containing only [main]
+      It will try to determine the SCM used by the main project,
+      as well as the project type.  You don't have to specify
+      a project type if you don't want to or if your project type
+      isn't supported.  It just means that when using 'install'
+      that you'll want to specify the path."],
+    [:touch_emptydirs, "Recurses through all directories from the
+      top and adds a .emptydir file to any empty directories it
+      comes across.  Useful for dealing with SCMs that refuse to
+      track empty directories (such as git, for example)"],
+    [:help, "You probably just ran this command just now."]
+  ]
+
+
+  FULL_COMMANDS = FULL_COMMANDS_HASH.map(&:first)
+  SHORT_COMMANDS =  SHORT_COMMANDS_HASH.map(&:first)
+  MAIN_COMMANDS = MAIN_COMMANDS_HASH.map(&:first)
+
+  COMMANDS = FULL_COMMANDS + SHORT_COMMANDS + MAIN_COMMANDS
+
+
+  class Ext
+    Dir.entries(File.join(File.dirname(__FILE__), '..', 'ext')).each do |extension|
+      require "ext/#{extension}" if extension =~ /.rb$/
+    end
+
+    Dir.entries(File.join(File.dirname(__FILE__), '..', 'externals','scms')).each do |project|
+      require "externals/scms/#{project}" if project =~ /_project.rb$/
+    end
+
+
+    def self.project_types
+      types = Dir.entries(PROJECT_TYPES_DIRECTORY).select do |file|
+        file =~ /\.rb$/
+      end
+
+      types.map do |type|
+        /^(.*)\.rb$/.match(type)[1]
+      end
+    end
+
+    #puts "Project types available: #{project_types.join(' ')}"
+
+    def self.project_type_files
+      project_types.map do |project_type|
+        "#{File.join(PROJECT_TYPES_DIRECTORY, project_type)}.rb"
+      end
+    end
+
+    project_type_files.each do |file|
+      require file
+    end
+
+    def self.new_opts main_options, sub_options
+      opts = OptionParser.new
+
+      opts.banner = "ext [OPTIONS] <command> [repository[:branch]] [path]"
+
+      project_classes.each do |project_class|
+        project_class.fill_in_opts(opts, main_options, sub_options)
+      end
+
+      opts.on("--type TYPE", "-t TYPE", "The type of project the main project is.  For example, 'rails'.",
+        Integer) {|type| sub_options[:scm] = main_options[:type] = type}
+      opts.on("--scm SCM", "-s SCM", "The SCM used to manage the main project.  For example, '--scm svn'.",
+        Integer) {|scm| sub_options[:scm] = main_options[:scm] = scm}
+      opts.on("--workdir DIR", "-w DIR", "The working directory to execute commands from.  Use this if for some reason you
+        cannot execute ext from the main project's directory (or if it's just inconvenient, such as in a script
+        or in a Capistrano task)",
+        String) {|dir|
+        raise "No such directory: #{dir}" unless File.exists?(dir) && File.directory?(dir)
+        main_options[:workdir] = dir
+      }
+      opts.on("--help", "does the same as 'ext help'  If you use this with a command
+        it will ignore the command and run help instead.") {main_options[:help] = true}
+    end
+
+    def self.run *arguments
+
+      main_options = {}
+      sub_options = {}
+
+      opts = new_opts main_options, sub_options
+
+      args = opts.parse(arguments)
+
+      unless args.nil? || args.empty?
+        command = args[0]
+        args = args[1..(args.size - 1)] || []
+      end
+
+      command &&= command.to_sym
+
+      command = :help if main_options[:help]
+
+      if !command || command.to_s == ''
+        puts "hey... you didn't tell me what you want to do."
+        puts "Try 'ext help' for a list of commands"
+        exit
+      end
+
+      unless COMMANDS.index command
+        puts "unknown command: #{command}"
+        puts "for a list of commands try 'ext help'"
+        exit
+      end
+
+      Dir.chdir(main_options[:workdir] || ".") do
+        new(main_options).send(command, args, sub_options)
+      end
+    end
+
+    def print_commands(commands)
+      commands.each do |command|
+        puts Command.new(*command)
+      end
+      puts
+    end
+
+    def help(args, options)
+      puts "#{self.class.new_opts({},{}).to_s}\n\n"
+
+      puts "\nCommands that apply to the main project or the .externals file:"
+      puts "#{MAIN_COMMANDS.join(', ')}\n\n"
+      print_commands(MAIN_COMMANDS_HASH)
+
+      puts "\nCommands that apply to the main project and all subprojects:"
+      puts "#{FULL_COMMANDS.join(', ')}\n\n"
+      print_commands(FULL_COMMANDS_HASH)
+
+      puts "\nCommands that only apply to the subprojects:"
+      puts "#{SHORT_COMMANDS.join(', ')}\n\n"
+      print_commands(SHORT_COMMANDS_HASH)
+    end
+
+    def self.registered_scms
+      return @registered_scms if @registered_scms
+      @registered_scms ||= []
+
+      scmdir = File.join(File.dirname(__FILE__), 'scms')
+
+      Dir.entries(scmdir).each do |file|
+        if file =~ /^(.*)_project\.rb$/
+          @registered_scms << $1
+        end
+      end
+
+      @registered_scms
+    end
+
+    def projects
+      configuration.projects
+    end
+
+    def subprojects
+      configuration.subprojects
+    end
+
+    def configuration
+      return @configuration if @configuration
+
+      @configuration = Configuration::Configuration.new
+    end
+
+    def reload_configuration
+      @configuration = nil
+      configuration
+    end
+
+    def initialize options
+      super()
+
+      scm = configuration['main']
+      scm = scm['scm'] if scm
+      scm ||= options[:scm]
+      #scm ||= infer_scm(repository)
+
+      type = configuration['main']
+      type = type['type'] if type
+
+      type ||= options[:type]
+
+      if type
+        install_project_type type
+      else
+        possible_project_types = self.class.project_types.select do |project_type|
+          self.class.project_type_detector(project_type).detected?
+        end
+
+        if possible_project_types.size > 1
+          raise "We found multiple project types that this could be: #{possible_project_types.join(',')}
+Please use
+ the --type option to tell ext which to use."
+        else
+          possible_project_types.each do |project_type|
+            install_project_type project_type
+          end
+        end
+      end
+    end
+
+    def self.project_class(scm)
+      Externals.module_eval("#{scm.to_s.cap_first}Project", __FILE__, __LINE__)
+    end
+
+    def self.project_classes
+      retval = []
+      registered_scms.each do |scm|
+        retval << project_class(scm)
+      end
+
+      retval
+    end
+
+    SHORT_COMMANDS.each do |command_name|
+      define_method command_name do |args, options|
+        project_name_or_path = nil
+
+        if args && !args.empty?
+          project_name_or_path = args.first
+        end
+
+        if project_name_or_path
+          project = subprojects.detect do |project|
+            project.name == project_name_or_path || project.path == project_name_or_path
+          end
+
+          raise "no such project" unless project
+
+          project.send command_name, args, options
+        else
+          subprojects.each {|p| p.send(*([command_name, args, options].flatten))}
+        end
+      end
+    end
+
+    def install args, options
+      init args, options unless File.exists? '.externals'
+      row = args.join " "
+
+      orig_options = options.dup
+
+      scm = options[:scm]
+
+      scm ||= infer_scm(row)
+
+      if !configuration[scm]
+        configuration.add_empty_section(scm)
+      end
+      configuration[scm].add_row(row)
+      configuration.write
+      reload_configuration
+
+      project = self.class.project_class(scm).new(row)
+
+      project.co
+
+      update_ignore args, orig_options
+    end
+
+    def update_ignore args, options
+      #path = args[0]
+
+
+      scm = configuration['main']
+      scm = scm['scm'] if scm
+
+      scm ||= options[:scm]
+
+      unless scm
+        raise "You need to either specify the scm as the first line in .externals (for example, scm = git), or use an option to specify it
+          (such as --git or --svn)"
+      end
+
+      project = self.class.project_class(scm).new(".")
+
+      raise "only makes sense for main project" unless project.main?
+
+      subprojects.each do |subproject|
+        puts "about to add #{subproject.path} to ignore"
+        project.update_ignore subproject.path
+        puts "finished adding #{subproject.path}"
+      end
+    end
+
+    def touch_emptydirs args, options
+      require 'find'
+
+      excludes = ['.','..','.svn', '.git']
+
+      excludes.dup.each do |exclude|
+        excludes << "./#{exclude}"
+      end
+
+      paths = []
+
+      Find.find('.') do |f|
+        if File.directory?(f)
+          excluded = false
+          File.split(f).each do |part|
+            exclude ||= excludes.index(part)
+          end
+
+          if !excluded && ((Dir.entries(f) - excludes).size == 0)
+            paths << f
+          end
+        end
+      end
+
+      paths.each do |p|
+        open(File.join(p,".emptydir"), "w").close
+      end
+
+    end
+
+
+    def status args, options
+      options ||= {}
+      repository = "."
+      path = "."
+      main_project = nil
+      scm = options[:scm]
+      scm ||= infer_scm(repository)
+
+      if !scm
+        scm ||= configuration['main']
+        scm &&= scm['scm']
+      end
+
+      if !scm
+        possible_project_classes = self.class.project_classes.select do |project_class|
+          project_class.detected?
+        end
+
+        raise "Could not determine this projects scm" if  possible_project_classes.empty?
+        if possible_project_classes.size > 1
+          raise "This project appears to be managed by multiple SCMs: #{
+          possible_project_classes.map(&:to_s).join(',')}
+Please explicitly declare the SCM (by using --git or --svn, or,
+by creating the .externals file manually"
+        end
+
+        scm = possible_project_classes.first.scm
+      end
+
+      unless scm
+        raise "You need to either specify the scm as the first line in .externals, or use an option to specify it
+          (such as --git or --svn)"
+      end
+
+      main_project = self.class.project_class(scm).new("#{repository} #{path}", :is_main)
+      main_project.st
+
+      self.class.new({}).st [], {} #args, options
+    end
+
+    def update args, options
+      options ||= {}
+      repository = args[0]
+      main_project = nil
+      scm = options[:scm]
+      scm ||= infer_scm(repository)
+
+      if !scm
+        scm ||= configuration['main']
+        scm &&= scm['scm']
+      end
+
+      unless scm
+        raise "You need to either specify the scm as the first line in .externals, or use an option to specify it
+          (such as --git or --svn)"
+      end
+
+      main_project = self.class.project_class(scm).new("#{repository} #{path}", :is_main)
+      main_project.up
+
+      self.class.new({}).up [], {} #args, options
+    end
+
+    def checkout args, options
+      options ||= {}
+
+      repository = args[0]
+      path = args[1] || "."
+
+      main_project = do_checkout_or_export repository, path, options, :checkout
+
+      if path == "."
+        path = main_project.name
+      end
+
+      Dir.chdir path do
+        self.class.new({}).co [], {} #args, options
+      end
+    end
+
+    def export args, options
+      options ||= {}
+
+      repository = args[0]
+      path = args[1] || "."
+
+      main_project = do_checkout_or_export repository, path, options, :checkout
+
+      if path == "."
+        path = main_project.name
+      end
+
+      Dir.chdir path do
+        self.class.new({}).ex [], {} #args, options
+      end
+    end
+
+    def init args, options = {}
+      raise ".externals already exists" if File.exists? '.externals'
+
+      scm = options[:scm]
+      type = options[:type]
+
+      if !scm
+        possible_project_classes = self.class.project_classes.select do |project_class|
+          project_class.detected?
+        end
+
+        raise "Could not determine this projects scm" if  possible_project_classes.empty?
+        if possible_project_classes.size > 1
+          raise "This project appears to be managed by multiple SCMs: #{
+          possible_project_classes.map(&:to_s).join(',')}
+Please explicitly declare the SCM (using --git or --svn, or, by creating .externals manually"
+        end
+
+        scm = possible_project_classes.first.scm
+      end
+
+      if !type
+        possible_project_types = self.class.project_types.select do |project_type|
+          self.class.project_type_detector(project_type).detected?
+        end
+
+        if possible_project_types.size > 1
+          raise "We found multiple project types that this could be: #{possible_project_types.join(',')}
+Please use the --type option to tell ext which to use."
+        elsif possible_project_types.size == 0
+          puts "WARNING: We could not automatically determine the project type.
+          Be sure to specify paths when adding subprojects to your .externals file"
+        else
+          type = possible_project_types.first
+        end
+      end
+
+      config = Configuration::Configuration.new_empty
+
+      config.sections << Configuration::Section.new("[main]\n",
+        "scm = #{scm}\n" +
+          "#{'type = ' + type if type}\n")
+
+      config.write
+      reload_configuration
+    end
+
+    def self.project_type_detector name
+      Externals.module_eval("#{name.classify}Detector", __FILE__, __LINE__)
+    end
+
+    def install_project_type name
+      Externals.module_eval("#{name.classify}ProjectType", __FILE__, __LINE__).install
+    end
+    #
+    #
+    #    def self.determine_project_type path = "."
+    #      Dir.chdir path do
+    #        raise "not done"
+    #      end
+    #    end
+
+    protected
+    def do_checkout_or_export repository, path, options, sym
+      if File.exists?('.externals')
+        raise "seems main project is already checked out here?"
+      else
+        #We appear to be attempting to checkout/export a main project
+        scm = options[:scm]
+
+        scm ||= infer_scm(repository)
+
+        if !scm
+          scm ||= configuration['main']
+          scm &&= scm['scm']
+        end
+
+        unless scm
+          raise "You need to either specify the scm as the first line in .externals, or use an option to specify it
+          (such as --git or --svn)"
+        end
+
+        main_project = self.class.project_class(scm).new("#{repository} #{path}", :is_main)
+
+        main_project.send(sym)
+        main_project
+      end
+    end
+
+    def infer_scm(path)
+      self.class.registered_scms.each do |scm|
+        return scm if self.class.project_class(scm).scm_path?(path)
+      end
+      nil
+    end
+  end
+end
+
+