p4ruby 2014.2.0.pre3-x86-linux

data/ext/P4/p4result.h

@@ -0,0 +1,86 @@
+/*******************************************************************************
+
+Copyright (c) 2001-2008, 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.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4result.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: C++ class for holding results of Perforce commands 
+ *
+ ******************************************************************************/
+
+class P4Result
+{
+    public:
+
+    P4Result();
+    
+    // Setting
+    void	AddOutput( VALUE v );
+    void	AddMessage( Error *e );
+    void	AddTrack( const char *msg );
+    void	AddTrack( VALUE t );
+    void 	DeleteTrack();
+
+    // Getting
+    VALUE	GetOutput()	{ return output;	}
+    VALUE	GetErrors()	{ return errors;	}
+    VALUE	GetWarnings()	{ return warnings;	}
+    VALUE	GetMessages()	{ return messages;	}
+    VALUE 	GetTrack()	{ return track;         }
+
+    // Get errors/warnings as a formatted string
+    void	FmtErrors( StrBuf &buf );
+    void	FmtWarnings( StrBuf &buf );
+
+    // Set API level for backwards compatibility
+    void	SetApiLevel( int l )	{ apiLevel = l; }
+    // Testing
+    int		ErrorCount();
+    int		WarningCount();
+
+    // Clear previous results
+    void	Reset();
+
+    // Ruby garbage collection
+    void	GCMark();
+
+    private:
+    int		Length( VALUE ary );
+    void	Fmt( const char *label, VALUE ary, StrBuf &buf );
+    VALUE	FmtMessage( Error *e );
+    VALUE	WrapMessage( Error *e );
+
+    VALUE	cP4Msg;
+    VALUE	output;
+    VALUE	warnings;
+    VALUE	errors;
+    VALUE	messages;
+    VALUE	track;
+    int		apiLevel;
+};

data/ext/P4/p4rubydebug.h

@@ -0,0 +1,45 @@
+/*******************************************************************************
+
+Copyright (c) 2001-2008, 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.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4rubydebug.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Debugging support for P4Ruby
+ *
+ ******************************************************************************/
+#ifndef P4RUBYDEBUG_H
+# define P4RUBYDEBUG_H
+
+#define 	P4RDB_COMMANDS	( debug > 0 )
+#define		P4RDB_CALLS	( debug > 1 )
+#define		P4RDB_DATA	( debug > 2 )
+#define		P4RDB_GC	( debug > 3 )
+#define		P4RDB_RPC	( debug > 8 )
+
+#endif

data/ext/P4/p4specdata.cpp

@@ -0,0 +1,108 @@
+/*******************************************************************************
+
+Copyright (c) 2009, 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.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4specdata.cpp
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Ruby bindings for the Perforce API. SpecData subclass for
+ * 		  P4Ruby. This class allows for manipulation of Spec data
+ * 		  stored in a Ruby hash using the standard Perforce classes
+ *
+ ******************************************************************************/
+
+#include <ruby.h>
+#include "undefdups.h"
+#include <p4/clientapi.h>
+#include <p4/i18napi.h>
+#include <p4/spec.h>
+#include <p4/debug.h>
+#include "p4rubydebug.h"
+#include "p4utils.h"
+#include "p4specdata.h"
+
+StrPtr *
+SpecDataRuby::GetLine( SpecElem *sd, int x, const char **cmt )
+{
+	*cmt = 0;
+	VALUE val;
+	VALUE key;
+	StrBuf t;
+
+	key = P4Utils::ruby_string( sd->tag.Text(), sd->tag.Length() );
+	val = rb_hash_aref( hash, key );
+	if( val == Qnil ) return 0;
+
+	if( !sd->IsList() )
+	{
+	    last = StringValuePtr( val );
+	    return &last;
+	}
+
+	// It's a list, which means we should have an array value here
+	
+	if( !rb_obj_is_kind_of( val, rb_cArray ) )
+	{
+	    rb_warn( "%s should be an array element. Ignoring...", 
+		    sd->tag.Text() );
+	    return 0;
+	}
+	val = rb_ary_entry( val, x );
+	if( val == Qnil ) return 0;
+
+	last = StringValuePtr( val );
+	return &last;
+}
+
+void	
+SpecDataRuby::SetLine( SpecElem *sd, int x, const StrPtr *v, Error *e )
+{
+	VALUE 	key;
+	VALUE	val;
+	VALUE	ary;
+	StrBuf	t;
+
+	key = P4Utils::ruby_string( sd->tag.Text(), sd->tag.Length() );
+	val = P4Utils::ruby_string( v->Text(), v->Length() );
+
+	if( sd->IsList() )
+	{
+	    ary = rb_hash_aref( hash, key );
+	    if( ary == Qnil )
+	    {
+		ary = rb_ary_new();
+		rb_hash_aset( hash, key, ary );
+	    }
+	    rb_ary_store( ary, x, val );
+	}
+	else
+	{
+	    rb_hash_aset( hash, key, val );
+	}
+	return;
+}

