pivotal-piston 1.9.4

data/lib/piston/version.rb

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

data/lib/piston/working_copy.rb

@@ -0,0 +1,183 @@
+module Piston
+  class WorkingCopy
+    class UnhandledWorkingCopy < RuntimeError; end
+    class NotWorkingCopy < RuntimeError; end
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+
+      def guess(path)
+        path = path.kind_of?(Pathname) ? path : Pathname.new(path.to_s)
+        try_path = path.exist? ? path : path.parent
+        logger.info {"Guessing the working copy type of #{try_path.inspect}"}
+        handler = handlers.detect do |handler|
+          logger.debug {"Asking #{handler.name} if it understands #{try_path}"}
+          handler.understands_dir?(try_path)
+        end
+
+        raise UnhandledWorkingCopy, "Don't know what working copy type #{path} is." if handler.nil?
+        handler.new(path)
+      end
+
+      @@handlers = Array.new
+      def add_handler(handler)
+        @@handlers << handler
+      end
+
+      def handlers
+        @@handlers
+      end
+      private :handlers
+    end
+
+    attr_reader :path
+
+    def initialize(path)
+      if path.kind_of?(Pathname)
+        raise ArgumentError, "#{path} must be absolute" unless path.absolute?
+        @path = path
+      else
+        @path = Pathname.new(File.expand_path(path))
+      end
+      logger.debug {"Initialized on #{@path}"}
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def to_s
+      "Piston::WorkingCopy(#{@path})"
+    end
+
+    def exist?
+      @path.exist? && @path.directory?
+    end
+    
+    def pistonized?
+      yaml_path.exist? && yaml_path.file?
+    end
+
+    def validate!
+      raise NotWorkingCopy unless self.pistonized?
+      self
+    end
+
+    # Creates the initial working copy for pistonizing a new repository.
+    def create
+      logger.debug {"Creating working copy at #{path}"}
+    end
+
+    # Copy files from +revision+.  +revision+ must
+    # #respond_to?(:each), and return each file that is to be copied.
+    # Only files must be returned.
+    #
+    # Each item yielded by Revision#each must be a relative path.
+    #
+    # WorkingCopy will call Revision#copy_to with the full path to where the
+    # file needs to be copied.
+    def copy_from(revision)
+      revision.each do |relpath|
+        target = path + relpath
+        target.dirname.mkdir rescue nil
+
+        logger.debug {"Copying #{relpath} to #{target}"}
+        revision.copy_to(relpath, target)
+      end
+    end
+
+    # Stores a Hash of values that can be retrieved later.
+    def remember(values, handler_values)
+      values["format"] = 1
+
+      # Stringify keys
+      values.keys.each do |key|
+        values[key.to_s] = values.delete(key)
+      end
+
+      logger.debug {"Remembering #{values.inspect} as well as #{handler_values.inspect}"}
+      File.open(yaml_path, "w+") do |f|
+        f.write(values.merge("handler" => handler_values).to_yaml)
+      end
+
+      logger.debug {"Calling \#after_remember on #{yaml_path}"}
+      after_remember(yaml_path)
+    end
+
+    # Callback after #remember is done, to do whatever the
+    # working copy needs to do with the file.
+    def after_remember(path)
+    end
+
+    # Recalls a Hash of values from the working copy.
+    def recall
+      YAML.load_file(yaml_path)
+    end
+
+    def finalize
+      logger.debug {"Finalizing #{path}"}
+    end
+    
+    # Returns basic information about this working copy.
+    def info
+      recall
+    end
+
+    def import(revision, lock)
+      repository = revision.repository
+      tmpdir = temp_dir_name
+      begin
+        logger.info {"Checking out the repository"}
+        revision.checkout_to(tmpdir)
+
+        logger.debug {"Creating the local working copy"}
+        create
+
+        logger.info {"Copying from #{revision}"}
+        copy_from(revision)
+
+        logger.debug {"Remembering values"}
+        remember(
+          {:repository_url => repository.url, :lock => lock, :repository_class => repository.class.name},
+          revision.remember_values
+        )
+
+        logger.debug {"Finalizing working copy"}
+        finalize
+
+        logger.info {"Checked out #{repository.url.inspect} #{revision.name} to #{path.to_s}"}
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    # Update this working copy from +from+ to +to+, which means merging local changes back in
+    def update(to, lock)
+      tmpdir = temp_dir_name
+      begin
+        to.checkout_to(tmpdir)
+        do_update(to, lock)
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    def temp_dir_name
+      path.parent + ".#{path.basename}.tmp"
+    end
+
+    protected
+    def do_update(to, lock)
+      raise NotImplementedError
+    end
+
+    # The path to the piston YAML file.
+    def yaml_path
+      path + ".piston.yml"
+    end
+  end
+end

data/lib/subclass_responsibility_error.rb

@@ -0,0 +1,2 @@
+class SubclassResponsibilityError < RuntimeError
+end

data/samples/common.rb

