p4ruby 2014.1 → 2014.2.0.pre1

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,604 @@
+/*******************************************************************************
+
+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;;"
+    },
+    {
+	"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;ro;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;;"
+    },
+    {
+	"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;;"
+    },
+    {
+	"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;;"
+	"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;;"
+	"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 );
+}