pivotal-piston 1.9.4

data/.gitignore

@@ -0,0 +1,8 @@
+*.swp
+*.log
+pkg
+*.iml
+*.ipr
+*.iws
+.config
+InstalledFiles

data/History.txt

@@ -0,0 +1,11 @@
+
+* Thanks to Brian Takita (btakita), piston update with a Git repository works!
+* Thanks to mattknox and scambra for manifest updates.
+* Thanks to Marcos Tapajós (tapajos) for many small improvements.
+
+== 1.9.3 2008-06-03
+
+* Import git branches using --revision origin/BRANCH_NAME, or a tag
+  using --revision TAG_NAME, or even a specific commit using
+  --revision COMMIT_ID.  In fact, use a committish and you'll be fine,
+  even HEAD^3.

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2008 François Beausoleil <francois@teksol.info>
+
+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/Manifest.txt

@@ -0,0 +1,85 @@
+.gitignore
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/piston
+config/hoe.rb
+config/requirements.rb
+lib/piston.rb
+lib/piston/cli.rb
+lib/piston/commands.rb
+lib/piston/commands/base.rb
+lib/piston/commands/import.rb
+lib/piston/commands/lock_unlock.rb
+lib/piston/commands/update.rb
+lib/piston/commands/info.rb
+lib/piston/git.rb
+lib/piston/git/client.rb
+lib/piston/git/commit.rb
+lib/piston/git/repository.rb
+lib/piston/git/working_copy.rb
+lib/piston/repository.rb
+lib/piston/revision.rb
+lib/piston/svn.rb
+lib/piston/svn/client.rb
+lib/piston/svn/repository.rb
+lib/piston/svn/revision.rb
+lib/piston/svn/working_copy.rb
+lib/piston/version.rb
+lib/piston/working_copy.rb
+lib/subclass_responsibility_error.rb
+log/.gitignore
+samples/common.rb
+samples/import_git_git.rb
+samples/import_git_svn.rb
+samples/import_svn_git.rb
+samples/import_svn_svn.rb
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/samples.rake
+tasks/test.rake
+tasks/website.rake
+test/integration/test_git_git.rb
+test/integration/test_git_svn.rb
+test/integration/test_import_svn_git.rb
+test/integration/test_import_svn_svn.rb
+test/integration_helpers.rb
+test/test_helper.rb
+test/unit/git/commit/test_checkout.rb
+test/unit/git/commit/test_each.rb
+test/unit/git/commit/test_rememberance.rb
+test/unit/git/repository/test_at.rb
+test/unit/git/repository/test_basename.rb
+test/unit/git/repository/test_guessing.rb
+test/unit/git/working_copy/test_copying.rb
+test/unit/git/working_copy/test_creation.rb
+test/unit/git/working_copy/test_existence.rb
+test/unit/git/working_copy/test_finalization.rb
+test/unit/git/working_copy/test_guessing.rb
+test/unit/git/working_copy/test_rememberance.rb
+test/unit/svn/repository/test_at.rb
+test/unit/svn/repository/test_basename.rb
+test/unit/svn/repository/test_guessing.rb
+test/unit/svn/revision/test_checkout.rb
+test/unit/svn/revision/test_each.rb
+test/unit/svn/revision/test_rememberance.rb
+test/unit/svn/working_copy/test_copying.rb
+test/unit/svn/working_copy/test_creation.rb
+test/unit/svn/working_copy/test_existence.rb
+test/unit/svn/working_copy/test_finalization.rb
+test/unit/svn/working_copy/test_guessing.rb
+test/unit/svn/working_copy/test_rememberance.rb
+test/unit/working_copy/test_guessing.rb
+test/unit/working_copy/test_rememberance.rb
+tmp/.gitignore
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,136 @@
+Piston is a utility that eases vendor branch management.
+This is similar to <tt>svn:externals</tt>, except you have a local copy of
+the files, which you can modify at will.  As long as the changes are
+mergeable, you should have no problems.
+
+This tool has a similar purpose than svnmerge.py which you can find in the
+contrib/client-side folder of the main Subversion repository at
+http://svn.collab.net/repos/svn/trunk/contrib/client-side/svnmerge.py.
+The main difference is that Piston is designed to work with remote
+repositories.  Another tool you might want to look at, SVK, which you can find
+at http://svk.elixus.org/.
+
+From Wikipedia's Piston page (http://en.wikipedia.org/wiki/Piston):
+  In general, a piston is a sliding plug that fits closely inside the bore
+  of a cylinder.
+
+  Its purpose is either to change the volume enclosed by the cylinder, or
+  to exert a force on a fluid inside the cylinder.
+
+For this utility, I retain the second meaning, "to exert a force on a fluid
+inside the cylinder."  Piston forces the content of a remote repository
+location back into our own.
+
+
+= Notes on 2.0
+
+In the 1.0 era, Piston was exclusively geared towards Subversion repositories.
+In early 2008, Git gained a lot of popularity among Ruby and Rails coders.
+Piston was rewritten during that period to allow many repositories and working
+copies to be used together.
+
+The documentation still refers to Subversion throughout, but 2.0 allows any
+repository to be used with any working copy.
+
+
+= Installation
+
+Nothing could be simpler:
+
+ $ gem install piston
+
+
+= Usage
+
+First, you need to import the remote repository location:
+
+ $ piston import http://dev.rubyonrails.org/svn/rails/trunk vendor/rails
+ Exported r4720 from 'http://dev.rubyonrails.org/svn/rails/trunk' to 'vendor/rails'
+
+ $ svn commit -m "Importing local copy of Rails"
+
+When you want to get the latest changes from the remote repository location:
+
+ $ piston update vendor/rails
+ Updated 'vendor/rails' to r4720.
+
+ $ svn commit -m "Updates vendor/rails to the latest revision"
+
+You can prevent a local Piston-managed folder from updating by using the
++lock+ subcommand:
+
+ $ piston lock vendor/rails
+ 'vendor/rails' locked at r4720.
+
+When you want to update again, you unlock:
+
+ $ piston unlock vendor/rails
+ 'vendor/rails' unlocked.
+
+If the branch you are following moves, you should use the switch subcommand:
+
+ $ piston import http://dev.rubyonrails.org/svn/rails/branches/1-2-pre-release vendor/rails
+ $ svn commit vendor/rails
+
+ # Vendor branch is renamed, let's follow it
+ $ piston switch http://dev.rubyonrails.org/svn/rails/branches/1-2-stable vendor/rails
+
+
+= Contributions
+
+== Bash Shell Completion Script
+
+Michael Schuerig contributed a Bash shell completion script.  You should copy
++contrib/piston+ from your gem repository to the appropriate folder.  Michael
+said:
+
+  I've put together a bash completion function for piston. On Debian, I
+  just put it in /etc/bash_completion.d, alternatively, the contents can
+  be copied to ~/.bash_completion. I don't know how things are organized
+  on other Unix/Linux systems.
+
+
+= Caveats
+
+== Speed
+
+This tool is SLOW.  The update process particularly so.  I use a brute force
+approach.  Subversion cannot merge from remote repositories, so instead I
+checkout the folder at the initial revision, and then run svn update and
+parse the results of that to determine what changes have occured.
+
+If a local copy of a file was changed, it's changes will be merged back in.
+If that introduces a conflict, Piston will not detect it.  The commit will be
+rejected by Subversion anyway.
+
+== Copies / Renames
+
+Piston *does not* track copies.  Since Subversion does renames in two
+phases (copy + delete), that is what Piston does.
+
+== Local Operations Only
+
+Piston only works if you have a working copy.  It also never commits your
+working copy directly.  You are responsible for reviewing the changes and
+applying any pending fixes.
+
+== Remote Repository UUID
+
+Piston caches the remote repository UUID, allowing it to know if the remote
+repos is still the same.  Piston refuses to work against a different
+repository than the one we checked out from originally.
+
+
+= Subversion Properties Used
+
+* <tt>piston:uuid</tt>: The remote repository's UUID, which we always confirm
+  before doing any operations.
+* <tt>piston:root</tt>: The repository root URL from which this Piston folder
+  was exported from.
+* <tt>piston:remote-revision</tt>: The <tt>Last Changed Rev</tt> of the remote
+  repository.
+* <tt>piston:local-revision</tt>: The <tt>Last Changed Rev</tt> of the Piston
+  managed folder, to enable us to know if we need to do any merging.
+* <tt>piston:locked</tt>: The revision at which this folder is locked.  If
+  this property is set and non-blank, Piston will skip the folder with
+  an appropriate message.

