p4util 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca08621e3878ebd6ab034b9046f0ed94425ad978
-  data.tar.gz: 5be2227361463716cd9b0870eee7b2769a079f50
+  metadata.gz: 45a2fa04d57ee5b6aca04b509acc1705dffb1f35
+  data.tar.gz: 0561143880e7350548859aa309f2c499d3ac3d70
 SHA512:
-  metadata.gz: 8ee68971ece495b7f3d3f7695e666e3b443d08a24e26c4d8a90b1a6a83df83d786c024c1d3ab12cb7980812028afa298508fae54628411d572a33e742348b347
-  data.tar.gz: b2f844d7ba44aabffadbdbdcd317d623d0e9b671633de45290f784ad466549bd0aa6949b14cd64ba1f6523db658e328f3ebde00b209323c1a175b39ca302a16a
+  metadata.gz: 1c01e49961c05d2fe79b25c504e7748349e014407ef0975c6f1dc1434b24e02a344512d840758f68601fcb3dcd434769bcd2281eb36ed5e700de064a25039292
+  data.tar.gz: d4e3bc148311ae182387bfe3db5541d10e5a1dae0c26fe8d8bd12a432f8749d181adfcbfc5ac27b766b18b0d38b07645f15bfd0e22267eec613254c63d8f1be2

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in p4_util.gemspec
+# Specify your gem's dependencies in p4util.gemspec
 gemspec

data/README.md

@@ -1,6 +1,20 @@
-# P4util
+# p4util - common p4 scripting tasks for ruby projects
+
+When building any kind of tool that uses Perforce underneath, it's pretty common
+to want a few capabilities:
+
+* Download different versions of p4, p4d, and the C++ API
+* Initialize up a consistent starting environment of p4d
+
+This is a binary script and set of rake tasks that allows this. 
+
+
+## Usage
+
+After installation, `p4util help` will list available commands, and 
+`p4util help [command]` will list instructions. Some commands, like `p4util init`
+are quite extensive, and should be used as the reference.
 
-TODO: Write a gem description
 
 ## Installation
 
@@ -18,14 +32,11 @@ Or install it yourself as:
 
     $ gem install p4util
 
-## Usage
 
-TODO: Write usage instructions here
+## Changes
 
-## Contributing
+* 0.1.0: Added `p4util init` command that can do some common p4d configurations,
+  like setting unicode and security settings, along with users and basic 
+  adds and edits of files.
 
-1. Fork it ( https://github.com/[my-github-username]/p4util/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+* 0.0.1-0.0.3: Basic download capabilities

data/Rakefile

@@ -1,2 +1,7 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rdoc/task'
 
+RDoc::Task.new do |rdoc|
+  rdoc.main = 'README.md'
+  rdoc.rdoc_files.include('README.md', 'lib/**/*.rb')
+end

data/bin/p4util

@@ -4,6 +4,6 @@
 #
 lib_path = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib_path)
-require 'p4_util'
+require 'p4util'
 
 P4Util::run ARGV

data/lib/commands/download.rb

@@ -5,6 +5,8 @@ require 'net/ftp'
 
 module Commands
 
+  # TODO the p4ruby extconf.rb file mechanism has some logic to search the ftp
+  # site for things. We might also want to use HTTP
   def Commands.download(options=nil)
     version = 'r14.2'
     binary = 'p4d'
@@ -25,6 +27,8 @@ module Commands
     end
 
     case binary
+      when 'p4'
+        download_p4_via_ftp(version)
       when 'p4d'
         download_p4d_via_ftp(version)
       when 'p4api'
@@ -36,15 +40,16 @@ module Commands
 
   def Commands.print_download_help
     puts <<-END.gsub(/^ {6}/, '')
-      p4util download [p4d|p4api]
+      p4util download [p4|p4d|p4api]
 
       Downloads one of the following utilities (in lieu of an installer) into
       a local work/ directory.
 
+      * p4
       * p4d
       * p4api
 
-      Will default to the latest release unless you don't know what that is.
+      Will default to the r14.2 release.
 
       Options:
 
