francois-piston 2.0.0

data/lib/piston/git/repository.rb

@@ -0,0 +1,63 @@
+require "piston/git/commit"
+require "uri"
+
+module Piston
+  module Git
+    class Repository < Piston::Repository
+      Piston::Repository.add_handler self
+
+      class << self
+        def understands_url?(url)
+          uri = URI.parse(url) rescue nil
+          return true if uri && %w(git).include?(uri.scheme)
+
+          begin
+            response = git("ls-remote", "--heads", url.sub(/\?.+$/, ""))
+            return false if response.nil? || response.strip.chomp.empty?
+            !!(response =~ /[a-f\d]{40}\s/)
+          rescue Piston::Git::Client::CommandError
+            false
+          end
+        end
+
+        def client
+          @@client ||= Piston::Git::Client.instance
+        end
+
+        def git(*args)
+          client.git(*args)
+        end
+        
+        def repository_type
+          'git'
+        end
+      end
+
+      attr_reader :branchname
+
+      def initialize(url)
+        @branchname = url.split("?")[1]
+        super(url.sub(/\?.+$/, ""))
+      end
+
+      def git(*args)
+        self.class.git(*args)
+      end
+
+      def at(commit)
+        case commit
+        when Hash
+          Piston::Git::Commit.new(self, commit[Piston::Git::COMMIT], commit)
+        when :head
+          Piston::Git::Commit.new(self, "HEAD")
+        else
+          Piston::Git::Commit.new(self, commit)
+        end
+      end
+
+      def basename
+        self.url.split("/").last.sub(".git", "")
+      end
+    end
+  end
+end

data/lib/piston/git/working_copy.rb

@@ -0,0 +1,142 @@
+require "piston/working_copy"
+require "piston/git/client"
+
+module Piston
+  module Git
+    class WorkingCopy < Piston::WorkingCopy
+      # Register ourselves as a handler for working copies
+      Piston::WorkingCopy.add_handler self
+
+      class << self
+        def understands_dir?(dir)
+          path = dir
+          begin
+            begin
+              logger.debug {"git status on #{path}"}
+              Dir.chdir(path) do
+                response = git(:status)
+                return true if response =~ /# On branch /
+              end
+            rescue Errno::ENOENT
+              # NOP, we assume this is simply because the folder hasn't been created yet
+              path = path.parent
+              retry unless path.to_s == "/"
+              return false
+            end
+          rescue Piston::Git::Client::BadCommand
+            # NOP, as we return false below
+          rescue Piston::Git::Client::CommandError
+            # This is certainly not a Git repository
+            false
+          end
+
+          false
+        end
+
+        def client
+          @@client ||= Piston::Git::Client.instance
+        end
+
+        def git(*args)
+          client.git(*args)
+        end
+      end
+
+      def git(*args)
+        self.class.git(*args)
+      end
+
+      def create
+        path.mkpath rescue nil
+      end
+
+      def exist?
+        path.directory?
+      end
+
+      def after_remember(path)
+        Dir.chdir(self.path) { git(:add, path.relative_path_from(self.path)) }
+      end
+
+      def finalize
+        Dir.chdir(path) { git(:add, ".") }
+      end
+
+      def add(added)
+        Dir.chdir(path) do
+          added.each { |item| git(:add, item) }
+        end
+      end
+
+      def delete(deleted)
+        Dir.chdir(path) do
+          deleted.each { |item| git(:rm, item) }
+        end
+      end
+
+      def rename(renamed)
+        Dir.chdir(path) do
+          renamed.each { |from, to| git(:mv, from, to) }
+        end
+      end
+
+      def downgrade_to(revision)
+        logger.debug {"Creating a branch to copy changes from remote repository"}
+        Dir.chdir(path) { git(:checkout, '-b', "my-#{revision}", revision) }
+      end
+      
+      def merge_local_changes(revision)
+        from_revision = current_revision
+        Dir.chdir(path) do
+          begin
+            logger.debug {"Saving changes in temporary branch"}
+            git(:commit, '-a', '-m', 'merging')
+            logger.debug {"Return to previous branch"}
+            git(:checkout, revision)
+            logger.debug {"Merge changes from temporary branch"}
+            git(:merge, '--squash', from_revision)
+          rescue Piston::Git::Client::CommandError
+            git(:checkout, revision)
+          ensure
+            logger.debug {"Deleting temporary branch"}
+            git(:branch, '-D', from_revision)
+          end
+        end
+      end
+
+      def locally_modified
+        logger.debug {"Get last changed revision for #{yaml_path}"}
+        # get latest commit for .piston.yml
+        initial_revision = last_changed_revision(yaml_path)
+        logger.debug {"Get last log line for #{path} after #{initial_revision}"}
+        # get latest revisions for this working copy since last update
+        Dir.chdir(path) { not git(:log, '-n', '1', "#{initial_revision}..", '.').empty? }
+      end
+
+      def exclude_for_diff
+        Piston::Git::EXCLUDE
+      end
+
+      def status(subpath=nil)
+        Dir.chdir(path) do
+          git(:status).split("\n").inject([]) do |memo, line|
+            next memo unless line =~ /\s(\w+):\s+(.*)$/
+            memo << [$1, $2]
+          end
+        end
+      end
+
+      protected
+      def current_revision
+        Dir.chdir(path) { git(:branch).match(/^\*\s+(.+)$/)[1] }
+      end
+
+      def last_changed_revision(path)
+        path = Pathname.new(path) unless path.is_a? Pathname
+        path = path.relative_path_from(self.path) unless path.relative?
+        logger.debug {"Get last log line for #{path}"}
+        Dir.chdir(self.path) { git(:log, '-n', '1', path).match(/commit\s+(.*)$/)[1] }
+      end
+    end
+  end
+end

