appsendr 0.0.1

data/README.rdoc

@@ -0,0 +1,50 @@
+# == Synopsis 
+#   Ruby command-line app that interacts with the Apple Developer Portal, Xcode, and the AppSendr webservice
+#
+# == Examples
+#   Calling this in a Xcode project directory will build the project with an active configuration of AdHoc
+#     appsendr 
+#
+#   Other examples:
+#     appsendr -q
+#     appsendr --verbose 
+#
+# == Usage 
+#   appsendr [options]
+#
+#   For help use: appsendr -h
+#
+# == Options
+#   -c, --active_config Sets the active configuration for the XCode project
+#   -u, --username		Apple Developer portal username
+#   -p, --password		Apple Developer portal password
+#   -d, --devices		Path to profiles if different then devices.ad
+#   -h, --help          Displays help message
+#   -v, --version       Display the version, then exit
+#   -q, --quiet         Output as little as possible, overrides verbose
+#   -V, --verbose       Verbose output
+#
+#
+# == Author
+#   Nolan Brown
+#
+# == Copyright
+#   Copyright (c) 2010 Nolan Brown. Licensed under the MIT License:
+#   http://www.opensource.org/licenses/mit-license.php
+
+
+=== General Commands
+
+help                         	# show this usage
+version                      	# show the gem version
+
+build <active configuration>	# build and deploy app
+build:clean						# clean project
+
+testers							# list testers for app
+testers:add <email> <name>		#t
+testers:remove <email>
+testers:clear
+
+deploy <active configuration> #deploy the current build
+deploy:notify #notify testers about the latest build

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+require 'lib/appsendr/constants'
+
+Echoe.new('appsendr', AppSendr::VERSION) do |p|
+  p.description    = "A gem that will build and distribute an iphone/ipad app to the web for remote install"
+  p.url            = "http://www.appsendr.com/gem"
+  p.author         = "AppSendr"
+  p.email          = "nolanbrown@gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+  p.runtime_dependencies = ["rest-client >=1.4.0", "rubyzip", "json_pure >=1.2.0"]
+  p.has_rdoc = true  
+
+end