@@ -55,6 +60,14 @@ module Commands
 
   private
 
+  def Commands.download_p4_via_ftp(version)
+    download_via_ftp(version, OsUtil.p4_executable, OsUtil.p4_path)
+
+    if !File.executable?(OsUtil.p4_path)
+      File.chmod(0755, OsUtil.p4_path)
+    end
+  end
+
   def Commands.download_p4d_via_ftp(version)
     download_via_ftp(version, OsUtil.p4d_executable, OsUtil.p4d_path)
 

data/lib/commands/init/changelist_model.rb

@@ -0,0 +1,101 @@
+require 'commands/init/init_model'
+require 'commands/init/p4_helpers'
+require 'fileutils'
+
+module Commands
+  module Init
+
+    class ChangelistModel < InitModel
+      include Commands::Init::P4Helpers
+
+      inheritable_attributes :description, :adds, :edits, :user
+
+      # Please make this descriptive
+      @description = 'Init changelist'
+
+      # An array of 'file definitions'
+      @adds = []
+
+      # An array of 'file definitions' expected to already exist
+      @edits = []
+
+      # The user we should operate as if you don't want to do this as the super
+      # user
+      @user = nil
+
+      #========================================================================
+      # Internal implementation
+      #========================================================================
+
+      def self.abstract
+        true
+      end
+
+      attr_accessor :description, :adds, :edits, :user
+
+      def initialize
+        @description = self.class.description
+        @adds = self.class.adds
+        @edits = self.class.edits
+        @user = self.class.user
+      end
+
+      def execute(p4, models, super_user)
+        # Set up our options with a user context if specified by searching the
+        # defined models.
+        options = {:p4 => p4}
+        if user
+          model = models.find {|m| m.class < UserModel && m.login == user }
+          options[:user] = model.login
+          options[:password] = model.password
+          options[:olduser] = super_user.login
+          options[:oldpass] = super_user.password
+        end
+
+        # Define the logic of what the changelist model really does: make adds
+        # and edits for the most part
+        open_client(options) do |client_path, name|
+
+          change_spec = p4.fetch_change
+          change_spec._description = description
+          results = p4.save_change(change_spec)
+          change_id = results[0].gsub(/^Change (\d+) created./, '\1')
+
+          @adds.each do |add|
+            add_path = File.join(client_path, add.path)
+            dir = File.dirname(add_path)
+            if dir && !dir.empty?
+              if !Dir.exist?(dir)
+                FileUtils.mkpath(dir)
+              end
+            end
+            if add.content
+              IO.write(add_path, add.content)
+            elsif add.local_path
+              FileUtils.copy(add.local_path, add_path)
+            end
+            p4.run_add('-c', change_id, add_path)
+          end
+
+          @edits.each do |edit|
+            edit_path = File.join(client_path, edit.path)
+            p4.run_edit('-c', change_id, edit_path)
+
+            if edit.content
+              IO.write(edit_path, edit.content)
+            else
+              FileUtils.copy(edit.local_path, edit_path)
+            end
+          end
+
+          p4.run_submit('-c', change_id)
+        end
+      end
+
+      private
+
+      # do stuff
+    end
+
+  end
+end

data/lib/commands/init/file_definition.rb

@@ -0,0 +1,16 @@
+
+module Commands
+  module Init
+
+    class FileDefinition
+      attr_accessor :path, :content, :local_path
+
+      # Options should indicate :content or :local_path, but not both
+      def initialize(options)
+        @path = options[:path]
+        @content = options[:content] if options.key?(:content)
+        @local_path = options[:local_path] if options.key?(:local_path)
+      end
+    end
+  end
+end

data/lib/commands/init/init_model.rb