data/lib/piston/repository.rb

@@ -0,0 +1,61 @@
+require "piston/revision"
+
+module Piston
+  class Repository
+    class UnhandledUrl < RuntimeError; end
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+
+      def guess(url)
+        logger.info {"Guessing the repository type of #{url.inspect}"}
+        
+        handler = handlers.detect do |handler|
+          logger.debug {"Asking #{handler}"}
+          handler.understands_url?(url)
+        end
+        
+        raise UnhandledUrl unless handler
+        
+        handler.new(url)
+      end
+
+      @@handlers = Array.new
+      def add_handler(handler)
+        @@handlers << handler
+      end
+
+      def handlers
+        @@handlers
+      end
+    end
+
+    attr_reader :url
+
+    def initialize(url)
+      @url = url
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def at(revision)
+      raise SubclassResponsibilityError, "Piston::Repository#at should be implemented by a subclass."
+    end
+
+    def to_s
+      @url
+    end
+
+    def inspect
+      "Piston::Repository(#{@url})"
+    end
+    
+    def ==(other)
+      url == other.url
+    end
+  end
+end

data/lib/piston/revision.rb

@@ -0,0 +1,83 @@
+module Piston
+  class Revision
+    include Enumerable
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+    end
+
+    attr_reader :repository, :revision, :recalled_values, :dir
+
+    def initialize(repository, revision, recalled_values={})
+      @repository, @revision, @recalled_values = repository, revision, recalled_values
+    end
+    
+    def url
+      repository.url
+    end
+    
+    def name
+      @revision
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def to_s
+      "revision #{@revision}"
+    end
+
+    def inspect
+      "Piston::Revision(#{@repository.url}@#{@revision})"
+    end
+
+    # Retrieve a copy of this repository into +dir+.
+    def checkout_to(dir)
+      logger.debug {"Checking out #{@repository}@#{@revision} into #{dir}"}
+      @dir = dir.kind_of?(Pathname) ? dir : Pathname.new(dir)
+    end
+
+    # Update a copy of this repository to revision +to+.
+    def update_to(to, lock)
+      raise SubclassResponsibilityError, "Piston::Revision#update_to should be implemented by a subclass."
+    end
+
+    # What values does this revision want to remember for the future ?
+    def remember_values
+      logger.debug {"Generating remember values"}
+      {}
+    end
+
+    # Yields each file of this revision in turn to our caller.
+    def each
+    end
+
+    # Copies +relpath+ (relative to ourselves) to +abspath+ (an absolute path).
+    def copy_to(relpath, abspath)
+      raise ArgumentError, "Revision #{revision} of #{repository.url} was never checked out -- can't iterate over files" unless @dir
+
+      Pathname.new(abspath).dirname.mkpath
+      FileUtils.cp(@dir + relpath, abspath)
+    end
+
+    # Copies +abspath+ (an absolute path) to +relpath+ (relative to ourselves).
+    def copy_from(abspath, relpath)
+      raise ArgumentError, "Revision #{revision} of #{repository.url} was never checked out -- can't iterate over files" unless @dir
+
+      target = @dir + relpath
+      Pathname.new(target).dirname.mkpath
+      FileUtils.cp(abspath, target)
+    end
+
+    def remotely_modified
+      raise SubclassResponsibilityError, "Piston::Revision#remotely_modified should be implemented by a subclass."
+    end
+
+    def exclude_for_diff
+      raise SubclassResponsibilityError, "Piston::Revision#exclude_for_diff should be implemented by a subclass."
+    end
+  end
+end

