p4ruby 2012.2 → 2014.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dce2dda614bba83402b98a5660980efd982ac116
+  data.tar.gz: 96095d48458278f90f6710bed7b49a8c585f08fc
+SHA512:
+  metadata.gz: 3943ab2ec560cb2173a433cf3311556fa525294adbba25f799fe915530c42c59fd37f85d10363db1c616335577d75d6012d2888beea76f0d1d46baea119164da
+  data.tar.gz: 07653d491f15c49c91cdb7287132c2e47e3e30fd36d0106d707d853ae7fdc2eaa06127bf71f0f0ed44a295d71a2805436dfc9af256aff6c374beea8a5f9487eb

data/CHANGES

@@ -1,24 +1,10 @@
 
 = p4ruby
 
-== version 1.0.11
+== Version 2014.1
+The gem has been completely rewritten.
 
-* remove previous workaround; now uses list of hosed versions to avoid
+Now it will build from source on Windows' provided that DevKit is present (Tested on Win7)
 
-== version 1.0.10
-
-* perforce ftp site has hosed 11.1 directory -- workaround hardcoded for 10.2
-
-== version 1.0.9
-
-* Non-universal p4api darwin libs were removed from Perforce ftp server
-* Pathname changes for 1.9 (even though P4Ruby does not compile for 1.9)
-
-== version 1.0.8
-
-* Compensate for Perforce ftp server directory changes
-
-== version 1.0.7
-
-* First release.
+It also builds from source on Linux and MacOSX (tested on Ubuntu and Mavericks).
 

data/README

@@ -1,95 +1,9 @@
+Author: Brett Bates and Jennifer Bottom.
 
-= P4Ruby -- Ruby interface to the Perforce API
+Credit to: James Lawrence
 
-This is only an installer for the P4Ruby package by Perforce Software.
+A readme that needs to be rewritten.
+Version 2014.1
+An entire rewrite of the p4ruby gem installer
 
-== Install
-
-  % gem install p4ruby
-
-Or if you are installing from the regular (non-gem) package,
-
-  % ruby install.rb
-
-This installer downloads P4Ruby and the Perforce API, compiles P4Ruby,
-and installs it.  On Windows the Perforce P4Ruby Windows installer is
-downloaded and executed instead.  Some options are available,
-
-  % ruby install.rb --help
-
-  Usage: ruby install.rb [options]
-    --version NN.N       Version to download, e.g. 08.1. Default finds latest.
-    --list-versions      List available versions.
-    --platform PLATFORM  Perforce-named platform to download. Default guesses.
-    --list-platforms     List available platforms for the given version.
-    --gem                Gem configuration (for the gem installer).
-    --uninstall          Uninstall.
-    --local              Use the files in work/distfiles (manual download).
-
-== Links
-
-* P4Ruby documentation 2009.1: http://perforce.com/perforce/doc.091/manuals/p4script/p4script.pdf
-* Perforce documentation: http://perforce.com/perforce/technical.html
-
-* Download (this installer only): http://rubyforge.org/frs/?group_id=6957
-* Repository (this installer only): http://github.com/quix/p4ruby
-* Simplified wrapper for P4Ruby: http://perforce.rubyforge.org
-
-== Credits
-
-=== P4Ruby
- 
- Copyright (c) 1997-2007, Perforce Software, Inc.  All rights reserved.
- 
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
- 
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- 
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- 
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE
- SOFTWARE, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
-=== Installer and Gem
- 
- This ruby package (install.rb and associated files) was written by
- James M. Lawrence.
-
- Copyright (c) 2009 James M. Lawrence
- Copyright (c) 2008 ImaginEngine, Inc.
-
- Distributed under the MIT license.
- 
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
- 
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
+Now entirely based around p4conf.rb

data/install.rb

@@ -1,507 +1,206 @@
-#
-# Author: James M. Lawrence <quixoticsycophant@gmail.com>.
-#
-
 require 'net/ftp'
 require 'rbconfig'