@@ -0,0 +1,95 @@
+require 'P4'
+
+module Commands
+  module Init
+    # Base class of 'initializers'.
+    #
+    # This actually acts more as a registry of defined classes.
+    class InitModel
+      # Child classes should define this number greater than one. 0 should be
+      # reserved for a single system settings instance.
+      def rank
+        1
+      end
+
+      # It's likely that the main child class will handle overriding this method.
+      # Our default method does nothing.
+      def execute(p4)
+      end
+
+      #========================================================================
+      # Ok, the real business starts here.
+      #
+      # Don't even think about overriding the following rules
+      #========================================================================
+
+      class << self
+        attr_accessor :model_classes
+      end
+
+      # The registered set of non-abstract model classes.
+      #
+      @model_classes = []
+
+      @inheritable_attributes ||= [:inheritable_attributes]
+
+      # A lot of our settings are actually class instance variables, which
+      # can be overridden. This allows the child classes that depend on these
+      # values to define what they are.
+      def self.inheritable_attributes(*args)
+        @inheritable_attributes += args
+        args.each do |arg|
+          class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
+        end
+        @inheritable_attributes
+      end
+
+      def self.inherited(subclass)
+        # Copy 'down' any inheritable attribute to the new child class
+        @inheritable_attributes.each do |inheritable_attribute|
+          instance_var = "@#{inheritable_attribute}"
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+        end
+
+        if subclass.respond_to?(:abstract) && subclass.send(:abstract)
+          InitModel.model_classes.push(subclass)
+        end
+      end
+
+      def self.run(p4port)
+        system_settings = nil
+        super_user = nil
+        models = []
+
+        InitModel.model_classes.each do |model|
+          if model <= DefaultSuperUser
+            # do nothing
+          elsif model <= SystemSettingsModel
+            system_settings = model.new
+          elsif !super_user and model <= UserModel and model.super
+            super_user = model.new
+          else
+            models << model.new
+          end
+        end
+
+        if !super_user
+          super_user = DefaultSuperUser.new
+        end
+
+        models.sort! { |a, b| a.rank <=> b.rank }
+
+        p4 = P4.new
+        p4.port = p4port
+        p4.connect
+        p4.exception_level = P4::RAISE_ERRORS
+
+        system_settings.execute(p4, super_user)
+
+        models.each { |m| m.execute(p4, models, super_user) }
+      end
+    end
+  end
+end

data/lib/commands/init/p4_helpers.rb

@@ -0,0 +1,75 @@
+
+require 'conventions'
+require 'random_util'
+
+module Commands
+  module Init
+    module P4Helpers
+
+      # Intended to be a block helper that creates a 'temporary client'
+      #
+      # Your block should take the client name and path.
+      #
+      # Example:
+      #
+      #     open_client(p4) do |path, name|
+      #       puts "my client #{name}'s root is #{path}"
+      #     end
+      def open_client(options)
+        p4 = options[:p4]
+
+        # Switch user only if specified
+        user = nil
+        password = nil
+        olduser = nil
+        oldpass = nil
+        if (options[:user])
+          user = options[:user]
+          password = options[:password] if options.key?(:password)
+          olduser = options[:olduser]
+          oldpass = options[:oldpass] if options.key?(:oldpass)
+          p4.user = user
+          p4.password = password
+          p4.run_login if password
+        end
+
+        name = RandomUtil.randstr
+        dir = File.join(Conventions.client_root_dir, name)
+
+        if !Dir.exist?(dir)
+          FileUtils.mkpath(dir)
+        end
+
+        spec = p4.fetch_client
+        spec._root = dir
+        spec._client = name
+        spec._description = 'p4util init temp client'
+        spec._view = ["//depot/... //#{name}/depot/..."]
+
+        p4.save_client(spec)
+
+        p4.client = name
+
+        p4.run_sync('-f', '//...')
+
+        if block_given?
+          yield dir, name
+        else
+          return dir, name
+        end
+      ensure
+        if block_given?
+          if (user)
+            p4.user = olduser
+            p4.password = oldpass
+            p4.run_login if oldpass
+          end
+
+          p4.run_client('-d', '-f', name)
+          p4.client = 'invalid'
+          FileUtils.rmtree(dir)
+        end
+      end
+    end
+  end
+end

data/lib/commands/init/system_settings_model.rb