data/Rakefile

@@ -0,0 +1,4 @@
+require "config/requirements"
+require "config/hoe" # setup Hoe + all gem configuration
+
+Dir["tasks/**/*.rake"].each { |rake| load rake }

data/bin/piston

@@ -0,0 +1,5 @@
+#! /usr/bin/ruby1.8
+require "piston"
+
+# Chain to the real command-line client
+require "piston/cli"

data/config/hoe.rb

@@ -0,0 +1,79 @@
+require "piston/version"
+
+AUTHOR = "Francois Beausoleil"
+EMAIL = "francois@teksol.info"
+DESCRIPTION = "description of gem"
+GEM_NAME = "piston"
+
+RUBYFORGE_PROJECT = "piston"
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load_file(File.expand_path(@config_file))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run "rubyforge setup" to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Piston::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ["--quiet", "--title", "Piston Documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == "hoe" } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ["**/.*.sw?", "*.gem", ".config", "**/.DS_Store"]  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+
+  # Don't specify dependencies using the full version or else it won't be the effect that was intended.
+  # ~> 2.8.0 really means "depend on 2.8.0 to 2.8.0.9999", and not 2.8.0 to 2.8.9
+  p.extra_deps = [
+    ["main", "~> 2.8"],
+    ["open4", "~> 0.9"],
+    ["log4r", "~> 1.0"],
+    ["activesupport", "~> 2.1"]
+  ]
+
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of("History.txt", 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,""), "rdoc")
+hoe.rsync_args = "-av --delete --ignore-errors"