-require 'ostruct'
-require 'fileutils'
-require 'optparse'
-require 'pathname'
-require 'rubygems'
-
-class Installer
-  include FileUtils
-
-  CONFIG = Config::CONFIG
-  BIT64 = (1.size == 8)
-
-  RB_BASENAME = Pathname.new "P4.rb"
-  SO_BASENAME = Pathname.new "P4.#{CONFIG['DLEXT']}"
+require 'zlib'
+require 'rubygems/package'
 
-  RAW_INSTALL_FILES = [
-    Pathname.new(CONFIG["sitelibdir"]) + RB_BASENAME,
-    Pathname.new(CONFIG["sitearchdir"]) + SO_BASENAME,
-  ]
+BUILD_DIR = "./build"
+DIST_DIR = "./dist"
 
-  GEM_INSTALL_FILES = [
-    Pathname.new("lib") + RB_BASENAME,
-    Pathname.new("ext") + SO_BASENAME,
-  ]
+FTP_SERVER = "ftp.perforce.com"
+TOP_DIR = "perforce"
+P4RUBY_FTP_DIR = "bin.tools"
 
-  SERVER = "ftp.perforce.com"
-  SERVER_TOP_DIR = Pathname.new "perforce"
+P4RUBY_ARCHIVE = "p4ruby.tgz"
 
-  # Mysterious "ghost" releases which lack files
-  HOSED_VERSIONS = %w[09.3 11.1]
-
-  P4API_REMOTE_BASENAME = Pathname.new "p4api.tgz"
-  P4RUBY_REMOTE_BASENAME = Pathname.new "p4ruby.tgz"
-
-  WORK_DIR = Pathname.new "work"
-  DISTFILES_DIR = WORK_DIR + "distfiles"
-  BUILD_DIR = WORK_DIR + "build"
-
-  def parse_command_line
-    OptionParser.new("Usage: ruby install.rb [options]", 24, "") {
-      |parser|
-      parser.on(
-        "--version NN.N",
-        "Version to download, e.g. 08.1. Default finds latest.") {
-        |version|
-        @s.version = version
-      }
-      parser.on(
-        "--list-versions",
-        "List available versions.") {
-        @s.list_versions = true
-      }
-      parser.on(
-        "--platform PLATFORM",
-        "Perforce-named platform to download. Default guesses.") {
-        |platform|
-        @s.platform = platform
-      }
-      parser.on(
-        "--list-platforms",
-        "List available platforms for the given version.") {
-        @s.list_platforms = true
-      }
-      parser.on(
-        "--gem",
-        "Gem configuration (for the gem installer).") {
-        @s.gem_config = true
-      }
-      parser.on(
-        "--uninstall",
-        "Uninstall.") {
-        @s.uninstall = true
-      }
-      parser.on(
-        "--local",
-        "Use the files in work/distfiles (manual download).") {
-        @s.local = true
-      }
-      parser.parse(ARGV)
-    }
-  end
+class Installer 
+    def initialize
+        unless File.directory?(DIST_DIR)
+            Dir.mkdir(DIST_DIR)
+        end
 
-  def run
-    @s = LazyStruct.new
-    parse_command_line
-    config
-    if @s.uninstall
-      uninstall
-    elsif @s.list_platforms
-      puts platforms
-    elsif @s.list_versions
-      puts versions
-    elsif @s.platform.nil?
-      platform_fail
-    elsif @s.platform =~ %r!\Ant!
-      windows_install
-    else
-      fetch
-      build
-      install
-      verify_install
-    end
-  end
+        unless File.directory?(BUILD_DIR)
+            Dir.mkdir(BUILD_DIR)
+        end
 
-  def config
-    if CONFIG["LIBRUBYARG_SHARED"].empty?
-      raise "error: ruby must be configured with --enable-shared"
+        @platform = guess_platform
+     
+        #TODO some way of the user supplying their own ftp path/ local path for the api's
+        fetch
+        build
     end
 
-    @s.ftp = Net::FTP.new(SERVER).tap { |t|
-      t.passive = true
-      t.login
-    }
-
-    @s.p4api =  LazyStruct.new.tap { |t|
-      t.basename = P4API_REMOTE_BASENAME
-    }
-
-    @s.p4ruby = LazyStruct.new.tap { |t|
-      t.basename = P4RUBY_REMOTE_BASENAME
-    }
-
-    @s.specs = [ @s.p4ruby, @s.p4api ]
-    @s.specs.each { |spec|
-      spec.local = DISTFILES_DIR + spec.basename
-    }
-    
-    unless @s.version
-      @s.version = latest_version
+    def fetch
+        p4_ftp = P4Ruby_FTP.new(@platform)
+        p4_ftp.download
     end
 
