p4tools 0.1.1

data/Gemfile

@@ -0,0 +1,5 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem 'rautomation', '0.14.1'
+gem 'P4Ruby-mingwx86', '~> 2014.1'

data/Gemfile.lock

@@ -0,0 +1,14 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    P4Ruby-mingwx86 (2014.1)
+    ffi (1.9.0-x86-mingw32)
+    rautomation (0.14.1)
+      ffi (= 1.9.0)
+
+PLATFORMS
+  x86-mingw32
+
+DEPENDENCIES
+  P4Ruby-mingwx86 (~> 2014.1)
+  rautomation (= 0.14.1)

data/bin/p4tools

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'p4_tools'
+
+P4Tools.run(ARGV)

data/lib/commands/move.rb

@@ -0,0 +1,80 @@
+module P4Tools
+  class Move
+    include CommandUtils
+
+    def self.run(arguments)
+      Move.new(arguments).run
+    end
+
+    def self.set_options(opts)
+      opts.set do
+        help 'Move a pending changelist from one workspace to another, optionally shelve and delete them before.'
+        help 'The changelist need to be empty to move(only shelved files allowed)!'
+        help ''
+        help 'Options:'
+        help ''
+        arg :workspace, "Name of the new workspace. If 'switch' option provided, this will be ignored.", :short => '-w', :type => :string
+        arg :switch, 'Switch between workspaces, only 2 workspace name allowed.', :short => '-i', :type => :strings
+        arg :changelist, 'Changelist number to move.', :short => '-c', :type => :int, :required => true
+        arg :revert, 'Revert before move.', :short => '-r'
+        arg :shelve, 'Shelve before move.', :short => '-s'
+      end
+    end
+
+
+    def initialize(args)
+      @args = args
+      @p4 = P4Tools.connection
+      @changelist = @args[:changelist]
+      @is_not_empty = !empty_changelist?(@changelist)
+    end
+
+    def run
+      shelve
+      revert
+
+      changelist_spec = @p4.fetch_change(@changelist)
+      changelist_spec['Client'] = get_workspace(changelist_spec)
+      @p4.save_change(changelist_spec)
+    end
+
+
+    private
+
+    def shelve
+      if @args[:shelve] && @is_not_empty
+        @p4.run_shelve('-f', '-c', @changelist)
+      end
+    end
+
+    def revert
+      if @args[:revert] && @is_not_empty && all_files_shelved?(@changelist, true)
+        @p4.run_revert('-w', '-c', @changelist, '//...')
+      end
+    end
+
+    def get_workspace(changelist_spec)
+      if @args[:switch]
+        current = changelist_spec['Client']
+        workspaces = @args[:switch]
+
+        validate_workspaces(workspaces, current)
+
+        workspaces.delete(current)
+        workspaces.first
+      else
+        @args[:workspace]
+      end
+    end
+
+    def validate_workspaces(workspaces, current)
+      if workspaces.length != 2
+        raise(ArgumentError, 'The switch parameter need to contains 2 workspace names exactly!')
+      end
+
+      unless workspaces.include?(current)
+        raise(ArgumentError, "The switch parameter does not contains the currently active workspace: #{current}!")
+      end
+    end
+  end
+end

data/lib/commands/revert.rb

@@ -0,0 +1,29 @@
+module P4Tools
+  class Revert
+    def self.run(arguments)
+      p4 = P4Tools.connection
+      parameters = []
+      parameters.push('-w') if arguments[:delete_added_files]
+
+      if arguments[:changelist]
+        parameters.push('-c').push(arguments[:changelist]).push('//...')
+      else
+        parameters.push(*arguments[:files])
+      end
+
+      p4.run_revert(parameters)
+    end
+
+    def self.set_options(opts)
+      opts.set do
+        help 'Revert the given files or all file in the changelist and optionally delete the added files from the disk too.'
+        help ''
+        help 'Options:'
+        help ''
+        arg :delete_added_files, 'Delete added files.', :short => '-d'
+        arg :changelist, 'Changelist number.', :short => '-c', :type => :int
+        arg :files, 'The absolute path of the files to delete.', :short => '-f', :type => :strings
+      end
+    end
+  end
+end

data/lib/commands/shelve.rb