data/ext/P4/p4specdata.h

@@ -0,0 +1,52 @@
+/*******************************************************************************
+
+Copyright (c) 2009, 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.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4specdata.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Ruby bindings for the Perforce API. SpecData subclass for
+ * 		  P4Ruby. This class allows for manipulation of Spec data
+ * 		  stored in a Ruby hash using the standard Perforce classes
+ *
+ ******************************************************************************/
+
+class SpecDataRuby : public SpecData
+{
+    public:
+	    		SpecDataRuby( VALUE h ) { hash = h; }
+
+	virtual StrPtr *GetLine( SpecElem *sd, int x, const char **cmt );
+	virtual void	SetLine( SpecElem *sd, int x, const StrPtr *val,
+				Error *e );
+
+    private:
+	VALUE	hash;
+	StrBuf	last;
+};
+

data/ext/P4/p4utils.cpp

@@ -0,0 +1,62 @@
+// vim:ts=8:sw=4:
+/*******************************************************************************
+
+Copyright (c) 2011, 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.
+
+*******************************************************************************/
+#include <ruby.h>
+#ifdef HAVE_RUBY_ENCODING_H  
+#include <ruby/encoding.h>
+#endif
+#include "p4utils.h"
+
+char *P4Utils::charset = 0;
+
+VALUE P4Utils::ruby_string( const char *msg, long len )
+{
+    VALUE str;
+    //	If a length has been passed then use it
+    if( len )
+    {
+	str = rb_str_new( msg, len );
+    }
+    else
+    {
+	str = rb_str_new2( msg );
+    }
+
+    //	Now check if an encoding should be set for the string.
+#ifdef HAVE_RUBY_ENCODING_H
+    if( charset )
+    {
+	rb_enc_associate(str, rb_enc_find("UTF-8"));  
+    }
+    else 
+    {
+	rb_enc_associate(str, rb_locale_encoding());  
+    }
+#endif  
+
+    return str;
+}

data/ext/P4/p4utils.h

@@ -0,0 +1,46 @@
+/*******************************************************************************
+
+Copyright (c) 2011, 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.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4utils.h
+ *
+ * Author	: Jayesh Mistry <jmistry@perforce.com>
+ *
+ * Description	: C++ class with useful methods 
+ *
+ ******************************************************************************/
+class P4Utils {
+	public:
+	static void	 SetCharset( const char *cs ) { charset = (char *) cs; };
+	static char* GetCharset() { return charset; };
+
+	static VALUE ruby_string( const char *msg, long len = 0);
+	
+	private:
+	static char* charset;
+};
+

data/ext/P4/specmgr.cpp

