Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Initial Commit

  • Loading branch information...
commit 7a8a505535c2ff4dc2af859d2c1a63ff6f8de609 0 parents
@adamsanderson authored
7 CHANGELOG.txt
@@ -0,0 +1,7 @@
+0.0.1 - Initial Release
+
+0.0.3 - Minor bug fixes
+
+0.0.4 - Fixed some really silly binary issues,
+ where I was using platform specific endian encoding.
+ - Added some more unit tests to make myself feel better.
0  History.txt
No changes.
21 Manifest.txt
@@ -0,0 +1,21 @@
+CHANGELOG.txt
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/palm.rb
+lib/palm/palm_record.rb
+lib/palm/palm_support.rb
+lib/palm/pdb.rb
+lib/palm/raw_record.rb
+lib/palm/version.rb
+lib/palm/waba_db.rb
+lib/palm/waba_io.rb
+lib/palm/waba_record.rb
+setup.rb
+test/HovData.pdb
+test/pdb_test.rb
+test/test_helper.rb
+test/waba_db_test.rb
+test/waba_io_test.rb
+test/waba_records_test.rb
40 README.txt
@@ -0,0 +1,40 @@
+= Palm
+The palm library is a pure ruby library for reading and writing Palm PDB
+databases. This library is based off of Andrew Arensburger's pdb.pm.
+
+ Adam Sanderson, 2006
+ netghost@gmail.com
+
+= Usage
+Here is a sample that reads through and prints some metadata.
+ pdb = Palm::PDB.new('palm_db.pdb')
+ puts pdb.name
+ puts "Creator #{pdb.creator} / Type #{pdb.type}"
+ puts "There are #{pdb.data.length} records."
+
+Here is an example of adding and removing records:
+ pdb = Palm::PDB.new('palm_db.pdb')
+ #Remove the last record
+ last_record = pdb.data.pop
+ #Append a new fake record
+ pdb.data << Palm::RawRecord.new("This would be binary data")
+ pdb.write_file('new_palm_db.pdb')
+
+= Extending
+The base Palm::PDB will read and write raw PDB files. Their binary data is
+maintained in each record. This is probably not very useful for most cases, but
+will allow access to all the common metadata.
+
+To create a more specific implementation, you should override pack_entry and
+unpack_entry to handle specific record types. See Palm::WabaDB for an example
+implementation supporting Waba format PDBs.
+
+= Plans I am not entirely sold on the current API, a lot of the structure of
+the code is based on Andrew Arensburger's perl code, which doesn't make for
+great ruby code. Where possible I have tried to make the code simpler, but some
+perly bits show through. So the API might change a little, I would really
+appreciate some input.
+
+I personally have no need for reading and writing the Palm Todo Lists,
+Calendars, Notes, and so forth, however if there is sufficient interest, it
+might be fun to add.
50 Rakefile
@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'palm', 'version')
+
+AUTHOR = "Adam Sanderson"
+EMAIL = "netghost@u.washington.edu"
+DESCRIPTION = "Pure Ruby library for reading and writing Palm PDB databases."
+GEM_NAME = "palm"
+RUBYFORGE_PROJECT = "palm"
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+RELEASE_TYPES = %w( gem tar ) # can use: gem, tar, zip
+
+
+NAME = "palm"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Palm::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "palm documentation",
+ "--opname", "index.html",
+ "--line-numbers",
+ "--main", "README",
+ "--inline-source"]
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+ p.author = AUTHOR
+ p.description = DESCRIPTION
+ p.email = EMAIL
+ p.summary = DESCRIPTION
+ p.url = HOMEPATH
+ p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+ p.test_globs = ["test/**/*_test.rb"]
+ p.clean_globs = CLEAN #An array of file patterns to delete on clean.
+
+ # == Optional
+ #p.changes - A description of the release's latest changes.
+ #p.extra_deps - An array of rubygem dependencies.
+ #p.spec_extras - A hash of extra values to set in the gemspec.
+end
+
1  lib/palm.rb
@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), 'palm/**/*.rb')].sort.each { |lib| require lib }
62 lib/palm/palm_record.rb
@@ -0,0 +1,62 @@
+module Palm
+ # Base class for all Palm::PDB Records. This stores the basic metadata for each
+ # record. Subclasses should extend this provide a useful interface for accessing
+ # specific record types.
+ class Record
+ RECORD_ATTRIBUTE_CODES = {
+ :expunged => 0x80,
+ :dirty => 0x40,
+ :deleted => 0x20,
+ :private => 0x10
+ }
+
+ attr_accessor :expunged, :dirty, :deleted, :private, :archive
+ attr_accessor :record_id, :category
+
+ def initialize
+ @category = 0
+ @record_id = 0
+ @dirty = true
+ end
+
+ def packed_attributes
+ encoded = 0
+ if @expunged or @deleted
+ encoded |= 0x08 if @archive
+ else
+ encoded = @category & 0x0f
+ end
+
+ RECORD_ATTRIBUTE_CODES.each do |name,code|
+ encoded |= code if send(name)
+ end
+
+ encoded
+ end
+
+ def packed_attributes=(value)
+ RECORD_ATTRIBUTE_CODES.each do |key,code|
+ self.send("#{key}=", (value & code) > 0)
+ end
+ if (value & 0xa0) == 0
+ @category = (value & 0x0f)
+ else
+ @archive = (value & 0x08) > 0
+ end
+ end
+
+ end
+
+ # Base class for all Palm::PDB Resources. This stores the basic metadata for each
+ # record. Subclasses should extend this provide a useful interface for accessing
+ # specific record types.
+ class Resource
+ attr_accessor :record_type, :record_id
+ def intialize
+ @record_type = "\0\0\0\0"
+ @record_id = 0
+ end
+
+ end
+
+end
12 lib/palm/palm_support.rb
@@ -0,0 +1,12 @@
+# Class extensions for making palm data easier to work with
+class Time
+ EPOC_1904 = 2082844800 # Difference between Palm's epoch
+
+ def to_palm_seconds
+ to_i + EPOC_1904
+ end
+
+ def self.at_palm_seconds(seconds)
+ at(seconds - EPOC_1904)
+ end
+end
371 lib/palm/pdb.rb
@@ -0,0 +1,371 @@
+require 'enumerator'
+
+# This is a port of Andrew Arensburger's Perl Palm database module
+# I have attempted to make the code as ruby friendly as possible, while still working ;)
+# Perl code does not good ruby api design make, thus, I'll be moving stuff
+# around to make something more natural soon. (Read API changes ahead)
+#
+# See the README for some more goodies.
+#
+# It is currently only somewhat tested, so I would love some more feedback
+# Adam Sanderson, 2006
+# netghost@gmail.com
+
+module Palm
+ # Internal structure for storing information about data entries
+ DataBlock = Struct.new( :offset, :record_length)
+ # Internal structure for recording index information
+ RecordIndex = Struct.new( :record_id,:packed_attributes, :offset, :record_length)
+ # Internal structure for recording index information
+ ResourceIndex = Struct.new( :record_id,:record_type, :offset, :record_length)
+
+ # PDB handles reading and writing raw Palm PDB records and resources.
+ # For most cases, users will probably want to extend this class class, overriding
+ # pack_entry and unpack_entry to support their record types.
+ #
+ # Records are simply stored as an array in +data+, so polish up on your
+ # enumerable tricks. The +created_at+, +modified_at+, and +backed_up_at+
+ # attributes are all stored as Times. Note that +modified_at+ is not
+ # automatically updated.
+ class PDB
+ attr_accessor :name, :attributes, :version
+ attr_accessor :created_at, :modified_at, :backed_up_at
+ attr_accessor :modnum, :type, :creator
+ attr_accessor :unique_id_seed
+ attr_accessor :data
+
+ HEADER_LENGTH = 32+2+2+(9*4) # Size of database header
+ RECORD_INDEX_HEADER_LEN = 6 # Size of record index header
+ INDEX_RECORD_LENGTH = 8 # Length of record index entry
+ INDEX_RESOURCE_LENGTH = 10 # Length of resource index entry
+
+ ATTRIBUTE_CODES = {
+ "resource" => 0x0001,
+ "read-only" => 0x0002,
+ "AppInfo dirty" => 0x0004,
+ "backup" => 0x0008,
+ "OK newer" => 0x0010,
+ "reset" => 0x0020,
+ "launchable" => 0x0200,
+ "open" => 0x8000,
+
+ # PalmOS 5.0 attribute names
+ "ResDB" => 0x0001,
+ "ReadOnly" => 0x0002,
+ "AppInfoDirty" => 0x0004,
+ "Backup" => 0x0008,
+ "OKToInstallNewer" => 0x0010,
+ "ResetAfterInstall"=> 0x0020,
+ "LaunchableData" => 0x0200,
+ "Recyclable" => 0x0400,
+ "Bundle" => 0x0800,
+ "Open" => 0x8000,
+ }
+
+ # Creates a new PDB. If +from+ is passed a String, a file will be
+ # loaded from that path (see +load_file+). If a IO object is passed in,
+ # then it will be used to load the palm data (see +load+).
+ def initialize(from = nil)
+ @attributes = {}
+ @data = []
+ @appinfo_block = nil
+ @sort_block = nil
+ @backed_up_at = @created_at = @modified_at = Time.now
+
+ case from
+ when NilClass
+ now = Time.now
+ @created_at = now
+ @modified_at = now
+ @version = 0
+ @modnum = 0
+ @type = "\0\0\0\0"
+ @creator = "\0\0\0\0"
+ @unique_id_seed = 0
+ when String
+ load(open(from))
+ when IO
+ load(from)
+ else
+ raise ArgumentError.new("Unknown value to load from #{from.inspect}. Use a String or IO object.")
+ end
+ end
+
+ # Returns true if the PDB is a set of resources, false if it is a set of records
+ def resource?
+ @attributes['resource'] || @attributes['ResDB']
+ end
+
+ # Loads the PDB from a file path
+ def load_file(path)
+ open path, "r" do |io|
+ load io
+ end
+ end
+
+ # Loads the PDB from the given IO source.
+ def load(io)
+ # Set to binary mode for windows environment
+ io.binmode if io.respond_to? :binmode
+
+ start_postion = io.pos
+ io.seek(0, IO::SEEK_END)
+ io_size = io.pos
+ io.seek(start_postion)
+
+ appinfo_offset, sort_offset = unpack_header(io.read(HEADER_LENGTH))
+
+ # parse the record index
+ record_index = io.read(RECORD_INDEX_HEADER_LEN)
+ next_index, record_count = record_index.unpack("N n")
+
+ # load the indexes, gather information about offsets and
+ # record lengths
+ indexes = nil
+ if resource?
+ indexes = load_resource_index(io, next_index, record_count)
+ else
+ indexes = load_record_index(io, next_index, record_count)
+ end
+ # Add the final offset as a Datablock for the end of the file
+ indexes << DataBlock.new(io_size, 0)
+ # Fill in the lengths for each of these index entries
+ indexes.each_cons(2){|starts, ends| starts.record_length = ends.offset - starts.offset }
+ # Calculate where the data starts (or end of file if empty)
+ data_offset = indexes.first.offset
+
+ # Pop the last entry back off. We pushed it on make it easier to calculate the lengths
+ # of each entry.
+ indexes.pop
+
+ # Load optional chunks
+ load_appinfo_block(io, appinfo_offset, sort_offset, data_offset) if appinfo_offset > 0
+ load_sort_block(io, sort_offset, data_offset) if sort_offset > 0
+
+ # Load data
+ load_data(io, indexes)
+ io.close
+ end
+
+ protected
+ # Custom PDB formats must overide this to support their record format.
+ # The default implementation returns
+ # RawRecord or RawResource classes depending on the PDB's metadata.
+ def unpack_entry(byte_string)
+ entry = resource? ? RawResource.new : RawRecord.new
+ entry.data = byte_string # Duck typing rules! :)
+ entry
+ end
+
+ # Parses the header, returning the app_info_offset and sort_offset
+ def unpack_header(header)
+ @name, bin_attributes, @version, @created_at, @modified_at, @backed_up_at,
+ @modnum, appinfo_offset, sort_offset, @type, @creator,
+ @unique_id_seed = header.unpack("a32 n n N N N N N N a4 a4 N")
+
+ # Clean up some of the input:
+ @name.rstrip! # Get rid of null characters at the end of the name
+
+ ATTRIBUTE_CODES.each do |key,code|
+ @attributes[key] = (bin_attributes & code) > 0
+ end
+
+ @created_at = Time.at_palm_seconds @created_at
+ @modified_at = Time.at_palm_seconds @modified_at
+ @backed_up_at = Time.at_palm_seconds @backed_up_at
+ [appinfo_offset, sort_offset]
+ end
+
+ def load_resource_index(io, next_index, record_count)
+ (0...record_count).map do |i|
+ index = ResourceIndex.new
+ resource_index = io.read(INDEX_RESOURCE_LENGTH)
+ index.record_type, index.record_id, index.offset = resource_index.unpack "a4 n N"
+ index
+ end
+ end
+
+ def load_record_index(io, next_index, record_count)
+ last_offset = 0
+ (0...record_count).map do |i|
+ index = RecordIndex.new
+ record_index = io.read(INDEX_RECORD_LENGTH)
+ offset, packed_attributes, id_a,id_b,id_c = record_index.unpack "N C C3"
+ # The ID is a 3 byte number... of course ;)
+ record_id = (id_a << 16) | (id_b << 8) | id_c
+
+ index.packed_attributes = packed_attributes
+ index.record_id = record_id
+ index.offset = offset
+ index
+ end
+ end
+
+ def load_appinfo_block(io, appinfo_offset, sort_offset, data_offset)
+ if io.pos > appinfo_offset
+ raise IOError.new("Bad appinfo_offset (#{appinfo_offset}), while at #{io.pos} of #{io.inspect}.")
+ end
+ io.seek(appinfo_offset)
+
+ # Read either to the sort offset, or to the data offset
+ length = (sort_offset > 0 ? sort_offset : data_offset) - appinfo_offset
+ unpack_appinfo_block(io.read(length))
+ end
+
+ def load_sort_block(io, sort_offset, data_offset)
+ if io.pos > sort_offset
+ raise IOError.new("Bad sort_offset (#{sort_offset}), while at #{io.pos} of #{io.inspect}.")
+ end
+
+ io.seek sort_offset
+ # Read to the data offset
+ length = data_offset - sort_offset
+ unpack_sort_block(io.read(length))
+ end
+
+ def load_data(io, indexes)
+ @data = indexes.map do |index|
+ if io.pos > index.offset
+ raise IOError.new("Bad index offset (#{index.offset}), while at #{io.pos} of #{io.inspect}.")
+ end
+ io.seek index.offset
+
+ #Create a record
+ byte_string = io.read(index.record_length)
+ entry = unpack_entry(byte_string)
+
+ # Fill in information from the header
+ entry.record_id = index.record_id
+ if resource?
+ entry.record_type = index.record_type
+ else
+ entry.packed_attributes = index.packed_attributes
+ end
+
+ entry
+ end
+ end
+
+ # Custom PDB formats may wish to overide this to support custom appinfo
+ # blocks.
+ def unpack_appinfo_block(data)
+ @appinfo_block = data
+ end
+
+ # Custom PDB formats may wish to overide this to support custom sort
+ # blocks.
+ def unpack_sort_block(data)
+ @sort_block = data
+ end
+
+ public
+ # Writes to the given path
+ def write_file(path)
+ open(path, "w") do |io|
+ write io
+ end
+ end
+
+ # Writes PDB to an IO object
+ def write(io)
+ io.binmode if io.respond_to? :binmode
+
+ # Track the current offset for each section
+ offset_position = HEADER_LENGTH + 2 #(2: Index Header length)
+
+ index_length = RECORD_INDEX_HEADER_LEN +
+ @data.length * (resource? ? INDEX_RESOURCE_LENGTH : INDEX_RECORD_LENGTH )
+
+ offset_position += index_length # Advance for the index
+
+ packed_entries = @data.map{|e| pack_entry(e)}
+
+ packed_app_info = pack_app_info_block()
+ packed_sort = pack_sort_block()
+
+ # Calculate AppInfo block offset
+ app_info_offset = 0
+ if packed_app_info and !packed_app_info.empty?
+ app_info_offset = offset_position
+ offset_position += packed_app_info.length # Advance for the app_info_block
+ end
+
+ # Calculate sort block offset
+ sort_offset = 0
+ if packed_sort and !packed_sort.empty?
+ sort_offset = offset_position
+ offset_position += packed_sort.length # Advance for the sort_block
+ end
+
+ packed_header = pack_header(app_info_offset, sort_offset)
+
+ index_header = [0, @data.length ].pack "N n"
+
+ packed_index = @data.zip(packed_entries).map do |entry, packed|
+ index = nil
+ if resource?
+ index = [entry.record_type, entry.record_id, offset_position].pack "a4 n N"
+ else
+ index = [
+ offset_position, entry.packed_attributes,
+ (entry.record_id >> 16) & 0xff,
+ (entry.record_id >> 8) & 0xff,
+ entry.record_id & 0xff
+ ].pack "N C C3"
+ end
+ offset_position += packed.length
+ index
+ end
+
+ # Write to IO stream
+ io << packed_header
+ io << index_header
+ io << packed_index.join
+ io << "\0\0" # 2 null byte separator
+ io << @app_info_block unless app_info_offset == 0
+ io << @sort_block unless sort_offset == 0
+ io << packed_entries.join
+ end
+
+ protected
+ def encode_attributes
+ encoded = 0
+ @attributes.each do |name,flagged|
+ encoded |= ATTRIBUTE_CODES[name] if flagged
+ end
+
+ encoded
+ end
+
+ def pack_header(app_info_offset, sort_offset)
+ attributes = encode_attributes
+
+ header_block = [
+ @name, attributes, @version,
+ @created_at.to_palm_seconds, @modified_at.to_palm_seconds, @backed_up_at.to_palm_seconds,
+ @modnum, app_info_offset, sort_offset,
+ @type, @creator,
+ @unique_id_seed
+ ].pack "a32 n n N N N N N N a4 a4 N"
+ header_block
+ end
+
+ # Custom PDB formats must overide this to support their record format.
+ def pack_entry(entry)
+ entry.data
+ end
+
+ # Custom PDB formats may wish to overide this to support custom sort
+ # blocks.
+ def pack_sort_block
+ @sort_block
+ end
+
+ # Custom PDB formats may wish to overide this to support custom appinfo
+ # blocks.
+ def pack_app_info_block
+ @appinfo_block
+ end
+ end
+
+end
21 lib/palm/raw_record.rb
@@ -0,0 +1,21 @@
+module Palm
+ # Stores the contents of the record in the data attribute as a byte string.
+ # This is suitable for any record where the actual content of the record is irrelevant.
+ class RawRecord < Record
+ attr_accessor :data
+ def initialize(bytes=nil)
+ super()
+ @data = bytes
+ end
+ end
+
+ # Stores the contents of the resource in the data attribute as a byte string.
+ # This is suitable for any resource where the actual content of the resource is irrelevant.
+ class RawResource < Resource
+ attr_accessor :data
+ def initialize(bytes=nil)
+ super()
+ @data = bytes
+ end
+ end
+end
9 lib/palm/version.rb
@@ -0,0 +1,9 @@
+module Palm #:nodoc:
+ module VERSION #:nodoc:
+ MAJOR = 0
+ MINOR = 0
+ TINY = 4
+
+ STRING = [MAJOR, MINOR, TINY].join('.')
+ end
+end
44 lib/palm/waba_db.rb
@@ -0,0 +1,44 @@
+module Palm
+ # SuperWaba supports Palm PDB files, but handles them a little awkwardly.
+ # Each of the file's different record types must be passed in when constructing
+ # a new WabaDB so we know what record types are available.
+ class WabaDB < Palm::PDB
+ # Create a new WabaDB with +record_classes+ as the available types of records.
+ # See Palm::WabaRecord for more information.
+ def initialize(*record_classes)
+ super()
+ if record_classes.empty?
+ raise ArgumentError.new('At least one WabaRecord class must be provided.')
+ end
+ @record_index = {}
+ record_classes.each{|c| @record_index[c.class_id] = c }
+ @last_class = record_classes.first
+ end
+
+ def unpack_entry(data)
+ s = WabaStringIO.new(data)
+ class_id = s.get_byte
+ c = class_for(class_id)
+ c.new.read(s)
+ end
+
+ def pack_entry(entry)
+ data = ""
+ s = WabaStringIO.new(data)
+ s.write_byte(entry.class_id)
+ entry.write(s)
+ data
+ end
+
+ protected
+ # Optimized for repeating record classes
+ def class_for(i)
+ if @last_class.class_id == i
+ @last_class
+ else
+ @last_class = @record_index[i]
+ end
+ end
+
+ end
+end
65 lib/palm/waba_io.rb
@@ -0,0 +1,65 @@
+require 'stringio'
+
+module Palm
+ # Wildly unoptimized! 50/50 stolen from SuperWaba's datastream and shortcuts with pack ;)
+ module WabaIOSupport
+ def get_string
+ read(get_short)
+ end
+
+ def get_short
+ s = read(2)
+ ((s[0] & 0xFF) << 8) | (s[1] & 0xFF)
+ end
+
+ def get_byte
+ readchar
+ end
+
+ def get_int
+ s = read(4)
+ ((s[0] & 0xFF) << 24) |
+ ((s[1] & 0xFF) << 16) |
+ ((s[2] & 0xFF) << 8) |
+ (s[3] & 0xFF)
+ end
+
+ def get_bool
+ read(1)[0] != 0
+ end
+
+ def write_string(string)
+ write_short(string.length)
+ write string
+ end
+
+ def write_short(short)
+ putc( (short >> 8) & 0xFF )
+ putc( (short >> 0) & 0xFF )
+ end
+
+ def write_byte(byte)
+ putc byte
+ end
+
+ def write_int(integer)
+ putc( (integer >> 24) & 0xFF )
+ putc( (integer >> 16) & 0xFF )
+ putc( (integer >> 8) & 0xFF )
+ putc( (integer >> 0) & 0xFF )
+ end
+
+ def write_bool(b)
+ putc b ? 1 : 0
+ end
+ end
+
+ class WabaStringIO < StringIO
+ include WabaIOSupport
+ end
+
+ class WabaIO < IO
+ include WabaIOSupport
+ end
+
+end
62 lib/palm/waba_record.rb
@@ -0,0 +1,62 @@
+module Palm
+ WabaField = Struct.new(:name, :type)
+
+ class WabaRecord < Record
+ WRITE_TYPES = {
+ # Value || Default
+ :string=> lambda{|io,v| io.write_string(v||'' )},
+ :int=> lambda{|io,v| io.write_int( v||0 )},
+ :byte=> lambda{|io,v| io.write_byte( v||0 )},
+ :short=> lambda{|io,v| io.write_short( v||0 )},
+ :boolean=>lambda{|io,v| io.write_bool( v||false)},
+ }
+
+ READ_TYPES = {
+ :string=> lambda{|io| io.get_string },
+ :int=> lambda{|io| io.get_int },
+ :byte=> lambda{|io| io.get_byte },
+ :short=> lambda{|io| io.get_short },
+ :boolean=>lambda{|io| io.get_bool },
+ }
+
+ class << self
+ def field(name,type)
+ # Add a new class method to for each trait.
+ attr_accessor name
+ (@fields ||= []) << WabaField.new(name,type)
+ end
+
+ def fields
+ @fields.dup
+ end
+
+ def class_id(value=nil)
+ if value
+ @class_id = value
+ else
+ @class_id
+ end
+ end
+ end
+
+ def class_id
+ self.class.class_id
+ end
+
+ # Assumes that the class_id has already been read off the stream
+ def read(waba_io)
+ self.class.fields.each do |f|
+ instance_variable_set "@#{f.name}", READ_TYPES[f.type].call(waba_io)
+ end
+ self
+ end
+
+ def write(waba_io)
+ self.class.fields.each do |f|
+ WRITE_TYPES[f.type].call(waba_io, instance_variable_get("@#{f.name}"))
+ end
+ self
+ end
+
+ end
+end
1,585 setup.rb
@@ -0,0 +1,1585 @@
+#
+# setup.rb
+#
+# Copyright (c) 2000-2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+#
+
+unless Enumerable.method_defined?(:map) # Ruby 1.4.6
+ module Enumerable
+ alias map collect
+ end
+end
+
+unless File.respond_to?(:read) # Ruby 1.6
+ def File.read(fname)
+ open(fname) {|f|
+ return f.read
+ }
+ end
+end
+
+unless Errno.const_defined?(:ENOTEMPTY) # Windows?
+ module Errno
+ class ENOTEMPTY
+ # We do not raise this exception, implementation is not needed.
+ end
+ end
+end
+
+def File.binread(fname)
+ open(fname, 'rb') {|f|
+ return f.read
+ }
+end
+
+# for corrupted Windows' stat(2)
+def File.dir?(path)
+ File.directory?((path[-1,1] == '/') ? path : path + '/')
+end
+
+
+class ConfigTable
+
+ include Enumerable
+
+ def initialize(rbconfig)
+ @rbconfig = rbconfig
+ @items = []
+ @table = {}
+ # options
+ @install_prefix = nil
+ @config_opt = nil
+ @verbose = true
+ @no_harm = false
+ end
+
+ attr_accessor :install_prefix
+ attr_accessor :config_opt
+
+ attr_writer :verbose
+
+ def verbose?
+ @verbose
+ end
+
+ attr_writer :no_harm
+
+ def no_harm?
+ @no_harm
+ end
+
+ def [](key)
+ lookup(key).resolve(self)
+ end
+
+ def []=(key, val)
+ lookup(key).set val
+ end
+
+ def names
+ @items.map {|i| i.name }
+ end
+
+ def each(&block)
+ @items.each(&block)
+ end
+
+ def key?(name)
+ @table.key?(name)
+ end
+
+ def lookup(name)
+ @table[name] or setup_rb_error "no such config item: #{name}"
+ end
+
+ def add(item)
+ @items.push item
+ @table[item.name] = item
+ end
+
+ def remove(name)
+ item = lookup(name)
+ @items.delete_if {|i| i.name == name }
+ @table.delete_if {|name, i| i.name == name }
+ item
+ end
+
+ def load_script(path, inst = nil)
+ if File.file?(path)
+ MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path
+ end
+ end
+
+ def savefile
+ '.config'
+ end
+
+ def load_savefile
+ begin
+ File.foreach(savefile()) do |line|
+ k, v = *line.split(/=/, 2)
+ self[k] = v.strip
+ end
+ rescue Errno::ENOENT
+ setup_rb_error $!.message + "\n#{File.basename($0)} config first"
+ end
+ end
+
+ def save
+ @items.each {|i| i.value }
+ File.open(savefile(), 'w') {|f|
+ @items.each do |i|
+ f.printf "%s=%s\n", i.name, i.value if i.value? and i.value
+ end
+ }
+ end
+
+ def load_standard_entries
+ standard_entries(@rbconfig).each do |ent|
+ add ent
+ end
+ end
+
+ def standard_entries(rbconfig)
+ c = rbconfig
+
+ rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT'])
+
+ major = c['MAJOR'].to_i
+ minor = c['MINOR'].to_i
+ teeny = c['TEENY'].to_i
+ version = "#{major}.#{minor}"
+
+ # ruby ver. >= 1.4.4?
+ newpath_p = ((major >= 2) or
+ ((major == 1) and
+ ((minor >= 5) or
+ ((minor == 4) and (teeny >= 4)))))
+
+ if c['rubylibdir']
+ # V > 1.6.3
+ libruby = "#{c['prefix']}/lib/ruby"
+ librubyver = c['rubylibdir']
+ librubyverarch = c['archdir']
+ siteruby = c['sitedir']
+ siterubyver = c['sitelibdir']
+ siterubyverarch = c['sitearchdir']
+ elsif newpath_p
+ # 1.4.4 <= V <= 1.6.3
+ libruby = "#{c['prefix']}/lib/ruby"
+ librubyver = "#{c['prefix']}/lib/ruby/#{version}"
+ librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}"
+ siteruby = c['sitedir']
+ siterubyver = "$siteruby/#{version}"
+ siterubyverarch = "$siterubyver/#{c['arch']}"
+ else
+ # V < 1.4.4
+ libruby = "#{c['prefix']}/lib/ruby"
+ librubyver = "#{c['prefix']}/lib/ruby/#{version}"
+ librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}"
+ siteruby = "#{c['prefix']}/lib/ruby/#{version}/site_ruby"
+ siterubyver = siteruby
+ siterubyverarch = "$siterubyver/#{c['arch']}"
+ end
+ parameterize = lambda {|path|
+ path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix')
+ }
+
+ if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg }
+ makeprog = arg.sub(/'/, '').split(/=/, 2)[1]
+ else
+ makeprog = 'make'
+ end
+
+ [
+ ExecItem.new('installdirs', 'std/site/home',
+ 'std: install under libruby; site: install under site_ruby; home: install under $HOME')\
+ {|val, table|
+ case val
+ when 'std'
+ table['rbdir'] = '$librubyver'
+ table['sodir'] = '$librubyverarch'
+ when 'site'
+ table['rbdir'] = '$siterubyver'
+ table['sodir'] = '$siterubyverarch'
+ when 'home'
+ setup_rb_error '$HOME was not set' unless ENV['HOME']
+ table['prefix'] = ENV['HOME']
+ table['rbdir'] = '$libdir/ruby'
+ table['sodir'] = '$libdir/ruby'
+ end
+ },
+ PathItem.new('prefix', 'path', c['prefix'],
+ 'path prefix of target environment'),
+ PathItem.new('bindir', 'path', parameterize.call(c['bindir']),
+ 'the directory for commands'),
+ PathItem.new('libdir', 'path', parameterize.call(c['libdir']),
+ 'the directory for libraries'),
+ PathItem.new('datadir', 'path', parameterize.call(c['datadir']),
+ 'the directory for shared data'),
+ PathItem.new('mandir', 'path', parameterize.call(c['mandir']),
+ 'the directory for man pages'),
+ PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']),
+ 'the directory for system configuration files'),
+ PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']),
+ 'the directory for local state data'),
+ PathItem.new('libruby', 'path', libruby,
+ 'the directory for ruby libraries'),
+ PathItem.new('librubyver', 'path', librubyver,
+ 'the directory for standard ruby libraries'),
+ PathItem.new('librubyverarch', 'path', librubyverarch,
+ 'the directory for standard ruby extensions'),
+ PathItem.new('siteruby', 'path', siteruby,
+ 'the directory for version-independent aux ruby libraries'),
+ PathItem.new('siterubyver', 'path', siterubyver,
+ 'the directory for aux ruby libraries'),
+ PathItem.new('siterubyverarch', 'path', siterubyverarch,
+ 'the directory for aux ruby binaries'),
+ PathItem.new('rbdir', 'path', '$siterubyver',
+ 'the directory for ruby scripts'),
+ PathItem.new('sodir', 'path', '$siterubyverarch',
+ 'the directory for ruby extentions'),
+ PathItem.new('rubypath', 'path', rubypath,
+ 'the path to set to #! line'),
+ ProgramItem.new('rubyprog', 'name', rubypath,
+ 'the ruby program using for installation'),
+ ProgramItem.new('makeprog', 'name', makeprog,
+ 'the make program to compile ruby extentions'),
+ SelectItem.new('shebang', 'all/ruby/never', 'ruby',
+ 'shebang line (#!) editing mode'),
+ BoolItem.new('without-ext', 'yes/no', 'no',
+ 'does not compile/install ruby extentions')
+ ]
+ end
+ private :standard_entries
+
+ def load_multipackage_entries
+ multipackage_entries().each do |ent|
+ add ent
+ end
+ end
+
+ def multipackage_entries
+ [
+ PackageSelectionItem.new('with', 'name,name...', '', 'ALL',
+ 'package names that you want to install'),
+ PackageSelectionItem.new('without', 'name,name...', '', 'NONE',
+ 'package names that you do not want to install')
+ ]
+ end
+ private :multipackage_entries
+
+ ALIASES = {
+ 'std-ruby' => 'librubyver',
+ 'stdruby' => 'librubyver',
+ 'rubylibdir' => 'librubyver',
+ 'archdir' => 'librubyverarch',
+ 'site-ruby-common' => 'siteruby', # For backward compatibility
+ 'site-ruby' => 'siterubyver', # For backward compatibility
+ 'bin-dir' => 'bindir',
+ 'bin-dir' => 'bindir',
+ 'rb-dir' => 'rbdir',
+ 'so-dir' => 'sodir',
+ 'data-dir' => 'datadir',
+ 'ruby-path' => 'rubypath',
+ 'ruby-prog' => 'rubyprog',
+ 'ruby' => 'rubyprog',
+ 'make-prog' => 'makeprog',
+ 'make' => 'makeprog'
+ }
+
+ def fixup
+ ALIASES.each do |ali, name|
+ @table[ali] = @table[name]
+ end
+ @items.freeze
+ @table.freeze
+ @options_re = /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/
+ end
+
+ def parse_opt(opt)
+ m = @options_re.match(opt) or setup_rb_error "config: unknown option #{opt}"
+ m.to_a[1,2]
+ end
+
+ def dllext
+ @rbconfig['DLEXT']
+ end
+
+ def value_config?(name)
+ lookup(name).value?
+ end
+
+ class Item
+ def initialize(name, template, default, desc)
+ @name = name.freeze
+ @template = template
+ @value = default
+ @default = default
+ @description = desc
+ end
+
+ attr_reader :name
+ attr_reader :description
+
+ attr_accessor :default
+ alias help_default default
+
+ def help_opt
+ "--#{@name}=#{@template}"
+ end
+
+ def value?
+ true
+ end
+
+ def value
+ @value
+ end
+
+ def resolve(table)
+ @value.gsub(%r<\$([^/]+)>) { table[$1] }
+ end
+
+ def set(val)
+ @value = check(val)
+ end
+
+ private
+
+ def check(val)
+ setup_rb_error "config: --#{name} requires argument" unless val
+ val
+ end
+ end
+
+ class BoolItem < Item
+ def config_type
+ 'bool'
+ end
+
+ def help_opt
+ "--#{@name}"
+ end
+
+ private
+
+ def check(val)
+ return 'yes' unless val
+ case val
+ when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes'
+ when /\An(o)?\z/i, /\Af(alse)\z/i then 'no'
+ else
+ setup_rb_error "config: --#{@name} accepts only yes/no for argument"
+ end
+ end
+ end
+
+ class PathItem < Item
+ def config_type
+ 'path'
+ end
+
+ private
+
+ def check(path)
+ setup_rb_error "config: --#{@name} requires argument" unless path
+ path[0,1] == '$' ? path : File.expand_path(path)
+ end
+ end
+
+ class ProgramItem < Item
+ def config_type
+ 'program'
+ end
+ end
+
+ class SelectItem < Item
+ def initialize(name, selection, default, desc)
+ super
+ @ok = selection.split('/')
+ end
+
+ def config_type
+ 'select'
+ end
+
+ private
+
+ def check(val)
+ unless @ok.include?(val.strip)
+ setup_rb_error "config: use --#{@name}=#{@template} (#{val})"
+ end
+ val.strip
+ end
+ end
+
+ class ExecItem < Item
+ def initialize(name, selection, desc, &block)
+ super name, selection, nil, desc
+ @ok = selection.split('/')
+ @action = block
+ end
+
+ def config_type
+ 'exec'
+ end
+
+ def value?
+ false
+ end
+
+ def resolve(table)
+ setup_rb_error "$#{name()} wrongly used as option value"
+ end
+
+ undef set
+
+ def evaluate(val, table)
+ v = val.strip.downcase
+ unless @ok.include?(v)
+ setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})"
+ end
+ @action.call v, table
+ end
+ end
+
+ class PackageSelectionItem < Item
+ def initialize(name, template, default, help_default, desc)
+ super name, template, default, desc
+ @help_default = help_default
+ end
+
+ attr_reader :help_default
+
+ def config_type
+ 'package'
+ end
+
+ private
+
+ def check(val)
+ unless File.dir?("packages/#{val}")
+ setup_rb_error "config: no such package: #{val}"
+ end
+ val
+ end
+ end
+
+ class MetaConfigEnvironment
+ def initialize(config, installer)
+ @config = config
+ @installer = installer
+ end
+
+ def config_names
+ @config.names
+ end
+
+ def config?(name)
+ @config.key?(name)
+ end
+
+ def bool_config?(name)
+ @config.lookup(name).config_type == 'bool'
+ end
+
+ def path_config?(name)
+ @config.lookup(name).config_type == 'path'
+ end
+
+ def value_config?(name)
+ @config.lookup(name).config_type != 'exec'
+ end
+
+ def add_config(item)
+ @config.add item
+ end
+
+ def add_bool_config(name, default, desc)
+ @config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc)
+ end
+
+ def add_path_config(name, default, desc)
+ @config.add PathItem.new(name, 'path', default, desc)
+ end
+
+ def set_config_default(name, default)
+ @config.lookup(name).default = default
+ end
+
+ def remove_config(name)
+ @config.remove(name)
+ end
+
+ # For only multipackage
+ def packages
+ raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer
+ @installer.packages
+ end
+
+ # For only multipackage
+ def declare_packages(list)
+ raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer
+ @installer.packages = list
+ end
+ end
+
+end # class ConfigTable
+
+
+# This module requires: #verbose?, #no_harm?
+module FileOperations
+
+ def mkdir_p(dirname, prefix = nil)
+ dirname = prefix + File.expand_path(dirname) if prefix
+ $stderr.puts "mkdir -p #{dirname}" if verbose?
+ return if no_harm?
+
+ # Does not check '/', it's too abnormal.
+ dirs = File.expand_path(dirname).split(%r<(?=/)>)
+ if /\A[a-z]:\z/i =~ dirs[0]
+ disk = dirs.shift
+ dirs[0] = disk + dirs[0]
+ end
+ dirs.each_index do |idx|
+ path = dirs[0..idx].join('')
+ Dir.mkdir path unless File.dir?(path)
+ end
+ end
+
+ def rm_f(path)
+ $stderr.puts "rm -f #{path}" if verbose?
+ return if no_harm?
+ force_remove_file path
+ end
+
+ def rm_rf(path)
+ $stderr.puts "rm -rf #{path}" if verbose?
+ return if no_harm?
+ remove_tree path
+ end
+
+ def remove_tree(path)
+ if File.symlink?(path)
+ remove_file path
+ elsif File.dir?(path)
+ remove_tree0 path
+ else
+ force_remove_file path
+ end
+ end
+
+ def remove_tree0(path)
+ Dir.foreach(path) do |ent|
+ next if ent == '.'
+ next if ent == '..'
+ entpath = "#{path}/#{ent}"
+ if File.symlink?(entpath)
+ remove_file entpath
+ elsif File.dir?(entpath)
+ remove_tree0 entpath
+ else
+ force_remove_file entpath
+ end
+ end
+ begin
+ Dir.rmdir path
+ rescue Errno::ENOTEMPTY
+ # directory may not be empty
+ end
+ end
+
+ def move_file(src, dest)
+ force_remove_file dest
+ begin
+ File.rename src, dest
+ rescue
+ File.open(dest, 'wb') {|f|
+ f.write File.binread(src)
+ }
+ File.chmod File.stat(src).mode, dest
+ File.unlink src
+ end
+ end
+
+ def force_remove_file(path)
+ begin
+ remove_file path
+ rescue
+ end
+ end
+
+ def remove_file(path)
+ File.chmod 0777, path
+ File.unlink path
+ end
+
+ def install(from, dest, mode, prefix = nil)
+ $stderr.puts "install #{from} #{dest}" if verbose?
+ return if no_harm?
+
+ realdest = prefix ? prefix + File.expand_path(dest) : dest
+ realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest)
+ str = File.binread(from)
+ if diff?(str, realdest)
+ verbose_off {
+ rm_f realdest if File.exist?(realdest)
+ }
+ File.open(realdest, 'wb') {|f|
+ f.write str
+ }
+ File.chmod mode, realdest
+
+ File.open("#{objdir_root()}/InstalledFiles", 'a') {|f|
+ if prefix
+ f.puts realdest.sub(prefix, '')
+ else
+ f.puts realdest
+ end
+ }
+ end
+ end
+
+ def diff?(new_content, path)
+ return true unless File.exist?(path)
+ new_content != File.binread(path)
+ end
+
+ def command(*args)
+ $stderr.puts args.join(' ') if verbose?
+ system(*args) or raise RuntimeError,
+ "system(#{args.map{|a| a.inspect }.join(' ')}) failed"
+ end
+
+ def ruby(*args)
+ command config('rubyprog'), *args
+ end
+
+ def make(task = nil)
+ command(*[config('makeprog'), task].compact)
+ end
+
+ def extdir?(dir)
+ File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb")
+ end
+
+ def files_of(dir)
+ Dir.open(dir) {|d|
+ return d.select {|ent| File.file?("#{dir}/#{ent}") }
+ }
+ end
+
+ DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn )
+
+ def directories_of(dir)
+ Dir.open(dir) {|d|
+ return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT
+ }
+ end
+
+end
+
+
+# This module requires: #srcdir_root, #objdir_root, #relpath
+module HookScriptAPI
+
+ def get_config(key)
+ @config[key]
+ end
+
+ alias config get_config
+
+ # obsolete: use metaconfig to change configuration
+ def set_config(key, val)
+ @config[key] = val
+ end
+
+ #
+ # srcdir/objdir (works only in the package directory)
+ #
+
+ def curr_srcdir
+ "#{srcdir_root()}/#{relpath()}"
+ end
+
+ def curr_objdir
+ "#{objdir_root()}/#{relpath()}"
+ end
+
+ def srcfile(path)
+ "#{curr_srcdir()}/#{path}"
+ end
+
+ def srcexist?(path)
+ File.exist?(srcfile(path))
+ end
+
+ def srcdirectory?(path)
+ File.dir?(srcfile(path))
+ end
+
+ def srcfile?(path)
+ File.file?(srcfile(path))
+ end
+
+ def srcentries(path = '.')
+ Dir.open("#{curr_srcdir()}/#{path}") {|d|
+ return d.to_a - %w(. ..)
+ }
+ end
+
+ def srcfiles(path = '.')
+ srcentries(path).select {|fname|
+ File.file?(File.join(curr_srcdir(), path, fname))
+ }
+ end
+
+ def srcdirectories(path = '.')
+ srcentries(path).select {|fname|
+ File.dir?(File.join(curr_srcdir(), path, fname))
+ }
+ end
+
+end
+
+
+class ToplevelInstaller
+
+ Version = '3.4.1'
+ Copyright = 'Copyright (c) 2000-2005 Minero Aoki'
+
+ TASKS = [
+ [ 'all', 'do config, setup, then install' ],
+ [ 'config', 'saves your configurations' ],
+ [ 'show', 'shows current configuration' ],
+ [ 'setup', 'compiles ruby extentions and others' ],
+ [ 'install', 'installs files' ],
+ [ 'test', 'run all tests in test/' ],
+ [ 'clean', "does `make clean' for each extention" ],
+ [ 'distclean',"does `make distclean' for each extention" ]
+ ]
+
+ def ToplevelInstaller.invoke
+ config = ConfigTable.new(load_rbconfig())
+ config.load_standard_entries
+ config.load_multipackage_entries if multipackage?
+ config.fixup
+ klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller)
+ klass.new(File.dirname($0), config).invoke
+ end
+
+ def ToplevelInstaller.multipackage?
+ File.dir?(File.dirname($0) + '/packages')
+ end
+
+ def ToplevelInstaller.load_rbconfig
+ if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg }
+ ARGV.delete(arg)
+ load File.expand_path(arg.split(/=/, 2)[1])
+ $".push 'rbconfig.rb'
+ else
+ require 'rbconfig'
+ end
+ ::Config::CONFIG
+ end
+
+ def initialize(ardir_root, config)
+ @ardir = File.expand_path(ardir_root)
+ @config = config
+ # cache
+ @valid_task_re = nil
+ end
+
+ def config(key)
+ @config[key]
+ end
+
+ def inspect
+ "#<#{self.class} #{__id__()}>"
+ end
+
+ def invoke
+ run_metaconfigs
+ case task = parsearg_global()
+ when nil, 'all'
+ parsearg_config
+ init_installers
+ exec_config
+ exec_setup
+ exec_install
+ else
+ case task
+ when 'config', 'test'
+ ;
+ when 'clean', 'distclean'
+ @config.load_savefile if File.exist?(@config.savefile)
+ else
+ @config.load_savefile
+ end
+ __send__ "parsearg_#{task}"
+ init_installers
+ __send__ "exec_#{task}"
+ end
+ end
+
+ def run_metaconfigs
+ @config.load_script "#{@ardir}/metaconfig"
+ end
+
+ def init_installers
+ @installer = Installer.new(@config, @ardir, File.expand_path('.'))
+ end
+
+ #
+ # Hook Script API bases
+ #
+
+ def srcdir_root
+ @ardir
+ end
+
+ def objdir_root
+ '.'
+ end
+
+ def relpath
+ '.'
+ end
+
+ #
+ # Option Parsing
+ #
+
+ def parsearg_global
+ while arg = ARGV.shift
+ case arg
+ when /\A\w+\z/
+ setup_rb_error "invalid task: #{arg}" unless valid_task?(arg)
+ return arg
+ when '-q', '--quiet'
+ @config.verbose = false
+ when '--verbose'
+ @config.verbose = true
+ when '--help'
+ print_usage $stdout
+ exit 0
+ when '--version'
+ puts "#{File.basename($0)} version #{Version}"
+ exit 0
+ when '--copyright'
+ puts Copyright
+ exit 0
+ else
+ setup_rb_error "unknown global option '#{arg}'"
+ end
+ end
+ nil
+ end
+
+ def valid_task?(t)
+ valid_task_re() =~ t
+ end
+
+ def valid_task_re
+ @valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/
+ end
+
+ def parsearg_no_options
+ unless ARGV.empty?
+ task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1)
+ setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}"
+ end
+ end
+
+ alias parsearg_show parsearg_no_options
+ alias parsearg_setup parsearg_no_options
+ alias parsearg_test parsearg_no_options
+ alias parsearg_clean parsearg_no_options
+ alias parsearg_distclean parsearg_no_options
+
+ def parsearg_config
+ evalopt = []
+ set = []
+ @config.config_opt = []
+ while i = ARGV.shift
+ if /\A--?\z/ =~ i
+ @config.config_opt = ARGV.dup
+ break
+ end
+ name, value = *@config.parse_opt(i)
+ if @config.value_config?(name)
+ @config[name] = value
+ else
+ evalopt.push [name, value]
+ end
+ set.push name
+ end
+ evalopt.each do |name, value|
+ @config.lookup(name).evaluate value, @config
+ end
+ # Check if configuration is valid
+ set.each do |n|
+ @config[n] if @config.value_config?(n)
+ end
+ end
+
+ def parsearg_install
+ @config.no_harm = false
+ @config.install_prefix = ''
+ while a = ARGV.shift
+ case a
+ when '--no-harm'
+ @config.no_harm = true
+ when /\A--prefix=/
+ path = a.split(/=/, 2)[1]
+ path = File.expand_path(path) unless path[0,1] == '/'
+ @config.install_prefix = path
+ else
+ setup_rb_error "install: unknown option #{a}"
+ end
+ end
+ end
+
+ def print_usage(out)
+ out.puts 'Typical Installation Procedure:'
+ out.puts " $ ruby #{File.basename $0} config"
+ out.puts " $ ruby #{File.basename $0} setup"
+ out.puts " # ruby #{File.basename $0} install (may require root privilege)"
+ out.puts
+ out.puts 'Detailed Usage:'
+ out.puts " ruby #{File.basename $0} <global option>"
+ out.puts " ruby #{File.basename $0} [<global options>] <task> [<task options>]"
+
+ fmt = " %-24s %s\n"
+ out.puts
+ out.puts 'Global options:'
+ out.printf fmt, '-q,--quiet', 'suppress message outputs'
+ out.printf fmt, ' --verbose', 'output messages verbosely'
+ out.printf fmt, ' --help', 'print this message'
+ out.printf fmt, ' --version', 'print version and quit'
+ out.printf fmt, ' --copyright', 'print copyright and quit'
+ out.puts
+ out.puts 'Tasks:'
+ TASKS.each do |name, desc|
+ out.printf fmt, name, desc
+ end
+
+ fmt = " %-24s %s [%s]\n"
+ out.puts
+ out.puts 'Options for CONFIG or ALL:'
+ @config.each do |item|
+ out.printf fmt, item.help_opt, item.description, item.help_default
+ end
+ out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's"
+ out.puts
+ out.puts 'Options for INSTALL:'
+ out.printf fmt, '--no-harm', 'only display what to do if given', 'off'
+ out.printf fmt, '--prefix=path', 'install path prefix', ''
+ out.puts
+ end
+
+ #
+ # Task Handlers
+ #
+
+ def exec_config
+ @installer.exec_config
+ @config.save # must be final
+ end
+
+ def exec_setup
+ @installer.exec_setup
+ end
+
+ def exec_install
+ @installer.exec_install
+ end
+
+ def exec_test
+ @installer.exec_test
+ end
+
+ def exec_show
+ @config.each do |i|
+ printf "%-20s %s\n", i.name, i.value if i.value?
+ end
+ end
+
+ def exec_clean
+ @installer.exec_clean
+ end
+
+ def exec_distclean
+ @installer.exec_distclean
+ end
+
+end # class ToplevelInstaller
+
+
+class ToplevelInstallerMulti < ToplevelInstaller
+
+ include FileOperations
+
+ def initialize(ardir_root, config)
+ super
+ @packages = directories_of("#{@ardir}/packages")
+ raise 'no package exists' if @packages.empty?
+ @root_installer = Installer.new(@config, @ardir, File.expand_path('.'))
+ end
+
+ def run_metaconfigs
+ @config.load_script "#{@ardir}/metaconfig", self
+ @packages.each do |name|
+ @config.load_script "#{@ardir}/packages/#{name}/metaconfig"
+ end
+ end
+
+ attr_reader :packages
+
+ def packages=(list)
+ raise 'package list is empty' if list.empty?
+ list.each do |name|
+ raise "directory packages/#{name} does not exist"\
+ unless File.dir?("#{@ardir}/packages/#{name}")
+ end
+ @packages = list
+ end
+
+ def init_installers
+ @installers = {}
+ @packages.each do |pack|
+ @installers[pack] = Installer.new(@config,
+ "#{@ardir}/packages/#{pack}",
+ "packages/#{pack}")
+ end
+ with = extract_selection(config('with'))
+ without = extract_selection(config('without'))
+ @selected = @installers.keys.select {|name|
+ (with.empty? or with.include?(name)) \
+ and not without.include?(name)
+ }
+ end
+
+ def extract_selection(list)
+ a = list.split(/,/)
+ a.each do |name|
+ setup_rb_error "no such package: #{name}" unless @installers.key?(name)
+ end
+ a
+ end
+
+ def print_usage(f)
+ super
+ f.puts 'Inluded packages:'
+ f.puts ' ' + @packages.sort.join(' ')
+ f.puts
+ end
+
+ #
+ # Task Handlers
+ #
+
+ def exec_config
+ run_hook 'pre-config'
+ each_selected_installers {|inst| inst.exec_config }
+ run_hook 'post-config'
+ @config.save # must be final
+ end
+
+ def exec_setup
+ run_hook 'pre-setup'
+ each_selected_installers {|inst| inst.exec_setup }
+ run_hook 'post-setup'
+ end
+
+ def exec_install
+ run_hook 'pre-install'
+ each_selected_installers {|inst| inst.exec_install }
+ run_hook 'post-install'
+ end
+
+ def exec_test
+ run_hook 'pre-test'
+ each_selected_installers {|inst| inst.exec_test }
+ run_hook 'post-test'
+ end
+
+ def exec_clean
+ rm_f @config.savefile
+ run_hook 'pre-clean'
+ each_selected_installers {|inst| inst.exec_clean }
+ run_hook 'post-clean'
+ end
+
+ def exec_distclean
+ rm_f @config.savefile
+ run_hook 'pre-distclean'
+ each_selected_installers {|inst| inst.exec_distclean }
+ run_hook 'post-distclean'
+ end
+
+ #
+ # lib
+ #
+
+ def each_selected_installers
+ Dir.mkdir 'packages' unless File.dir?('packages')
+ @selected.each do |pack|
+ $stderr.puts "Processing the package `#{pack}' ..." if verbose?
+ Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}")
+ Dir.chdir "packages/#{pack}"
+ yield @installers[pack]
+ Dir.chdir '../..'
+ end
+ end
+
+ def run_hook(id)
+ @root_installer.run_hook id
+ end
+
+ # module FileOperations requires this
+ def verbose?
+ @config.verbose?
+ end
+
+ # module FileOperations requires this
+ def no_harm?
+ @config.no_harm?
+ end
+
+end # class ToplevelInstallerMulti
+
+
+class Installer
+
+ FILETYPES = %w( bin lib ext data conf man )
+
+ include FileOperations
+ include HookScriptAPI
+
+ def initialize(config, srcroot, objroot)
+ @config = config
+ @srcdir = File.expand_path(srcroot)
+ @objdir = File.expand_path(objroot)
+ @currdir = '.'
+ end
+
+ def inspect
+ "#<#{self.class} #{File.basename(@srcdir)}>"
+ end
+
+ def noop(rel)
+ end
+
+ #
+ # Hook Script API base methods
+ #
+
+ def srcdir_root
+ @srcdir
+ end
+
+ def objdir_root
+ @objdir
+ end
+
+ def relpath
+ @currdir
+ end
+
+ #
+ # Config Access
+ #
+
+ # module FileOperations requires this
+ def verbose?
+ @config.verbose?
+ end
+
+ # module FileOperations requires this
+ def no_harm?
+ @config.no_harm?
+ end
+
+ def verbose_off
+ begin
+ save, @config.verbose = @config.verbose?, false
+ yield
+ ensure
+ @config.verbose = save
+ end
+ end
+
+ #
+ # TASK config
+ #
+
+ def exec_config
+ exec_task_traverse 'config'
+ end
+
+ alias config_dir_bin noop
+ alias config_dir_lib noop
+
+ def config_dir_ext(rel)
+ extconf if extdir?(curr_srcdir())
+ end
+
+ alias config_dir_data noop
+ alias config_dir_conf noop
+ alias config_dir_man noop
+
+ def extconf
+ ruby "#{curr_srcdir()}/extconf.rb", *@config.config_opt
+ end
+
+ #
+ # TASK setup
+ #
+
+ def exec_setup
+ exec_task_traverse 'setup'
+ end
+
+ def setup_dir_bin(rel)
+ files_of(curr_srcdir()).each do |fname|
+ update_shebang_line "#{curr_srcdir()}/#{fname}"
+ end
+ end
+
+ alias setup_dir_lib noop
+
+ def setup_dir_ext(rel)
+ make if extdir?(curr_srcdir())
+ end
+
+ alias setup_dir_data noop
+ alias setup_dir_conf noop
+ alias setup_dir_man noop
+
+ def update_shebang_line(path)
+ return if no_harm?
+ return if config('shebang') == 'never'
+ old = Shebang.load(path)
+ if old
+ $stderr.puts "warning: #{path}: Shebang line includes too many args. It is not portable and your program may not work." if old.args.size > 1
+ new = new_shebang(old)
+ return if new.to_s == old.to_s
+ else
+ return unless config('shebang') == 'all'
+ new = Shebang.new(config('rubypath'))
+ end
+ $stderr.puts "updating shebang: #{File.basename(path)}" if verbose?
+ open_atomic_writer(path) {|output|
+ File.open(path, 'rb') {|f|
+ f.gets if old # discard
+ output.puts new.to_s
+ output.print f.read
+ }
+ }
+ end
+
+ def new_shebang(old)
+ if /\Aruby/ =~ File.basename(old.cmd)
+ Shebang.new(config('rubypath'), old.args)
+ elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby'
+ Shebang.new(config('rubypath'), old.args[1..-1])
+ else
+ return old unless config('shebang') == 'all'
+ Shebang.new(config('rubypath'))
+ end
+ end
+
+ def open_atomic_writer(path, &block)
+ tmpfile = File.basename(path) + '.tmp'
+ begin
+ File.open(tmpfile, 'wb', &block)
+ File.rename tmpfile, File.basename(path)
+ ensure
+ File.unlink tmpfile if File.exist?(tmpfile)
+ end
+ end
+
+ class Shebang
+ def Shebang.load(path)
+ line = nil
+ File.open(path) {|f|
+ line = f.gets
+ }
+ return nil unless /\A#!/ =~ line
+ parse(line)
+ end
+
+ def Shebang.parse(line)
+ cmd, *args = *line.strip.sub(/\A\#!/, '').split(' ')
+ new(cmd, args)
+ end
+
+ def initialize(cmd, args = [])
+ @cmd = cmd
+ @args = args
+ end
+
+ attr_reader :cmd
+ attr_reader :args
+
+ def to_s
+ "#! #{@cmd}" + (@args.empty? ? '' : " #{@args.join(' ')}")
+ end
+ end
+
+ #
+ # TASK install
+ #
+
+ def exec_install
+ rm_f 'InstalledFiles'
+ exec_task_traverse 'install'
+ end
+
+ def install_dir_bin(rel)
+ install_files targetfiles(), "#{config('bindir')}/#{rel}", 0755
+ end
+
+ def install_dir_lib(rel)
+ install_files libfiles(), "#{config('rbdir')}/#{rel}", 0644
+ end
+
+ def install_dir_ext(rel)
+ return unless extdir?(curr_srcdir())
+ install_files rubyextentions('.'),
+ "#{config('sodir')}/#{File.dirname(rel)}",
+ 0555
+ end
+
+ def install_dir_data(rel)
+ install_files targetfiles(), "#{config('datadir')}/#{rel}", 0644
+ end
+
+ def install_dir_conf(rel)
+ # FIXME: should not remove current config files
+ # (rename previous file to .old/.org)
+ install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644
+ end
+
+ def install_dir_man(rel)
+ install_files targetfiles(), "#{config('mandir')}/#{rel}", 0644
+ end
+
+ def install_files(list, dest, mode)
+ mkdir_p dest, @config.install_prefix
+ list.each do |fname|
+ install fname, dest, mode, @config.install_prefix
+ end
+ end
+
+ def libfiles
+ glob_reject(%w(*.y *.output), targetfiles())
+ end
+
+ def rubyextentions(dir)
+ ents = glob_select("*.#{@config.dllext}", targetfiles())
+ if ents.empty?
+ setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first"
+ end
+ ents
+ end
+
+ def targetfiles
+ mapdir(existfiles() - hookfiles())
+ end
+
+ def mapdir(ents)
+ ents.map {|ent|
+ if File.exist?(ent)
+ then ent # objdir
+ else "#{curr_srcdir()}/#{ent}" # srcdir
+ end
+ }
+ end
+
+ # picked up many entries from cvs-1.11.1/src/ignore.c
+ JUNK_FILES = %w(
+ core RCSLOG tags TAGS .make.state
+ .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb
+ *~ *.old *.bak *.BAK *.orig *.rej _$* *$
+
+ *.org *.in .*
+ )
+
+ def existfiles
+ glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.')))
+ end
+
+ def hookfiles
+ %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt|
+ %w( config setup install clean ).map {|t| sprintf(fmt, t) }
+ }.flatten
+ end
+
+ def glob_select(pat, ents)
+ re = globs2re([pat])
+ ents.select {|ent| re =~ ent }
+ end
+
+ def glob_reject(pats, ents)
+ re = globs2re(pats)
+ ents.reject {|ent| re =~ ent }
+ end
+
+ GLOB2REGEX = {
+ '.' => '\.',
+ '$' => '\$',
+ '#' => '\#',
+ '*' => '.*'
+ }
+
+ def globs2re(pats)
+ /\A(?:#{
+ pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|')
+ })\z/
+ end
+
+ #
+ # TASK test
+ #
+
+ TESTDIR = 'test'
+
+ def exec_test
+ unless File.directory?('test')
+ $stderr.puts 'no test in this package' if verbose?
+ return
+ end
+ $stderr.puts 'Running tests...' if verbose?
+ begin
+ require 'test/unit'
+ rescue LoadError
+ setup_rb_error 'test/unit cannot loaded. You need Ruby 1.8 or later to invoke this task.'
+ end
+ runner = Test::Unit::AutoRunner.new(true)
+ runner.to_run << TESTDIR
+ runner.run
+ end
+
+ #
+ # TASK clean
+ #
+
+ def exec_clean
+ exec_task_traverse 'clean'
+ rm_f @config.savefile
+ rm_f 'InstalledFiles'
+ end
+
+ alias clean_dir_bin noop
+ alias clean_dir_lib noop
+ alias clean_dir_data noop
+ alias clean_dir_conf noop
+ alias clean_dir_man noop
+
+ def clean_dir_ext(rel)
+ return unless extdir?(curr_srcdir())
+ make 'clean' if File.file?('Makefile')
+ end
+
+ #
+ # TASK distclean
+ #
+
+ def exec_distclean
+ exec_task_traverse 'distclean'
+ rm_f @config.savefile
+ rm_f 'InstalledFiles'
+ end
+
+ alias distclean_dir_bin noop
+ alias distclean_dir_lib noop
+
+ def distclean_dir_ext(rel)
+ return unless extdir?(curr_srcdir())
+ make 'distclean' if File.file?('Makefile')
+ end
+
+ alias distclean_dir_data noop
+ alias distclean_dir_conf noop
+ alias distclean_dir_man noop
+
+ #
+ # Traversing
+ #
+
+ def exec_task_traverse(task)
+ run_hook "pre-#{task}"
+ FILETYPES.each do |type|
+ if type == 'ext' and config('without-ext') == 'yes'
+ $stderr.puts 'skipping ext/* by user option' if verbose?
+ next
+ end
+ traverse task, type, "#{task}_dir_#{type}"
+ end
+ run_hook "post-#{task}"
+ end
+
+ def traverse(task, rel, mid)
+ dive_into(rel) {
+ run_hook "pre-#{task}"
+ __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '')
+ directories_of(curr_srcdir()).each do |d|
+ traverse task, "#{rel}/#{d}", mid
+ end
+ run_hook "post-#{task}"
+ }
+ end
+
+ def dive_into(rel)
+ return unless File.dir?("#{@srcdir}/#{rel}")
+
+ dir = File.basename(rel)
+ Dir.mkdir dir unless File.dir?(dir)
+ prevdir = Dir.pwd
+ Dir.chdir dir
+ $stderr.puts '---> ' + rel if verbose?
+ @currdir = rel
+ yield
+ Dir.chdir prevdir
+ $stderr.puts '<--- ' + rel if verbose?
+ @currdir = File.dirname(rel)
+ end
+
+ def run_hook(id)
+ path = [ "#{curr_srcdir()}/#{id}",
+ "#{curr_srcdir()}/#{id}.rb" ].detect {|cand| File.file?(cand) }
+ return unless path
+ begin
+ instance_eval File.read(path), path, 1
+ rescue
+ raise if $DEBUG
+ setup_rb_error "hook #{path} failed:\n" + $!.message
+ end
+ end
+
+end # class Installer
+
+
+class SetupError < StandardError; end
+
+def setup_rb_error(msg)
+ raise SetupError, msg
+end
+
+if $0 == __FILE__
+ begin
+ ToplevelInstaller.invoke
+ rescue SetupError
+ raise if $DEBUG
+ $stderr.puts $!.message
+ $stderr.puts "Try 'ruby #{$0} --help' for detailed usage."
+ exit 1
+ end
+end
BIN  test/HovData.pdb
Binary file not shown
83 test/pdb_test.rb
@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'enumerator'
+
+class TC_PdbTest < Test::Unit::TestCase
+ def setup
+ setup_paths
+ @pdb = Palm::PDB.new
+ @pdb.load_file(@path)
+ end
+
+ def teardown
+ File.delete(@temp_path) if File.exist? @temp_path
+ end
+
+ def test_meta_data
+ assert_equal 'Trac' , @pdb.creator