@@ -0,0 +1,53 @@
+module P4Tools
+  class Shelve
+    include CommandUtils
+
+    def self.run(arguments)
+      Shelve.new(arguments).run
+    end
+
+    def self.set_options(opts)
+      opts.set do
+        help 'Shelve all files to the given changelist or create a new one if not provided.'
+        help ''
+        help 'Options:'
+        help ''
+        arg :files, 'The absolute path of the files to shelve.', :short => '-f', :type => :strings, :required => true
+        arg :changelist, 'The changelist number to shelve, if not given, then create a new one.', :short => '-c', :type => :int
+      end
+    end
+
+
+    def initialize(args)
+      @files = args[:files]
+      @shelve_changelist = args[:changelist] || create_new_changelist("Shelve container for files:\n\n#{@files.join("\n")}")
+      @p4 = P4Tools.connection
+    end
+
+    def run
+      current_changelist = get_current_changelist
+
+      move_to(@shelve_changelist)
+      shelve
+      move_to(current_changelist)
+    end
+
+
+    private
+
+    def get_current_changelist
+      file_info = @p4.run_opened('-u', @p4.user, @files.first).first
+      file_info['change']
+    end
+
+    def shelve
+      @p4.run_shelve('-f', '-c', @shelve_changelist, @files)
+    end
+
+    def move_to(changelist)
+      @p4.run_reopen('-c', changelist, @files)
+    end
+
+  end
+
+end

data/lib/config/README

@@ -0,0 +1 @@
+Put your 'p4.ini' file to this folder to load automatically during script run.

data/lib/p4_tools.rb

@@ -0,0 +1,88 @@
+require 'P4'
+require_relative 'p4tools/environment'
+require_relative 'p4tools/p4_delegate'
+require_relative 'p4tools/utils/utils'
+require_relative 'p4tools/utils/command_utils'
+require_relative 'p4tools/utils/window_manager'
+require_relative 'p4tools/parsers/command_parser'
+require_relative 'p4tools/parsers/trollop_custom'
+require_relative 'p4tools/parsers/command_options'
+require_relative 'p4tools/parsers/command_entry'
+
+module P4Tools
+
+  # @param [Array<String>] args
+  # @return [void]
+  def self.run(args=ARGV)
+    entries = CommandParser.new(args).parse
+    global_arguments = entries.shift.arguments
+
+    setup_perforce_config(global_arguments[:p4config])
+    create_perforce_connection
+
+    begin
+      run_commands(entries)
+      WindowManager.refresh if global_arguments[:refresh]
+    ensure
+      @p4.disconnect
+    end
+  end
+
+  # @param [CommandOptions] opts
+  # @return [void]
+  def self.set_options(opts)
+    opts.set do
+      help 'Simple command line tool to run custom perforce actions through subcommands.'
+      help 'For more information, please check the help page of the command.'
+      help ''
+      help "Available subcommands are:\n  #{SUB_COMMANDS.join("\n  ")}"
+      help ''
+      help 'Global options:'
+      help ''
+      arg :refresh, 'Send a refresh keystroke(F5) to the Visual Client.', :short => '-r'
+      arg :p4config, 'Absolute path of the P4CONFIG file.', :short => '-p', :type => :string
+    end
+  end
+
+  # @return [P4]
+  def self.connection
+    @p4
+  end
+
+
+  class << self
+    private
+
+    # @return [void]
+    def create_perforce_connection
+      @p4 = P4.new
+      @p4.connect
+    end
+
+    # @param [Hash<Module, Hash<Symbol, Object>>] commands
+    # @return [void]
+    def run_commands(entries)
+      entries.each do |entry|
+        command = entry.command
+        arguments = entry.arguments
+
+        command.run(arguments)
+      end
+    end
+
+    # @param [String] config_path
+    # @return [void]
+    def setup_perforce_config(config_path)
+      if config_path
+        ENV['P4CONFIG'] = config_path
+      elsif ENV['P4CONFIG'].nil?
+        ENV['P4CONFIG'] = CONFIG_ROOT + '/p4.ini'
+      end
+    end
+  end
+
+
+  if __FILE__ == $PROGRAM_NAME
+    run
+  end
+end

data/lib/p4tools/environment.rb