-    @s.version_dir = SERVER_TOP_DIR + "r#{@s.version}"
-
-    unless @s.platform
-      @s.platform = guess_platform
+    def build
+        wd = Dir.getwd
+        api_dir = get_api_build_dir
+        Dir.chdir(get_ruby_build_dir)
+        puts `yes | ruby p4conf.rb -d #{api_dir}`
+        puts `make`
+        puts `ruby test.rb`
+        puts `make install`
+        #TODO Deal with known issue wheree we have to ignore -Werror in Makefile
+        Dir.chdir(wd)
     end
 
-    if @s.platform =~ /nt/
-      @s.p4api.remote = @s.version_dir + "bin.#{@s.platform}"
-    else
-      @s.p4api.remote = @s.version_dir + "bin.#{@s.platform}" + @s.p4api.basename
-      @s.p4ruby.remote = @s.version_dir + "bin.tools" + @s.p4ruby.basename
+    def guess_cpu(os)
+        cpu = RbConfig::CONFIG['target_cpu']
+        case os 
+        when :darwin, :linux
+            if cpu =~ /i686/
+                "x86"
+            else
+                cpu
+            end
+        else
+            case cpu
+            when /ia/i
+                'ia64'
+            else
+                cpu 
+            end
+        end
     end
 
-
-  end
-
-  def guess_cpu
-    if CONFIG["target_os"] =~ /darwin/i
-      if CONFIG["build"] =~ /i686|x86_64/
-        "x86_64"
-      else
-        "x86"
-      end
-    else
-      case CONFIG["target_cpu"]
-      when %r!ia!i
-        "ia64"
-      when %r!86!
-        # note: with '_'
-        "x86" + (BIT64 ? "_64" : "")
-      when %r!(ppc|sparc)!i
-        # note: without '_'
-        $1 + (BIT64 ? "64" : "")
-      else
-        ""
-      end
+    def guess_platform()
+        case RbConfig::CONFIG["target_os"].downcase 
+        when /nt|mswin/
+            "nt#{guess_cpu(:windows)}"
+        when /mingw/
+            "mingwx86"
+        when /darwin/
+            #TODO look at darwin 100, can you complile bin for 90 on 100?
+            "darwin90#{guess_cpu(:darwin)}"
+        when /solaris/
+            "solaris10#{guess_cpu(:solaris)}"
+        when /linux/
+            "linux26#{guess_cpu(:linux)}" 
+        when /cygwin/
+            #No longer built for
+        end
     end
-  end
 
