piston 1.0.0

data/CHANGELOG

@@ -0,0 +1,4 @@
+*SVN*
+
+2006-08-24 1.0.0
+* Initial version

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2006 Francois 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/README

@@ -0,0 +1,114 @@
+Piston is a utility that enables merge tracking of remote repositories.
+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, situated 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.
+
+= Installation
+
+Nothing could be simpler:
+
+ $ gem install --include-dependencies 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.
+
+
+= 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.
+
+
+= Dependencies
+
+Piston depends on the following libraries:
+
+* yaml
+* getoptlong
+* uri
+* fileutils
+
+These dependencies are all included in a stock 1.8.4 Ruby distribution.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'piston', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'piston'
+PKG_VERSION   = Piston::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "piston"
+RUBY_FORGE_USER    = "fbos"
+
+task :default => :test
+Rake::TestTask.new { |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = false
+}
+
+# Create compressed packages
+dist_dirs = [ "lib", "test"]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Piston is a utility that enables merge tracking of remote repositories."
+  s.description = %q{This is similar to svn:externals, 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.}
+
+  s.bindir = "bin"                               # Use these for applications.
+  s.executables = ["piston"]
+  s.default_executable = "piston"
+
+  s.files = [ "CHANGELOG", "README", "LICENSE", "Rakefile" ] + FileList["{bin,test,lib}/**/*"].to_a
+
+  s.require_path = 'lib'
+  s.has_rdoc = false
+
+  s.author = "Francois Beausoleil"
+  s.email = "francois@teksol.info"
+  s.homepage = "http://piston.rubyforge.org/"
+  s.rubyforge_project = "piston"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  `rubyforge login`
+
+  for ext in %w( gem tgz zip )
+    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}"
+    puts release_command
+    system(release_command)
+  end
+end

data/bin/piston

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # no rubygems to load, so we fail silently
+end
+
+require 'piston'
+require 'piston/ui/command_line'
+
+Piston::Ui::CommandLine.start

data/lib/core_ext/core_ext/range.rb

@@ -0,0 +1,5 @@
+class Range
+  def to_svn
+    to_s.gsub(/\.{2,3}/, ':')
+  end
+end

data/lib/core_ext/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def tmp
+    self + ".tmp"
+  end
+end

data/lib/piston/command.rb

@@ -0,0 +1,46 @@
+module Piston
+  # The base class which all commands subclass to obtain services from.
+  class Command
+    attr_accessor :revision, :dry_run, :quiet, :verbose, :force, :lock,
+                  :logging_stream
+
+    # Execute this command.  The arguments are pre-processed to expand any
+    # wildcards using Dir#[].  This is because the Windows shell does not
+    # know it should expand wildcards before calling an executable.
+    def execute(args)
+      # Because the Windows shell does not process wildcards, we must do it
+      # here ourselves
+      args.map do |arg|
+        next arg unless arg =~ /[*?]/
+        Dir[arg]
+      end
+
+      run(args.flatten)
+    end
+
+    # Run a Subversion command using the shell.  If the Subversion command
+    # returns an existstatus different from zero, a RuntimeError is raised.
+    def svn(*args)
+      args = args.flatten.compact.map do |arg|
+        if arg.to_s =~ /[ *?@]/ then
+          %Q("#{arg}")
+        else
+          arg
+        end
+      end
+
+      command = "svn #{args.join(' ')}"
+      logging_stream.puts command if verbose
+      return if dry_run
+      result = `#{command}`
+      logging_stream.puts result if verbose
+      raise "Command #{command} resulted in an error:\n\n#{result}" unless $?.exitstatus.zero?
+      result
+    end
+
+    # Returns an IO-like object to which all information should be logged.
+    def logging_stream
+      @logging_stream ||= $stdout
+    end
+  end
+end

data/lib/piston/command_error.rb

@@ -0,0 +1,4 @@
+module Piston
+  # Raised whenever an argument is not correct during processing.
+  class CommandError < ArgumentError; end
+end

data/lib/piston/commands/help.rb