@@ -0,0 +1,120 @@
+
+require 'commands'
+require 'commands/init/init_model'
+
+module Commands
+  module Init
+
+    class SystemSettingsModel < InitModel
+      inheritable_attributes :unicode, :security_level, :configure_settings
+
+      # Pick some normal defaults
+
+      # This basically will upgrade the DB before anything happens to unicode
+      # mode. The default is false, though you probably should use true for
+      # most default 'setups' these days.
+      @unicode = false
+
+      # The security level is set basically as the first major setting, before
+      # most users are generated, to avoid password mayhem
+      @security_level = 0
+
+      # These basically map to 'p4 configure set #{key}=#{value}'
+      @configure_settings = {}
+
+      #========================================================================
+      # Internal implementation - don't mess with this
+      #========================================================================
+
+      def rank
+        0
+      end
+
+      def self.abstract
+        true
+      end
+
+      attr_reader :unicode, :security_level, :configure_settings
+
+      def initialize
+        @unicode = self.class.unicode
+        @security_level = self.class.security_level
+        @configure_settings = self.class.configure_settings
+      end
+
+      # If the security level is > 0, we generate the super_user first, change
+      # security, then reset the super's password. The p4 connection is
+      # established here with whatever credentials we end up with the super
+      # user as.
+      def execute(p4, super_user)
+        set_unicode_mode(p4)
+        set_security_and_super_user(p4, super_user)
+        create_default_protections(p4)
+      end
+
+      private
+
+      def set_unicode_mode(p4)
+        if unicode
+          p4.disconnect
+
+          # Halt any exiting perforce server
+          Commands.kill
+
+          # Execute the upgrade of the p4d instance
+          Commands.unicode_upgrade
+
+          # Restart: this assumes the cwd of the init call is the same as the
+          # 'start' call. This is a pretty safe assumption, since our .init
+          # function will call start if it's not running.
+          Commands.start
+
+          while !Commands.p4d_running?
+            sleep 0.2
+          end
+
+          # I'm not sure this should be anything else for the purposes of
+          # initialization
+          p4.charset = 'auto'
+
+          p4.connect
+        end
+      end
+
+      def set_security_and_super_user(p4, super_user)
+        # update security mode if needed
+        if security_level > 0
+          # On some security levels, you *must* reset passwords when updating
+          # even if the base password is strong.
+          super_pwd = super_user.password
+          super_user.password = ''
+          super_user.execute(p4)
+
+          p4.run('configure', 'set', "security=#{security_level}")
+
+          p4.user = super_user.login
+          p4.password = super_user.password
+
+          p4.run_password(super_user.password, super_pwd)
+          super_user.password = super_pwd
+
+          p4.password = super_user.password
+          p4.run_login
+        else
+          # Just create the user
+          super_user.execute(p4)
+          if super_user.password
+            p4.password = super_user.password
+            p4.run_login
+          end
+        end
+      end
+
+      def create_default_protections(p4)
+        # This actually will establish the defaults with our super user as the
+        # only entry
+        results = p4.run_protect('-o')
+      end
+    end
+  end
+end

data/lib/commands/init/user_model.rb

@@ -0,0 +1,84 @@
+require 'commands/init/init_model'
+
+module Commands
+  module Init
+
+    class UserModel < InitModel
+      inheritable_attributes :login, :full_name, :password, :email, :super
+
+      @login = nil
+      @full_name = nil
+      @password = nil
+      @email = nil
+      # Set this to true if you want the user to be our 'super user'. We'll
+      # generally need one of these for each init step. We will make sure a
+      # protections entry for this user exists
+      @super = false
+
+      #========================================================================
+      # Internal implementation - don't mess with this
+      #========================================================================
+
+      def self.abstract
+        true
+      end
+
+      attr_accessor :login, :password
+
+      def initialize
+        @login = self.class.login
+        @full_name = self.class.full_name
+        @password = self.class.password
+        @email = self.class.email
+        @super = self.class.super
+      end
+
+      def email
+        @email || "#{login}@example.com"
+      end
+
+      def full_name
+        @full_name || login
+      end
+
+      def super?
+        @super
+      end
+
+      def to_s
+        "UserModel: login=#{login} email=#{email} full_name=#{full_name} password=#{password}"
+      end
+
+      def to_spec
+        spec = {
+            'User' => login,
+            'Email' => email,
+            'FullName' => full_name
+        }
+        spec
+      end
+
+      def execute(p4, models=nil, super_user=nil)
+        p4.save_user(to_spec, '-f')
+
+        p4.user = login
+        p4.password = ''
+
+        p4.run_password('', password) if password
+
+        if super_user
+          p4.user = super_user.login
+          p4.password = super_user.password
+        end
+      end
+    end
+
+    class DefaultSuperUser < UserModel
+      @login = 'p4super'
+      @password = 'superuser1A!'
+      @full_name = 'Super User'
+      @super = true
+    end
+
+  end
+end