data/config/requirements.rb

@@ -0,0 +1,18 @@
+require "fileutils"
+include FileUtils
+
+require "rubygems"
+%w[rake hoe newgem rubigen mocha activesupport].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib])))
+
+require "piston"
+require "piston/commands"

data/lib/piston.rb

@@ -0,0 +1,18 @@
+require "subclass_responsibility_error"
+
+require "piston/repository"
+require "piston/revision"
+require "piston/working_copy"
+
+require "piston/git"
+require "piston/svn"
+
+require "pathname"
+
+module Piston
+  class << self
+    def version_message
+      "Piston %s\nCopyright 2006-2008, François Beausoleil <francois@teksol.info>\nhttp://piston.rubyforge.org/\nDistributed under an MIT-like license." % Piston::VERSION::STRING
+    end
+  end
+end

data/lib/piston/cli.rb

@@ -0,0 +1,315 @@
+require "main"
+require "log4r"
+require "activesupport"
+require "piston/version"
+require "piston/commands"
+
+Main {
+  program "piston"
+  author "François Beausoleil <francois@teksol.info>"
+  version Piston::VERSION::STRING
+
+  mixin :standard_options do
+    option("verbose", "v") { 
+      argument_optional
+      cast :integer
+      default 0
+      validate {|value| (0..5).include?(value)}
+      description "Verbosity level (0 to 5, 0 being the default)"
+    }
+    option("quiet", "q") { default false }
+    option("force") { default false }
+    option("dry-run") { default false }
+  end
+
+  mixin :revision_or_commit do
+    option "revision", "r" do
+      argument_required
+      default "HEAD"
+      description "The revision you wish to operate on"
+    end
+
+    option "commit" do
+      argument_required
+      default "HEAD"
+      description "The commit you wish to operate on"
+    end
+
+    def target_revision
+      case
+      when params["revision"].given?
+        params["revision"].value
+      when params["commit"].given?
+        params["commit"].value
+      else
+        :head
+      end
+    end
+  end
+
+  mixin :lock_options do
+    option("lock") do
+      default false
+      description "Automatically lock down the revision/commit to protect against blanket updates"
+    end
+  end
+
+  mode "import" do
+    mixin :standard_options
+    mixin :revision_or_commit
+    mixin :lock_options
+
+    argument "repository" do
+      required
+      description "The repository you wish to Pistonize"
+    end 
+
+    argument "directory" do
+      optional
+      default nil
+      description "Where to put the Pistonized repository"
+    end
+
+    option("repository-type") do
+      argument :required
+      default nil
+      description "Force a specific repository type, for when it's not possible to guess"
+    end
+
+    logger_level Logger::DEBUG
+    def run
+      configure_logging!
+
+      if params["revision"].given? && params["commit"].given? then
+        raise ArgumentError, "Only one of --revision or --commit can be given.  Received both."
+      end
+
+      cmd = Piston::Commands::Import.new(:verbose => params["verbose"].value,
+                                         :quiet => params["quiet"].value,
+                                         :force => params["force"].value,
+                                         :dry_run => params["dry-run"].value,
+                                         :repository_type => params["repository-type"].value)
+
+      begin
+        cmd.run(params[:repository].value, self.target_revision, params[:directory].value)
+      rescue Piston::Repository::UnhandledUrl => e
+        supported_types = Piston::Repository.handlers.collect do |handler|
+          handler.repository_type
+        end
+        puts "Unsure how to handle:"
+        puts "\t#{params[:repository].value.inspect}."
+        puts "You should try using --repository-type. Supported types are:"
+        supported_types.each do |type|
+          puts "\t#{type}"
+        end
+        exit_failure!
+      end
+
+      # Lock the working copy, if the user asked for it
+      cmd = Piston::Commands::LockUnlock.new(:verbose => params["verbose"].value,
+                                             :quiet => params["quiet"].value,
+                                             :force => params["force"].value,
+                                             :dry_run => params["dry-run"].value)
+      cmd.run(params["directory"].value, params["lock"].value) if params["lock"].value
+    end
+  end
+  
+  mode "convert" do
+    mixin :standard_options
+    
+    argument "directories" do
+      argument_required
+      optional
+      arity -1
+      description "Which directory/directories to convert from svn:externals to Piston.  Not specifying this argument recursively converts the whole directory tree starting from the current dir."
+    end
+
+    logger_level Logger::DEBUG
+    def run
+      configure_logging!
+
+      cmd = Piston::Commands::Convert.new(:verbose => params["verbose"].value,
+                                          :quiet => params["quiet"].value,
+                                          :force => params["force"].value)
+      dirs = cmd.run(params["directories"].values.map {|dir| Pathname.new(dir)})
+      puts "#{dirs.length} directories converted"
+    end
+  end
+  
+  mode "lock" do
+    mixin :standard_options
+    
+    argument "directory" do
+      argument_required
+      optional
+      description "Which directory to lock"
+    end
+
+    logger_level Logger::DEBUG
+    def run
+      configure_logging!
+
+      cmd = Piston::Commands::LockUnlock.new(:wcdir => params["directory"].value,
+                                             :verbose => params["verbose"].value,
+                                             :quiet => params["quiet"].value,
+                                             :force => params["force"].value)
+      begin
+        cmd.run(true)
+        puts "#{params["directory"].value} locked"
+      rescue Piston::WorkingCopy::NotWorkingCopy
+        puts "The #{params["directory"].value} is not Pistonized"
+      end
+    end
+  end
+  
+  mode "unlock" do
+    mixin :standard_options
+    
+    argument "directory" do
+      argument_required
+      optional
+      description "Which directory to lock"
+    end
+
+    logger_level Logger::DEBUG
+    def run
+      configure_logging!
+
+      cmd = Piston::Commands::LockUnlock.new(:wcdir => params["directory"].value,
+                                             :verbose => params["verbose"].value,
+                                             :quiet => params["quiet"].value,
+                                             :force => params["force"].value)
+      begin
+        cmd.run(false)
+        puts "#{params["directory"].value} unlocked"
+      rescue Piston::WorkingCopy::NotWorkingCopy
+        puts "The #{params["directory"].value} is not Pistonized"
+      end
+    end
+  end
+  
+  
+  mode "info" do
+    mixin :standard_options
+    
+    argument "directory" do
+      argument_required
+      optional
+      description "Which directory to get info"
+    end
+
+    logger_level Logger::DEBUG
+    def run
+      configure_logging!
+
+      cmd = Piston::Commands::Info.new(:wcdir => params["directory"].value,
+                                             :verbose => params["verbose"].value,
+                                             :quiet => params["quiet"].value,
+                                             :force => params["force"].value)
+      begin
+        puts cmd.run(params["directory"].value)
+      rescue Piston::WorkingCopy::NotWorkingCopy
+        puts "#{params["directory"].value} is not Pistonized"
+      end
+    end
+  end
+
+  mode "update" do
+    mixin :standard_options
+    mixin :revision_or_commit
+    mixin :lock_options
+
+    argument("directory") do
+      optional
+      default '.'
+    end
+
+    logger_level Logger::DEBUG
+    def run
+      configure_logging!
+
+      if params["revision"].given? && params["commit"].given? then
+        raise ArgumentError, "Only one of --revision or --commit can be given.  Received both."
+      end
+
+      cmd = Piston::Commands::Update.new(:lock => params["lock"].value,
+                                         :verbose => params["verbose"].value,
+                                         :quiet => params["quiet"].value,
+                                         :force => params["force"].value,
+                                         :dry_run => params["dry-run"].value)
+
+      begin
+        cmd.run(File.expand_path(params["directory"].value), target_revision)
+      rescue
+        $stderr.puts $!.message
+        $stderr.puts $!.backtrace.join("\n")
+        exit_failure!
+      end
+    end
+  end
+
+  option("version", "v")
+
+  def run
+    if params["version"].given? || ARGV.first == "version" then
+      puts Piston.version_message
+      exit_success!
+    elsif ARGV.empty?
+      puts Piston.version_message
+      puts "\nNo mode given.  Call with help to find out the available options."
+      exit_failure!
+    else
+      puts "Unrecognized mode: #{ARGV.first.inspect}.  Use the help mode to find the available options."
+      exit_warn!
+    end
+  end
+
+  def configure_logging!
+    Log4r::Logger.root.level = Log4r::DEBUG
+
+    case params["verbose"].value
+    when 0
+      main_level = Log4r::INFO
+      handler_level = Log4r::WARN
+      client_level = Log4r::WARN
+      client_out_level = Log4r::WARN
+      stdout_level = Log4r::INFO
+    when 1
+      main_level = Log4r::DEBUG
+      handler_level = Log4r::INFO
+      client_level = Log4r::WARN
+      client_out_level = Log4r::WARN
+      stdout_level = Log4r::DEBUG
+    when 2
+      main_level = Log4r::DEBUG
+      handler_level = Log4r::DEBUG
+      client_level = Log4r::INFO
+      client_out_level = Log4r::WARN
+      stdout_level = Log4r::DEBUG
+    when 3
+      main_level = Log4r::DEBUG
+      handler_level = Log4r::DEBUG
+      client_level = Log4r::DEBUG
+      client_out_level = Log4r::INFO
+      stdout_level = Log4r::DEBUG
+    when 4, 5
+      main_level = Log4r::DEBUG
+      handler_level = Log4r::DEBUG
+      client_level = Log4r::DEBUG
+      client_out_level = Log4r::DEBUG
+      stdout_level = Log4r::DEBUG
+    else
+      raise ArgumentError, "Did not expect verbosity to be outside 0..5: #{params["verbose"].value}"
+    end
+
+    Log4r::Logger.new("main", main_level)
+    Log4r::Logger.new("handler", handler_level)
+    Log4r::Logger.new("handler::client", client_level)
+    Log4r::Logger.new("handler::client::out", client_out_level)
+
+    Log4r::StdoutOutputter.new("stdout", :level => stdout_level)
+
+    Log4r::Logger["main"].add "stdout"
+    Log4r::Logger["handler"].add "stdout"
+  end
+}