@@ -0,0 +1,44 @@
+module Piston
+  module Commands
+    class Help < Piston::Command
+      def run(targets=nil)
+        command = targets.shift
+
+        return help_on_command(command) if command
+        general_help
+      end
+
+      def help_on_command(command_name)
+        begin
+          require File.join(PISTON_ROOT, 'piston', 'commands', command_name)
+          command = Piston::Commands.const_get(command_name.capitalize)
+          command.detailed_help(logging_stream)
+        rescue LoadError
+          logging_stream.puts "No help available for '#{command_name}'"
+          general_help
+        end
+      end
+
+      def general_help
+        logging_stream.puts "Available commands are:"
+        commands = Array.new
+        Dir[File.join(PISTON_ROOT, 'piston', 'commands', '*.rb')].each do |file|
+          require file
+          commands << Piston::Commands.const_get(File.basename(file).gsub(/\.rb$/, '').capitalize)
+        end
+
+        commands.each do |command|
+          logging_stream.printf "  %-12s %s\n", command.aliases.first, command.help
+        end
+      end
+
+      def self.help
+        "Returns detailed help on a specific command"
+      end
+
+      def self.aliases
+        %w(help)
+      end
+    end
+  end
+end

data/lib/piston/commands/import.rb

@@ -0,0 +1,68 @@
+module Piston
+  module Commands
+    class Import < Piston::Command
+      def run(args)
+        raise Piston::CommandError, "Missing REPOS_URL argument" if args.empty?
+
+        repos, dir = args.shift, args.shift
+        raise Piston::CommandError, "Too many arguments" unless args.empty?
+        dir = File.basename(URI.parse(repos).path) unless dir
+
+        if File.exists?(dir) then
+          raise Piston::CommandError, "Target folder already exists" unless force
+          svn :revert, '--recursive', dir
+          FileUtils.rm_rf(dir)
+        end
+
+        info = YAML::load(svn(:info, repos))
+        options = [:export]
+        options << ['--revision', revision] if revision
+        options << repos
+        options << dir
+        export = svn options
+        export.each_line do |line|
+          next unless line =~ /Exported revision (\d+)./i
+          @revision = $1
+          break
+        end
+
+        svn :add, '--force', dir
+        svn :propset, Piston::ROOT, repos, dir
+        svn :propset, Piston::UUID, info['Repository UUID'], dir
+        svn :propset, Piston::REMOTE_REV, revision, dir
+        svn :propset, Piston::LOCAL_REV, YAML::load(svn(:info))['Last Changed Rev'], dir
+        svn :propset, Piston::LOCKED, revision, dir if lock
+
+        logging_stream.puts "Exported r#{revision} from '#{repos}' to '#{dir}'"
+      end
+
+      def self.help
+        "Prepares a folder for merge tracking"
+      end
+
+      def self.detailed_help(stream)
+        stream.puts <<EOF
+import (init): #{help}
+usage: import REPOS_URL [DIR]
+
+  Exports the specified REPOS_URL (which must be a Subversion repository) to
+  DIR, defaulting to the last component of REPOS_URL if DIR is not present.
+
+  If the local folder already exists, this command will abort with an error.
+
+  Valid options:
+      -r [--revision] arg   : Start merge tracking at ARG instead of HEAD
+      --lock                : Close down and lock the folder from future
+                              updates immediately
+      --verbose             : Show Subversion commands and results as they
+                              are executed
+
+EOF
+      end
+
+      def self.aliases
+        %w(import init)
+      end
+    end
+  end
+end

data/lib/piston/commands/lock.rb

@@ -0,0 +1,38 @@
+module Piston
+  module Commands
+    class Lock < Piston::Command
+      def run(args)
+        raise Piston::CommandError, "No targets to run against" if args.empty?
+
+        args.each do |dir|
+          remote_rev = svn(:propget, Piston::REMOTE_REV, dir).chomp.to_i
+          svn :propset, Piston::LOCKED, remote_rev, dir
+        end
+
+        logging_stream.puts "Locked #{args.size} folder(s)"
+      end
+
+      def self.help
+        "Lock one or more folders to a specific revision"
+      end
+
+      def self.detailed_help(stream)
+        stream.puts <<EOF
+lock: #{help}
+usage: lock DIR [DIR [...]]
+
+  Locked folders will not be updated to the latest revision when updating.
+
+  Valid options:
+      --verbose             : Show Subversion commands and results as they
+                              are executed
+
+EOF
+      end
+
+      def self.aliases
+        %w(lock)
+      end
+    end
+  end
+end

data/lib/piston/commands/unlock.rb