data/appsendr.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{appsendr}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["AppSendr"]
+  s.date = %q{2010-11-20}
+  s.default_executable = %q{appsendr}
+  s.description = %q{A gem that will build and distribute an iphone/ipad app to the web for remote install}
+  s.email = %q{nolanbrown@gmail.com}
+  s.executables = ["appsendr"]
+  s.extra_rdoc_files = ["README.rdoc", "bin/appsendr", "lib/appsendr.rb", "lib/appsendr/binary_plist.rb", "lib/appsendr/client.rb", "lib/appsendr/command.rb", "lib/appsendr/commands/app.rb", "lib/appsendr/commands/auth.rb", "lib/appsendr/commands/base.rb", "lib/appsendr/commands/build.rb", "lib/appsendr/commands/deploy.rb", "lib/appsendr/commands/help.rb", "lib/appsendr/commands/testers.rb", "lib/appsendr/commands/version.rb", "lib/appsendr/constants.rb", "lib/appsendr/helpers.rb"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "appsendr.gemspec", "bin/appsendr", "lib/appsendr.rb", "lib/appsendr/binary_plist.rb", "lib/appsendr/client.rb", "lib/appsendr/command.rb", "lib/appsendr/commands/app.rb", "lib/appsendr/commands/auth.rb", "lib/appsendr/commands/base.rb", "lib/appsendr/commands/build.rb", "lib/appsendr/commands/deploy.rb", "lib/appsendr/commands/help.rb", "lib/appsendr/commands/testers.rb", "lib/appsendr/commands/version.rb", "lib/appsendr/constants.rb", "lib/appsendr/helpers.rb"]
+  s.homepage = %q{http://www.appsendr.com/gem}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Appsendr", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{appsendr}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A gem that will build and distribute an iphone/ipad app to the web for remote install}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rest-client>, [">= 1.4.0"])
+      s.add_runtime_dependency(%q<rubyzip>, [">= 0"])
+      s.add_runtime_dependency(%q<json_pure>, [">= 1.2.0"])
+    else
+      s.add_dependency(%q<rest-client>, [">= 1.4.0"])
+      s.add_dependency(%q<rubyzip>, [">= 0"])
+      s.add_dependency(%q<json_pure>, [">= 1.2.0"])
+    end
+  else
+    s.add_dependency(%q<rest-client>, [">= 1.4.0"])
+    s.add_dependency(%q<rubyzip>, [">= 0"])
+    s.add_dependency(%q<json_pure>, [">= 1.2.0"])
+  end
+end

data/bin/appsendr

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'appsendr'
+require 'appsendr/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+AppSendr::Command.run(command, args)
+

data/lib/appsendr/binary_plist.rb

@@ -0,0 +1,514 @@
+require "date"
+require "nkf"
+require "set"
+require "stringio"
+
+## https://github.com/schlueter/Ipa-Reader/blob/master/lib/ipa_reader/ipa_file.rb
+# (The MIT License)
+# 
+# Copyright (c) 2010
+# 
+# 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.
+
+module AppSendr
+  module Plist
+    module Binary
+      # Encodes +obj+ as a binary property list. If +obj+ is an Array, Hash, or
+      # Set, the property list includes its contents.
+      def self.binary_plist(obj)
+        encoded_objs = flatten_collection(obj)
+        ref_byte_size = min_byte_size(encoded_objs.length - 1)
+        encoded_objs.collect! {|o| binary_plist_obj(o, ref_byte_size)}
+        # Write header and encoded objects.
+        plist = "bplist00" + encoded_objs.join
+        # Write offset table.
+        offset_table_addr = plist.length
+        offset = 8
+        offset_table = []
+        encoded_objs.each do |o|
+          offset_table << offset
+          offset += o.length
+        end
+        offset_byte_size = min_byte_size(offset)
+        offset_table.each do |offset|
+          plist += pack_int(offset, offset_byte_size)
+        end
+        # Write trailer.
+        plist += "\0\0\0\0\0\0" # Six unused bytes
+        plist += [
+          offset_byte_size,
+          ref_byte_size,
+          encoded_objs.length >> 32, encoded_objs.length & 0xffffffff,
+          0, 0, # Index of root object
+          offset_table_addr >> 32, offset_table_addr & 0xffffffff
+        ].pack("CCNNNNNN")
+        plist
+      end
+    
+      def self.decode_binary_plist(plist)
+        # Check header.
+        unless plist[0, 6] == "bplist"
+          raise ArgumentError, "argument is not a binary property list"
+        end
+        version = plist[6, 2]
+        unless version == "00"
+          raise ArgumentError,
+            "don't know how to decode format version #{version}"
+        end
+        # Read trailer.
+        trailer = plist[-26, 26].unpack("CCNNNNNN")
+        offset_byte_size    = trailer[0]
+        ref_byte_size       = trailer[1]
+        encoded_objs_length = combine_ints(32, trailer[2], trailer[3])
+        root_index          = combine_ints(32, trailer[4], trailer[5])
+        offset_table_addr   = combine_ints(32, trailer[6], trailer[7])
+        # Decode objects.
+        root_offset = offset_for_index(plist, offset_table_addr,
+          offset_byte_size, root_index)
+        root_obj = decode_binary_plist_obj(plist, root_offset, ref_byte_size)
+        unflatten_collection(root_obj, [root_obj], plist, offset_table_addr,
+          offset_byte_size, ref_byte_size)
+      end
+    
+    private
+    
+      # These marker bytes are prefixed to objects in a binary property list to
+      # indicate the type of the object.
+      CFBinaryPlistMarkerNull = 0x00 # :nodoc:
+      CFBinaryPlistMarkerFalse = 0x08 # :nodoc:
+      CFBinaryPlistMarkerTrue = 0x09 # :nodoc:
+      CFBinaryPlistMarkerFill = 0x0F # :nodoc:
+      CFBinaryPlistMarkerInt = 0x10 # :nodoc:
+      CFBinaryPlistMarkerReal = 0x20 # :nodoc:
+      CFBinaryPlistMarkerDate = 0x33 # :nodoc:
+      CFBinaryPlistMarkerData = 0x40 # :nodoc:
+      CFBinaryPlistMarkerASCIIString = 0x50 # :nodoc:
+      CFBinaryPlistMarkerUnicode16String = 0x60 # :nodoc:
+      CFBinaryPlistMarkerUID = 0x80 # :nodoc:
+      CFBinaryPlistMarkerArray = 0xA0 # :nodoc:
+      CFBinaryPlistMarkerSet = 0xC0 # :nodoc:
+      CFBinaryPlistMarkerDict = 0xD0 # :nodoc:
+    
+      # POSIX uses a reference time of 1970-01-01T00:00:00Z; Cocoa's reference
+      # time is in 2001. This interval is for converting between the two.
+      NSTimeIntervalSince1970 = 978307200.0 # :nodoc:
+    
+      # Takes an object (nominally a collection, like an Array, Set, or Hash, but
+      # any object is acceptable) and flattens it into a one-dimensional array.
+      # Non-collection objects appear in the array as-is, but the contents of
+      # Arrays, Sets, and Hashes are modified like so: (1) The contents of the
+      # collection are added, one-by-one, to the one-dimensional array. (2) The
+      # collection itself is modified so that it contains indexes pointing to the
+      # objects in the one-dimensional array. Here's an example with an Array:
+      #
+      #   ary = [:a, :b, :c]
+      #   flatten_collection(ary) # => [[1, 2, 3], :a, :b, :c]
+      #
+      # In the case of a Hash, keys and values are both appended to the one-
+      # dimensional array and then replaced with indexes.
+      #
+      #   hsh = {:a => "blue", :b => "purple", :c => "green"}
+      #   flatten_collection(hsh)
+      #   # => [{1 => 2, 3 => 4, 5 => 6}, :a, "blue", :b, "purple", :c, "green"]
+      #
+      # An object will never be added to the one-dimensional array twice. If a
+      # collection refers to an object more than once, the object will be added
+      # to the one-dimensional array only once.
+      #
+      #   ary = [:a, :a, :a]
+      #   flatten_collection(ary) # => [[1, 1, 1], :a]
+      #
+      # The +obj_list+ and +id_refs+ parameters are private; they're used for
+      # descending into sub-collections recursively.
+      def self.flatten_collection(collection, obj_list = [], id_refs = {})
+        case collection
+        when Array, Set
+          if id_refs[collection.object_id]
+            return obj_list[id_refs[collection.object_id]]
+          end
+          obj_refs = collection.class.new
+          id_refs[collection.object_id] = obj_list.length
+          obj_list << obj_refs
+          collection.each do |obj|
+            flatten_collection(obj, obj_list, id_refs)
+            obj_refs << id_refs[obj.object_id]
+          end
+          return obj_list
+        when Hash
+          if id_refs[collection.object_id]
+            return obj_list[id_refs[collection.object_id]]
+          end
+          obj_refs = {}
+          id_refs[collection.object_id] = obj_list.length
+          obj_list << obj_refs
+          collection.each do |key, value|
+            key = key.to_s if key.is_a?(Symbol)
+            flatten_collection(key, obj_list, id_refs)
+            flatten_collection(value, obj_list, id_refs)
+            obj_refs[id_refs[key.object_id]] = id_refs[value.object_id]
+          end
+          return obj_list
+        else
+          unless id_refs[collection.object_id]
+            id_refs[collection.object_id] = obj_list.length
+            obj_list << collection
+          end
+          return obj_list
+        end
+      end
+    
+      def self.unflatten_collection(collection, obj_list, plist,
+        offset_table_addr, offset_byte_size, ref_byte_size)
+        case collection
+        when Array, Set
+          collection.collect! do |index|
+            if obj = obj_list[index]
+              obj
+            else
+              offset = offset_for_index(plist, offset_table_addr, offset_byte_size,
+                index)
+              obj = decode_binary_plist_obj(plist, offset, ref_byte_size)
+              obj_list[index] = obj
+              unflatten_collection(obj, obj_list, plist, offset_table_addr,
+                offset_byte_size, ref_byte_size)
+            end
+          end
+        when Hash
+          hsh = {}
+          collection.each do |key, value|
+            unless key_obj = obj_list[key]
+              offset = offset_for_index(plist, offset_table_addr, offset_byte_size,
+                key)
+              key_obj = decode_binary_plist_obj(plist, offset, ref_byte_size)
+              obj_list[key] = key_obj
+              key_obj = unflatten_collection(key_obj, obj_list, plist,
+                offset_table_addr, offset_byte_size, ref_byte_size)
+            end
+            unless value_obj = obj_list[value]
+              offset = offset_for_index(plist, offset_table_addr, offset_byte_size,
+                value)
+              value_obj = decode_binary_plist_obj(plist, offset, ref_byte_size)
+              obj_list[value] = value_obj
+              value_obj = unflatten_collection(value_obj, obj_list, plist,
+                offset_table_addr, offset_byte_size, ref_byte_size)
+            end
+            hsh[key_obj] = value_obj
+          end
+          collection.replace(hsh)
+        end
+        return collection
+      end
+    
+      # Returns a binary property list fragment that represents +obj+. The
+      # returned string is not a complete property list, just a fragment that
+      # describes +obj+, and is not useful without a header, offset table, and
+      # trailer.
+      #
+      # The following classes are recognized: String, Float, Integer, the Boolean
+      # classes, Time, IO, StringIO, Array, Set, and Hash. IO and StringIO
+      # objects are rewound, read, and the contents stored as data (i.e., Cocoa
+      # applications will decode them as NSData). All other classes are dumped
+      # with Marshal and stored as data.
+      #
+      # Note that subclasses of the supported classes will be encoded as though
+      # they were the supported superclass. Thus, a subclass of (for example)
+      # String will be encoded and decoded as a String, not as the subclass:
+      #
+      #   class ExampleString < String
+      #     ...
+      #   end
+      #
+      #   s = ExampleString.new("disquieting plantlike mystery")
+      #   encoded_s = binary_plist_obj(s)
+      #   decoded_s = decode_binary_plist_obj(encoded_s)
+      #   puts decoded_s.class # => String
+      #
+      # +ref_byte_size+ is the number of bytes to use for storing references to
+      # other objects.
+      def self.binary_plist_obj(obj, ref_byte_size = 4)
+        case obj
+        when String
+          obj = obj.to_s if obj.is_a?(Symbol)
+          # This doesn't really work. NKF's guess method is really, really bad
+          # at discovering UTF8 when only a handful of characters are multi-byte.
+          encoding = NKF.guess2(obj)
+          if encoding == NKF::ASCII && obj =~ /[\x80-\xff]/
+            encoding = NKF::UTF8
+          end
+          if [NKF::ASCII, NKF::BINARY, NKF::UNKNOWN].include?(encoding)
+            result = (CFBinaryPlistMarkerASCIIString |
+              (obj.length < 15 ? obj.length : 0xf)).chr
+            result += binary_plist_obj(obj.length) if obj.length >= 15
+            result += obj
+            return result
+          else
+            # Convert to UTF8.
+            if encoding == NKF::UTF8
+              utf8 = obj
+            else
+              utf8 = NKF.nkf("-m0 -w", obj)
+            end
+            # Decode each character's UCS codepoint.
+            codepoints = []
+            i = 0
+            while i < utf8.length
+              byte = utf8[i]
+              if byte & 0xe0 == 0xc0
+                codepoints << ((byte & 0x1f) << 6) + (utf8[i+1] & 0x3f)
+                i += 1
+              elsif byte & 0xf0 == 0xe0
+                codepoints << ((byte & 0xf) << 12) + ((utf8[i+1] & 0x3f) << 6) +
+                  (utf8[i+2] & 0x3f)
+                i += 2
+              elsif byte & 0xf8 == 0xf0
+                codepoints << ((byte & 0xe) << 18) + ((utf8[i+1] & 0x3f) << 12) +
+                  ((utf8[i+2] & 0x3f) << 6) + (utf8[i+3] & 0x3f)
+                i += 3
+              else
+                codepoints << byte
+              end
+              if codepoints.last > 0xffff
+                raise(ArgumentError, "codepoint too high - only the Basic Multilingual Plane can be encoded")
+              end
+              i += 1
+            end
+            # Return string of 16-bit codepoints.
+            data = codepoints.pack("n*")
+            result = (CFBinaryPlistMarkerUnicode16String |
+              (codepoints.length < 15 ? codepoints.length : 0xf)).chr
+            result += binary_plist_obj(codepoints.length) if codepoints.length >= 15
+            result += data
+            return result
+          end
+        when Float
+          return (CFBinaryPlistMarkerReal | 3).chr + [obj].pack("G")
+        when Integer
+          nbytes = min_byte_size(obj)
+          size_bits = { 1 => 0, 2 => 1, 4 => 2, 8 => 3, 16 => 4 }[nbytes]
+          return (CFBinaryPlistMarkerInt | size_bits).chr + pack_int(obj, nbytes)
+        when TrueClass
+          return CFBinaryPlistMarkerTrue.chr
+        when FalseClass
+          return CFBinaryPlistMarkerFalse.chr
+        when Time
+          return CFBinaryPlistMarkerDate.chr +
+            [obj.to_f - NSTimeIntervalSince1970].pack("G")
+        when IO, StringIO
+          obj.rewind
+          return binary_plist_data(obj.read)
+        when Array
+          # Must be an array of object references as returned by flatten_collection.
+          result = (CFBinaryPlistMarkerArray | (obj.length < 15 ? obj.length : 0xf)).chr
+          result += binary_plist_obj(obj.length) if obj.length >= 15
+          result += obj.collect! { |i| pack_int(i, ref_byte_size) }.join
+        when Set
+          # Must be a set of object references as returned by flatten_collection.
+          result = (CFBinaryPlistMarkerSet | (obj.length < 15 ? obj.length : 0xf)).chr
+          result += binary_plist_obj(obj.length) if obj.length >= 15
+          result += obj.to_a.collect! { |i| pack_int(i, ref_byte_size) }.join
+        when Hash
+          # Must be a table of object references as returned by flatten_collection.
+          result = (CFBinaryPlistMarkerDict | (obj.length < 15 ? obj.length : 0xf)).chr
+          result += binary_plist_obj(obj.length) if obj.length >= 15
+          result += obj.keys.collect! { |i| pack_int(i, ref_byte_size) }.join
+          result += obj.values.collect! { |i| pack_int(i, ref_byte_size) }.join
+        else
+          return binary_plist_data(Marshal.dump(obj))
+        end
+      end
+    
+      def self.decode_binary_plist_obj(plist, offset, ref_byte_size)
+        case plist[offset]
+        when CFBinaryPlistMarkerASCIIString..(CFBinaryPlistMarkerASCIIString | 0xf)
+          length, offset = decode_length(plist, offset)
+          return plist[offset, length]
+        when CFBinaryPlistMarkerUnicode16String..(CFBinaryPlistMarkerUnicode16String | 0xf)
+          length, offset = decode_length(plist, offset)
+          codepoints = plist[offset, length * 2].unpack("n*")
+          str = ""
+          codepoints.each do |codepoint|
+            if codepoint <= 0x7f
+              ch = ' '
+              ch[0] = to_i
+            elsif codepoint <= 0x7ff
+              ch = '  '
+              ch[0] = ((codepoint & 0x7c0) >> 6) | 0xc0
+              ch[1] = codepoint & 0x3f | 0x80
+            else
+              ch = '   '
+              ch[0] = ((codepoint & 0xf000) >> 12) | 0xe0
+              ch[1] = ((codepoint & 0xfc0) >> 6) | 0x80
+              ch[2] = codepoint & 0x3f | 0x80
+            end
+            str << ch
+          end
+          return str
+        when CFBinaryPlistMarkerReal | 3
+          return plist[offset+1, 8].unpack("G").first
+        when CFBinaryPlistMarkerInt..(CFBinaryPlistMarkerInt | 0xf)
+          num_bytes = 2 ** (plist[offset] & 0xf)
+          return unpack_int(plist[offset+1, num_bytes])
+        when CFBinaryPlistMarkerTrue
+          return true
+        when CFBinaryPlistMarkerFalse
+          return false
+        when CFBinaryPlistMarkerDate
+          secs = plist[offset+1, 8].unpack("G").first + NSTimeIntervalSince1970
+          return Time.at(secs)
+        when CFBinaryPlistMarkerData..(CFBinaryPlistMarkerData | 0xf)
+          length, offset = decode_length(plist, offset)
+          return StringIO.new(plist[offset, length])
+        when CFBinaryPlistMarkerArray..(CFBinaryPlistMarkerArray | 0xf)
+          ary = []
+          length, offset = decode_length(plist, offset)
+          length.times do
+            ary << unpack_int(plist[offset, ref_byte_size])
+            offset += ref_byte_size
+          end
+          return ary
+        when CFBinaryPlistMarkerDict..(CFBinaryPlistMarkerDict | 0xf)
+          hsh = {}
+          keys = []
+          length, offset = decode_length(plist, offset)
+          length.times do
+            keys << unpack_int(plist[offset, ref_byte_size])
+            offset += ref_byte_size
+          end
+          length.times do |i|
+            hsh[keys[i]] = unpack_int(plist[offset, ref_byte_size])
+            offset += ref_byte_size
+          end
+          return hsh
+        end
+      end
+    
+      # Returns a binary property list fragment that represents a data object
+      # with the contents of the string +data+. A Cocoa application would decode
+      # this fragment as NSData. Like binary_plist_obj, the value returned by
+      # this method is not usable by itself; it is only useful as part of a
+      # complete binary property list with a header, offset table, and trailer.
+      def self.binary_plist_data(data)
+        result = (CFBinaryPlistMarkerData |
+          (data.length < 15 ? data.length : 0xf)).chr
+        result += binary_plist_obj(data.length) if data.length > 15
+        result += data
+        return result
+      end
+    
+      # Determines the minimum number of bytes that is a power of two and can
+      # represent the integer +i+. Raises a RangeError if the number of bytes
+      # exceeds 16. Note that the property list format considers integers of 1,
+      # 2, and 4 bytes to be unsigned, while 8- and 16-byte integers are signed;
+      # thus negative integers will always require at least 8 bytes of storage.
+      def self.min_byte_size(i)
+        if i < 0
+          i = i.abs - 1
+        else
+          if i <= 0xff
+            return 1
+          elsif i <= 0xffff
+            return 2
+          elsif i <= 0xffffffff
+            return 4
+          end
+        end      
+        if i <= 0x7fffffffffffffff
+          return 8
+        elsif i <= 0x7fffffffffffffffffffffffffffffff
+          return 16
+        end
+        raise(RangeError, "integer too big - exceeds 128 bits")
+      end
+    
+      # Packs an integer +i+ into its binary representation in the specified
+      # number of bytes. Byte order is big-endian. Negative integers cannot be
+      # stored in 1, 2, or 4 bytes.
+      def self.pack_int(i, num_bytes)
+        if i < 0 && num_bytes < 8
+          raise(ArgumentError, "negative integers require 8 or 16 bytes of storage")
+        end
+        case num_bytes
+        when 1
+          [i].pack("c")
+        when 2
+          [i].pack("n")
+        when 4
+          [i].pack("N")
+        when 8
+          [(i >> 32) & 0xffffffff, i & 0xffffffff].pack("NN")
+        when 16
+          [i >> 96, (i >> 64) & 0xffffffff, (i >> 32) & 0xffffffff,
+            i & 0xffffffff].pack("NNNN")
+        else
+          raise(ArgumentError, "num_bytes must be 1, 2, 4, 8, or 16")
+        end
+      end
+    
+      def self.combine_ints(num_bits, *ints)
+        i = ints.pop
+        shift_bits = num_bits
+        ints.reverse.each do |i_part|
+          i += i_part << shift_bits
+          shift_bits += num_bits
+        end
+        return i
+      end
+    
+      def self.offset_for_index(plist, table_addr, offset_byte_size, index)
+        offset = plist[table_addr + index * offset_byte_size, offset_byte_size]
+        unpack_int(offset)
+      end
+    
+      def self.unpack_int(s)
+        case s.length
+        when 1
+          s.unpack("C").first
+        when 2
+          s.unpack("n").first
+        when 4
+          s.unpack("N").first
+        when 8
+          i = combine_ints(32, *(s.unpack("NN")))
+          (i & 0x80000000_00000000 == 0) ?
+            i :
+            -(i ^ 0xffffffff_ffffffff) - 1
+        when 16
+          i = combine_ints(32, *(s.unpack("NNNN")))
+          (i & 0x80000000_00000000_00000000_00000000 == 0) ?
+            i :
+            -(i ^ 0xffffffff_ffffffff_ffffffff_ffffffff) - 1
+        else
+          raise(ArgumentError, "length must be 1, 2, 4, 8, or 16 bytes")
+        end
+      end
+    
+      def self.decode_length(plist, offset)
+        if plist[offset] & 0xf == 0xf
+          offset += 1
+          length = decode_binary_plist_obj(plist, offset, 0)
+          offset += min_byte_size(length) + 1
+          return length, offset
+        else
+          return (plist[offset] & 0xf), (offset + 1)
+        end
+      end
+    end
+  end
+end