data/lib/commands/init.rb

@@ -0,0 +1,155 @@
+
+require 'commands/start'
+require 'commands/init/init_model'
+require 'commands/init/changelist_model'
+require 'commands/init/file_definition'
+require 'commands/init/system_settings_model'
+require 'commands/init/user_model'
+
+module Commands
+
+  def Commands.init(options=nil)
+    init_dir = 'p4init'
+    # TODO we may want to allow this to be overridden, though I find this a
+    #      spurious and dangerous use case
+    p4port = '127.0.0.1:1666'
+
+    if options and !options.params.empty?
+      init_dir = options.params.shift
+    end
+
+    if !p4d_running?
+      # The way this works: if you specify any options, like what to download
+      # you must specify the initialization directory.
+      Commands.start(options)
+    end
+
+    initialize_p4d(init_dir, p4port)
+  end
+
+  def Commands.print_init_help
+    puts <<-END.gsub(/^ {6}/, '')
+      p4util init [p4_init_dir]
+
+      Reads definitions in the directory p4_init_dir - by default, just
+      'p4init' - and then calls methods on a p4d instance assumed to be running
+      locally.
+
+      This assumes we are basically starting from scratch. If you have an
+      existing p4d instance, it's highly likely your initialization run will
+      fail. Delete your settings and working area and reset.
+
+      ## Definition Files ##
+
+      Files are Ruby scripts, each basically extending a model class defined
+      by this application.
+
+      Each model type is defined separately later, however, you should have
+      at least one User model that's marked as a super user. If you don't do
+      this, you will always have a super user created with the login 'p4super'
+      and the password 'superuser1A!'.
+
+      ## Execution Order ##
+
+      Each model you define has a 'rank'. Models classes generate instances, and
+      each instance is sorted based on this rank. If you specify no rank, or
+      any rank is equivalent, well, you submit your will to the gods of random.
+
+      The only special model type that does not obey these rules is the
+      SystemSettings model, which is always handled in a very particular order.
+
+
+      ## SystemSettingsModel ##
+
+      Example:
+
+      class MySystemSettings < SystemSettingsModel
+        # These are default settings
+        @unicode = true
+        @security_level = 0
+
+        # By default this is empty, but here's an example of usage
+        @configure_settings = {
+          'dm.keys.hide' => '2'
+        }
+      end
+
+      When `unicode` is enabled, this assumes that the `p4util init` command
+      is run in the *same directory*  as `p4util start`.
+
+
+      ## UserModel ##
+
+      Example of a super user (you need one):
+
+      class SuperUser < UserModel
+        @super = true
+        # if you don't set, we'll just use this for the full_name and email
+        @login = 'super'
+        @password = 'superuser1A'
+      end
+
+      Example of a normal user:
+
+      class JohnDoeUser < UserModel
+        def rank; 100; end
+        @login = 'jdoe'
+        @full_name = 'John Doe'
+        @email = 'jdoe@example.com'
+        @password = 'johndoe1A!'
+      end
+
+      Note that with the super user, you don't really need a rank, but with
+      your other models, it's a good idea. (You can mix when users come and go
+      with other changes.)
+
+
+      ## ChangelistModel ##
+
+      Example of a changelist with an add and edit:
+
+      class Changelist2 < ChangelistModel
+        def rank; 1001 end
+        @description = 'An example add and edit'
+        @user = 'jdoe'
+        @edits = [
+            FileDefinition.new(:path => 'depot/README.txt',
+                           :content => <<-STOP.gsub(/^ {8}/, '')
+              This is an example readme.
+              Added a second line
+            STOP
+            )
+          ]
+          @adds = [
+              FileDefinition.new(:path => 'depot/main/project2/example.txt',
+                                 :local_path => 'p4init/some_text.txt')
+          ]
+      end
+
+      Note that adds an edits are specified with 'FileDefinition' objects. Each
+      file definition instance can define text content inline, or via a
+      'local_path' to a file relative to the current working directory.
+
+      The `@user` is not necessary, but you probably don't want to add everything
+      as your super user, so set this to a UserModel instance that should exist
+      at this point.
+
+    END
+  end
+
+  private
+
+  def Commands.initialize_p4d(init_dir, p4port)
+    # Go through our init_dir, and evaluate each script as if it were defined
+    # in the Commands::Init module.
+    Dir.glob("#{init_dir}/**/*.rb") do |file|
+      contents = IO.read(file)
+      Commands::Init.class_eval(contents, file)
+    end
+
+    # Note that nothing is actually done until this line. This allows classes
+    # to re-define methods and do fancy shit, like, 'oh in security_settings 0
+    # this guy actually doesn't have a password'.
+    Commands::Init::InitModel.run(p4port)
+  end
+end