@@ -0,0 +1,18 @@
+# The absolute path of the main script(p4_tools.rb)
+ROOT = File.expand_path('..', File.dirname(__FILE__))
+# The absolute path of the folder which contains the command files
+COMMANDS_ROOT = ROOT + '/commands'
+# The absolute path of the folder which contains the custom command files
+CUSTOM_COMMANDS_ROOT = ROOT + '/commands/custom'
+# The absolute path of the folder which contains the configuration files
+CONFIG_ROOT = ROOT + '/config'
+# Special command to simply delegate everything to p4.run
+P4_COMMAND = 'p4'
+# Array of command names, read from the COMMAND_ROOT folder
+SUB_COMMANDS = Dir[COMMANDS_ROOT + '/*.rb'].collect { |file|
+                File.basename(file, '.rb')
+              }
+SUB_COMMANDS.push(P4_COMMAND)
+
+
+$LOAD_PATH.unshift(CUSTOM_COMMANDS_ROOT, COMMANDS_ROOT)

data/lib/p4tools/p4_delegate.rb

@@ -0,0 +1,13 @@
+module P4Tools
+  class P4Delegate
+
+    def self.run(arguments)
+      @p4 = P4Tools.connection
+      @p4.run(arguments[:raw])
+    end
+
+    def self.set_options(opts)
+    end
+
+  end
+end

data/lib/p4tools/parsers/command_entry.rb

@@ -0,0 +1,11 @@
+module P4Tools
+  class CommandEntry
+    attr_reader :command, :arguments
+
+    def initialize(command, arguments)
+      @command = command
+      @arguments = arguments
+    end
+
+  end
+end

data/lib/p4tools/parsers/command_options.rb

@@ -0,0 +1,32 @@
+module P4Tools
+  class CommandOptions
+
+    attr_reader :show_help
+
+    def initialize(parser)
+      @parser = parser
+      @show_help = true
+    end
+
+    # @param [String] text
+    def help(text)
+      @parser.banner(text)
+    end
+
+    # @param [Symbol] name
+    # @param [String] desc
+    # @param [Hash<Symbol, Object>] options
+    def arg(name, desc='', options={})
+      @parser.opt(name, desc, options)
+    end
+
+    def allow_empty_args
+      @show_help = false
+    end
+
+    def set(&opts)
+      self.instance_eval &opts
+    end
+
+  end
+end

data/lib/p4tools/parsers/command_parser.rb

@@ -0,0 +1,78 @@
+module P4Tools
+  class CommandParser
+
+    # @param [Array<String>] args
+    def initialize(args)
+      @raw_args = args
+      @parsed_args = []
+    end
+
+    # @return [Array<CommandEntry>]
+    def parse
+      parse_global_arguments
+      parse_commands
+
+      @parsed_args
+    end
+
+    private
+
+    # @return [void]
+    def parse_global_arguments
+      entry = CommandEntry.new(P4Tools, parse_arguments(P4Tools))
+      @parsed_args.push(entry)
+    end
+
+    # @return [void]
+    def parse_commands
+      while command = @raw_args.shift
+        if command == P4_COMMAND
+          entry = CommandEntry.new(P4Delegate, parse_p4_arguments)
+          @parsed_args.push(entry)
+        else
+          command_module = load_module_for_command(command)
+          entry = CommandEntry.new(command_module, parse_arguments(command_module))
+          @parsed_args.push(entry)
+        end
+      end
+    end
+
+    # @param [Module] command_module
+    # @return [Hash<Symbol, Object>]
+    def parse_arguments(command_module)
+      parser = Trollop::Parser.new
+      options = CommandOptions.new(parser)
+
+      command_module.set_options(options)
+      parser.stop_on SUB_COMMANDS
+
+      Trollop.with_standard_exception_handling(parser) {
+        raise Trollop::HelpNeeded if ARGV.empty? && options.show_help
+        parser.parse @raw_args
+      }
+    end
+
+    def parse_p4_arguments
+      args = []
+      i = 0
+      current = @raw_args[i]
+
+      begin
+        i += 1
+        args.push(current)
+        current = @raw_args[i]
+      end while !SUB_COMMANDS.include?(current) && i < @raw_args.length
+
+      @raw_args = @raw_args[i .. -1]
+      {:raw => args}
+    end
+
+    # @param [String] command
+    # @return [Module]
+    def load_module_for_command(command)
+      require command
+      P4Tools.const_get(Utils.classify(command))
+    end
+
+  end
+end