data/lib/piston/svn.rb

@@ -0,0 +1,15 @@
+require "piston/svn/client"
+require "piston/svn/repository"
+require "piston/svn/revision"
+require "piston/svn/working_copy"
+
+module Piston
+  module Svn
+    ROOT        = "piston:root"
+    UUID        = "piston:uuid"
+    REMOTE_REV  = "piston:remote-revision"
+    LOCAL_REV   = "piston:local-revision"
+    LOCKED      = "piston:locked"
+    EXCLUDE     = [".svn"]
+  end
+end

data/lib/piston/svn/client.rb

@@ -0,0 +1,88 @@
+require "singleton"
+
+module Piston
+  module Svn
+    class Client
+      include Singleton
+
+      class CommandError < RuntimeError; end
+      class Failed < CommandError; end
+      class BadCommand < CommandError; end
+
+      def logger
+        @logger ||= Log4r::Logger["handler::client"]
+      end
+
+      def out_logger
+        @out_logger ||= Log4r::Logger["handler::client::out"]
+      end
+
+      def svnadmin(*args)
+        run_cmd :svnadmin, *args
+      end
+
+      def svn(*args)
+        run_cmd :svn, *args
+      end
+
+      def svnlook(*args)
+        run_cmd :svnlook, *args
+      end
+
+      def svnversion(*args)
+        run_cmd :svnversion, *args
+      end
+
+      private
+      def run_cmd(executable, *args)
+        args.collect! {|arg| arg.to_s =~ /\s|\*|\?|"|\n|\r/ ? %Q('#{arg}') : arg}
+        args.collect! {|arg| arg ? arg : '""'}
+        cmd = %Q|#{executable} #{args.join(' ')}|
+        logger.debug {"> " + cmd}
+
+        original_language = ENV["LANGUAGE"]
+        begin
+          ENV["LANGUAGE"] = "C"
+          value = run_real(cmd)
+          out_logger.info {"< " + value} unless (value || "").strip.empty?
+          return value
+        ensure
+          ENV["LANGUAGE"] = original_language
+        end
+      end
+
+      begin
+        raise LoadError, "Not implemented on Win32 machines" if RUBY_PLATFORM =~ /mswin32/
+
+          begin
+            require "rubygems"
+          rescue LoadError
+            # NOP -- attempt to load without Rubygems
+          end
+
+        require "open4"
+
+        def run_real(cmd)
+          begin
+            pid, stdin, stdout, stderr = Open4::popen4(cmd)
+            _, cmdstatus = Process.waitpid2(pid)
+            raise CommandError, "#{cmd.inspect} exited with status: #{cmdstatus.exitstatus}\n#{stderr.read}" unless cmdstatus.success?
+            return stdout.read
+          rescue Errno::ENOENT
+            raise BadCommand, cmd.inspect
+          end
+        end
+
+      rescue LoadError
+        # On platforms where open4 is unavailable, we fallback to running using
+        # the backtick method of Kernel.
+        def run_real(cmd)
+          out = `#{cmd}`
+          raise BadCommand, cmd.inspect if $?.exitstatus == 127
+          raise Failed, "#{cmd.inspect} exited with status: #{$?.exitstatus}" unless $?.success?
+          out
+        end
+      end
+    end
+  end
+end