data/lib/commands/kill.rb

@@ -1,3 +1,4 @@
+require 'commands/util'
 require 'sys/proctable'
 
 include Sys
@@ -5,8 +6,21 @@ include Sys
 module Commands
 
   def Commands.kill(options=nil)
-    ProcTable.ps().find_all{|p| p.comm =~ /p4d/}
-                  .each{|p| Process.kill('TERM', p.pid)}
+    ProcTable.ps().find_all{|p| p.comm =~ /p4d/}.each do |p|
+      begin
+        Process.kill('TERM', p.pid)
+      rescue
+        puts "Problem killing #{p}, ignoring"
+      end
+    end
+
+    is_running = true
+    while is_running
+      is_running = p4d_running?
+      if is_running
+        sleep 0.2
+      end
+    end
   end
 
   def Commands.print_kill_help
@@ -15,8 +29,6 @@ module Commands
 
       Finds local p4d processes and kills them.
 
-      There should be a timeout that will force kill anything that appears stuck.
-
       On unix machines, will probably use `ps -x` and 'p4d', then will send
       SIGTERM signals to each process.
     END

data/lib/commands/start.rb

@@ -1,9 +1,9 @@
 
 module Commands
 
-  def Commands.start(options)
+  def Commands.start(options=nil)
     if !File.exists?(OsUtil.p4d_path)
-      Commands.download
+      Commands.download(options)
     end
     Conventions.init_p4droot_dir
     spawn_p4d
@@ -13,6 +13,14 @@ module Commands
     pid = Process.spawn("#{OsUtil.p4d_path} -r #{Conventions.p4droot_dir} "+
                         "-v server=1 -L #{Conventions.p4d_log_path}")
     Process.detach(pid)
+
+    while !p4d_running?
+      sleep 0.2
+    end
+
+    while !p4d_available?
+      sleep 0.1
+    end
   end
 
   def Commands.print_start_help

data/lib/commands/util.rb

@@ -0,0 +1,27 @@
+require 'sys/proctable'
+require 'P4'
+
+module Commands
+  def Commands.p4d_running?
+    !ProcTable.ps().find_all { |p| p.comm =~ /p4d/ }.empty?
+  end
+
+  def Commands.p4d_available?(port=':1666')
+    begin
+      p4 = P4.new
+      p4.port = port
+      p4.connect
+      p4.disconnect
+      true
+    rescue
+      false
+    end
+  end
+
+  def Commands.unicode_upgrade
+    system("#{OsUtil.p4d_path} -r #{Conventions.p4droot_dir} "+
+               "-v server=1 -L #{Conventions.p4d_log_path} " +
+               "-xi")
+
+  end
+end

data/lib/commands.rb

