Redmine

# redMine - project management software

# Copyright (C) 2006-2007  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require 'redmine/scm/adapters/abstract_adapter'

require 'rexml/document'

require "P4"

module Redmine

  module Scm

    module Adapters

      class PerforceAdapter < AbstractAdapter

        # whether we sould be supporting extended

        #  revision info on the revision #rev/head (ie. #1/7

        def supports_extended_revision?

          true

        end

        # Get info about the P4 repo

        def info

          path = fix_url(url)

          p4 = P4.new

          begin

            p4.port = root_url

            p4.user = @login

            if (!@password.nil? && !@password.empty?)

              p4.password = @password

            end

            p4.connect

            # get latest change for the depot spec

            h = p4.run_changes("-m 1 -s submitted", "#{path}...").shift

            change = P4Change.new( h )

            info = Info.new({:root_url => url,

                :lastrev => Revision.new({

                    :identifier => change.change,

                    :time => change.time,

                    :author => change.user.downcase

                  })

              })

            return info

          end

        rescue P4Exception

          p4.errors.each { |e| logger.error("Error executing [p4 changes -m 1 -s submitted #{path}...]:\n #{e}") }

        rescue Exception => e

          logger.error("Error executing [p4 changes -m 1 -s submitted #{path}...]: #{e.message}")

        ensure

          p4.disconnect

        end

        # Returns an Entries collection

        # or nil if the given path doesn't exist in the repository

        def entries(path=nil, identifier=nil)

          path = (path.blank? ? "#{fix_url(url)}" : "#{fix_url(url)}#{relative_path(path)}")

          path = fix_url(path)

          p4 = P4.new

          begin

            entries = Entries.new

            begin

              p4.port = root_url

              p4.user = @login

              if (!@password.nil? && !@password.empty?)

                p4.password = @password

              end

              p4.connect

              p4.run_dirs( path + "*" ).each do

                |directory|

                directory = directory[ "dir" ]

                dirname = entry_name(directory)

                dirpath = relative_path(directory)

                h = p4.run_changes("-m 1 -s submitted",  directory + "/...").shift

                change = P4Change.new( h )

                entries << Entry.new({:name => dirname,

                    :path => dirpath,

                    :kind => 'dir',

                    :size => nil,

                    :lastrev => Revision.new({

                        :identifier => change.change,

                        :time => change.time,

                        :author => change.user.downcase

                      })

                  })

              end

            rescue P4Exception

              p4.errors.each { |e| logger.error("Error executing [p4 dirs #{path}*]:\n #{e}") }

            end

            begin

            #run filelog to get files for change

            p4.run_filelog( path + "*" ).each do

                |depotfile|

                # newest one

                rev = depotfile.revisions[0]

                pathname = relative_path(rev.depot_file)

                name = entry_name(rev.depot_file)

                # iff deleted skip it

                next if rev.action == "delete"

                entries << Entry.new({:name => name,

                    :path => pathname,

                    :kind => 'file',

                    :size => rev.filesize.to_i,

                    :lastrev => Revision.new({

                        :identifier => rev.change,

                        :time => rev.time,

                        :author => (rev.user ? rev.user.downcase : "")

                      })

                  })

              end

            rescue P4Exception

              p4.errors.each { |e| logger.error("Error executing [p4 filelog #{path}*]:\n #{e}") }

            end

          rescue Exception => e

            logger.error("Error creating entries: #{e.message}")

          ensure

            p4.disconnect

          end

          logger.debug("Found #{entries.size} entries in the repository for #{path}") if logger && logger.debug?

          entries.sort_by_name

        end

        def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})

          path = (path.blank? ? "#{fix_url(url)}" : "#{fix_url(url)}#{relative_path(path)}")

          p4 = P4.new

          begin

            revisions = Revisions.new

            p4.port = root_url

            p4.user = @login

            if (!@password.nil? && !@password.empty?)

              p4.password = @password

            end

            p4.connect

            identifier_from = (identifier_from and identifier_from.to_i > 0) ? identifier_from.to_i : ""

            identifier_to = (identifier_to and identifier_to.to_i > 0) ? identifier_to.to_i : 1

            opts = "-m 10 -s submitted"

            spec = path

            if identifier_from.is_a?(Integer)

              changecount = identifier_from - identifier_to

              opts = "-m " + changecount.to_s + " -s submitted"

              spec = path + "...@#{identifier_from}"

            end

            changenum = nil

            p4.run_changes("-L", opts, spec).each do

              |changehash|

              # describe the change

              changenum = changehash[ "change" ]

              describehash = p4.run("describe", "-s", changenum).shift

              # create the change

              change = P4Change.new( describehash )

              # load files into the change

              if ( describehash.has_key?( "depotFile" ) )

                describehash[ "depotFile" ].each_index do

                  |i|

                  name = describehash[ "depotFile"	][ i ]

                  type = describehash[ "type"	][ i ]

                  rev	 = describehash[ "rev" ][ i ]

                  act	 = describehash[ "action"	][ i ]

                  # create change file

                  p4chg = P4ChangeFile.new(name)

                  p4chg.type = type

                  p4chg.revno = rev.to_i

                  p4chg.action = act

                  # get head revision if needed

                  if ( p4chg.revno > 1 )

                    flog = p4.run_filelog( p4chg.depot_file ).shift

                    p4chg.head = flog.revisions.length

                  end

                  change.files.push( p4chg )

                end

              end

              revisions << Revision.new({:identifier => change.change,

                  :author => change.user.downcase,

                  :time => change.time,

                  :message => change.desc,

                  :paths => change.files

                })

            end

          rescue P4Exception

            p4.errors.each { |e| logger.error("Error executing [p4 describe -s #{changenum}]:\n #{e}") }

          rescue Exception => e

            logger.error("Error executing [p4 describe -s #{changenum}]: #{e.message}")

          ensure

            p4.disconnect

          end

          # return

          revisions

        end

        def diff(path, identifier_from, identifier_to=nil, type="inline")

          spec1 = nil

          spec2 = nil

          diff = []

          begin

            fixedpath = (path.blank? ? "#{fix_url(url)}" : "#{fix_url(url)}#{relative_path(path)}")

            if identifier_to.nil?

              if(path.empty?)

                # this handles when we have NO path..meaning ALL paths in the 'identifier_from' change

                p4 = P4.new

                begin

                  p4.port = root_url

                  p4.user = @login

                  if (!@password.nil? && !@password.empty?)

                    p4.password = @password

                  end

                  p4.connect

                  describehash = p4.run("describe", "-s", identifier_from).shift

                  change = P4Change.new( describehash )

                  change.load_files( describehash )

                  change.files.each do

                    |p4dfile|

                    # the specs to diff

                    spec1 = p4dfile.depot_file + '#' + p4dfile.revno.to_s

                    spec2 = p4dfile.depot_file + '#' + (p4dfile.revno.to_i <= 2 ? 1 : p4dfile.revno.to_i-1).to_s

                    # run diff

                    diff += p4diff( spec1, spec2, "@#{identifier_from}")

                  end

                rescue P4Exception

                  p4.errors.each { |e| logger.error("Error executing [p4 describe -s #{identifier_from}]:\n #{e}") }

                rescue Exception => e

                  logger.error("Error executing [p4 describe -s #{identifier_from}]: #{e.message}")

                ensure

                  p4.disconnect

                end

              else

                # this handles when we have a path..meaning just one path in the 'identifier_from' change

                # the specs to diff

                spec1 = fixedpath + ((identifier_from.to_i <= 2) ? "@#{identifier_from}" : "@#{identifier_from.to_i-1}")

                spec2 = fixedpath + "@#{identifier_from}"

                # run diff

                diff += p4diff( spec1, spec2, identifier_from )

              end

            elsif !identifier_to.nil?

              # this handles when we have a path and a 'identifier_to' change number..meaning change-to-change

              identifier_from = (identifier_from and identifier_from.to_i > 0) ? ("@#{identifier_from}") : ""

              identifier_to = (identifier_to and identifier_to.to_i > 0) ? ("@#{identifier_to}") : ""

              # the specs to diff

              spec2 = fixedpath + identifier_from

              spec1 = fixedpath + identifier_to

              # run diff

              diff += p4diff( spec1, spec2, identifier_from )

            end

          rescue Exception => e

            logger.error("Error performing diff on #{spec1} #{spec2}]: #{e.message}")

          end

          diff

        end

        def p4diff(spec1, spec2, change)

          diff = []

          p4 = P4.new

          begin

            # untagged execution

            p4.tagged = false

            p4.port = root_url

            p4.user = @login

            if (!@password.nil? && !@password.empty?)

              p4.password = @password

            end

            p4.connect

            p4.run("diff2", "-u", spec1, spec2).each do

              |elem|

              # normalize to '\n'

              elem.gsub(/\r\n?/, "\n");

              elem.split("\n").each do

                |line|

                # look for file identifier..if found replace date/time with change#

                diff << line.gsub(/\d{4}\/\d{2}\/\d{2}\s+\d{2}:\d{2}:\d{2}/, "#{change}")

              end

            end

          rescue P4Exception

            p4.errors.each { |e| logger.error("Error executing [p4 diff2 -u #{spec1} #{spec2}]:\n #{e}") }

          rescue Exception => e

            logger.error("Error executing [p4 diff2 -u #{spec1} #{spec2}]: #{e.message}")

          ensure

            p4.disconnect

          end

          diff

        end

        def cat(path, identifier=nil)

          path = (path.blank? ? "#{fix_url(url)}" : "#{fix_url(url)}#{relative_path(path)}")

          cat = nil

          p4 = P4.new

          begin

            # untagged execution

            p4.tagged = false

            p4.port = root_url

            p4.user = @login

            if (!@password.nil? && !@password.empty?)

              p4.password = @password

            end

            p4.connect

            identifier = (identifier and identifier.to_i > 0) ? ("@#{identifier}") : ""

            spec = path + identifier

            cat = p4.run_print("-q", spec)

            cat = cat.to_s

          rescue P4Exception

            p4.errors.each { |e| logger.error("Error executing [p4 print -q #{spec}]:\n #{e}") }

          rescue Exception => e

            logger.error("Error executing [p4 print -q #{spec}]: #{e.message}")

          ensure

            p4.disconnect

          end

          cat

        end

        # Returns just the name of the entry from the depot spec

        def entry_name(path)

          @entry_name = ( path.include?('/') ? path[1+path.rindex('/')..-1] : path )

        end

        # Returns a path relative to the depotspec(url) of the repository

        def relative_path(path)

          @relative_path = path.gsub(fix_url(url), '')

        end

        # Make sure there is a begining '//' and an ending '/', also remove trailing ...

        def fix_url(path)

          path = (path.starts_with?("//") ? path : "//" + path)

          path = path.gsub('/...', '')

          @fix_url = (path.ends_with?("/") ? path : path + "/")

        end

      end

      class P4Change

        # Constructor. Pass the hash returned by P4#run_describe( "-s" ) in

        # tagged mode.

        def initialize( hash )

          @change = hash[ "change"  ]

          @user	= hash[ "user"    ]

          @client = hash[ "client"  ]

          @desc	= hash[ "desc"    ]

          @time 	= Time.at( hash[ "time" ].to_i )

          @status	= hash[ "status"  ]

          @files	= Array.new

          @jobs = Hash.new

          if ( hash.has_key?( "job" ) )

            hash[ "job" ].each_index do

              |i|

              job 	= hash[ "job" 	  ][ i ]

              status	= hash[ "jobstat" ][ i ]

              @jobs[ job ] = status

            end

          end

        end

        attr_reader :change, :user, :client, :desc, :time, :status, :files, :jobs

        attr_writer :files

        # Shorthand iterator for looking at the files in the change

        def each_file( &block )

          @files.each { |f| yield( f ) }

        end

        # Shorthand iterator for looking at the jobs fixed by the change

        def each_job( &block )

          @jobs.each { |j| yield( j ) }

        end

        def load_files( hash )

          if ( hash.has_key?( "depotFile" ) )

            hash[ "depotFile" ].each_index do

              |i|

              name = hash[ "depotFile"	][ i ]

              type = hash[ "type"	][ i ]

              rev	 = hash[ "rev" ][ i ]

              act	 = hash[ "action"	][ i ]

              # create change file

              p4chg = P4ChangeFile.new(name)

              p4chg.type = type

              p4chg.revno = rev.to_i

              p4chg.action = act

              @files.push( p4chg )

            end

          end

        end

      end

      class P4ChangeFile

        def initialize( depotfile )

          @depot_file = depotfile

          @revno

          @type

          @action

          @head = 1

        end

        attr_reader :depot_file

        attr_accessor :revno, :type, :head, :action

      end

    end

  end

end