-  def guess_version(os)
-    if match = `uname -a`.match(%r!#{os}\s+\S+\s+(\d+)\.(\d+)!i)
-      version = match.captures.join
-      cpu = guess_cpu
-      platforms = self.platforms
-      built_platforms = (0..version.to_i).map { |n|
-        [os, n.to_s, cpu].join
-      }.select { |platform|
-        platforms.include? platform
-      }
-      if os =~ /darwin/
-        built_platforms.last
-      else
-        built_platforms.last
-      end
-    else
-      nil
+    def get_ruby_build_dir
+        Dir.foreach(BUILD_DIR) do |d|
+            if d =~ /p4ruby/
+                return File.join(BUILD_DIR,d)
+            end
+        end
     end
-  end
-
-  def guess_platform(opts = {})
-    config_os = CONFIG["target_os"].downcase
-    windows_cpu = BIT64 ? "x64" : "x86"
 
-    if config_os =~ %r!cygwin!i
-      "cygwin" + windows_cpu
-    elsif config_os =~ %r!(mswin|mingw)!i
-      "nt" + windows_cpu
-    elsif @s.local
-      "<local>"
-    else
-      if match = config_os.match(%r!\A\D+!)
-        guess_version(match[0])
-      else
-        nil
-      end
+    def get_api_build_dir
+        Dir.foreach(BUILD_DIR) do |d|
+            if d =~ /p4api/
+                return File.join(Dir.getwd, BUILD_DIR,d)
+            end
+        end
     end
-  end
+end
 
-  def platform_fail
-    install_fail {
-      @s.version = "<version>"
-      @s.platform = "<platform>"
-      message = %Q{
-        Auto-fetch not yet handled for this platform.  Run:
-    
-        \truby install.rb --list-platforms
-    
-        to see the available platforms, then run
-    
-        \truby install.rb --platform PLATFORM
-    
-        with your platform.
-    
-        If all of the above fails, manually fetch
-    
-        \tftp://#{SERVER}/#{@s.p4api.remote}
-    
-        Copy it to #{@s.p4api.local} and run install.rb --local.
-      }.gsub(%r!^ +(?=\S)!, "")
-  
-      mkdir_p(DISTFILES_DIR)
-      puts message
-    }
-  end
+class P4Ruby_FTP
 
-  def install_fail
-    yield
-    exit(1)
-  end
+    def initialize(platform)
+        @ftp = Net::FTP.new(FTP_SERVER)
+        @ftp.login
+        @ftp.chdir(TOP_DIR)
 
-  def sys(*args)
-    system(*args).tap { |result|
-      unless result
-        raise "system() failed: #{args.join(" ")}"
-      end
-    }
-  end
+        @latest = latest_version
+        @ftp.chdir("r#{@latest}")
 
-  def unpack(distfile, target_dir)
-    sys("tar", "zxvf", distfile.to_s, "-C", target_dir.to_s)
-  end
+        @platform = "bin.#{platform}"
 
-  def fetch_spec(spec)
-    unless @s.local
-      mkdir_p(spec.local.dirname)
-      puts "downloading ftp://#{SERVER}/#{spec.remote} ..."
-      @s.ftp.getbinaryfile(spec.remote.to_s, spec.local.to_s)
+        if @platform =~ /nt|mingw/
+            @p4api_archive = "p4api.zip"
+        else
+            @p4api_archive = "p4api.tgz"
+        end
     end
-  end
-
-  def fetch
-    @s.specs.each { |spec|
-      fetch_spec(spec)
-    }
-  end
 
-  def remote_files_matching(dir, regex)
-    @s.ftp.ls(dir.to_s).map { |entry|
-      if match = entry.match(regex)
-        yield match
-      else
-        nil
-      end
-    }.reject { |entry|
-      entry.nil?
-    }
-  end
-
-  def platforms
-    remote_files_matching(@s.version_dir, %r!bin\.(\w+)!) { |match|
-      match.captures.first
-    }.reject { |platform|
-      platform =~ %r!java!
-    }.sort
-  end
+    def versions
+        remote_files_matching(".", /r(1\d\.\d)/) { |match|
+            match.captures.first
+        }.sort
+    end
 
-  def versions
-    remote_files_matching(SERVER_TOP_DIR, %r!r([0-8]\d\.\d)!) { |match|
-      match.captures.first
-    }.reject { |version|
-      HOSED_VERSIONS.include? version
-    }.sort
-  end
+    def latest_version
+        versions.reverse_each{ |v|
+            begin
+                remote_files_matching("r#{v}/bin.tools",/p4ruby/) do
+                    return v
+                end
+            rescue
+                next
+            end
+        }
+    end
+    
+    def remote_files_matching(dir, regex)
+        @ftp.ls(dir.to_s).map { |entry|
+            if match = entry.match(regex)
+                yield match
+            else
+                nil
+            end
+        }.reject { |entry|
+            entry.nil?
+        }
+    end
 
-  def latest_version
-    versions.reverse_each{ |v|
-      begin
-        remote_files_matching("#{SERVER_TOP_DIR}/r#{v}/bin.tools",/p4ruby/) do
-          return v
+    def download
+        begin
+            download_p4api
+            download_p4ruby
+        rescue => e
+            puts "Failed to download API or p4ruby, please compile manually"
         end
-      rescue
-        next
-      end
-    }
-  end
-
-  def make(*args)
-    sys("make", *args)
-  end
-
-  def ruby(*args)
-    exe = Pathname.new(CONFIG["bindir"]) + CONFIG["RUBY_INSTALL_NAME"]
-    sys(exe.to_s, *args)
-  end
-
-  def build
-    puts "building..."
-    rm_rf(BUILD_DIR)
-    mkdir_p(BUILD_DIR)
-
-    @s.specs.each { |spec|
-      unpack(spec.local, BUILD_DIR)
-    }
-
-    Dir.chdir(BUILD_DIR) {
-      api_dir = Pathname.glob("p4api*").last
-      p4ruby_dir = Pathname.glob("p4ruby*").last
-      Dir.chdir(p4ruby_dir) {
-        ruby("p4conf.rb", "--apidir", "../#{api_dir}")
-        make
-      }
-      @s.p4ruby_build_dir = BUILD_DIR + p4ruby_dir
-    }
-  end
-
-  def raw_install_to_gem_install
-    RAW_INSTALL_FILES.zip(GEM_INSTALL_FILES) { |source, dest|
-      mkdir_p(dest.dirname)
-      puts "move #{source} --> #{dest}"
-      mv(source, dest)
-    }
-  end
-
-  def install
-    puts "installing..."
-    Dir.chdir(@s.p4ruby_build_dir) {
-      make("install")
-    }
-    if @s.gem_config
-      raw_install_to_gem_install
     end
-  end
 
-  def verify_install(on_error = nil)
-    puts "verifying..."
-    files =
-      if @s.gem_config
-        GEM_INSTALL_FILES
-      else
-        RAW_INSTALL_FILES
-      end.map { |t| t.expand_path }
+    def download_p4api
+        @ftp.chdir(@platform)
+        @ftp.getbinaryfile(@p4api_archive, "#{DIST_DIR}/#{@p4api_archive}", 1024)
+        @ftp.chdir("..")
 
-    if files.all? { |t| t.exist? }
-      puts "Installed files:"
-      puts files
-    elsif on_error
-      install_fail(&on_error)
-    else
-      install_fail {
-        puts "These files were supposed to be installed, but were not:"
-        puts files
-        puts "Install failed!"
-      }
+        decompress("#{DIST_DIR}/#{@p4api_archive}","#{BUILD_DIR}/")
     end
-  end
-
-  def find_ruby_version(spec)
-    remote_files_matching(spec.remote, /p4ruby\d\d.exe/) {|r_ver|
 
-      #Find the latest version of p4ruby for this version of ruby
-      v_max = CONFIG["MAJOR"]
-      v_min = CONFIG["MINOR"]
-      version = [v_max, v_min].join
-      if r_ver.to_s =~ /p4ruby#{version}.exe/
-        return "p4ruby#{version}.exe"
-      end
+    def download_p4ruby
+        @ftp.chdir(P4RUBY_FTP_DIR)
+        @ftp.getbinaryfile(P4RUBY_ARCHIVE, "#{DIST_DIR}/#{P4RUBY_ARCHIVE}", 1024)
+        @ftp.chdir("..")
 
-    }
-    nil
-  end
-
-  def windows_install
-    #
-    # For Windows, p4ruby is located in the p4api directory on the
-    # perforce server -- switcharoo --
-    #
-    spec = @s.p4api
-    
-    p4ruby_exe = find_ruby_version(spec)
-    if p4ruby_exe && !(spec.remote.to_s =~ /p4ruby/)
-      spec.remote += p4ruby_exe.to_s
-    else
-      abort("Failed to find a suitable p4ruby executable for ruby #{CONFIG["MAJOR"]}.#{CONFIG["MINOR"]}")
+        decompress("#{DIST_DIR}/#{P4RUBY_ARCHIVE}","#{BUILD_DIR}/")
     end
-    fetch_spec(spec)
 
-    error = lambda {
-      puts "The Perforce P4Ruby Windows installer failed!"
-      puts "You may re-run it manually here:"
-      puts spec.local.expand_path
-    }
-
-    puts "running Perforce P4Ruby Windows installer..."
-    if system(spec.local.to_s, "/S", "/v/qn")
-      if @s.gem_config
-        sleep(1)
-        raw_install_to_gem_install
-        sleep(1)
-        unless system(spec.local, "/V", "/x", "/S", "/v/qn")
-          # We don't much care if this fails; just write to the log
-          puts "Note: the Perforce P4Ruby Windows uninstaller failed."
+    def decompress(tgz, destination)
+        if tgz =~ /\.zip/
+            `unzip #{tgz} -d #{destination}`
+            return 
+        end
+        Gem::Package::TarReader.new(Zlib::GzipReader.open tgz) do |tar|
+            tar.each do |entry|
+                if entry.directory?
+                    puts "Making dir #{File.join(destination, entry.full_name)}"
+                    unless File.exists?(File.join(destination, entry.full_name))
+                        Dir.mkdir(File.join(destination, entry.full_name))
+                    end
+                elsif entry.file?
+                    puts "Making file #{File.join(destination, entry.full_name)}"
+                    unless File.exists?(File.join(destination, entry.full_name))
+                        File.open(File.join(destination, entry.full_name), "w") do |f|
+                            f.write(entry.read)
+                        end
+                    end
+                elsif entry.header.typeflag == '2'
+                    #TODO remove if not necessary
+                    binding.pry
+                end
+            end
         end
-      end
-      verify_install(error)
-    else
-      install_fail(&error)
-    end
-  end
-
-  def uninstall
-    RAW_INSTALL_FILES.each { |file|
-      if file.exist?
-        puts "delete #{file}"
-        rm_f(file)
-      end
-    }
-  end
-end
-
-#
-# An OpenStruct with optional lazy-evaluated fields.
-#
-class LazyStruct < OpenStruct
-  #
-  # For mixing into an existing OpenStruct instance singleton class.
-  #
-  module Mixin
-    #
-    # &block is evaluated when this attribute is requested.  The
-    # same result is returned for subsquent calls, until the field
-    # is assigned a different value.
-    #
-    def attribute(reader, &block)
-      singleton = (class << self ; self ; end)
-      singleton.instance_eval {
-        #
-        # Define a special reader method in the singleton class.
-        #
-        define_method(reader) {
-          block.call.tap { |value|
-            #
-            # The value has been computed.  Replace this method with a
-            # one-liner giving the value.
-            #
-            singleton.instance_eval {
-              remove_method(reader)
-              define_method(reader) { value }
-            }
-          }
-        }
-        
-        #
-        # Revert to the old OpenStruct behavior when the writer is called.
-        #
-        writer = "#{reader}=".to_sym
-        define_method(writer) { |value|
-          singleton.instance_eval {
-            remove_method(reader)
-            remove_method(writer)
-          }
-          method_missing(writer, value)
-        }
-      }
     end
-  end
-  
-  include Mixin
 end
 
-# version < 1.8.7 compatibility
-module Kernel
-  unless respond_to? :tap
-    def tap
-      yield self
-      self
-    end
-  end
-end
+i = Installer.new
 
-Installer.new.run

data/p4ruby.gemspec

@@ -1,22 +1,19 @@
 
 Gem::Specification.new { |t| 
   t.name = "p4ruby"
-  t.version = "2012.2"
+  t.version = "2014.1"
   t.summary = "Ruby interface to the Perforce API"
   t.description = t.summary + "."
-  t.author = "Perforce Software (ruby gem by James M. Lawrence)"
-  t.email = "p4ruby@perforce.com"
-  t.homepage = "http://p4ruby.rubyforge.org"
-  t.rubyforge_project = "p4ruby"
-  t.extensions << "Rakefile"
-  t.add_dependency "rake"
-  t.add_dependency "rdoc"
-  t.require_paths << "ext"
+  t.author = "Perforce Software (ruby gem by Brett Bates and Jennifer Bottom)"
+  t.email = "jbottom@perforce.com"
+  t.homepage = "https://rubygems.org/gems/p4ruby"
+
+  t.add_runtime_dependency 'rake', '~> 0'
+  t.add_runtime_dependency 'test-unit', '>=0'
 
   t.files = %w[
     README
     CHANGES
-    Rakefile
     install.rb
     p4ruby.gemspec
   ]

metadata

@@ -1,107 +1,85 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: p4ruby
-version: !ruby/object:Gem::Version 
-  hash: 8063
-  prerelease: 
-  segments: 
-  - 2012
-  - 2
-  version: "2012.2"
+version: !ruby/object:Gem::Version
+  version: '2014.1'
 platform: ruby
-authors: 
-- Perforce Software (ruby gem by James M. Lawrence)
+authors:
+- Perforce Software (ruby gem by Brett Bates and Jennifer Bottom)
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-10-11 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rdoc
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id002
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby interface to the Perforce API.
-email: p4ruby@perforce.com
+email: jbottom@perforce.com
 executables: []
-
-extensions: 
-- Rakefile
-extra_rdoc_files: 
-- README
-files: 
+extensions: []
+extra_rdoc_files:
 - README
+files:
 - CHANGES
-- Rakefile
+- README
 - install.rb
 - p4ruby.gemspec
-homepage: http://p4ruby.rubyforge.org
+homepage: https://rubygems.org/gems/p4ruby
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --title
-- "P4Ruby: Ruby interface to the Perforce API"
-- --main
+rdoc_options:
+- "--title"
+- 'P4Ruby: Ruby interface to the Perforce API'
+- "--main"
 - README
-- --exclude
+- "--exclude"
 - CHANGES
-- --exclude
-- Rakefile
-- --exclude
+- "--exclude"
 - install.rb
-- --exclude
+- "--exclude"
 - p4ruby.gemspec
-require_paths: 
+require_paths:
 - lib
-- ext
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: p4ruby
-rubygems_version: 1.8.24
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby interface to the Perforce API
 test_files: []
-

data/Rakefile

@@ -1,109 +0,0 @@
-
-begin
-  require 'rubygems'
-  gem 'rdoc'
-rescue LoadError
-end
-
-require 'rubygems/package_task'
-require 'rdoc/task'
-require 'rake/contrib/rubyforgepublisher'
-require 'fileutils'
-
-include FileUtils
-
-README = "README"
-GEMSPEC = eval(File.read("p4ruby.gemspec"))
-RAKEFILE = "Rakefile"
-RAKEFILE_ORIG = "Rakefile.orig"
-
-default_task_definition = %{
-  INSTALLER = './install.rb'
-
-  #
-  # default task compiles for the gem
-  #
-  task :default do
-    ARGV.clear
-    ARGV.push "--gem"
-    load INSTALLER
-  end
-}
-
-eval(default_task_definition)
-
-task :clean => :clobber do
-  rm_rf ["work", "lib", "ext"]
-end
-
-task :update_docs do
-  ruby_path = File.join(
-    Config::CONFIG["bindir"],
-    Config::CONFIG["RUBY_INSTALL_NAME"])
-
-  help = "--help"
-  command = "ruby #{File.basename(INSTALLER)} #{help}"
-  output = `#{ruby_path} #{INSTALLER} #{help}`
-
-  # insert help output into README
-  replace_file(README) { |contents|
-    contents.sub(%r!#{command}.*?==!m) {
-      command + "\n\n  " +
-      output + "\n=="
-    }
-  }
-end
-
-task :doc => :update_docs
-task :doc => :rdoc
-
-task :package => [:clean, :doc]
-task :gem => :clean
-
-RDoc::Task.new { |t|
-  t.main = README
-  t.rdoc_files.include([README])
-  t.rdoc_dir = "html"
-  t.title = "P4Ruby: #{GEMSPEC.summary}"
-}
-
-Gem::PackageTask.new(GEMSPEC) { |t| 
-  t.need_tar = true 
-} 
-
-task :publish => :doc do
-  Rake::RubyForgePublisher.new('p4ruby', 'quix').upload
-end
-
-task :release do
-  mv(RAKEFILE, RAKEFILE_ORIG)
-  begin
-    File.open(RAKEFILE, "w") { |out|
-      out.puts default_task_definition.gsub(%r!^  !m, "")
-    }
-    Rake::Task[:package].invoke
-  ensure
-    mv(RAKEFILE_ORIG, RAKEFILE)
-  end
-end
-
-##################################################
-# util
-
-unless respond_to? :tap
-  module Kernel
-    def tap
-      yield self
-      self
-    end
-  end
-end
-
-def replace_file(file)
-  old_contents = File.read(file)
-  yield(old_contents).tap { |new_contents|
-    File.open(file, "w") { |output|
-      output.print(new_contents)
-    }
-  }
-end