@@ -1,4 +1,5 @@
 require 'commands/download'
+require 'commands/init'
 require 'commands/help'
 require 'commands/kill'
 require 'commands/start'

data/lib/conventions.rb

@@ -17,6 +17,10 @@ module Conventions
     File.expand_path(File.join(working_dir,'p4droot'))
   end
 
+  def Conventions.client_root_dir
+    File.expand_path(File.join(working_dir,'clients'))
+  end
+
   def Conventions.init_p4droot_dir
     if !File.directory?(p4droot_dir)
       FileUtils::makedirs(p4droot_dir)

data/lib/osutil.rb

@@ -15,6 +15,18 @@ module OsUtil
     File.expand_path(File.join(Conventions.working_dir, OsUtil.p4d_executable))
   end
 
+  def OsUtil.p4_executable
+    if windows?
+      'p4.exe'
+    else
+      'p4'
+    end
+  end
+
+  def OsUtil.p4_path
+    File.expand_path(File.join(Conventions.working_dir, OsUtil.p4_executable))
+  end
+
   def OsUtil.osx?
     RbConfig::CONFIG['host_os'] =~ /darwin/
   end

data/lib/p4util/tasks.rb

@@ -0,0 +1,94 @@
+# p4util/task.rb - Rake tasks
+
+require 'commands'
+require 'conventions'
+require 'fileutils'
+require 'ostruct'
+require 'rake/tasklib'
+
+module P4Util
+  # Creates a few tasks to allow launching init and kill commands via rake
+  # tasks, which should make it easy to script with test tasks, for example.
+  #
+  # Example:
+  #
+  #     require 'p4util/tasks'
+  #
+  #     P4Util::Tasks.new do |p4util|
+  #       p4util.version = 'r14.2' # Indicate p4d version to download
+  #     end
+  #
+  # Tasks:
+  # - p4init
+  # - p4kill
+  # - p4reset
+  class Tasks < Rake::TaskLib
+    # The task base name, defaults to ':p4'
+    attr_accessor :basename
+
+    # P4 Version to use, defaults to 'r14.2'
+    attr_accessor :version
+
+    # The directory containing p4 init scripts, defaults to 'p4init'
+    attr_accessor :p4_init_dir
+
+    def initialize basename = :p4
+      @basename = basename
+      @version = 'r14.2'
+      @p4_init_dir = 'p4init'
+
+      yield self if block_given?
+
+      define_tasks
+    end
+
+    # Create the tasks defined by this task library
+    def define_tasks
+      desc init_task_description
+      task init_task_name do
+        options = OpenStruct.new
+        options.params = [p4_init_dir, '--version', version]
+        Commands.init(options)
+      end
+
+      desc kill_task_description
+      task kill_task_name do
+        options = OpenStruct.new
+        options.params = ['--version', version]
+        Commands.kill(options)
+      end
+
+      desc reset_task_description
+      task reset_task_name => kill_task_name do
+        FileUtils.rmtree(Conventions.p4droot_dir)
+      end
+
+      self
+    end
+
+    def init_task_description
+      "Initializes a p4d instance, and ensures it's downloaded and running"
+    end
+
+    def init_task_name
+      "#{basename}init"
+    end
+
+    def kill_task_description
+      'Halt any locally running p4d instance'
+    end
+
+    def kill_task_name
+      "#{basename}kill"
+    end
+
+    def reset_task_description
+      'Cleans out the current p4droot working directory (after killing p4d)'
+    end
+
+    def reset_task_name
+      "#{basename}reset"
+    end
+  end
+end
+

data/lib/p4util/version.rb

@@ -0,0 +1,3 @@
+module P4Util
+  VERSION = '0.1.0'
+end

data/lib/{p4_util.rb → p4util.rb}

@@ -1,4 +1,4 @@
-require 'p4_util/version'
+require 'p4util/version'
 require 'commands'
 require 'optparse'
 require 'ostruct'

data/lib/random_util.rb

@@ -0,0 +1,7 @@
+
+module RandomUtil
+
+  def RandomUtil.randstr(len=8)
+    (0...len).map { (65 + rand(26)).chr }.join
+  end
+end