@@ -0,0 +1,34 @@
+module Piston
+  module Commands
+    class Unlock < Piston::Command
+      def run(args)
+        raise Piston::CommandError, "No targets to run against" if args.empty?
+        svn :propdel, Piston::LOCKED, *args
+        logging_stream.puts "Unlocked #{args.size} folder(s)"
+      end
+
+      def self.help
+        "Undoes the changes enabled by lock"
+      end
+
+      def self.detailed_help(stream)
+        stream.puts <<EOF
+unlock: #{help}
+usage: unlock DIR [DIR [...]]
+
+  Unlocked folders are free to be updated to the latest revision when
+  updating.
+
+  Valid options:
+      --verbose             : Show Subversion commands and results as they
+                              are executed
+
+EOF
+      end
+
+      def self.aliases
+        %w(unlock)
+      end
+    end
+  end
+end

data/lib/piston/commands/update.rb

@@ -0,0 +1,107 @@
+module Piston
+  module Commands
+    class Update < Piston::Command
+      def run(args)
+        args.each do |dir|
+          update dir
+        end
+      end
+
+      def update(dir)
+        next unless File.directory?(dir)
+        next skip(dir, "locked") unless svn(:propget, LOCKED, dir) == ''
+        status = svn :status, '--show-updates', dir
+        next skip(dir, "pending updates -- run \"svn update #{dir}\"") if status.split("\n").size > 1
+
+        logging_stream.print "Processing '#{dir}'...  "
+        repos = svn(:propget, Piston::ROOT, dir).chomp
+        uuid = svn(:propget, Piston::UUID, dir).chomp
+        remote_revision = svn(:propget, Piston::REMOTE_REV, dir).chomp.to_i
+        local_revision = svn(:propget, Piston::LOCAL_REV, dir).chomp.to_i
+
+        info = YAML::load(svn(:info, repos))
+        next skip(dir, "Repository UUID changed\n  Expected #{uuid}\n  Found    #{info['Repository UUID']}\n  Repository: #{repos}") unless uuid == info['Repository UUID']
+
+        new_remote_rev = info['Last Changed Rev'].to_i
+        next skip(dir, "unchanged from revision #{remote_revision}") if remote_revision == new_remote_rev
+
+        info = YAML::load(svn(:info))
+        new_local_rev = info['Last Changed Rev']
+
+        revisions = (remote_revision .. (revision || new_remote_rev))
+        svn :checkout, '--ignore-externals', '--revision', revisions.first, repos, dir.tmp
+        updates = svn :update, '--ignore-externals', '--revision', revisions.last, dir.tmp
+        merges = Array.new
+        changes = 0
+        updates.each_line do |line|
+          next unless line =~ %r{^([A-Z]).*\s+#{Regexp.escape(dir.tmp)}[\\/](.+)$}
+          op, file = $1, $2
+          changes += 1
+
+          case op
+          when 'A'
+            copy(dir, file)
+            svn :add, File.join(dir, file)
+          when 'D'
+            svn :remove, File.join(dir, file)
+          else
+            copy(dir, file)
+            merges << file
+          end
+        end
+
+        merges.each do |file|
+          svn :merge, '--revision', (local_revision.succ .. new_local_rev).to_svn, File.join(dir, file), File.join(dir, file)
+        end unless local_revision == new_local_rev
+
+        FileUtils.rm_rf dir.tmp
+
+        svn :propset, Piston::REMOTE_REV, revisions.last, dir
+        svn :propset, Piston::LOCAL_REV, new_local_rev, dir
+        svn :propset, Piston::LOCKED, revisions.last, dir if lock
+
+        logging_stream.puts "Updated to #{revisions.last} (#{changes} changed files)"
+      end
+
+      def copy(dir, file)
+        FileUtils.cp(File.join(dir.tmp, file), File.join(dir, file))
+      end
+
+      def skip(dir, msg)
+        logging_stream.puts "Skipping '#{dir}': #{msg}"
+      end
+
+      def self.help
+        "Updates one or more folders to the latest revision"
+      end
+
+      def self.detailed_help(stream)
+        stream.puts <<EOF
+update: #{help}
+usage: update DIR [...]
+
+  This operation has the effect of downloading all remote changes back to our
+  working copy.  If any local modifications were done, they will be preserved.
+  If merge conflicts occur, they will not be taken care of, and your subsequent
+  commit will fail.
+
+  Piston will refuse to update a folder if it has pending updates.  Run
+  'svn update' on the target folder to update it before running Piston
+  again.
+
+    Valid options:
+      -r [--revision] arg   : Update to ARG instead of HEAD
+      --lock                : Close down and lock the folder from future
+                              updates immediately
+      --verbose             : Show Subversion commands and results as they
+                              are executed
+
+EOF
+      end
+
+      def self.aliases
+        %w(update up)
+      end
+    end
+  end
+end

data/lib/piston/ui/command_line.rb

@@ -0,0 +1,69 @@
+require 'getoptlong'
+
+module Piston
+  module Ui
+    module CommandLine
+      def self.start
+        opts = ::GetoptLong.new(
+          [ '--revision', '-r', GetoptLong::REQUIRED_ARGUMENT ],
+          [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+          [ '--dry-run', GetoptLong::NO_ARGUMENT ],
+          [ '--quiet', '-q', GetoptLong::NO_ARGUMENT ],
+          [ '--verbose', '-v', GetoptLong::NO_ARGUMENT ],
+          [ '--lock', GetoptLong::NO_ARGUMENT ],
+          [ '--force', '-f', GetoptLong::NO_ARGUMENT ],
+          [ '--version', GetoptLong::NO_ARGUMENT ]
+        )
+
+        options = Hash.new
+
+        opts.each do |opt, arg|
+          case opt
+          when '--revision'
+            options[:revision] = arg.to_i
+
+          when '--help'
+            return help
+
+          when '--version'
+            require 'piston/version'
+            puts "Piston #{Piston::VERSION::STRING}"
+            puts "Copyright 2006, Francois Beausoleil"
+            puts "\nSee the LICENSE file for details"
+            exit
+
+          when /--([-\w]+)$/
+            options[$1.gsub('-', '_').to_sym] = true
+          end
+        end
+
+        return help if ARGV.empty?
+
+        command_name = ARGV.shift.downcase
+        begin
+          require File.join(PISTON_ROOT, 'piston', 'commands', command_name)
+        rescue LoadError
+          return help
+        end
+
+        command_class = Piston::Commands.const_get("#{command_name.capitalize}")
+        command = command_class.new
+        options.each do |key, value|
+          command.send "#{key}=", value
+        end
+
+        begin
+          command.execute(ARGV)
+        rescue Piston::CommandError
+          $stderr.puts "ERROR: #{$!.message}"
+          exit 1
+        end
+      end
+
+      def self.help
+        require File.join(PISTON_ROOT, 'piston', 'commands', 'help')
+        Piston::Commands::Help.new.run(ARGV)
+      end
+    end
+  end
+end

data/lib/piston/version.rb

@@ -0,0 +1,9 @@
+module Piston
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/piston.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2006 Francois 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.
+
+# $HeadURL: svn://rubyforge.org/var/svn/piston/tags/1.0.0/lib/piston.rb $
+# $Id: piston.rb 11 2006-08-25 02:47:12Z fbos $
+
+require 'yaml'
+require 'uri'
+require 'fileutils'
+
+PISTON_ROOT = File.dirname(__FILE__)
+Dir[File.join(PISTON_ROOT, 'core_ext', '*.rb')].each do |file|
+  require file
+end
+
+require File.join(PISTON_ROOT, 'piston', 'command')
+require File.join(PISTON_ROOT, 'piston', 'command_error')
+require File.join(PISTON_ROOT, 'piston', 'ui', 'command_line')
+
+module Piston
+  ROOT        = "piston:root"
+  UUID        = "piston:uuid"
+  REMOTE_REV  = "piston:remote-revision"
+  LOCAL_REV   = "piston:local-revision"
+  LOCKED      = "piston:locked"
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: piston
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2006-08-25 00:00:00 +00:00
+summary: Piston is a utility that enables merge tracking of remote repositories.
+require_paths: 
+- lib
+email: francois@teksol.info
+homepage: http://piston.rubyforge.org/
+rubyforge_project: piston
+description: This is similar to svn:externals, 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.
+autorequire: 
+default_executable: piston
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Francois Beausoleil
+files: 
+- CHANGELOG
+- README
+- LICENSE
+- Rakefile
+- bin/piston
+- lib/core_ext
+- lib/piston
+- lib/piston.rb
+- lib/core_ext/core_ext
+- lib/core_ext/core_ext/string.rb
+- lib/core_ext/core_ext/range.rb
+- lib/piston/commands
+- lib/piston/ui
+- lib/piston/command_error.rb
+- lib/piston/command.rb
+- lib/piston/version.rb
+- lib/piston/commands/update.rb
+- lib/piston/commands/help.rb
+- lib/piston/commands/lock.rb
+- lib/piston/commands/import.rb
+- lib/piston/commands/unlock.rb
+- lib/piston/ui/command_line.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- piston
+extensions: []
+
+requirements: []
+
+dependencies: []
+