@@ -0,0 +1,687 @@
+/*******************************************************************************
+
+Copyright (c) 2007-2011, 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.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name         : specmgr.cc
+ *
+ * Description  : Ruby bindings for the Perforce API. Class for handling
+ *                Perforce specs. This class provides other classes with
+ *                generic support for parsing and formatting Perforce
+ *                specs.
+ *
+ ******************************************************************************/
+#include <ctype.h>
+#include <ruby.h>
+#include "p4utils.h"
+#include "undefdups.h"
+#include <p4/clientapi.h>
+#include <p4/strops.h>
+#include <p4/spec.h>
+#include <p4/strtable.h>
+#include "p4rubyconf.h"
+#include "gc_hack.h"
+#include "p4rubydebug.h"
+#include "p4specdata.h"
+#include "specmgr.h"
+
+struct defaultspec {
+    const char *type;
+    const char *spec;
+} speclist[] = {
+    {
+        "branch",
+        "Branch;code:301;rq;ro;fmt:L;len:32;;"
+        "Update;code:302;type:date;ro;fmt:L;len:20;;"
+        "Access;code:303;type:date;ro;fmt:L;len:20;;"
+        "Owner;code:304;fmt:R;len:32;;"
+        "Description;code:306;type:text;len:128;;"
+        "Options;code:309;type:line;len:32;val:"
+            "unlocked/locked;;"
+        "View;code:311;type:wlist;words:2;len:64;;"
+    },
+    {
+        "changeX",
+        "Change;code:201;rq;ro;fmt:L;seq:1;len:10;;"
+        "Date;code:202;type:date;ro;fmt:R;seq:3;len:20;;"
+        "Client;code:203;ro;fmt:L;seq:2;len:32;;"
+        "User;code:204;ro;fmt:L;seq:4;len:32;;"
+        "Status;code:205;ro;fmt:R;seq:5;len:10;;"
+        "Type;code:211;seq:6;type:select;fmt:L;len:10;"
+            "val:public/restricted;;"
+        "Description;code:206;type:text;rq;;"
+        "Jobs;code:209;type:wlist;words:2;len:32;;"
+        "Files;code:210;type:llist;len:64;;"
+    },
+    {
+        "change",
+        "Change;code:201;rq;ro;fmt:L;seq:1;len:10;;"
+        "Date;code:202;type:date;ro;fmt:R;seq:3;len:20;;"
+        "Client;code:203;ro;fmt:L;seq:2;len:32;;"
+        "User;code:204;ro;fmt:L;seq:4;len:32;;"
+        "Status;code:205;ro;fmt:R;seq:5;len:10;;"
+        "Type;code:211;seq:6;type:select;fmt:L;len:10;"
+            "val:public/restricted;;"
+        "Description;code:206;type:text;rq;seq:7;;"
+        "JobStatus;code:207;fmt:I;type:select;seq:9;;"
+        "Jobs;code:208;type:wlist;seq:8;len:32;;"
+        "Files;code:210;type:llist;len:64;;"
+    },
+    {
+        "client",
+        "Client;code:301;rq;ro;seq:1;len:32;;"
+        "Update;code:302;type:date;ro;seq:2;fmt:L;len:20;;"
+        "Access;code:303;type:date;ro;seq:4;fmt:L;len:20;;"
+        "Owner;code:304;seq:3;fmt:R;len:32;;"
+        "Host;code:305;seq:5;fmt:R;len:32;;"
+        "Description;code:306;type:text;len:128;;"
+        "Root;code:307;rq;type:line;len:64;;"
+        "AltRoots;code:308;type:llist;len:64;;"
+        "Options;code:309;type:line;len:64;val:"
+            "noallwrite/allwrite,noclobber/clobber,nocompress/compress,"
+            "unlocked/locked,nomodtime/modtime,normdir/rmdir;;"
+        "SubmitOptions;code:313;type:select;fmt:L;len:25;val:"
+            "submitunchanged/submitunchanged+reopen/revertunchanged/"
+            "revertunchanged+reopen/leaveunchanged/leaveunchanged+reopen;;"
+        "LineEnd;code:310;type:select;fmt:L;len:12;val:"
+            "local/unix/mac/win/share;;"
+        "Stream;code:314;type:line;len:64;;"
+        "StreamAtChange;code:316;type:line;len:64;;"
+        "ServerID;code:315;type:line;ro;len:64;;"
+        "View;code:311;type:wlist;words:2;len:64;;"
+        "ChangeView;code:317;type:llist;len:64;;"
+    },
+    {
+        "clientX",
+        "Client;code:301;rq;ro;seq:1;len:32;;"
+        "Update;code:302;type:date;ro;seq:2;fmt:L;len:20;;"
+        "Access;code:303;type:date;ro;seq:4;fmt:L;len:20;;"
+        "Owner;code:304;seq:3;fmt:R;len:32;;"
+        "Host;code:305;seq:5;fmt:R;len:32;;"
+        "Description;code:306;type:text;len:128;;"
+        "Root;code:307;rq;type:line;len:64;;"
+        "AltRoots;code:308;type:llist;len:64;;"
+        "Options;code:309;type:line;len:64;val:"
+            "noallwrite/allwrite,noclobber/clobber,nocompress/compress,"
+            "unlocked/locked,nomodtime/modtime,normdir/rmdir;;"
+        "SubmitOptions;code:313;type:select;fmt:L;len:25;val:"
+            "submitunchanged/submitunchanged+reopen/revertunchanged/"
+            "revertunchanged+reopen/leaveunchanged/leaveunchanged+reopen;;"
+        "LineEnd;code:310;type:select;fmt:L;len:12;val:"
+            "local/unix/mac/win/share;;"
+        "View;code:311;type:wlist;words:2;len:64;;"
+    },
+    {
+        "clientSpecing021",
+        "Client;code:301;rq;ro;len:32;;"
+        "Update;code:302;type:date;ro;len:20;;"
+        "Access;code:303;type:date;ro;len:20;;"
+        "Owner;code:304;len:32;;"
+        "Host;code:305;len:32;;"
+        "Description;code:306;type:text;len:128;;"
+        "Root;code:307;rq;type:line;len:64;;"
+        "AltRoots;code:308;type:text;len:64;;"
+        "Options;code:309;type:line;len:64;val:"
+            "noallwrite/allwrite,noclobber/clobber,nocompress/compress,"
+            "unlocked/locked,nomodtime/modtime,normdir/rmdir;;"
+        "LineEnd;code:310;type:select;len:12;val:local/unix/mac/win/share;;"
+        "View;code:311;type:wlist;words:2;len:64;;"
+    },
+    {
+        "depot",
+        "Depot;code:251;rq;ro;len:32;;"
+        "Owner;code:252;len:32;;"
+        "Date;code:253;type:date;ro;len:20;;"
+        "Description;code:254;type:text;len:128;;"
+        "Type;code:255;rq;len:10;;"
+        "Address;code:256;len:64;;"
+        "Suffix;code:258;len:64;;"
+        "Map;code:257;rq;len:64;;"
+        "SpecMap;code:259;type:wlist;len:64;;"
+    },
+    {
+        "group",
+        "Group;code:401;rq;ro;len:32;;"
+        "MaxResults;code:402;type:word;len:12;;"
+        "MaxScanRows;code:403;type:word;len:12;;"
+        "MaxLockTime;code:407;type:word;len:12;;"
+        "Timeout;code:406;type:word;len:12;;"
+        "PasswordTimeout;code:409;type:word;len:12;;"
+        "Subgroups;code:404;type:wlist;len:32;opt:default;;"
+        "Owners;code:408;type:wlist;len:32;opt:default;;"
+        "Users;code:405;type:wlist;len:32;opt:default;;"
+    },
+    {
+        "job",
+        "Job;code:101;rq;len:32;;"
+        "Status;code:102;type:select;rq;len:10;"
+            "pre:open;val:open/suspended/closed;;"
+        "User;code:103;rq;len:32;pre:$user;;"
+        "Date;code:104;type:date;ro;len:20;pre:$now;;"
+        "Description;code:105;type:text;rq;pre:$blank;;"
+    },
+    {
+        "label",
+        "Label;code:301;rq;ro;fmt:L;len:32;;"
+        "Update;code:302;type:date;ro;fmt:L;len:20;;"
+        "Access;code:303;type:date;ro;fmt:L;len:20;;"
+        "Owner;code:304;fmt:R;len:32;;"
+        "Description;code:306;type:text;len:128;;"
+        "Options;code:309;type:line;len:64;val:"
+            "unlocked/locked,noautoreload/autoreload;;"
+        "Revision;code:312;type:word;words:1;len:64;;"
+        "ServerID;code:315;type:line;ro;len:64;;"
+        "View;code:311;type:wlist;len:64;;"
+    },
+    {
+        "ldap",
+        "Name;code:801;rq;len:32;;"
+        "Host;code:802;rq;type:word;words:1;len:128;;"
+        "Port;code:803;rq;type:word;words:1;len:5;;"
+        "Encryption;code:804;rq;len:10;val:"
+            "none/ssl/tls;;"
+        "BindMethod;code:805;rq;len:10;val:"
+            "simple/search/sasl;;"
+        "SimplePattern;code:806;type:line;len:128;;"
+        "SearchBaseDN;code:807;type:line;len:128;;"
+        "SearchFilter;code:808;type:line;len:128;;"
+        "SearchScope;code:809;len:10;val:"
+            "baseonly/children/subtree;;"
+        "SearchBindDN;code:810;type:line;len:128;;"
+        "SearchPasswd;code:811;type:line;len:128;;"
+        "SaslRealm;code:812;type:word;words:1;len:128;;"
+        "GroupBaseDN;code:813;type:line;len:128;;"
+        "GroupSearchFilter;code:814;type:line;len:128;;"
+        "GroupSearchScope;code:815;len:10;val:"
+            "baseonly/children/subtree;;"
+    },
+    {
+        "license",
+        "License;code:451;len:32;;"
+        "License-Expires;code:452;len:10;;"
+        "Support-Expires;code:453;len:10;;"
+        "Customer;code:454;type:line;len:128;;"
+        "Application;code:455;len:32;;"
+        "IPaddress;code:456;len:24;;"
+        "IPservice;code:461;type:wlist;len:24;;"
+        "Platform;code:457;len:32;;"
+        "Clients;code:458;len:8;;"
+        "Users;code:459;len:8;;"
+        "Files;code:460;len:8;;"
+    },
+    {
+        "protect",
+        "Protections;code:501;type:wlist;words:5;opt:default;len:64;;"
+    },
+    {
+        "specW",
+        "Fields;code:351;type:wlist;words:5;rq;;"
+        "Required;code:357;type:wlist;;"
+        "Readonly;code:358;type:wlist;;"
+        "Words;code:352;type:wlist;words:2;;"
+        "Formats;code:353;type:wlist;words:3;;"
+        "Values;code:354;type:wlist;words:2;;"
+        "Presets;code:355;type:wlist;words:2;;"
+        "Comments;code:356;type:text;;"
+    },
+    {
+        "spec",
+        "Fields;code:351;type:wlist;words:5;rq;;"
+        "Words;code:352;type:wlist;words:2;;"
+        "Formats;code:353;type:wlist;words:3;;"
+        "Values;code:354;type:wlist;words:2;;"
+        "Presets;code:355;type:wlist;words:2;;"
+        "Comments;code:356;type:text;;"
+    },
+    {
+        "stream",
+        "Stream;code:701;rq;ro;len:64;;"
+        "Update;code:705;type:date;ro;fmt:L;len:20;;"
+        "Access;code:706;type:date;ro;fmt:L;len:20;;"
+        "Owner;code:704;len:32;;"
+        "Name;code:703;rq;type:line;len:32;;"
+        "Parent;code:702;rq;len:64;;"
+        "Type;code:708;rq;len:32;;"
+        "Description;code:709;type:text;len:128;;"
+        "Options;code:707;type:line;len:64;val:"
+            "allsubmit/ownersubmit,unlocked/locked,"
+            "toparent/notoparent,fromparent/nofromparent;;"
+        "Paths;code:710;rq;type:wlist;words:2;maxwords:3;len:64;;"
+        "Remapped;code:711;type:wlist;words:2;len:64;;"
+        "Ignored;code:712;type:wlist;words:1;len:64;;"
+        "View;code:713;type:wlist;words:2;len:64;;"
+        "ChangeView;code:714;type:llist;ro;len:64;;"
+    },
+    {
+        "triggers",
+        "Triggers;code:551;type:wlist;words:4;len:64;opt:default;"
+    },
+    {
+       "typemap",
+        "TypeMap;code:601;type:wlist;words:2;len:64;opt:default;"
+    },
+    {
+        "user",
+        "User;code:651;rq;ro;seq:1;len:32;;"
+        "Type;code:659;ro;fmt:R;len:10;;"
+        "Email;code:652;fmt:R;rq;seq:3;len:32;;"
+        "Update;code:653;fmt:L;type:date;ro;seq:2;len:20;;"
+        "Access;code:654;fmt:L;type:date;ro;len:20;;"
+        "FullName;code:655;fmt:R;type:line;rq;len:32;;"
+        "JobView;code:656;type:line;len:64;;"
+        "Password;code:657;len:32;;"
+        "AuthMethod;code:662;fmt:L;len:10;val:perforce/ldap;;"
+        "Reviews;code:658;type:wlist;len:64;;"
+    },
+    {
+        "server",
+        "ServerID;code:751;rq;ro;len:32;;"
+        "Type;code:752;rq;len:32;;"
+        "Name;code:753;type:line;len:32;;"
+        "Address;code:754;type:line;len:32;;"
+        "Services;code:755;rq;len:128;;"
+        "Description;code:756;type:text;len:128;;"
+        "User;code:760;type:line;len:64;;"
+        "ClientDataFilter;code:757;type:wlist;len:64;;"
+        "RevisionDataFilter;code:758;type:wlist;len:64;;"
+        "ArchiveDataFilter;code:759;type:wlist;len:64;;"
+    },
+    { 0, 0 }
+};
+
+SpecMgr::SpecMgr()
+{
+    debug = 0;
+    specs = 0;
+    Reset();
+}
+
+SpecMgr::~SpecMgr()
+{
+    delete specs;
+}
+
+void
+SpecMgr::AddSpecDef( const char *type, StrPtr &specDef )
+{
+    if( specs->GetVar( type ) )
+        specs->RemoveVar( type );
+    specs->SetVar( type, specDef );
+}
+
+void
+SpecMgr::AddSpecDef( const char *type, const char *specDef )
+{
+    if( specs->GetVar( type ) )
+        specs->RemoveVar( type );
+    specs->SetVar( type, specDef );
+}
+
+
+void
+SpecMgr::Reset()
+{
+    delete specs;
+    specs = new StrBufDict;
+
+    for( struct defaultspec *sp = &speclist[ 0 ]; sp->type; sp++ )
+        AddSpecDef( sp->type, sp->spec );
+
+}
+
+int
+SpecMgr::HaveSpecDef( const char *type )
+{
+    return specs->GetVar( type ) != 0;
+}
+
+//
+// Convert a Perforce StrDict into a Ruby hash. Convert multi-level
+// data (Files0, Files1 etc. ) into (nested) array members of the hash.
+//
+
+VALUE
+SpecMgr::StrDictToHash( StrDict *dict, VALUE hash )
+{
+    StrRef      var, val;
+    int         i;
+
+    if( hash == Qnil )
+        hash = rb_hash_new();
+
+    for ( i = 0; dict->GetVar( i, var, val ); i++ )
+    {
+        if ( var == "specdef" || var == "func" || var == "specFormatted" )
+            continue;
+
+        InsertItem( hash, &var, &val );
+    }
+    return hash;
+}
+
+//
+// Convert a Perforce StrDict into a P4::Spec object
+//
+
+VALUE
+SpecMgr::StrDictToSpec( StrDict *dict, StrPtr *specDef )
+{
+
+    // This converts it to a string, and then to a hash, so we go from one
+    // type of dictionary to another, via an intermediate form (a StrBuf).
+
+    Error               e;
+    SpecDataTable       dictData( dict );
+#if P4APIVER_ID >= 513538
+    Spec                s( specDef->Text(), "", &e );
+#else
+    Spec                s( specDef->Text(), "" );
+#endif
+    StrBuf              form;
+
+    if( e.Test() ) return Qfalse;
+
+    // Format the StrDict into a StrBuf object
+    s.Format( &dictData, &form );
+
+    // Now parse the StrBuf into a new P4::Spec object
+    VALUE               spec = NewSpec( specDef );
+    SpecDataRuby        hashData( spec );
+
+    s.ParseNoValid( form.Text(), &hashData, &e );
+    if( e.Test() ) return Qfalse;
+
+    // Now see if there are any extraTag fields as we'll need to
+    // add those fields into our output. Just iterate over them
+    // extracting the fields and inserting them as we go.
+    int i = 0;
+    StrRef et("extraTag" );
+    for( i = 0; ; i++ )
+    {
+        StrBuf tag;
+        StrPtr *var;
+        StrPtr *val;
+
+        tag << et << i;
+        if( !(var = dict->GetVar( tag ) ) )
+            break;
+
+        val = dict->GetVar( *var );
+        if( !val ) continue;
+
+        InsertItem( spec, var, val );
+    }
+
+    return spec;
+}
+
+VALUE
+SpecMgr::StringToSpec( const char *type, const char *form, Error *e )
+{
+
+    StrPtr *            specDef = specs->GetVar( type );
+    VALUE               hash = NewSpec( specDef );
+    SpecDataRuby        specData( hash );
+#if P4APIVER_ID >= 513538
+    Spec                s( specDef->Text(), "", e );
+#else
+    Spec                s( specDef->Text(), "" );
+#endif
+
+    if( !e->Test() )
+        s.ParseNoValid( form, &specData, e );
+
+    if ( e->Test() )
+        return Qfalse;
+
+    return hash;
+}
+
+
+//
+// Format routine. updates a StrBuf object with the form content.
+// The StrBuf can then be converted to a Ruby string where required.
+//
+void
+SpecMgr::SpecToString( const char *type, VALUE hash, StrBuf &b, Error *e )
+{
+
+    StrBuf      buf;
+    StrPtr *    specDef = specs->GetVar( type );
+    if ( !specDef )
+    {
+        e->Set( E_FAILED, "No specdef available. Cannot convert hash to a "
+                          "Perforce form" );
+        return;
+    }
+
+    SpecDataRuby        specData( hash );
+#if P4APIVER_ID >= 513538
+    Spec                s( specDef->Text(), "", e );
+#else
+    Spec                s( specDef->Text(), "" );
+#endif
+
+    if( e->Test() ) return;
+
+    s.Format( &specData, &b );
+}
+
+//
+// This method returns a hash describing the valid fields in the spec. To
+// make it easy on our users, we map the lowercase name to the name defined
+// in the spec. Thus, the users can always user lowercase, and if the field
+// should be in mixed case, it will be. See P4::Spec::method_missing
+//
+
+VALUE
+SpecMgr::SpecFields( const char *type )
+{
+    return SpecFields( specs->GetVar( type ) );
+}
+
+VALUE
+SpecMgr::SpecFields( StrPtr *specDef )
+{
+    if( !specDef ) return Qnil;
+
+    //
+    // Here we abuse the fact that SpecElem::tag is public, even though it's
+    // only supposed to be public to SpecData's subclasses. It's hard to
+    // see that changing anytime soon, and it makes this so simple and
+    // reliable. So...
+    //
+    VALUE       hash = rb_hash_new();
+    Error       e;
+
+#if P4APIVER_ID >= 513538
+    Spec        s( specDef->Text(), "", &e );
+#else
+    Spec        s( specDef->Text(), "" );
+#endif
+    if( e.Test() ) return Qnil;
+
+    for( int i = 0; i < s.Count(); i++ )
+    {
+        StrBuf          k;
+        StrBuf          v;
+        SpecElem *      se = s.Get( i );
+
+        v = se->tag;
+        k = v;
+        StrOps::Lower( k );
+
+        rb_hash_aset(hash,
+                    P4Utils::ruby_string( k.Text(), k.Length() ),
+                    P4Utils::ruby_string( v.Text(), v.Length() ) );
+    }
+    return hash;
+}
+
+//
+// Split a key into its base name and its index. i.e. for a key "how1,0"
+// the base name is "how" and they index is "1,0". We work backwards from
+// the end of the key looking for the first char that is neither a
+// digit, nor a comma.
+//
+
+void
+SpecMgr::SplitKey( const StrPtr *key, StrBuf &base, StrBuf &index )
+{
+    int i = 0;
+
+    base = *key;
+    index = "";
+    for ( i = key->Length(); i; i-- )
+    {
+        char    prev = (*key)[ i-1 ];
+        if ( !isdigit( prev ) && prev != ',' )
+        {
+            base.Set( key->Text(), i );
+            index.Set( key->Text() + i );
+            break;
+        }
+    }
+}
+
+//
+// Insert an element into the response structure. The element may need to
+// be inserted into an array nested deeply within the enclosing hash.
+//
+
+void
+SpecMgr::InsertItem( VALUE hash, const StrPtr *var, const StrPtr *val )
+{
+    VALUE       ary = 0;
+    VALUE       tary = 0;
+    VALUE       key;
+    ID          idLength = rb_intern( "length" );
+    StrBuf      base, index;
+    StrRef      comma( "," );
+
+    SplitKey( var, base, index );
+
+    // If there's no index, then we insert into the top level hash
+    // but if the key is already defined then we need to rename the key. This
+    // is probably one of those special keys like otherOpen which can be
+    // both an array element and a scalar. The scalar comes last, so we
+    // just rename it to "otherOpens" to avoid trashing the previous key
+    // value
+    if ( index == "" )
+{
+        ID idHasKey     = rb_intern( "has_key?");
+        ID idPlus       = rb_intern( "+" );
+
+        key =  P4Utils::ruby_string( var->Text() );
+        if ( rb_funcall( hash, idHasKey, 1, key ) == Qtrue )
+            key = rb_funcall( key, idPlus, 1,  P4Utils::ruby_string( "s" ) );
+
+        if( P4RDB_DATA )
+            fprintf( stderr, "... %s -> %s\n", StringValuePtr( key ), val->Text() );
+
+        rb_hash_aset( hash, key,  P4Utils::ruby_string( val->Text() ) );
+        return;
+    }
+
+    //
+    // Get or create the parent array from the hash.
+    //
+    key =  P4Utils::ruby_string( base.Text() );
+    ary = rb_hash_aref( hash, key );
+
+    if ( Qnil == ary )
+    {
+        ary = rb_ary_new();
+        rb_hash_aset( hash, key, ary );
+    }
+    else if( rb_obj_is_kind_of( ary, rb_cArray ) != Qtrue )
+    {
+        //
+        // There's an index in our var name, but the name is already defined
+        // and the value it contains is not an array. This means we've got a
+        // name collision. This can happen in 'p4 diff2' for example, when
+        // one file gets 'depotFile' and the other gets 'depotFile2'. In
+        // these cases it makes sense to keep the structure flat so we
+        // just use the raw variable name.
+        //
+        if( P4RDB_DATA )
+            fprintf( stderr, "... %s -> %s\n", var->Text(), val->Text() );
+
+        rb_hash_aset( hash,  P4Utils::ruby_string( var->Text() ) ,
+                             P4Utils::ruby_string( val->Text() ) );
+        return;
+}
+
+    // The index may be a simple digit, or it could be a comma separated
+    // list of digits. For each "level" in the index, we need a containing
+    // array.
+    if( P4RDB_DATA )
+        fprintf( stderr, "... %s -> [", base.Text() );
+
+    for( const char *c = 0 ; ( c = index.Contains( comma ) ); )
+    {
+        StrBuf  level;
+        level.Set( index.Text(), c - index.Text() );
+        index.Set( c + 1 );
+
+        // Found another level so we need to get/create a nested array
+        // under the current entry. We use the level as an index so that
+        // missing entries are left empty deliberately.
+
+        tary = rb_ary_entry( ary, level.Atoi() );
+        if ( ! RTEST( tary ) )
+{
+            tary = rb_ary_new();
+            rb_ary_store( ary, level.Atoi(), tary );
+        }
+        if( P4RDB_DATA )
+            fprintf( stderr, "%s][", level.Text() );
+        ary = tary;
+    }
+    int pos = index.Atoi();
+
+    if( P4RDB_DATA )
+        fprintf( stderr, "%d] = %s\n", pos, val->Text() );
+
+    rb_ary_store( ary, pos,  P4Utils::ruby_string( val->Text() )  );
+}
+
+//
+// Create a new P4::Spec object and return it.
+//
+
+VALUE
+SpecMgr::NewSpec( StrPtr *specDef )
+{
+    ID          idNew           = rb_intern( "new" );
+    ID          idP4            = rb_intern( "P4" );
+    ID          idP4Spec        = rb_intern( "Spec" );
+    VALUE       cP4             = rb_const_get_at( rb_cObject, idP4 );
+    VALUE       cP4Spec         = rb_const_get_at( cP4, idP4Spec );
+    VALUE       fields          = SpecFields( specDef );
+
+    return rb_funcall( cP4Spec, idNew, 1, fields );
+}