data/p4init/test_changelists.rb

@@ -0,0 +1,36 @@
+
+class Changelist1 < ChangelistModel
+  def rank; 1000 end
+  @description = 'A couple of new files'
+  @adds = [
+      FileDefinition.new(:path => 'depot/README.txt',
+        :content => <<-END.gsub(/^ {8}/, '')
+          This is an example readme.
+        END
+      ),
+      FileDefinition.new(:path => 'depot/dev/memorabilia/kitty.jpg',
+        :local_path => 'p4init/287.jpg'
+      )
+  ]
+end
+
+class Changelist2 < ChangelistModel
+  def rank; 1001 end
+  @description = 'An example add and edit'
+  @user = 'jdoe'
+  @edits = [
+      FileDefinition.new(:path => 'depot/README.txt',
+                     :content => <<-END.gsub(/^ {8}/, '')
+          This is an example readme.
+          Added a second line
+      END
+      )
+  ]
+  @adds = [
+      FileDefinition.new(:path => 'depot/main/project2/example.txt',
+                     :content => <<-END.gsub(/^ {8}/, '')
+          Example text file.
+      END
+      )
+  ]
+end

data/p4init/test_system_settings.rb

@@ -0,0 +1,4 @@
+
+class TestSystemSettings < SystemSettingsModel
+  @unicode = true
+end

data/p4init/test_users.rb

@@ -0,0 +1,15 @@
+# User ranks should generally be 10-100, creating them early makes sense.
+
+class TestSuperUser < UserModel
+  @login = 'p4super'
+  @password = 'superuser1A!'
+  @full_name = 'Super User'
+  @super = true
+end
+
+class JohnDoeUser < UserModel
+  def rank; 10 end
+  @login = 'jdoe'
+  @full_name = 'John Doe'
+  @password = 'johndoe1A!'
+end

data/p4util.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'p4_util/version'
+require 'p4util/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'p4util'
@@ -19,7 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'rake', '~> 10.0'
 
   spec.add_runtime_dependency 'sys-proctable', '~> 0.9'
+  spec.add_runtime_dependency 'p4ruby', '2014.2.0.pre1'
+  spec.add_runtime_dependency 'rake', '~> 10.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: p4util
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Tristan Juricek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-23 00:00:00.000000000 Z
+date: 2014-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,33 +25,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: sys-proctable
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
+        version: '0.9'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: sys-proctable
+  name: p4ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2014.2.0.pre1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2014.2.0.pre1
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '10.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '10.3'
 description: The p4util command itself provides other commands, see 'p4util help'
   after install. This allows you to things like download a p4d, start it, kill it,
   etc mostly for quick setup of testing systems.
@@ -70,12 +84,26 @@ files:
 - "./lib/commands.rb"
 - "./lib/commands/download.rb"
 - "./lib/commands/help.rb"
+- "./lib/commands/init.rb"
+- "./lib/commands/init/changelist_model.rb"
+- "./lib/commands/init/file_definition.rb"
+- "./lib/commands/init/init_model.rb"
+- "./lib/commands/init/p4_helpers.rb"
+- "./lib/commands/init/system_settings_model.rb"
+- "./lib/commands/init/user_model.rb"
 - "./lib/commands/kill.rb"
 - "./lib/commands/start.rb"
+- "./lib/commands/util.rb"
 - "./lib/conventions.rb"
 - "./lib/osutil.rb"
-- "./lib/p4_util.rb"
-- "./lib/p4_util/version.rb"
+- "./lib/p4util.rb"
+- "./lib/p4util/tasks.rb"
+- "./lib/p4util/version.rb"
+- "./lib/random_util.rb"
+- "./p4init/287.jpg"
+- "./p4init/test_changelists.rb"
+- "./p4init/test_system_settings.rb"
+- "./p4init/test_users.rb"
 - "./p4util.gemspec"
 - bin/p4util
 homepage: http://perforce.com

data/lib/p4_util/version.rb

@@ -1,3 +0,0 @@
-module P4Util
-  VERSION = "0.0.3"
-end