@@ -0,0 +1,19 @@
+# Common code between all sample files.
+# Setup the environment.
+require "pathname"
+require "logger"
+
+@root = Pathname.new(File.dirname(__FILE__)).parent
+$:.unshift("#{@root}lib"
+
+require "piston"
+require "piston/svn"
+require "piston/git"
+
+PISTON_DEFAULT_LOGGER = Logger.new(STDOUT)
+Piston::Repository.logger = Piston::WorkingCopy.logger = PISTON_DEFAULT_LOGGER
+def logger; PISTON_DEFAULT_LOGGER; end
+
+include Piston::Svn::Client
+include Piston::Git::Client
+

data/samples/import_git_git.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+#
+# Import an SVN repository into an SVN working copy.
+require "#{File.dirname(__FILE__)}/common"
+
+@root = @root + "tmp/git_git"
+@root.rmtree rescue nil
+@root.mkpath
+
+@tmp = @root + "plugin.tmp"
+
+@plugin = @root + "plugin"
+@plugin.mkpath
+File.open(@plugin + "README", "wb") {|f| f.puts "Hello World"}
+File.open(@plugin + "init.rb", "wb") {|f| f.puts "# Some init code"}
+Dir.chdir(@plugin) do
+  git :init
+  git :add, "."
+  git :commit, "-m", "initial commit"
+end
+
+@wc = @root + "wc"
+@wc.mkpath
+File.open(@wc + "README", "wb") {|f| f.puts "My local project"}
+Dir.chdir(@wc) do
+  git :init
+  git :add, "."
+  git :commit, "-m", "initial commit"
+end
+
+repos = Piston::Git::Repository.new("file://" + @plugin.realpath)
+commit = repos.at(:head)
+commit.checkout_to(@tmp)
+
+wc = Piston::Git::WorkingCopy.new(@wc + "vendor")
+wc.create
+wc.copy_from(commit)
+wc.remember(commit.remember_values)
+wc.finalize

data/samples/import_git_svn.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+#
+# Import a Git project into a Subversion working copy.
+require "#{File.dirname(__FILE__)}/common"
+
+@root = @root + "tmp/git_svn"
+@root.rmtree rescue nil
+@root.mkpath
+
+@repos = @root + "repos"
+@wc = @root + "wc"
+
+@plugin = @root + "plugin"
+@tmp = @root + "plugin.tmp"
+
+svnadmin :create, @repos
+svn :checkout, "--quiet", "file://" + @repos.realpath, @wc
+
+@plugin.mkpath
+File.open(@plugin + "README", "wb") {|f| f.puts "Hello World"}
+File.open(@plugin + "init.rb", "wb") {|f| f.puts "# Some initialization code here"}
+Dir.chdir(@plugin) do
+  logger.debug {"CWD: #{Dir.getwd}"}
+  git :init
+  git :add, "."
+  git :commit, "-m", "initial commit"
+end
+
+repos = Piston::Git::Repository.new("file://" + @plugin.realpath)
+commit = repos.at(:head)
+commit.checkout_to(@tmp)
+wc = Piston::Svn::WorkingCopy.new(@wc + "vendor")
+wc.create
+wc.copy_from(commit)
+wc.remember(commit.remember_values)
+wc.finalize

data/samples/import_svn_git.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+# Import an SVN repository into a Git working copy.
+require "#{File.dirname(__FILE__)}/common"
+
+@root = @root + "tmp/svn_git"
+@root.rmtree rescue nil
+@root.mkpath
+
+@repos = @root + "repos"
+@wc = @root + "wc"
+@tmp = @root + "xlsuite.tmp"
+
+@wc.mkpath
+File.open(@wc + "README", "wb") {|f| f.write "Hello World"}
+Dir.chdir(@wc) do
+  git :init
+  git :add, "."
+  git :commit, "-m", "initial"
+end
+
+repos = Piston::Svn::Repository.new("http://svn.xlsuite.org/trunk/lib")
+rev = repos.at(:head)
+rev.checkout_to(@tmp)
+wc = Piston::Git::WorkingCopy.new(@wc + "vendor")
+wc.create
+wc.copy_from(rev)
+wc.remember(rev.remember_values)
+wc.finalize

data/samples/import_svn_svn.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#
+# Import an SVN repository into an SVN working copy.
+require "#{File.dirname(__FILE__)}/common"
+
+@root = @root + "tmp/svn_svn"
+@root.rmtree rescue nil
+@root.mkpath
+
+@repos = @root + "repos"
+@wc = @root + "wc"
+@tmp = @root + "xlsuite.tmp"
+
+svnadmin :create, @repos
+svn :checkout, "file://#{@repos.realpath}", @wc
+
+repos = Piston::Svn::Repository.new("http://svn.xlsuite.org/trunk/lib")
+rev = repos.at(:head)
+rev.checkout_to(@tmp)
+wc = Piston::Svn::WorkingCopy.new(@wc + "tmp")
+wc.create
+wc.copy_from(rev)
+wc.remember(rev.remember_values)
+wc.finalize

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/piston/version.rb'
+
+version  = Piston::VERSION::STRING
+download = 'http://rubyforge.org/projects/piston'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)