├── .gitignore
├── ColdDoc.cfc
├── README.md
├── licence.txt
├── run.cfm
└── strategy
    ├── AbstractTemplateStrategy.cfc
    ├── api
        ├── HTMLAPIStrategy.cfc
        └── resources
        │   ├── static
        │       ├── index.html
        │       ├── resources
        │       │   └── inherit.gif
        │       └── stylesheet.css
        │   └── templates
        │       ├── allclasses-frame.html
        │       ├── class.html
        │       ├── inc
        │           └── nav.html
        │       ├── index.html
        │       ├── overview-frame.html
        │       ├── overview-summary.html
        │       ├── package-frame.html
        │       └── package-summary.html
    └── uml2tools
        ├── XMIStrategy.cfc
        └── resources
            └── templates
                └── template.uml


/.gitignore:
--------------------------------------------------------------------------------
1 | #ignore these files
2 | .*
3 | !.gitignore
4 | settings.xml
5 | *.iml
6 | docs/*
7 | 


--------------------------------------------------------------------------------
/ColdDoc.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent hint="Core class for ColdDoc documentation generation framework" output="false">
  2 | 
  3 | <!------------------------------------------- PUBLIC ------------------------------------------->
  4 | 
  5 | <cffunction name="init" hint="Constructor" access="public" returntype="ColdDoc" output="false">
  6 | 	<cfscript>
  7 | 		variables.instance = {};
  8 | 
  9 | 		return this;
 10 | 	</cfscript>
 11 | </cffunction>
 12 | 
 13 | <cffunction name="generate" hint="generates the documentation" access="public" returntype="void" output="false">
 14 | 	<cfargument name="inputSource" hint="either, the string directory source, OR an array of structs containing inputDir and inputMapping key" type="any" required="yes">
 15 | 	<cfargument name="inputMapping" hint="the base mapping for the folder. Only required if the inputSource is a string." type="string" required="false" default="">
 16 | 	<cfscript>
 17 | 		var qMetaData = 0;
 18 | 		var source = 0;
 19 | 
 20 | 		if(NOT hasStrategy())
 21 | 		{
 22 | 			throwException("colddoc.StrategyNotSetException", "No Template Strategy has been set.",
 23 | 							"Create a Template Strategy, and set it with setStrategy() before calling generate()");
 24 | 		}
 25 | 
 26 | 		if(isSimpleValue(arguments.inputSource))
 27 | 		{
 28 | 			source = [{ inputDir=arguments.inputSource, inputMapping=arguments.inputMapping }];
 29 | 		}
 30 | 		else
 31 | 		{
 32 | 			source = arguments.inputSource;
 33 | 		}
 34 | 
 35 | 		qMetaData = buildMetaDataCollection(source);
 36 | 
 37 | 		getStrategy().run(qMetaData);
 38 | 	</cfscript>
 39 | </cffunction>
 40 | 
 41 | <cffunction name="getStrategy" hint="Returns the current document templating strategy that is being userd" access="public" returntype="any" output="false"
 42 | 			colddoc:generic="colddoc.strategy.AbstractTemplateStrategy">
 43 | 	<cfreturn instance.strategy />
 44 | </cffunction>
 45 | 
 46 | <cffunction name="setStrategy" hint="Set the document templating strategy that is going to be used" access="public" returntype="void" output="false">
 47 | 	<cfargument name="strategy" hint="The strategy object that is called to generate the doc. Usually extends colddoc.strategy.AbstractTemplateStrategy."
 48 | 				type="any" required="true" colddoc:generic="colddoc.strategy.AbstractTemplateStrategy">
 49 | 	<cfset instance.strategy = arguments.strategy />
 50 | </cffunction>
 51 | 
 52 | <cffunction name="hasStrategy" hint="whether this object has a strategy" access="public" returntype="boolean" output="false">
 53 | 	<cfreturn StructKeyExists(instance, "strategy") />
 54 | </cffunction>
 55 | 
 56 | <!------------------------------------------- PACKAGE ------------------------------------------->
 57 | 
 58 | <!------------------------------------------- PRIVATE ------------------------------------------->
 59 | 
 60 | <cffunction name="buildMetaDataCollection" hint="builds the searchable meta data collection" access="private" returntype="query" output="false">
 61 | 	<cfargument name="inputSource" hint="an array of structs containing inputDir and inputMapping" type="array" required="yes"> <!--- of struct --->
 62 | 
 63 | 	<cfscript>
 64 | 		var qFiles = 0;
 65 | 		var currentPath = 0;
 66 | 		var qMetaData = QueryNew("package,name,extends,metadata,type,implements,fullextends");
 67 | 		var cfcPath = 0;
 68 | 		var packagePath = 0;
 69 | 		var cfcName = 0;
 70 | 		var meta = 0;
 71 | 		var i = 0;
 72 | 		var implements = 0;
 73 | 		var fullextends = 0;
 74 | 	</cfscript>
 75 | 
 76 |     <cfloop index="i" from="1" to="#ArrayLen(arguments.inputSource)#">
 77 | 
 78 |         <cfdirectory action="list" directory="#arguments.inputSource[i].inputDir#" recurse="true" name="qFiles" filter="*.cfc">
 79 | 
 80 |         <cfloop query="qFiles">
 81 |             <cfscript>
 82 |                 currentPath = replace(directory, arguments.inputSource[i].inputDir, "");
 83 |                 currentPath = reReplace(currentPath, "[/\\]", "");
 84 |                 currentPath = reReplace(currentPath, "[/\\]", ".", "all");
 85 | 
 86 |                 if(len(currentPath))
 87 |                 {
 88 |                     packagePath = ListAppend(arguments.inputSource[i].inputMapping, currentPath, ".");
 89 |                 }
 90 |                 else
 91 |                 {
 92 |                     packagePath = arguments.inputSource[i].inputMapping;
 93 |                 }
 94 | 
 95 |                 cfcName = ListGetAt(name, 1, ".");
 96 | 
 97 | 				try
 98 | 				{
 99 | 	                if (Len(packagePath)) {
100 | 	                    meta = getComponentMetaData(packagePath & "." & cfcName);
101 | 	                }
102 | 	                else {
103 | 	                    meta = getComponentMetaData(cfcName);
104 | 	                }
105 | 
106 | 	                //let's do some cleanup, in case CF sucks.
107 | 	                if(Len (packagePath) AND NOT meta.name contains packagePath)
108 | 	                {
109 | 						meta.name = packagePath & "." & cfcName;
110 | 	                }
111 | 
112 | 					QueryAddRow(qMetaData);
113 | 					QuerySetCell(qMetaData, "package", packagePath);
114 | 					QuerySetCell(qMetaData, "name", cfcName);
115 | 					QuerySetCell(qMetaData, "metadata", meta);
116 | 					QuerySetCell(qMetaData, "type", meta.type);
117 | 
118 | 					implements = getImplements(meta);
119 | 					implements = listQualify(arrayToList(implements), ':');
120 | 
121 | 					QuerySetCell(qMetaData, "implements", implements);
122 | 
123 | 					fullextends = getInheritence(meta);
124 | 					fullextends = listQualify(arrayToList(fullextends), ':');
125 | 
126 | 					QuerySetCell(qMetaData, "fullextends", fullextends);
127 | 
128 | 	                //so we cane easily query direct desendents
129 | 	                if(StructKeyExists(meta, "extends"))
130 | 	                {
131 | 						if(meta.type eq "interface")
132 | 						{
133 | 							QuerySetCell(qMetaData, "extends", meta.extends[structKeyList(meta.extends)].name);
134 | 						}
135 | 						else
136 | 						{
137 | 		                    QuerySetCell(qMetaData, "extends", meta.extends.name);
138 | 						}
139 | 	                }
140 | 	                else
141 | 	                {
142 | 	                    QuerySetCell(qMetaData, "extends", "-");
143 | 	                }
144 | 
145 | 				}
146 | 				catch(Any exc)
147 | 				{
148 | 					warnError(packagePath & "." & cfcName, exc);
149 | 				}
150 |             </cfscript>
151 |         </cfloop>
152 | 
153 | 	</cfloop>
154 | 
155 | 	<cfreturn qMetaData />
156 | </cffunction>
157 | 
158 | <cffunction name="warnError" hint="Warn the user that there was an error through cftrace" access="private" returntype="void" output="false">
159 | 	<cfargument name="cfcName" hint="the name of the cfc" type="string" required="Yes">
160 | 	<cfargument name="error" hint="the error struct" type="any" required="Yes">
161 | 	<cfset var dump = 0 />
162 | 	<!---
163 | 	<cfset _trace(error)>
164 | 	 --->
165 | 	<cfsetting showdebugoutput="true">
166 | 	<cftrace category="ColdDoc" inline="true" type="Warning" text="Warning, the following script has errors: #arguments.cfcName#, #toString(arguments.error)#">
167 | </cffunction>
168 | 
169 | <cffunction name="getImplements" hint="gets an array of the interfaces that this metadata implements" access="private" returntype="array" output="false">
170 | 	<cfargument name="metadata" hint="the metadata to look at" type="struct" required="Yes">
171 | 	<cfscript>
172 | 		var localmeta = arguments.metadata;
173 | 		var interfaces = {};
174 | 		var key = 0;
175 | 		var imeta = 0;
176 | 
177 | 		if(arguments.metadata.type neq "component")
178 | 		{
179 | 			return ArrayNew(1);
180 | 		}
181 | 
182 | 		while(StructKeyExists(localmeta, "extends"))
183 | 		{
184 | 			if(StructKeyExists(localmeta, "implements"))
185 | 			{
186 | 				for(key in localmeta.implements)
187 | 				{
188 | 					imeta = localmeta.implements[local.key];
189 | 					interfaces[imeta.name] = 1;
190 | 				}
191 | 			}
192 | 			localmeta = localmeta.extends;
193 | 		}
194 | 
195 | 		interfaces = structKeyArray(interfaces);
196 | 
197 | 		arraySort(interfaces, "textnocase");
198 | 
199 | 		return interfaces;
200 |     </cfscript>
201 | </cffunction>
202 | 
203 | <cffunction name="getInheritence" hint="gets an array of the classes that this metadata extends, in order of extension" access="private" returntype="array" output="false">
204 | 	<cfargument name="metadata" hint="the metadata to look at" type="struct" required="Yes">
205 | 	<cfscript>
206 | 			var localmeta = arguments.metadata;
207 | 			//ignore top level
208 | 			var inheritence = [];
209 | 
210 | 			while(StructKeyExists(localmeta, "extends"))
211 | 			{
212 | 				//manage interfaces
213 | 				if(localmeta.type eq "interface")
214 | 				{
215 | 					localmeta = localmeta.extends[structKeyList(localmeta.extends)];
216 | 				}
217 | 				else
218 | 				{
219 | 					localmeta = localmeta.extends;
220 | 				}
221 | 
222 | 				ArrayPrepend(inheritence, localmeta.name);
223 | 			}
224 | 
225 | 			return inheritence;
226 | 	</cfscript>
227 | </cffunction>
228 | 
229 | 
230 | <cffunction name="_trace">
231 | 	<cfargument name="s">
232 | 	<cfset var g = "">
233 | 	<cfsetting showdebugoutput="true">
234 | 	<cfsavecontent variable="g">
235 | 		<cfdump var="#arguments.s#">
236 | 	</cfsavecontent>
237 | 	<cftrace text="#g#">
238 | </cffunction>
239 | 
240 | <cffunction name="_dump">
241 | 	<cfargument name="s">
242 | 	<cfargument name="abort" default="true">
243 | 	<cfset var g = "">
244 | 		<cfdump var="#arguments.s#">
245 | 		<cfif arguments.abort>
246 | 		<cfabort>
247 | 		</cfif>
248 | </cffunction>
249 | 
250 | <cffunction name="throwException" access="private" hint="Throws an Exception" output="false">
251 | 	<cfargument name="type" hint="The type of exception" type="string" required="Yes">
252 | 	<cfargument name="message" hint="The message to accompany the exception" type="string" required="Yes">
253 | 	<cfargument name="detail" type="string" hint="The detail message for the exception" required="No" default="">
254 | 		<cfthrow type="#arguments.type#" message="#arguments.message#" detail="#arguments.detail#">
255 | </cffunction>
256 | 
257 | 
258 | </cfcomponent>
259 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ColdDoc 1.0
 2 | ==========
 3 | 
 4 | Thanks for taking the time to look at ColdDoc!
 5 | 
 6 | The ColdDoc home page can be found at [http://www.compoundtheory.com/?action=colddoc.index][1]
 7 | 
 8 | Documentation for ColdDoc can be found on the [GitHub Wiki][2].
 9 | 
10 | The main Git repository and downloads can be found on [GitHub][3].
11 | 
12 | For support, the ColdDoc mailing list can be found on [Google Groups][4].
13 | 
14 | [1]: http://www.compoundtheory.com/?action=colddoc.index
15 | [2]: https://github.com/markmandel/ColdDoc/wiki
16 | [3]: https://github.com/markmandel/ColdDoc
17 | [4]: https://groups.google.com/forum/#!forum/colddoc-dev
18 | 
19 | 


--------------------------------------------------------------------------------
/licence.txt:
--------------------------------------------------------------------------------
  1 | Common Public License Version 1.0
  2 | 
  3 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC
  4 | LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
  5 | CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
  6 | 
  7 | 1. DEFINITIONS
  8 | 
  9 | "Contribution" means:
 10 | 
 11 |     a) in the case of the initial Contributor, the initial code and
 12 | documentation distributed under this Agreement, and
 13 | 
 14 |     b) in the case of each subsequent Contributor:
 15 | 
 16 |     i) changes to the Program, and
 17 | 
 18 |     ii) additions to the Program;
 19 | 
 20 |     where such changes and/or additions to the Program originate from and are
 21 | distributed by that particular Contributor. A Contribution 'originates' from a
 22 | Contributor if it was added to the Program by such Contributor itself or anyone
 23 | acting on such Contributor's behalf. Contributions do not include additions to
 24 | the Program which: (i) are separate modules of software distributed in
 25 | conjunction with the Program under their own license agreement, and (ii) are not
 26 | derivative works of the Program.
 27 | 
 28 | "Contributor" means any person or entity that distributes the Program.
 29 | 
 30 | "Licensed Patents " mean patent claims licensable by a Contributor which are
 31 | necessarily infringed by the use or sale of its Contribution alone or when
 32 | combined with the Program.
 33 | 
 34 | "Program" means the Contributions distributed in accordance with this Agreement.
 35 | 
 36 | "Recipient" means anyone who receives the Program under this Agreement,
 37 | including all Contributors.
 38 | 
 39 | 2. GRANT OF RIGHTS
 40 | 
 41 |     a) Subject to the terms of this Agreement, each Contributor hereby grants
 42 | Recipient a non-exclusive, worldwide, royalty-free copyright license to
 43 | reproduce, prepare derivative works of, publicly display, publicly perform,
 44 | distribute and sublicense the Contribution of such Contributor, if any, and such
 45 | derivative works, in source code and object code form.
 46 | 
 47 |     b) Subject to the terms of this Agreement, each Contributor hereby grants
 48 | Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed
 49 | Patents to make, use, sell, offer to sell, import and otherwise transfer the
 50 | Contribution of such Contributor, if any, in source code and object code form.
 51 | This patent license shall apply to the combination of the Contribution and the
 52 | Program if, at the time the Contribution is added by the Contributor, such
 53 | addition of the Contribution causes such combination to be covered by the
 54 | Licensed Patents. The patent license shall not apply to any other combinations
 55 | which include the Contribution. No hardware per se is licensed hereunder.
 56 | 
 57 |     c) Recipient understands that although each Contributor grants the licenses
 58 | to its Contributions set forth herein, no assurances are provided by any
 59 | Contributor that the Program does not infringe the patent or other intellectual
 60 | property rights of any other entity. Each Contributor disclaims any liability to
 61 | Recipient for claims brought by any other entity based on infringement of
 62 | intellectual property rights or otherwise. As a condition to exercising the
 63 | rights and licenses granted hereunder, each Recipient hereby assumes sole
 64 | responsibility to secure any other intellectual property rights needed, if any.
 65 | For example, if a third party patent license is required to allow Recipient to
 66 | distribute the Program, it is Recipient's responsibility to acquire that license
 67 | before distributing the Program.
 68 | 
 69 |     d) Each Contributor represents that to its knowledge it has sufficient
 70 | copyright rights in its Contribution, if any, to grant the copyright license set
 71 | forth in this Agreement.
 72 | 
 73 | 3. REQUIREMENTS
 74 | 
 75 | A Contributor may choose to distribute the Program in object code form under its
 76 | own license agreement, provided that:
 77 | 
 78 |     a) it complies with the terms and conditions of this Agreement; and
 79 | 
 80 |     b) its license agreement:
 81 | 
 82 |     i) effectively disclaims on behalf of all Contributors all warranties and
 83 | conditions, express and implied, including warranties or conditions of title and
 84 | non-infringement, and implied warranties or conditions of merchantability and
 85 | fitness for a particular purpose;
 86 | 
 87 |     ii) effectively excludes on behalf of all Contributors all liability for
 88 | damages, including direct, indirect, special, incidental and consequential
 89 | damages, such as lost profits;
 90 | 
 91 |     iii) states that any provisions which differ from this Agreement are offered
 92 | by that Contributor alone and not by any other party; and
 93 | 
 94 |     iv) states that source code for the Program is available from such
 95 | Contributor, and informs licensees how to obtain it in a reasonable manner on or
 96 | through a medium customarily used for software exchange. 
 97 | 
 98 | When the Program is made available in source code form:
 99 | 
100 |     a) it must be made available under this Agreement; and
101 | 
102 |     b) a copy of this Agreement must be included with each copy of the Program. 
103 | 
104 | Contributors may not remove or alter any copyright notices contained within the
105 | Program.
106 | 
107 | Each Contributor must identify itself as the originator of its Contribution, if
108 | any, in a manner that reasonably allows subsequent Recipients to identify the
109 | originator of the Contribution.
110 | 
111 | 4. COMMERCIAL DISTRIBUTION
112 | 
113 | Commercial distributors of software may accept certain responsibilities with
114 | respect to end users, business partners and the like. While this license is
115 | intended to facilitate the commercial use of the Program, the Contributor who
116 | includes the Program in a commercial product offering should do so in a manner
117 | which does not create potential liability for other Contributors. Therefore, if
118 | a Contributor includes the Program in a commercial product offering, such
119 | Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
120 | every other Contributor ("Indemnified Contributor") against any losses, damages
121 | and costs (collectively "Losses") arising from claims, lawsuits and other legal
122 | actions brought by a third party against the Indemnified Contributor to the
123 | extent caused by the acts or omissions of such Commercial Contributor in
124 | connection with its distribution of the Program in a commercial product
125 | offering. The obligations in this section do not apply to any claims or Losses
126 | relating to any actual or alleged intellectual property infringement. In order
127 | to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
128 | Contributor in writing of such claim, and b) allow the Commercial Contributor to
129 | control, and cooperate with the Commercial Contributor in, the defense and any
130 | related settlement negotiations. The Indemnified Contributor may participate in
131 | any such claim at its own expense.
132 | 
133 | For example, a Contributor might include the Program in a commercial product
134 | offering, Product X. That Contributor is then a Commercial Contributor. If that
135 | Commercial Contributor then makes performance claims, or offers warranties
136 | related to Product X, those performance claims and warranties are such
137 | Commercial Contributor's responsibility alone. Under this section, the
138 | Commercial Contributor would have to defend claims against the other
139 | Contributors related to those performance claims and warranties, and if a court
140 | requires any other Contributor to pay any damages as a result, the Commercial
141 | Contributor must pay those damages.
142 | 
143 | 5. NO WARRANTY
144 | 
145 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
146 | "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
147 | IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
148 | NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
149 | Recipient is solely responsible for determining the appropriateness of using and
150 | distributing the Program and assumes all risks associated with its exercise of
151 | rights under this Agreement, including but not limited to the risks and costs of
152 | program errors, compliance with applicable laws, damage to or loss of data,
153 | programs or equipment, and unavailability or interruption of operations.
154 | 
155 | 6. DISCLAIMER OF LIABILITY
156 | 
157 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
158 | CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
159 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
160 | PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
161 | STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
162 | OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
163 | GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
164 | 
165 | 7. GENERAL
166 | 
167 | If any provision of this Agreement is invalid or unenforceable under applicable
168 | law, it shall not affect the validity or enforceability of the remainder of the
169 | terms of this Agreement, and without further action by the parties hereto, such
170 | provision shall be reformed to the minimum extent necessary to make such
171 | provision valid and enforceable.
172 | 
173 | If Recipient institutes patent litigation against a Contributor with respect to
174 | a patent applicable to software (including a cross-claim or counterclaim in a
175 | lawsuit), then any patent licenses granted by that Contributor to such Recipient
176 | under this Agreement shall terminate as of the date such litigation is filed. In
177 | addition, if Recipient institutes patent litigation against any entity
178 | (including a cross-claim or counterclaim in a lawsuit) alleging that the Program
179 | itself (excluding combinations of the Program with other software or hardware)
180 | infringes such Recipient's patent(s), then such Recipient's rights granted under
181 | Section 2(b) shall terminate as of the date such litigation is filed.
182 | 
183 | All Recipient's rights under this Agreement shall terminate if it fails to
184 | comply with any of the material terms or conditions of this Agreement and does
185 | not cure such failure in a reasonable period of time after becoming aware of
186 | such noncompliance. If all Recipient's rights under this Agreement terminate,
187 | Recipient agrees to cease use and distribution of the Program as soon as
188 | reasonably practicable. However, Recipient's obligations under this Agreement
189 | and any licenses granted by Recipient relating to the Program shall continue and
190 | survive.
191 | 
192 | Everyone is permitted to copy and distribute copies of this Agreement, but in
193 | order to avoid inconsistency the Agreement is copyrighted and may only be
194 | modified in the following manner. The Agreement Steward reserves the right to
195 | publish new versions (including revisions) of this Agreement from time to time.
196 | No one other than the Agreement Steward has the right to modify this Agreement.
197 | IBM is the initial Agreement Steward. IBM may assign the responsibility to serve
198 | as the Agreement Steward to a suitable separate entity. Each new version of the
199 | Agreement will be given a distinguishing version number. The Program (including
200 | Contributions) may always be distributed subject to the version of the Agreement
201 | under which it was received. In addition, after a new version of the Agreement
202 | is published, Contributor may elect to distribute the Program (including its
203 | Contributions) under the new version. Except as expressly stated in Sections
204 | 2(a) and 2(b) above, Recipient receives no rights or licenses to the
205 | intellectual property of any Contributor under this Agreement, whether
206 | expressly, by implication, estoppel or otherwise. All rights in the Program not
207 | expressly granted under this Agreement are reserved.
208 | 
209 | This Agreement is governed by the laws of the State of New York and the
210 | intellectual property laws of the United States of America. No party to this
211 | Agreement will bring a legal action under this Agreement more than one year
212 | after the cause of action arose. Each party waives its rights to a jury trial in
213 | any resulting litigation.
214 | 


--------------------------------------------------------------------------------
/run.cfm:
--------------------------------------------------------------------------------
 1 | <!---
 2 | Let's generate our default HTML documentation on myself: 
 3 |  --->
 4 | <cfscript>
 5 | 	colddoc = createObject("component", "ColdDoc").init();
 6 | 
 7 | 	strategy = createObject("component", "colddoc.strategy.api.HTMLAPIStrategy").init(expandPath("./docs"), "ColdDoc 1.0");
 8 | 	colddoc.setStrategy(strategy);
 9 | 
10 | 	colddoc.generate(expandPath("/colddoc"), "colddoc");
11 | </cfscript>
12 | 
13 | <h1>Done!</h1>
14 | 
15 | <a href="docs">Documentation</a>
16 | 


--------------------------------------------------------------------------------
/strategy/AbstractTemplateStrategy.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent hint="Abstract base class for general templating strategies" output="false"
  2 | 			 colddoc:abstract="true">
  3 | 
  4 | <!------------------------------------------- PUBLIC ------------------------------------------->
  5 | 
  6 | <cfscript>
  7 | 	instance.static.META_ABSTRACT = "colddoc:abstract";
  8 | 	instance.static.META_GENERIC = "colddoc:generic";
  9 | </cfscript>
 10 | 
 11 | <cffunction name="run" hint="Run this strategy" access="public" returntype="void" output="false">
 12 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
 13 | 	<cfthrow type="AbstractMethodException" message="Method is abstract and must be overwritten"
 14 | 			detail="The method 'run' in  component '#getMetadata(this).name#' is abstract and must be overwritten" />
 15 | </cffunction>
 16 | 
 17 | <!------------------------------------------- PACKAGE ------------------------------------------->
 18 | 
 19 | <!------------------------------------------- PRIVATE ------------------------------------------->
 20 | 
 21 | <cffunction name="init" hint="Constructor" access="private" returntype="void" output="false">
 22 | 	<cfscript>
 23 | 		setFunctionQueryCache(StructNew());
 24 | 	</cfscript>
 25 | </cffunction>
 26 | 
 27 | <cffunction name="buildPackageTree" hint="builds a data structure that shows the tree structure of the packages" access="public" returntype="struct" output="false"
 28 | 			colddoc:generic="string,struct">
 29 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
 30 | 	<cfscript>
 31 | 		var qPackages = 0;
 32 | 		var tree = {};
 33 | 		var root = 0;
 34 | 		var node = 0;
 35 | 		var item = 0;
 36 |     </cfscript>
 37 | 	<cfquery name="qPackages" dbtype="query" debug="false">
 38 | 		SELECT DISTINCT
 39 | 			package
 40 | 		FROM
 41 | 			arguments.qMetaData
 42 | 		ORDER BY
 43 | 			package
 44 | 	</cfquery>
 45 | 
 46 | 	<cfloop query="qPackages">
 47 | 		<cfset node = tree>
 48 | 		<cfloop list="#package#" index="item" delimiters=".">
 49 | 			<cfscript>
 50 | 				if(NOT structKeyExists(node, item))
 51 | 				{
 52 | 					node[item] = {};
 53 | 				}
 54 | 
 55 | 				node = node[item];
 56 |       </cfscript>
 57 | 		</cfloop>
 58 | 	</cfloop>
 59 | 
 60 | 	<cfreturn tree />
 61 | </cffunction>
 62 | 
 63 | <cffunction name="visitPackageTree" hint="visit each element on the package tree" access="private" returntype="void" output="false">
 64 | 	<cfargument name="packageTree" hint="the package tree" type="struct" required="Yes" colddoc:generic="string,struct">
 65 | 	<cfargument name="startCommand" hint="the command to call on each visit" type="any" required="Yes">
 66 | 	<cfargument name="endCommand" hint="the command to call on each visit" type="any" required="Yes">
 67 | 	<cfargument name="args" hint="the extra arguments to get passed on to the visitor command (name, and fullname get passed by default)" type="struct" required="No" default="#structNew()#" colddoc:generic="string,any">
 68 | 	<cfscript>
 69 | 		var startCall = arguments.startCommand;
 70 | 		var endCall = arguments.endCommand;
 71 | 		var key = 0;
 72 | 		var thisArgs = 0;
 73 | 
 74 | 		if(NOT StructKeyExists(args, "fullname"))
 75 | 		{
 76 | 			arguments.args.fullname = "";
 77 | 		}
 78 | 
 79 | 		for(key in arguments.packageTree)
 80 | 		{
 81 | 			thisArgs = structCopy(arguments.args);
 82 | 			thisArgs.name = key;
 83 | 			thisArgs.fullName = listAppend(thisArgs.fullName, thisArgs.name, ".");
 84 | 
 85 | 			startCall(argumentCollection=thisArgs);
 86 | 
 87 | 			visitPackageTree(packageTree[key], startCall, endCall, thisArgs);
 88 | 
 89 | 			endCall(argumentCollection=thisArgs);
 90 | 		}
 91 | 
 92 |     </cfscript>
 93 | </cffunction>
 94 | 
 95 | <cffunction name="isPrimitive" hint="is the type a primitive value?" access="private" returntype="boolean" output="false">
 96 | 	<cfargument name="type" hint="the cf type" type="string" required="Yes">
 97 | 	<cfscript>
 98 | 		var primitives = "string,date,struct,array,void,binary,numeric,boolean,query,xml,uuid,any,component";
 99 | 		return ListFindNoCase(primitives, arguments.type);
100 |     </cfscript>
101 | </cffunction>
102 | 
103 | <cffunction name="buildFunctionMetaData" hint="builds a sorted query of function meta" access="public" returntype="query" output="false">
104 | 	<cfargument name="metadata" hint="" type="struct" required="Yes">
105 | 	<cfscript>
106 | 		var qFunctions = QueryNew("name,metadata");
107 | 		var func = 0;
108 | 		var results = 0;
109 | 		var cache = getFunctionQueryCache();
110 | 
111 | 		if(StructKeyExists(cache, arguments.metadata.name))
112 | 		{
113 | 			return cache[arguments.metadata.name];
114 | 		}
115 | 
116 | 		if(NOT StructKeyExists(arguments.metadata, "functions"))
117 | 		{
118 | 			return qFunctions;
119 | 		}
120 | 	</cfscript>
121 | 	<cfloop array="#arguments.metadata.functions#" index="func">
122 | 		<cfscript>
123 | 			//dodge cfthread functions
124 | 			if(NOT JavaCast("string", func.name).startsWith("_cffunccfthread_"))
125 | 			{
126 | 				QueryAddRow(qFunctions);
127 | 				QuerySetCell(qFunctions, "name", func.name);
128 | 				QuerySetCell(qFunctions, "metadata", safeFunctionMeta(func, arguments.metadata));
129 | 			}
130 | 		</cfscript>
131 | 	</cfloop>
132 | 
133 | 	<cfset results = getMetaSubQuery(query=qFunctions, orderby="name asc") />
134 | 
135 | 	<cfset cache[arguments.metadata.name] = results />
136 | 
137 | 	<cfreturn results />
138 | </cffunction>
139 | 
140 | <cffunction name="getObjectName" hint="returns the simple object name from a full class name" access="private" returntype="string" output="false">
141 | 	<cfargument name="class" hint="the class name" type="string" required="Yes">
142 | 	<cfscript>
143 | 		if(len(arguments.class))
144 | 		{
145 | 			return ListGetAt(arguments.class, ListLen(arguments.class, "."), ".");
146 | 		}
147 | 
148 | 		return arguments.class;
149 | 	</cfscript>
150 | </cffunction>
151 | 
152 | <cfscript>
153 | 	function getPackage(class)
154 | 	{
155 | 		var objectname = getObjectName(arguments.class);
156 | 		var lenCount = Len(arguments.class) - (Len(objectname) + 1);
157 | 	       
158 | 		if( lenCount gt 0 )
159 | 		{
160 | 		    return Left(arguments.class, lenCount);
161 | 		}
162 | 		else
163 | 		{
164 | 		    return arguments.class;
165 | 		}
166 | 	}
167 | </cfscript>
168 | 
169 | <cffunction name="classExists" hint="Whether or not the CFC class exists (does not test for primitives)" access="private" returntype="boolean" output="false">
170 | 	<cfargument name="qMetaData" hint="the meta data query" type="query" required="Yes">
171 | 	<cfargument name="className" hint="the name of the class to check for" type="string" required="Yes">
172 | 	<cfargument name="package" hint="the package the class comes from" type="string" required="Yes">
173 | 	<cfscript>
174 | 		var resolvedClassName = resolveClassName(arguments.className, arguments.package);
175 | 		var objectName = getObjectName(resolvedClassName);
176 | 		var packageName = getPackage(resolvedClassName);
177 | 		var qClass = getMetaSubQuery(arguments.qMetaData, "LOWER(package)=LOWER('#packageName#') AND LOWER(name)=LOWER('#objectName#')");
178 | 
179 | 		return qClass.recordCount;
180 |   </cfscript>
181 | </cffunction>
182 | 
183 | <cffunction name="typeExists" hint="whether a type exists at all - be it class name, or primitive type" access="private" returntype="boolean" output="false">
184 | 	<cfargument name="qMetaData" hint="the meta data query" type="query" required="Yes">
185 | 	<cfargument name="className" hint="the name of the class to check for" type="string" required="Yes">
186 | 	<cfargument name="package" hint="the package the class comes from" type="string" required="Yes">
187 | 	<cfscript>
188 | 		return isPrimitive(arguments.className) OR classExists(argumentCollection=arguments);
189 | 	</cfscript>
190 | </cffunction>
191 | 
192 | <cffunction name="resolveClassName" hint="resolves a class name that may not be full qualified" access="private" returntype="string" output="false">
193 | 	<cfargument name="className" hint="the name of the class" type="string" required="Yes">
194 | 	<cfargument name="package" hint="the package the class comes from" type="string" required="Yes">
195 | 	<cfscript>
196 | 		if(ListLen(arguments.className, ".") eq 1)
197 | 		{
198 | 			arguments.className = arguments.package & "." & arguments.className;
199 | 		}
200 | 
201 | 		return arguments.className;
202 | 	</cfscript>
203 | </cffunction>
204 | 
205 | <cffunction name="getMetaSubQuery" hint="returns a query on the meta query" access="private" returntype="query" output="false">
206 | 	<cfargument name="query" hint="the meta data query" type="query" required="Yes">
207 | 	<cfargument name="where" hint="the where string" type="string" required="false">
208 | 	<cfargument name="orderby" hint="the order by string" type="string" required="false">
209 | 	<cfset qSub = 0 />
210 | 	<cfquery name="qSub" dbtype="query" debug="false">
211 | 		SELECT *
212 | 		from
213 | 		arguments.query
214 | 		<cfif StructKeyExists(arguments, "where")>
215 | 			WHERE
216 | 			#PreserveSingleQuotes(arguments.where)#
217 | 		</cfif>
218 | 		<cfif StructKeyExists(arguments, "orderby")>
219 | 			ORDER BY
220 | 			#arguments.orderby#
221 | 		</cfif>
222 | 	</cfquery>
223 | 	<cfreturn qSub />
224 | </cffunction>
225 | 
226 | <cffunction name="safeFunctionMeta" hint="sets default values" access="private" returntype="any" output="false">
227 | 	<cfargument name="func" hint="the function meta" type="any" required="Yes">
228 | 	<cfargument name="metadata" hint="the original meta data" type="struct" required="Yes">
229 | 	<cfscript>
230 | 		var local = {};
231 | 
232 | 		if(NOT StructKeyExists(arguments.func, "returntype"))
233 | 		{
234 | 			arguments.func.returntype = "any";
235 | 		}
236 | 
237 | 		if(NOT StructKeyExists(arguments.func, "access"))
238 | 		{
239 | 			arguments.func.access = "public";
240 | 		}
241 | 
242 | 		//move the cfproperty hints onto functions
243 | 		if(StructKeyExists(arguments.metadata, "properties"))
244 | 		{
245 | 			if(Lcase(arguments.func.name).startsWith("get") AND NOT StructKeyExists(arguments.func, "hint"))
246 | 			{
247 | 				local.name = replaceNoCase(arguments.func.name, "get", "");
248 | 				local.property = getPropertyMeta(local.name, arguments.metadata.properties);
249 | 
250 | 				if(structKeyExists(local.property, "hint"))
251 | 				{
252 | 					arguments.func.hint = "get: " & local.property.hint;
253 | 				}
254 | 
255 | 			}
256 | 			else if(LCase(arguments.func.name).startsWith("set") AND NOT StructKeyExists(arguments.func, "hint"))
257 | 			{
258 | 				local.name = replaceNoCase(arguments.func.name, "set", "");
259 | 				local.property = getPropertyMeta(local.name, arguments.metadata.properties);
260 | 
261 | 				if(structKeyExists(local.property, "hint"))
262 | 				{
263 | 					arguments.func.hint = "set: " & local.property.hint;
264 | 				}
265 | 			}
266 | 		}
267 | 
268 | 		//move any argument meta from @foo.bar annotations onto the argument meta
269 | 		if(structKeyExists(arguments.func, "parameters"))
270 | 		{
271 | 			for(local.metaKey in arguments.func)
272 | 			{
273 | 				if(ListLen(local.metaKey, ".") gt 1)
274 | 				{
275 | 					local.paramKey = listGetAt(local.metaKey, 1, ".");
276 | 					local.paramExtraMeta = listGetAt(local.metaKey, 2, ".");
277 | 					local.paramMetaValue = arguments.func[local.metaKey];
278 | 
279 | 					local.len = ArrayLen(arguments.func.parameters);
280 |                     for(local.counter=1; local.counter lte local.len; local.counter++)
281 |                     {
282 |                     	local.param = arguments.func.parameters[local.counter];
283 | 
284 | 						if(local.param.name eq local.paramKey)
285 | 						{
286 | 							local.param[local.paramExtraMeta] = local.paramMetaValue;
287 | 						}
288 |                     }
289 | 				}
290 | 			}
291 | 		}
292 | 		return arguments.func;
293 | 	</cfscript>
294 | </cffunction>
295 | 
296 | <cffunction name="getPropertyMeta" hint="returns the property meta by a given name" access="private" returntype="struct" output="false">
297 | 	<cfargument name="name" hint="the name of the property" type="string" required="Yes">
298 | 	<cfargument name="properties" hint="the property meta" type="array" required="Yes">
299 | 	<cfscript>
300 | 		var local = {};
301 |     </cfscript>
302 | 	<cfloop array="#arguments.properties#" index="local.property">
303 | 		<cfif local.property.name eq arguments.name>
304 | 			<cfreturn local.property />
305 | 		</cfif>
306 | 	</cfloop>
307 | 	<cfreturn StructNew() />
308 | </cffunction>
309 | 
310 | <cffunction name="safeParamMeta" hint="sets default values" access="private" returntype="any" output="false">
311 | 	<cfargument name="param" hint="the param meta" type="any" required="Yes">
312 | 	<cfscript>
313 | 		if(NOT StructKeyExists(arguments.param, "type"))
314 | 		{
315 | 			arguments.param.type = "any";
316 | 		}
317 | 
318 | 		return arguments.param;
319 | 	</cfscript>
320 | </cffunction>
321 | 
322 | <cffunction name="writeTemplate" hint="builds a template" access="private" returntype="void" output="false">
323 | 	<cfargument name="path" hint="where to write the template" type="string" required="Yes">
324 | 	<cfargument name="template" hint="the tempalte to write out" type="string" required="Yes">
325 | 	<cfscript>
326 | 		var html = 0;
327 | 		var local = {}; //for local variables
328 | 	</cfscript>
329 | 	<cfsavecontent variable="html"><cfinclude template="#arguments.template#"></cfsavecontent>
330 | 	<cfscript>
331 | 		fileWrite(arguments.path, html);
332 | 	</cfscript>
333 | </cffunction>
334 | 
335 | <cffunction name="recursiveCopy" hint="does a recursive copy from one dir to another" access="private" returntype="void" output="false">
336 | 	<cfargument name="fromDir" hint="the input directory" type="string" required="Yes">
337 | 	<cfargument name="toDir" hint="the output directory" type="string" required="Yes">
338 | 	<cfscript>
339 | 		var qFiles = 0;
340 | 		var currentDir = "";
341 | 		var safeDir = "";
342 | 
343 | 		arguments.fromDir = replaceNoCase(arguments.fromDir, "\", "/", "all");
344 | 		arguments.toDir = replaceNoCase(arguments.toDir, "\", "/", "all");
345 | 	</cfscript>
346 | 	
347 | 	<cfdirectory action="list" directory="#arguments.fromDir#" recurse="true" name="qFiles">
348 | 
349 | 	<cfoutput group="directory" query="qFiles">
350 | 
351 | 		<cfset safeDir = replaceNoCase(directory, "\", "/", "all") />
352 | 
353 | 		<!--- dodge svn directories --->
354 | 		<cfif NOT FindNoCase("/.", directory)>
355 | 			<cfscript>
356 | 				currentDir = arguments.toDir & replaceNoCase(safeDir & "/", arguments.fromDir, "");
357 | 				ensureDirectory(currentDir);
358 | 			</cfscript>
359 | 			<cfoutput>
360 | 				<cfscript>
361 | 					if(type neq "dir")
362 | 					{
363 | 						fileCopy(directory & "/" & name, currentDir & name);
364 | 					}
365 | 				</cfscript>
366 | 			</cfoutput>
367 | 		</cfif>
368 | 	</cfoutput>
369 | </cffunction>
370 | 
371 | <cffunction name="ensureDirectory" hint="if a directory doesn't exist, create it" access="private" returntype="void" output="false">
372 | 	<cfargument name="path" hint="" type="string" required="Yes">
373 | 	<cfif NOT directoryExists(arguments.path)>
374 | 		<cfdirectory action="create" directory="#arguments.path#">
375 | 	</cfif>
376 | </cffunction>
377 | 
378 | <!--- anotation discovery methods --->
379 | <cffunction name="isAbstractClass" hint="is this class annotated as an abstract class?" access="private" returntype="boolean" output="false">
380 | 	<cfargument name="class" hint="the class name" type="string" required="Yes">
381 | 	<cfargument name="package" hint="the package the class comes from" type="string" required="Yes">
382 | 	<cfscript>
383 | 		var meta = 0;
384 | 		arguments.class = resolveClassName(arguments.class, arguments.package);
385 | 
386 | 		meta = getComponentMetadata(arguments.class);
387 | 
388 | 		if(structKeyExists(meta, instance.static.META_ABSTRACT))
389 | 		{
390 | 			return meta[instance.static.META_ABSTRACT];
391 | 		}
392 | 
393 | 		return false;
394 |     </cfscript>
395 | </cffunction>
396 | 
397 | <cffunction name="getGenericTypes" hint="return an array of generic types associated with this function/argument" access="private" returntype="array" output="false"
398 | 	colddoc:generic="string">
399 | 	<cfargument name="meta" hint="either function, or argument metadata struct" type="struct" required="Yes">
400 | 	<cfargument name="package" hint="what package are we currently in?" type="string" required="Yes">
401 | 	<cfscript>
402 | 		var array = [];
403 | 		var local = {};
404 | 
405 | 		if(structKeyExists(arguments.meta, instance.static.META_GENERIC))
406 | 		{
407 | 			array = listToArray(arguments.meta[instance.static.META_GENERIC]);
408 | 
409 | 			local.len = ArrayLen(array);
410 |             for(local.counter=1; local.counter lte local.len; local.counter++)
411 |             {
412 |             	local.class = array[local.counter];
413 | 				if(NOT isPrimitive(local.class))
414 | 				{
415 | 					array[local.counter] = resolveClassName(local.class, arguments.package);
416 | 				}
417 |             }
418 | 		}
419 | 
420 | 		return array;
421 |     </cfscript>
422 | </cffunction>
423 | 
424 | <cffunction name="getFunctionQueryCache" access="private" returntype="struct" output="false" colddoc:generic="string,struct">
425 | 	<cfreturn instance.functionQueryCache />
426 | </cffunction>
427 | 
428 | <cffunction name="setFunctionQueryCache" access="private" returntype="void" output="false">
429 | 	<cfargument name="functionQueryCache" type="struct" required="true" colddoc:generic="string,query">
430 | 	<cfset instance.functionQueryCache = arguments.functionQueryCache />
431 | </cffunction>
432 | 
433 | <cffunction name="_trace">
434 | 	<cfargument name="s">
435 | 	<cfset var g = "">
436 | 	<cfsetting showdebugoutput="true">
437 | 	<cfsavecontent variable="g">
438 | 		<cfdump var="#arguments.s#">
439 | 	</cfsavecontent>
440 | 	<cftrace text="#g#">
441 | </cffunction>
442 | 
443 | <cffunction name="_dump">
444 | 	<cfargument name="s">
445 | 	<cfargument name="abort" default="true">
446 | 	<cfset var g = "">
447 | 		<cfdump var="#arguments.s#">
448 | 		<cfif arguments.abort>
449 | 		<cfabort>
450 | 		</cfif>
451 | </cffunction>
452 | 
453 | </cfcomponent>
454 | 


--------------------------------------------------------------------------------
/strategy/api/HTMLAPIStrategy.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent hint="Default Document Strategy for ColdDoc" extends="colddoc.strategy.AbstractTemplateStrategy" output="false">
  2 | 
  3 | <!------------------------------------------- PUBLIC ------------------------------------------->
  4 | 
  5 | <cfscript>
  6 | 	instance.static.TEMPLATE_PATH = "/colddoc/strategy/api/resources/templates";
  7 | </cfscript>
  8 | 
  9 | 
 10 | <cffunction name="init" hint="Constructor" access="public" returntype="HTMLAPIStrategy" output="false">
 11 | 	<cfargument name="outputDir" hint="the output directory" type="string" required="Yes">
 12 | 	<cfargument name="projectTitle" hint="the title of the project" type="string" required="No" default="Untitled">
 13 | 	<cfscript>
 14 | 		super.init();
 15 | 
 16 | 		setOutputDir(arguments.outputDir);
 17 | 		setProjectTitle(arguments.projectTitle);
 18 | 
 19 | 		return this;
 20 | 	</cfscript>
 21 | </cffunction>
 22 | 
 23 | <cffunction name="run" hint="Run this strategy" access="public" returntype="void" output="false">
 24 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
 25 | 	<cfscript>
 26 | 		var basePath = getDirectoryFromPath(getMetaData(this).path);
 27 | 		var args = 0;
 28 | 
 29 | 		recursiveCopy(basePath & "resources/static", getOutputDir());
 30 | 
 31 | 		//write the index template
 32 | 		args = {path=getOutputDir() & "/index.html", template="#instance.static.TEMPLATE_PATH#/index.html", projectTitle=getProjectTitle()};
 33 | 		writeTemplate(argumentCollection=args);
 34 | 
 35 | 		writeOverviewSummaryAndFrame(arguments.qMetaData);
 36 | 
 37 | 		writeAllClassesFrame(arguments.qMetaData);
 38 | 
 39 | 		writePackagePages(arguments.qMetaData);
 40 |     </cfscript>
 41 | </cffunction>
 42 | 
 43 | <!------------------------------------------- PACKAGE ------------------------------------------->
 44 | 
 45 | <!------------------------------------------- PRIVATE ------------------------------------------->
 46 | 
 47 | <cffunction name="writePackagePages" hint="writes the package summaries" access="private" returntype="void" output="false">
 48 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
 49 | 	<cfscript>
 50 | 		var currentDir = 0;
 51 | 		var qPackage = 0;
 52 | 		var qClasses = 0;
 53 | 		var qInterfaces = 0;
 54 | 	</cfscript>
 55 | 
 56 | 	<cfoutput query="arguments.qMetaData" group="package">
 57 | 		<cfscript>
 58 | 			currentDir = getOutputDir() & "/" & replace(package, ".", "/", "all");
 59 | 			ensureDirectory(currentDir);
 60 | 			qPackage = getMetaSubquery(arguments.qMetaData, "package = '#package#'", "name asc");
 61 | 			qClasses = getMetaSubquery(qPackage, "type='component'", "name asc");
 62 | 			qInterfaces = getMetaSubquery(qPackage, "type='interface'", "name asc");
 63 | 
 64 | 			writeTemplate(path=currentDir & "/package-summary.html",
 65 | 						template="#instance.static.TEMPLATE_PATH#/package-summary.html",
 66 | 						projectTitle = getProjectTitle(),
 67 | 						package = package,
 68 | 						qClasses = qClasses,
 69 | 						qInterfaces = qInterfaces);
 70 | 
 71 | 			writeTemplate(path=currentDir & "/package-frame.html",
 72 | 						template="#instance.static.TEMPLATE_PATH#/package-frame.html",
 73 | 						projectTitle = getProjectTitle(),
 74 | 						package = package,
 75 | 						qClasses = qClasses,
 76 | 						qInterfaces = qInterfaces);
 77 | 
 78 | 			buildClassPages(qPackage,
 79 | 							arguments.qMetadata
 80 | 							);
 81 | 		</cfscript>
 82 | 	</cfoutput>
 83 | </cffunction>
 84 | 
 85 | <cffunction name="buildClassPages" hint="builds the class pages" access="private" returntype="void" output="false">
 86 | 	<cfargument name="qPackage" hint="the query for a specific package" type="query" required="Yes">
 87 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
 88 | 	<cfscript>
 89 | 		var qSubClass = 0;
 90 | 		var qImplementing = 0;
 91 | 		var currentDir = 0;
 92 | 		var subClass = 0;
 93 | 		var safeMeta = 0;
 94 | 	</cfscript>
 95 | 
 96 | <!---	<cfif arguments.qPackage.package eq "coldspring.aop">
 97 | 	<cfdump show="name,package,type" var="#arguments.qPackage#" ><cfabort>
 98 | 	</cfif>--->
 99 | 
100 | 	<cfloop query="arguments.qPackage">
101 | 		<cfscript>
102 | 			currentDir = getOutputDir() & "/" & replace(package, ".", "/", "all");
103 | 			safeMeta = structCopy(metadata);
104 | 
105 | 			if(safeMeta.type eq "component")
106 | 			{
107 | 				qSubClass = getMetaSubquery(arguments.qMetaData, "UPPER(extends) = UPPER('#arguments.qPackage.package#.#arguments.qPackage.name#')", "package asc, name asc");
108 | 				qImplementing = QueryNew("");
109 | 			}
110 | 			else
111 | 			{
112 | 				//all implementing subclasses
113 | 				qSubClass = getMetaSubquery(arguments.qMetaData, "UPPER(fullextends) LIKE UPPER('%:#arguments.qPackage.package#.#arguments.qPackage.name#:%')", "package asc, name asc");
114 | 				qImplementing = getMetaSubquery(arguments.qMetaData, "UPPER(implements) LIKE UPPER('%:#arguments.qPackage.package#.#arguments.qPackage.name#:%')", "package asc, name asc");
115 | 			}
116 | 
117 | 			writeTemplate(path=currentDir & "/#name#.html",
118 | 						template="#instance.static.TEMPLATE_PATH#/class.html",
119 | 						projectTitle = getProjectTitle(),
120 | 						package = arguments.qPackage.package,
121 | 						name = arguments.qPackage.name,
122 | 						qSubClass = qSubClass,
123 | 						qImplementing = qImplementing,
124 | 						qMetadata = qMetaData,
125 | 						metadata = safeMeta
126 | 						);
127 | 		</cfscript>
128 | 	</cfloop>
129 | </cffunction>
130 | 
131 | 
132 | <cffunction name="writeOverviewSummaryAndFrame" hint="writes the overview-summary.html" access="private" returntype="void" output="false">
133 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
134 | 	<cfscript>
135 | 		var qPackages = 0;
136 | 	</cfscript>
137 | 		<cfquery name="qPackages" dbtype="query" debug="false">
138 | 			SELECT DISTINCT
139 | 				package
140 | 			FROM
141 | 				arguments.qMetaData
142 | 			ORDER BY
143 | 				package
144 | 		</cfquery>
145 | 
146 | 	<cfscript>
147 | 		writeTemplate(path=getOutputDir() & "/overview-summary.html",
148 | 					template="#instance.static.TEMPLATE_PATH#/overview-summary.html",
149 | 					projectTitle = getProjectTitle(),
150 | 					qPackages = qPackages);
151 | 
152 | 
153 | 		//overview frame
154 | 		writeTemplate(path=getOutputDir() & "/overview-frame.html",
155 | 					template="#instance.static.TEMPLATE_PATH#/overview-frame.html",
156 | 					projectTitle=getProjectTitle(),
157 | 					qPackages = qPackages);
158 | 	</cfscript>
159 | </cffunction>
160 | 
161 | <cffunction name="writeAllClassesFrame" hint="writes the allclasses-frame.html" access="private" returntype="void" output="false">
162 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
163 | 	<cfscript>
164 | 		arguments.qMetadata = getMetaSubquery(query=arguments.qMetaData, orderby="name asc");
165 | 
166 | 		writeTemplate(path=getOutputDir() & "/allclasses-frame.html",
167 | 					template="#instance.static.TEMPLATE_PATH#/allclasses-frame.html",
168 | 					qMetaData = arguments.qMetaData);
169 | 	</cfscript>
170 | </cffunction>
171 | 
172 | <cffunction name="getOutputDir" access="private" returntype="string" output="false">
173 | 	<cfreturn instance.outputDir />
174 | </cffunction>
175 | 
176 | <cffunction name="setOutputDir" access="private" returntype="void" output="false">
177 | 	<cfargument name="outputDir" type="string" required="true">
178 | 	<cfset instance.outputDir = arguments.outputDir />
179 | </cffunction>
180 | 
181 | <cffunction name="getProjectTitle" access="private" returntype="string" output="false">
182 | 	<cfreturn instance.projectTitle />
183 | </cffunction>
184 | 
185 | <cffunction name="setProjectTitle" access="private" returntype="void" output="false">
186 | 	<cfargument name="projectTitle" type="string" required="true">
187 | 	<cfset instance.projectTitle = arguments.projectTitle />
188 | </cffunction>
189 | 
190 | </cfcomponent>


--------------------------------------------------------------------------------
/strategy/api/resources/static/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
 2 | <!--NewPage-->
 3 | <HTML>
 4 | <HEAD>
 5 | <!-- Generated by javadoc on Thu Jun 14 00:09:26 CEST 2007-->
 6 | <TITLE>
 7 | Generated Documentation (Untitled)
 8 | </TITLE>
 9 | <SCRIPT type="text/javascript">
10 |     targetPage = "" + window.location.search;
11 |     if (targetPage != "" && targetPage != "undefined")
12 |         targetPage = targetPage.substring(1);
13 |     if (targetPage.indexOf(":") != -1)
14 |         targetPage = "undefined";
15 |     function loadFrames() {
16 |         if (targetPage != "" && targetPage != "undefined")
17 |              top.classFrame.location = top.targetPage;
18 |     }
19 | </SCRIPT>
20 | <NOSCRIPT>
21 | </NOSCRIPT>
22 | </HEAD>
23 | <FRAMESET cols="20%,80%" title="" onLoad="top.loadFrames()">
24 | <FRAMESET rows="30%,70%" title="" onLoad="top.loadFrames()">
25 | <FRAME src="overview-frame.html" name="packageListFrame" title="All Packages">
26 | <FRAME src="allclasses-frame.html" name="packageFrame" title="All classes and interfaces (except non-static nested types)">
27 | </FRAMESET>
28 | <FRAME src="overview-summary.html" name="classFrame" title="Package, class and interface descriptions" scrolling="yes">
29 | <NOFRAMES>
30 | <H2>
31 | Frame Alert</H2>
32 | 
33 | <P>
34 | This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client.
35 | <BR>
36 | Link to<A HREF="overview-summary.html">Non-frame version.</A>
37 | </NOFRAMES>
38 | </FRAMESET>
39 | </HTML>
40 | 


--------------------------------------------------------------------------------
/strategy/api/resources/static/resources/inherit.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/markmandel/ColdDoc/1dc40049ccaa44f72d043cd633ef0412b3708f2d/strategy/api/resources/static/resources/inherit.gif


--------------------------------------------------------------------------------
/strategy/api/resources/static/stylesheet.css:
--------------------------------------------------------------------------------
 1 | /* Javadoc style sheet */
 2 | 
 3 | /* Define colors, fonts and other style attributes here to override the defaults */
 4 | 
 5 | /* Page background color */
 6 | body { background-color: #FFFFFF }
 7 | 
 8 | /* Headings */
 9 | h1 { font-size: 145% }
10 | 
11 | /* Table colors */
12 | .TableHeadingColor     { background: #CCCCFF } /* Dark mauve */
13 | .TableSubHeadingColor  { background: #EEEEFF } /* Light mauve */
14 | .TableRowColor         { background: #FFFFFF } /* White */
15 | 
16 | /* Font used in left-hand frame lists */
17 | .FrameTitleFont   { font-size: 100%; font-family: Helvetica, Arial, sans-serif }
18 | .FrameHeadingFont { font-size:  90%; font-family: Helvetica, Arial, sans-serif }
19 | .FrameItemFont    { font-size:  90%; font-family: Helvetica, Arial, sans-serif }
20 | 
21 | /* Navigation bar fonts and colors */
22 | .NavBarCell1    { background-color:#EEEEFF;} /* Light mauve */
23 | .NavBarCell1Rev { background-color:#00008B;} /* Dark Blue */
24 | .NavBarFont1    { font-family: Arial, Helvetica, sans-serif; color:#000000;}
25 | .NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;}
26 | 
27 | .NavBarCell2    { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}
28 | .NavBarCell3    { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}
29 | 
30 | 


--------------------------------------------------------------------------------
/strategy/api/resources/templates/allclasses-frame.html:
--------------------------------------------------------------------------------
 1 | <cfoutput>
 2 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 3 | <!--NewPage-->
 4 | <HTML>
 5 | <HEAD>
 6 | <!-- Generated by colddoc on #Now()# -->
 7 | <TITLE>
 8 | All Classes
 9 | </TITLE>
10 | 
11 | <LINK REL ="stylesheet" TYPE="text/css" HREF="stylesheet.css" TITLE="Style">
12 | 
13 | </HEAD>
14 | 
15 | <BODY BGCOLOR="white">
16 | <FONT size="+1" CLASS="FrameHeadingFont">
17 | <B>All Classes</B></FONT>
18 | 
19 | <BR>
20 | 
21 | <TABLE BORDER="0" WIDTH="100%" SUMMARY="">
22 | <TR>
23 | <TD NOWRAP><FONT CLASS="FrameItemFont">
24 | <cfloop query="arguments.qMetaData">
25 | <A HREF="#replace(package, ".", "/", "all")#/#name#.html" title="class in #package#" target="classFrame"><cfif type eq "interface"><i>#name#</i><cfelse>#name#</cfif></A>
26 | <BR>
27 | </cfloop>
28 | </FONT>
29 | </TD>
30 | </TR>
31 | </TABLE>
32 | 
33 | </BODY>
34 | </HTML>
35 | </cfoutput>


--------------------------------------------------------------------------------
/strategy/api/resources/templates/class.html:
--------------------------------------------------------------------------------
  1 | <cfoutput>
  2 | 
  3 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4 | <!--NewPage-->
  5 | <HTML>
  6 | <HEAD>
  7 | <!-- Generated by colddoc on #Now()# -->
  8 | <TITLE>
  9 | Callable
 10 | </TITLE>
 11 | 
 12 | <META NAME="keywords" CONTENT="#arguments.package#.concurrent.Callable interface">
 13 | 
 14 | <cfset instance.class.root = RepeatString('../', ListLen(arguments.package, ".")) />
 15 | 
 16 | <LINK REL ="stylesheet" TYPE="text/css" HREF="#instance.class.root#stylesheet.css" TITLE="Style">
 17 | 
 18 | <SCRIPT type="text/javascript">
 19 | function windowTitle()
 20 | {
 21 |     parent.document.title="#arguments.name#";
 22 | }
 23 | </SCRIPT>
 24 | <NOSCRIPT>
 25 | </NOSCRIPT>
 26 | 
 27 | </HEAD>
 28 | 
 29 | <BODY BGCOLOR="white" onload="windowTitle();">
 30 | 
 31 | 
 32 | <cfmodule template="inc/nav.html"
 33 | 			page="Class"
 34 | 			projectTitle= "#arguments.projectTitle#"
 35 | 			package = "#arguments.package#"
 36 | 			file="#replace(arguments.package, '.', '/', 'all')#/#arguments.name#"
 37 | 			>
 38 | 
 39 | <HR>
 40 | <!-- ======== START OF CLASS DATA ======== -->
 41 | <H2>
 42 | <FONT SIZE="-1">
 43 | #arguments.package#</FONT>
 44 | <BR>
 45 | <cfif arguments.metadata.type eq "interface">
 46 | Interface
 47 | <cfelse>
 48 | Class
 49 | </cfif>
 50 |  #arguments.name#</H2>
 51 | 
 52 | <cfset local.i = 0 />
 53 | 
 54 | <cfset local.ls = createObject("java", "java.lang.System").getProperty("line.separator") />
 55 | <cfset local.buffer = createObject("java", "java.lang.StringBuffer").init() />
 56 | <cfset local.thisClass = arguments.package & "." & arguments.name/>
 57 | 
 58 | <cfloop array="#getInheritence(arguments.metadata)#" index="className">
 59 | 	<cfif local.i++ gt 0>
 60 | 		<cfset local.buffer.append('#RepeatString("    ", local.i)#<IMG SRC="#instance.class.root#resources/inherit.gif" ALT="extended by ">') />
 61 | 		<cfif className neq local.thisClass>
 62 | 			<cfset local.buffer.append(writeClassLink(getPackage(className), getObjectName(className), arguments.qMetaData, "long")) />
 63 | 		<cfelse>
 64 | 			<cfset local.buffer.append(className) />
 65 | 		</cfif>
 66 | 	<cfelse>
 67 | 		<cfset local.buffer.append(className) />
 68 | 	</cfif>
 69 | 	<cfset local.buffer.append(local.ls) />
 70 | </cfloop>
 71 | 
 72 | <PRE>#local.buffer.toString()#</PRE>
 73 | 
 74 | <cfif arguments.metadata.type eq "component">
 75 | 	<cfset interfaces = getImplements(arguments.metadata)>
 76 | 	<cfif NOT arrayIsEmpty(interfaces)>
 77 | 		<DL>
 78 | 		<DT><B>All Implemented Interfaces:</B>
 79 | 		<DD>
 80 | 		<cfset local.len = arrayLen(interfaces)>
 81 | 		<cfloop from="1" to="#local.len#" index="local.counter">
 82 | 			<cfset interface = interfaces[local.counter]>
 83 | 			<cfif local.counter neq 1>,</cfif>
 84 | 			#writeClassLink(getPackage(interface), getObjectName(interface), arguments.qMetaData, "short")#
 85 | 		</cfloop>
 86 | 		</DD>
 87 | 		</DL>
 88 | 	</cfif>
 89 | <cfelse>
 90 | 	<cfif arguments.qImplementing.recordCount>
 91 | 	<DL>
 92 | 	<DT><B>All Known Implementing Classes:</B>
 93 | 	<DD>
 94 | 		<cfloop query="arguments.qImplementing">
 95 | 			<cfif arguments.qImplementing.currentRow neq 1>,</cfif>
 96 | 			#writeClassLink(arguments.qImplementing.package, arguments.qImplementing.name, arguments.qMetaData, "short")#
 97 | 		</cfloop>
 98 | 	</DD>
 99 | 	</DL>
100 | 	</cfif>
101 | </cfif>
102 | 
103 | <cfif arguments.qSubclass.recordCount>
104 | <DL>
105 | <DT><B><cfif arguments.metadata.type eq "component">Direct Known Subclasses<cfelse>All Known Subinterfaces</cfif>:</B>
106 | <DD>
107 | 	<cfloop query="arguments.qSubclass">
108 | 		<cfif arguments.qSubclass.currentRow neq 1>,</cfif>
109 | 		<A HREF="#instance.class.root#/#replace(arguments.qSubclass.package, '.', '/', 'all')#/#arguments.qSubclass.name#.html" title="class in #arguments.package#">#arguments.qSubclass.name#</A>
110 | 	</cfloop>
111 | </DD>
112 | </DL>
113 | </cfif>
114 | 
115 | <HR>
116 | <DL>
117 | <DT>
118 | 
119 | <cfscript>
120 | 	local.buffer.setLength(0);
121 | 	local.buffer.append("public ");
122 | 	if(isAbstractClass(name, arguments.package))
123 | 	{
124 | 		local.buffer.append("abstract ");
125 | 	}
126 | 
127 | 	if(arguments.metadata.type eq "interface")
128 | 	{
129 | 		local.buffer.append("interface");
130 | 	}
131 | 	else
132 | 	{
133 | 		local.buffer.append("class");
134 | 	}
135 | 
136 | 	local.buffer.append(" <B>#arguments.name#</B>");
137 | 	local.buffer.append(local.ls);
138 | 	if(StructKeyExists(arguments.metadata, "extends"))
139 | 	{
140 | 		local.extendsmeta = arguments.metadata.extends;
141 | 		if(arguments.metadata.type eq "interface")
142 | 		{
143 | 			local.extendsmeta = arguments.metadata.extends[structKeyList(local.extendsmeta)];
144 | 		}
145 | 		local.buffer.append("<DT>extends #writeClassLink(getPackage(local.extendsmeta.name), getObjectName(local.extendsmeta.name), arguments.qMetaData, 'short')#</DT>");
146 | 	}
147 | </cfscript>
148 | 
149 | <PRE>#local.buffer.toString()#</PRE>
150 | </DT>
151 | </DL>
152 | 
153 | <cfif StructKeyExists(arguments.metadata, "hint")>
154 | <P>
155 | 	#arguments.metadata.hint#
156 | <P>
157 | </cfif>
158 | 
159 | <HR>
160 | 
161 | <p>
162 | 
163 | <cfscript>
164 | 	instance.class.cache = StructNew();
165 | 	local.localFunctions = StructNew();
166 | 
167 | 	local.qFunctions = buildFunctionMetaData(arguments.metadata);
168 | 
169 | 	local.qInit = getMetaSubQuery(local.qFunctions, "UPPER(name)='INIT'");
170 | </cfscript>
171 | 
172 | <cfif local.qInit.recordCount>
173 | 	<cfset local.init = local.qInit.metadata />
174 | 	<cfset local.localFunctions[local.init.name] = 1 />
175 | 	<!-- ======== CONSTRUCTOR SUMMARY ======== -->
176 | 
177 | 	<A NAME="constructor_summary"><!-- --></A>
178 | 	<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
179 | 	<TR BGCOLOR="##CCCCFF" CLASS="TableHeadingColor">
180 | 	<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
181 | 	<B>Constructor Summary</B></FONT></TH>
182 | 	</TR>
183 | 	<TR BGCOLOR="white" CLASS="TableRowColor">
184 | 	<cfif local.init.access neq "public">
185 | 		<td align="right" valign="top" width="1%"><font size="-1">
186 | 		<code>#local.init.access# </code></font></td>
187 | 	</cfif>
188 | 	<TD>
189 | 		#writeMethodLink(arguments.name, arguments.package, local.init, arguments.qMetaData)#
190 | 	<BR>
191 | 	<cfif StructKeyExists(local.init, "hint")>
192 | 		<!--- only grab the first sentence of the hint --->
193 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#listGetAt(local.init.hint, 1, ".")#
194 | 	</cfif>
195 | 	</TD>
196 | 	</TR>
197 | 	</TABLE>
198 | 	&nbsp;
199 | </cfif>
200 | 
201 | <cfset local.qFunctions = getMetaSubQuery(local.qFunctions, "UPPER(name)!='INIT'") />
202 | 
203 | <cfif local.qFunctions.recordCount>
204 | <!-- ========== METHOD SUMMARY =========== -->
205 | 
206 | <A NAME="method_summary"><!-- --></A>
207 | <TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
208 | <TR BGCOLOR="##CCCCFF" CLASS="TableHeadingColor">
209 | <TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
210 | <B>Method Summary</B></FONT></TH>
211 | </TR>
212 | 
213 | <cfloop query="local.qFunctions">
214 | <cfset local.func = local.qFunctions.metadata />
215 | <cfset local.localFunctions[local.func.name] = 1 />
216 | <TR BGCOLOR="white" CLASS="TableRowColor">
217 | <TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
218 | <CODE><cfif local.func.access neq "public">#local.func.access#</cfif>&nbsp;#writeTypeLink(local.func.returnType, arguments.package, arguments.qMetadata, local.func)#</CODE></FONT></TD>
219 | <TD>#writeMethodLink(arguments.name, arguments.package, local.func, arguments.qMetaData)#
220 | <BR>
221 | <cfif StructKeyExists(local.func, "hint") AND Len(local.func.hint)>
222 | <!--- only grab the first sentence of the hint --->
223 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#listGetAt(local.func.hint, 1, ".")#
224 | </cfif>
225 | </TD>
226 | </TR>
227 | </cfloop>
228 | </TR>
229 | </TABLE>
230 | 
231 | </cfif>
232 | 
233 | <cfset local.localmeta = arguments.metadata />
234 | 
235 | <cfloop condition="#StructKeyExists(local.localmeta, 'extends')#">
236 | 	<cfscript>
237 | 		if(local.localmeta.type eq "interface")
238 | 		{
239 | 			local.localmeta = local.localmeta.extends[structKeyList(local.localmeta.extends)];
240 | 		}
241 | 		else
242 | 		{
243 | 			local.localmeta = local.localmeta.extends;
244 | 		}
245 |     </cfscript>
246 | 
247 | 	<cfset local.qFunctions = buildFunctionMetaData(local.localmeta)>
248 | 
249 | 	&nbsp;
250 | 	<a name="methods_inherited_from_class_#local.localmeta.name#"><!-- --></a>
251 | 	<table summary="" border="1" cellpadding="3" cellspacing="0" width="100%">
252 | 	<tbody><tr class="TableSubHeadingColor" bgcolor="##eeeeff">
253 | 	<th align="left"><b>Methods inherited from class #writeClassLink(getPackage(local.localmeta.name), getObjectName(local.localmeta.name), arguments.qMetaData, 'long')#</b></th>
254 | 	</tr>
255 | 	<tr class="TableRowColor" bgcolor="white">
256 | 	<td>
257 | 		<cfset local.buffer.setLength(0) />
258 | 		<cfset i = 1 />
259 | 		<cfloop query="local.qFunctions">
260 | 			<cfset local.func = local.qFunctions.metadata />
261 | 			<cfif NOT StructKeyExists(local.localFunctions, local.func.name)>
262 | 			<cfif i++ neq 1>
263 | 				<cfset local.buffer.append(", ") />
264 | 			</cfif>
265 | 			<cfset local.buffer.append('<a href="#instance.class.root#/#replace(getPackage(local.localmeta.name), '.', '/', 'all')#/#getObjectName(local.localmeta.name)#.html###local.func.name#()">#local.func.name#</a>') />
266 | 			<cfset local.localFunctions[local.func.name] = 1 />
267 | 			</cfif>
268 | 		</cfloop>
269 | 
270 | 		<code>#local.buffer.toString()#</code>
271 | 	</td>
272 | 	</tr>
273 | 	</tbody></table>
274 | </cfloop>
275 | 
276 | &nbsp;
277 | <P>
278 | 
279 | <cfif StructKeyExists(local, "init")>
280 | 
281 | <!-- ========= CONSTRUCTOR DETAIL ======== -->
282 | 
283 | <a name="constructor_detail"><!-- --></a>
284 | </p><table summary="" border="1" cellpadding="3" cellspacing="0" width="100%">
285 | <tbody><tr class="TableHeadingColor" bgcolor="##ccccff">
286 | <th colspan="1" align="left"><font size="+2">
287 | <b>Constructor Detail</b></font></th>
288 | </tr>
289 | </tbody></table>
290 | 
291 | <a name="#local.init.name#()"><!-- --></a><h3>
292 | 
293 | #local.init.name#</h3>
294 | <CODE>#local.init.access# #writeMethodLink(arguments.name, arguments.package, local.init, arguments.qMetaData, false)#</CODE>
295 | <dl>
296 | <dd>
297 | <cfif StructKeyExists(local.init, "hint")>
298 | #local.init.hint#
299 | </cfif>
300 | <p>
301 | </p>
302 | <cfif StructKeyExists(local.init, "parameters") AND ArrayLen(local.init.parameters)>
303 | <dl>
304 | <dt><b>Parameters:</b></dt>
305 | <cfloop array="#local.init.parameters#" index="local.param">
306 | <dd><code>#local.param.name#</code><cfif StructKeyExists(local.param, "hint")> - #local.param.hint#</cfif></dd>
307 | </cfloop>
308 | </dl>
309 | </cfif>
310 | 
311 | </dd></dl>
312 | <!--- <hr> --->
313 | </cfif>
314 | 
315 | <cfset local.qFunctions = buildFunctionMetaData(arguments.metadata) />
316 | <cfset local.qFunctions = getMetaSubQuery(local.qFunctions, "UPPER(name)!='INIT'") />
317 | 
318 | <cfif local.qFunctions.recordCount>
319 | 
320 | <!-- ============ METHOD DETAIL ========== -->
321 | 
322 | <a name="method_detail"><!-- --></a>
323 | <table summary="" border="1" cellpadding="3" cellspacing="0" width="100%">
324 | <tbody><tr class="TableHeadingColor" bgcolor="##ccccff">
325 | <th colspan="1" align="left"><font size="+2">
326 | <b>Method Detail</b></font></th>
327 | </tr>
328 | </tbody></table>
329 | <cfloop query="local.qFunctions">
330 | 	<cfset local.func = local.qFunctions.metadata />
331 | 	<a name="#local.func.name#()"><!-- --></a><h3>
332 | 	#local.func.name#</h3>
333 | 	<code>#local.func.access# #writeTypeLink(local.func.returnType, arguments.package, arguments.qMetaData, local.func)# #writeMethodLink(arguments.name, arguments.package, local.func, arguments.qMetaData, false)#</code>
334 | 
335 | 	<dl>
336 | 	<dd>
337 | 	<cfif StructKeyExists(local.func, "hint") AND Len(local.func.hint)>
338 | 	#local.func.hint#
339 | 	</cfif>
340 | 	<p>
341 | 	</p></dd>
342 | 
343 | 	<!---
344 | 		<dl>
345 | 			<dt><b>Specified by:</b></dt>
346 | 			<dd>
347 | 			<code>
348 | 				<a href="../../java/lang/Appendable.html#append%28java.lang.CharSequence%29">append</a>
349 | 			</code>
350 | 			 in interface
351 | 			<code>
352 | 			<a href="../../java/lang/Appendable.html" title="interface in java.lang">Appendable</a></code>
353 | 			</dd>
354 | 		</dl>
355 | 	 --->
356 | 	<cfif arguments.metadata.type eq "component">
357 | 		<cfset local.specified = findSpecifiedBy(arguments.metaData, local.func.name) />
358 | 		<cfif Len(local.specified)>
359 | 			<dl>
360 | 				<dt><b>Specified by:</b></dt>
361 | 				<dd>
362 | 				<code>
363 | 				<a href="#instance.class.root#/#replace(getPackage(local.specified), '.', '/', 'all')#/#getObjectName(local.specified)#.html###local.func.name#()">#local.func.name#</a></code>
364 | 				in interface
365 | 				<code>
366 | 					#writeClassLink(getPackage(local.specified), getObjectName(local.specified), arguments.qMetaData, 'short')#
367 | 				</code>
368 | 				</dd>
369 | 			</dl>
370 | 		</cfif>
371 | 	</cfif>
372 | 
373 | 	<cfset local.overWrites = findOverwrite(arguments.metaData, local.func.name) />
374 | 	<cfif Len(local.overWrites)>
375 | 	<dl>
376 | 		<dt><b>Overrides:</b></dt>
377 | 		<dd>
378 | 		<code>
379 | 		<a href="#instance.class.root#/#replace(getPackage(local.overWrites), '.', '/', 'all')#/#getObjectName(local.overWrites)#.html###local.func.name#()">#local.func.name#</a></code>
380 | 		in class
381 | 		<code>
382 | 			#writeClassLink(getPackage(local.overWrites), getObjectName(local.overWrites), arguments.qMetaData, 'short')#
383 | 		</code>
384 | 		</dd>
385 | 	</dl>
386 | 	</cfif>
387 | 
388 | 	<cfif StructKeyExists(local.func, "parameters") AND ArrayLen(local.func.parameters)>
389 | 	<dl>
390 | 	<dt><b>Parameters:</b></dt>
391 | 	<cfloop array="#local.func.parameters#" index="local.param">
392 | 	<dd><code>#local.param.name#</code><cfif StructKeyExists(local.param, "hint")> - #local.param.hint#</cfif></dd>
393 | 	</cfloop>
394 | 	</dl>
395 | 	</cfif>
396 | 
397 | 	</dd>
398 | 	</dl>
399 | 	<hr>
400 | </cfloop>
401 | </cfif>
402 | 
403 | <cfmodule template="inc/nav.html"
404 | 			page="Class"
405 | 			projectTitle= "#arguments.projectTitle#"
406 | 			package = "#arguments.package#"
407 | 			file="#replace(arguments.package, '.', '/', 'all')#/#arguments.name#"
408 | 			>
409 | 
410 | <HR>
411 | 
412 | </BODY>
413 | </HTML>
414 | </cfoutput>
415 | <cfsilent>
416 | 	<cffunction name="writeMethodLink" hint="draws a method link" access="private" returntype="string" output="false">
417 | 		<cfargument name="name" hint="the name of the class" type="string" required="Yes">
418 | 		<cfargument name="package" hint="out current package" type="string" required="Yes">
419 | 		<cfargument name="func" hint="the function to link to" required="Yes">
420 | 		<cfargument name="qMetaData" hint="the meta daya query" type="query" required="Yes">
421 | 		<cfargument name="drawMethodLink" hint="actually draw the link on the method" type="boolean" required="No" default="true">
422 | 		<cfset var param = 0 />
423 | 		<cfset var i = 1 />
424 | 		<cfset var builder = createObject("java", "java.lang.StringBuilder").init() />
425 | 		<cfsilent>
426 | 
427 | 		<cfif StructKeyExists(arguments.func, "parameters")>
428 | 			<cfset builder.append("(") />
429 | 				<cfloop array="#arguments.func.parameters#" index="param">
430 | 					<cfscript>
431 | 						if(i++ neq 1)
432 | 						{
433 | 							builder.append(", ");
434 | 						}
435 | 
436 | 						if(NOT StructKeyExists(param, "required"))
437 | 						{
438 | 							param.required = false;
439 | 						}
440 | 
441 | 						if(NOT param.required)
442 | 						{
443 | 							builder.append("[");
444 | 						}
445 | 					</cfscript>
446 | 
447 | 					<cfscript>
448 | 						safeParamMeta(param);
449 | 						builder.append(writeTypeLink(param.type, arguments.package, arguments.qMetadata, param));
450 | 
451 | 						builder.append(" " & param.name);
452 | 
453 | 						if(StructKeyExists(param, "default"))
454 | 						{
455 | 							builder.append("='" & param.default & "'");
456 | 						}
457 | 
458 | 						if(NOT param.required)
459 | 						{
460 | 							builder.append("]");
461 | 						}
462 | 					</cfscript>
463 | 				</cfloop>
464 | 			<cfset builder.append(")") />
465 | 		</cfif>
466 | 
467 | 		</cfsilent>
468 | 		<cfif arguments.drawMethodLink>
469 | 		<cfreturn '<CODE><B><A HREF="#arguments.name#.html###arguments.func.name#()">#arguments.func.name#</A></B>#builder.toString()#</CODE>'/>
470 | 		<cfelse>
471 | 		<cfreturn '<B>#arguments.func.name#</B>#builder.toString()#'/>
472 | 		</cfif>
473 | 	</cffunction>
474 | 
475 | 	<cffunction name="writeTypeLink" hint="writes a link to a type, or a class" access="private" returntype="string" output="false">
476 | 		<cfargument name="type" hint="the type/class" type="string" required="Yes">
477 | 		<cfargument name="package" hint="the current package" type="string" required="Yes">
478 | 		<cfargument name="qMetaData" hint="the meta data query" type="query" required="Yes">
479 | 		<cfargument name="genericMeta" hint="optional meta that may contain generic type information" type="struct" required="No" default="#structNew()#">
480 | 		<cfscript>
481 | 			var result = createObject("java", "java.lang.StringBuilder").init();
482 | 			var local = {};
483 | 
484 | 			if(isPrimitive(arguments.type))
485 | 			{
486 | 				result.append(arguments.type);
487 | 			}
488 | 			else
489 | 			{
490 | 				arguments.type = resolveClassName(arguments.type, arguments.package);
491 | 				result.append(writeClassLink(getPackage(arguments.type), getObjectName(arguments.type), arguments.qMetaData, 'short'));
492 | 			}
493 | 
494 | 			if(NOT structIsEmpty(arguments.genericMeta))
495 | 			{
496 | 				local.array = getGenericTypes(arguments.genericMeta, arguments.package);
497 | 				if(NOT arrayIsEmpty(local.array))
498 | 				{
499 | 					result.append("&lt;");
500 | 
501 | 					local.len = ArrayLen(local.array);
502 |                     for(local.counter=1; local.counter lte local.len; local.counter++)
503 |                     {
504 | 						if(local.counter neq 1)
505 | 						{
506 | 							result.append(",");
507 | 						}
508 | 
509 |                     	local.generic = local.array[local.counter];
510 | 						result.append(writeTypeLink(local.generic, arguments.package, arguments.qMetaData));
511 |                     }
512 | 
513 | 					result.append("&gt;");
514 | 				}
515 | 			}
516 | 
517 | 			return result.toString();
518 |         </cfscript>
519 | 	</cffunction>
520 | 
521 | 	<cfscript>
522 | 		/*
523 | 		function getArgumentList(func)
524 | 		{
525 | 			var list = "";
526 | 			var len = 0;
527 | 			var counter = 1;
528 | 			var param = 0;
529 | 
530 | 			if(StructKeyExists(arguments.func, "parameters"))
531 | 			{
532 | 				len = ArrayLen(arguments.func.parameters);
533 | 				for(; counter lte len; counter = counter + 1)
534 | 				{
535 | 					param = safeParamMeta(arguments.func.parameters[counter]);
536 | 					list = listAppend(list, param.type);
537 | 				}
538 | 			}
539 | 
540 | 			return list;
541 | 		}
542 | 		*/
543 | 
544 | 		function writeClassLink(package, name, qMetaData, format)
545 | 		{
546 | 			var qClass = getMetaSubQuery(arguments.qMetaData, "LOWER(package)=LOWER('#arguments.package#') AND LOWER(name)=LOWER('#arguments.name#')");
547 | 			var builder = 0;
548 | 			var safeMeta = 0;
549 | 			var title = 0;
550 | 
551 | 			if(qClass.recordCount)
552 | 			{
553 | 				safeMeta = StructCopy(qClass.metadata);
554 | 
555 | 				title = "class";
556 | 				if(safeMeta.type eq "interface")
557 | 				{
558 | 					title = "interface";
559 | 				}
560 | 
561 | 				builder = createObject("java", "java.lang.StringBuilder").init();
562 | 				builder.append('<a href="#instance.class.root#/#replace(qClass.package, '.', '/', 'all')#/#qClass.name#.html" title="#title# in #qClass.package#">');
563 | 				if(arguments.format eq "short")
564 | 				{
565 | 					builder.append(qClass.name);
566 | 				}
567 | 				else
568 | 				{
569 | 					builder.append(qClass.package & "." & qClass.name);
570 | 				}
571 | 				builder.append("</a>");
572 | 
573 | 				return builder.toString();
574 | 			}
575 | 
576 | 			return package & "." & name;
577 | 		}
578 | 
579 | 		function getInheritence(metadata)
580 | 		{
581 | 			var localmeta = arguments.metadata;
582 | 			var inheritence = [arguments.metadata.name];
583 | 
584 | 			while(StructKeyExists(localmeta, "extends"))
585 | 			{
586 | 				//manage interfaces
587 | 				if(localmeta.type eq "interface")
588 | 				{
589 | 					localmeta = localmeta.extends[structKeyList(localmeta.extends)];
590 | 				}
591 | 				else
592 | 				{
593 | 					localmeta = localmeta.extends;
594 | 				}
595 | 
596 | 				ArrayPrepend(inheritence, localmeta.name);
597 | 			}
598 | 
599 | 			return inheritence;
600 | 		}
601 | 
602 | 		function getImplements(metadata)
603 | 		{
604 | 			var localmeta = arguments.metadata;
605 | 			var interfaces = {};
606 | 			var key = 0;
607 | 			var imeta = 0;
608 | 
609 | 			while(StructKeyExists(localmeta, "extends"))
610 | 			{
611 | 				if(StructKeyExists(localmeta, "implements"))
612 | 				{
613 | 					for(key in localmeta.implements)
614 | 					{
615 | 						imeta = localmeta.implements[local.key];
616 | 						interfaces[imeta.name] = 1;
617 | 					}
618 | 				}
619 | 				localmeta = localmeta.extends;
620 | 			}
621 | 
622 | 			interfaces = structKeyArray(interfaces);
623 | 
624 | 			arraySort(interfaces, "textnocase");
625 | 
626 | 			return interfaces;
627 | 		}
628 | 
629 | 		function findOverwrite(metadata, functionName)
630 | 		{
631 | 			var qFunctions = 0;
632 | 
633 | 			while(StructKeyExists(arguments.metadata, "extends"))
634 | 			{
635 | 				if(arguments.metadata.type eq "interface")
636 | 				{
637 | 					arguments.metadata = arguments.metadata.extends[structKeyList(arguments.metadata.extends)];
638 | 				}
639 | 				else
640 | 				{
641 | 					arguments.metadata = arguments.metadata.extends;
642 | 				}
643 | 
644 | 				qFunctions = buildFunctionMetaData(arguments.metadata);
645 | 				qFunctions = getMetaSubQuery(qFunctions, "name='#arguments.functionName#'");
646 | 
647 | 				if(qFunctions.recordCount)
648 | 				{
649 | 					return arguments.metadata.name;
650 | 
651 | 				}
652 | 			}
653 | 
654 | 			return "";
655 | 		}
656 | 
657 | 		function findSpecifiedBy(metadata, functionname)
658 | 		{
659 | 			var imeta = 0;
660 | 			var qFunctions = 0;
661 | 			var key = 0;
662 | 
663 | 			if(structKeyExists(arguments.metadata, "implements"))
664 | 			{
665 | 				for(key in arguments.metadata.implements)
666 | 				{
667 | 					imeta = arguments.metadata.implements[local.key];
668 | 
669 | 					qFunctions = buildFunctionMetaData(imeta);
670 | 					qFunctions = getMetaSubQuery(qFunctions, "name='#arguments.functionName#'");
671 | 
672 | 					if(qFunctions.recordCount)
673 | 					{
674 | 						return imeta.name;
675 | 					}
676 | 
677 | 					//now look up super-interfaces
678 | 					while(structKeyExists(imeta, "extends"))
679 | 					{
680 | 						imeta = imeta.extends[structKeyList(imeta.extends)];
681 | 
682 | 						qFunctions = buildFunctionMetaData(imeta);
683 | 						qFunctions = getMetaSubQuery(qFunctions, "name='#arguments.functionName#'");
684 | 
685 | 						if(qFunctions.recordCount)
686 | 						{
687 | 							return imeta.name;
688 | 						}
689 | 					}
690 | 				}
691 | 
692 | 			}
693 | 
694 | 			return "";
695 | 		}
696 | 
697 | 		//stupid cleanup
698 | 
699 | 		StructDelete(variables, "findOverwrite");
700 | 		StructDelete(variables, "writeTypeLink");
701 | 		StructDelete(variables, "writeMethodLink");
702 | 		StructDelete(variables, "getArgumentList");
703 | 		StructDelete(variables, "writeClassLink");
704 | 		StructDelete(variables, "getInheritence");
705 | 		StructDelete(variables, "writeObjectLink");
706 | 		StructDelete(variables, "getImplements");
707 | 		StructDelete(variables, "findSpecifiedBy");
708 | 
709 | 		//store for resident data
710 | 		StructDelete(variables.instance, "class");
711 | 	</cfscript>
712 | </cfsilent>


--------------------------------------------------------------------------------
/strategy/api/resources/templates/inc/nav.html:
--------------------------------------------------------------------------------
 1 | <cfparam name="attributes.package" default="">
 2 | <cfparam name="attributes.file">
 3 | 
 4 | <!-- ========= START OF NAVBAR ======= -->
 5 | <A NAME="navbar_top"><!-- --></A>
 6 | <A HREF="#skip-navbar_top" title="Skip navigation links"></A>
 7 | <TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
 8 | <TR>
 9 | <TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
10 | <A NAME="navbar_top_firstrow"><!-- --></A>
11 | <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
12 |   <TR ALIGN="center" VALIGN="top">
13 | 	<cfset root = RepeatString('../', ListLen(attributes.package, ".")) />
14 | 
15 |   <cfif attributes.page eq "Overview">
16 | 	<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Overview</B></FONT>&nbsp;</TD>
17 |   <cfelse>
18 | 	<cfoutput>
19 | 	<TD BGCOLOR="##EEEEFF" CLASS="NavBarCell1">    <A HREF="#root#overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
20 | 	</cfoutput>
21 |   </cfif>
22 | 
23 |   <cfif attributes.page eq "Package">
24 | 	<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Package</B></FONT>&nbsp;</TD>
25 |   <cfelseif attributes.page eq "Class">
26 | 	<TD BGCOLOR="##EEEEFF" CLASS="NavBarCell1">    <A HREF="package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A>&nbsp;</TD>
27 |   <cfelse>
28 | 	<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
29 |   </cfif>
30 | 
31 | 	<cfif attributes.page eq "Class">
32 | 		<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Class</B></FONT>&nbsp;</TD>
33 | 	<cfelse>
34 | 	<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
35 | 	</cfif>
36 | 
37 |   <!---
38 |   <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
39 |   <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
40 |   <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
41 |   <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A>&nbsp;</TD>
42 |   --->
43 | 
44 |   </TR>
45 | </TABLE>
46 | </TD>
47 | <TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
48 | <cfoutput>
49 | #attributes.projectTitle#</EM>
50 | </cfoutput>
51 | </TD>
52 | </TR>
53 | 
54 | <TR>
55 | 
56 | <TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
57 | 	<cfoutput>
58 | 	  <A HREF="#root#index.html?#attributes.file#.html" target="_top"><B>FRAMES</B></A>  &nbsp;
59 | 	</cfoutput>
60 | </FONT></TD>
61 | 
62 | </TR>
63 | </TABLE>
64 | <A NAME="skip-navbar_top"></A>
65 | <!-- ========= END OF NAVBAR ========= -->


--------------------------------------------------------------------------------
/strategy/api/resources/templates/index.html:
--------------------------------------------------------------------------------
 1 | <cfoutput><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
 2 | <!--NewPage-->
 3 | <HTML>
 4 | <HEAD>
 5 | <!-- Generated by colddoc on #Now()# -->
 6 | <TITLE>
 7 | Generated Documentation (#arguments.projectTitle#)
 8 | </TITLE>
 9 | <SCRIPT type="text/javascript">
10 |     targetPage = "" + window.location.search;
11 |     if (targetPage != "" && targetPage != "undefined")
12 |         targetPage = targetPage.substring(1);
13 |     if (targetPage.indexOf(":") != -1)
14 |         targetPage = "undefined";
15 |     function loadFrames() {
16 |         if (targetPage != "" && targetPage != "undefined")
17 |              top.classFrame.location = top.targetPage;
18 |     }
19 | </SCRIPT>
20 | <NOSCRIPT>
21 | </NOSCRIPT>
22 | </HEAD>
23 | <FRAMESET cols="20%,80%" title="" onLoad="top.loadFrames()">
24 | <FRAMESET rows="30%,70%" title="" onLoad="top.loadFrames()">
25 | <FRAME src="overview-frame.html" name="packageListFrame" title="All Packages">
26 | <FRAME src="allclasses-frame.html" name="packageFrame" title="All classes and interfaces (except non-static nested types)">
27 | </FRAMESET>
28 | <FRAME src="overview-summary.html" name="classFrame" title="Package, class and interface descriptions" scrolling="yes">
29 | <NOFRAMES>
30 | <H2>
31 | Frame Alert</H2>
32 | 
33 | <P>
34 | This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client.
35 | <BR>
36 | Link to<A HREF="overview-summary.html">Non-frame version.</A>
37 | </NOFRAMES>
38 | </FRAMESET>
39 | </HTML>
40 | </cfoutput>


--------------------------------------------------------------------------------
/strategy/api/resources/templates/overview-frame.html:
--------------------------------------------------------------------------------
 1 | <cfoutput>
 2 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 3 | <!--NewPage-->
 4 | <HTML>
 5 | <HEAD>
 6 | <!-- Generated by colddoc on #Now()# -->
 7 | <TITLE>
 8 | Overview
 9 | </TITLE>
10 | 
11 | <META NAME="keywords" CONTENT="Overview">
12 | 
13 | <LINK REL ="stylesheet" TYPE="text/css" HREF="stylesheet.css" TITLE="Style">
14 | 
15 | 
16 | </HEAD>
17 | 
18 | <BODY BGCOLOR="white">
19 | 
20 | <TABLE BORDER="0" WIDTH="100%" SUMMARY="">
21 | <TR>
22 | <TH ALIGN="left" NOWRAP><FONT size="+1" CLASS="FrameTitleFont">
23 | <B>#arguments.projectTitle#</B></FONT></TH>
24 | </TR>
25 | </TABLE>
26 | 
27 | <TABLE BORDER="0" WIDTH="100%" SUMMARY="">
28 | <TR>
29 | <TD NOWRAP><FONT CLASS="FrameItemFont"><A HREF="allclasses-frame.html" target="packageFrame">All Classes</A></FONT>
30 | <P>
31 | <FONT size="+1" CLASS="FrameHeadingFont">
32 | Packages</FONT>
33 | <BR>
34 | 
35 | </cfoutput>
36 | <cfoutput query="arguments.qPackages">
37 | <FONT CLASS="FrameItemFont"><A HREF="#replace(package, ".", "/", "all")#/package-frame.html" target="packageFrame">#package#</A></FONT>
38 | <br/>
39 | </cfoutput>
40 | <cfoutput>
41 | 
42 | <BR>
43 | 
44 | </TD>
45 | </TR>
46 | </TABLE>
47 | 
48 | <P>
49 | &nbsp;
50 | </BODY>
51 | </HTML>
52 | </cfoutput>


--------------------------------------------------------------------------------
/strategy/api/resources/templates/overview-summary.html:
--------------------------------------------------------------------------------
 1 | <cfoutput>
 2 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 3 | <!--NewPage-->
 4 | <HTML>
 5 | <HEAD>
 6 | <!-- Generated by colddoc on #Now()# -->
 7 | <TITLE>
 8 | Overview
 9 | </TITLE>
10 | 
11 | <META NAME="keywords" CONTENT="Overview">
12 | 
13 | <LINK REL ="stylesheet" TYPE="text/css" HREF="stylesheet.css" TITLE="Style">
14 | 
15 | <SCRIPT type="text/javascript">
16 | function windowTitle()
17 | {
18 |     parent.document.title="Overview";
19 | }
20 | </SCRIPT>
21 | <NOSCRIPT>
22 | </NOSCRIPT>
23 | 
24 | </HEAD>
25 | 
26 | <BODY BGCOLOR="white" onload="windowTitle();">
27 | 
28 | <cfmodule template="inc/nav.html"
29 | 			page="Overview"
30 | 			projectTitle= "#arguments.projectTitle#"
31 | 			file="overview-summary"
32 | 			>
33 | 
34 | <HR>
35 | 
36 | <H2>
37 | #arguments.projectTitle#
38 | </H2>
39 | 
40 | 
41 | <TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
42 | <TR BGCOLOR="##CCCCFF" CLASS="TableHeadingColor">
43 | <TH ALIGN="left" COLSPAN="1"><FONT SIZE="+2">
44 | <B>Packages</B></FONT></TH>
45 | </TR>
46 | 
47 | </cfoutput>
48 | <cfoutput query="arguments.qPackages">
49 | <TR BGCOLOR="white" CLASS="TableRowColor">
50 | <TD WIDTH="20%"><B><A HREF="#replace(package, ".", "/", "all")#/package-summary.html">#package#</A></B></TD>
51 | </TR>
52 | </cfoutput>
53 | <cfoutput>
54 | 
55 | </TABLE>
56 | 
57 | <P>
58 | &nbsp;<HR>
59 | 
60 | <cfmodule template="inc/nav.html"
61 | 			page="Overview"
62 | 			projectTitle= "#arguments.projectTitle#"
63 | 			file="overview-summary"
64 | 			>
65 | 
66 | <HR>
67 | 
68 | </BODY>
69 | </HTML>
70 | </cfoutput>


--------------------------------------------------------------------------------
/strategy/api/resources/templates/package-frame.html:
--------------------------------------------------------------------------------
 1 | <cfoutput>
 2 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 3 | <!--NewPage-->
 4 | <HTML>
 5 | <HEAD>
 6 | <!-- Generated by colddoc on #Now()# -->
 7 | <TITLE>
 8 | #arguments.package#
 9 | </TITLE>
10 | 
11 | <META NAME="keywords" CONTENT="#arguments.package# package">
12 | 
13 | <LINK REL ="stylesheet" TYPE="text/css" HREF="#RepeatString('../', ListLen(arguments.package, "."))#stylesheet.css" TITLE="Style">
14 | 
15 | </HEAD>
16 | 
17 | <BODY BGCOLOR="white">
18 | <FONT size="+1" CLASS="FrameTitleFont">
19 | 
20 | <A HREF="package-summary.html" target="classFrame">#arguments.package#</A></FONT>
21 | 
22 | <cfif arguments.qInterfaces.recordCount>
23 | <TABLE BORDER="0" WIDTH="100%" SUMMARY="">
24 | <TR>
25 | <TD NOWRAP>
26 | 	<FONT size="+1" CLASS="FrameHeadingFont">
27 | 	Interfaces</FONT>&nbsp;
28 | 	<FONT CLASS="FrameItemFont">
29 | 	<cfloop query="arguments.qInterfaces">
30 | 	<BR>
31 | 	<A HREF="#name#.html" title="class in #package#" target="classFrame"><I>#name#</I></A>
32 | 	</cfloop>
33 | </TD>
34 | </TR>
35 | </TABLE>
36 | </cfif>
37 | 
38 | <cfif arguments.qClasses.recordCount>
39 | <TABLE BORDER="0" WIDTH="100%" SUMMARY="">
40 | <TR>
41 | <TD NOWRAP>
42 | 	<FONT size="+1" CLASS="FrameHeadingFont">
43 | 	Classes</FONT>&nbsp;
44 | 	<FONT CLASS="FrameItemFont">
45 | 	<cfloop query="arguments.qClasses">
46 | 	<BR>
47 | 	<A HREF="#name#.html" title="class in #package#" target="classFrame">#name#</A>
48 | 	</cfloop>
49 | </TD>
50 | </TR>
51 | </TABLE>
52 | 
53 | </cfif>
54 | 
55 | </BODY>
56 | </HTML>
57 | </cfoutput>


--------------------------------------------------------------------------------
/strategy/api/resources/templates/package-summary.html:
--------------------------------------------------------------------------------
 1 | <cfoutput>
 2 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 3 | <!--NewPage-->
 4 | <HTML>
 5 | <HEAD>
 6 | <!-- Generated by colddoc on #Now()# -->
 7 | <TITLE>
 8 | #arguments.package#
 9 | </TITLE>
10 | 
11 | <META NAME="keywords" CONTENT="#arguments.package# package">
12 | 
13 | <LINK REL ="stylesheet" TYPE="text/css" HREF="#RepeatString('../', ListLen(arguments.package, "."))#stylesheet.css" TITLE="Style">
14 | 
15 | <SCRIPT type="text/javascript">
16 | function windowTitle()
17 | {
18 |     parent.document.title="#arguments.package#";
19 | }
20 | </SCRIPT>
21 | <NOSCRIPT>
22 | </NOSCRIPT>
23 | 
24 | </HEAD>
25 | 
26 | <BODY BGCOLOR="white" onload="windowTitle();">
27 | 
28 | 
29 | <cfmodule template="inc/nav.html"
30 | 			page="Package"
31 | 			projectTitle= "#arguments.projectTitle#"
32 | 			package = "#arguments.package#"
33 | 			file="#replace(arguments.package, '.', '/', 'all')#/package-summary"
34 | 			>
35 | <HR>
36 | <H2>
37 | Package #arguments.package#
38 | </H2>
39 | 
40 | <P>
41 | 
42 | <cfif arguments.qInterfaces.recordCount>
43 | 	<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
44 | 	<TR BGCOLOR="##CCCCFF" CLASS="TableHeadingColor">
45 | 	<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
46 | 	<B>Interface Summary</B></FONT></TH>
47 | 	</TR>
48 | 
49 | 	<cfloop query="arguments.qInterfaces">
50 | 		<TR BGCOLOR="white" CLASS="TableRowColor">
51 | 		<TD WIDTH="15%"><B><A HREF="#name#.html" title="class in #package#">#name#</A></B></TD>
52 | 		<TD>
53 | 			<cfset meta = metadata>
54 | 			<cfif StructKeyExists(meta, "hint")>
55 | 				#ListGetAt(meta.hint, 1, ".")#
56 | 			</cfif>
57 | 		</TD>
58 | 		</TR>
59 | 	</cfloop>
60 | 	</TABLE>
61 | <p>
62 | </cfif>
63 | 
64 | <cfif arguments.qClasses.recordCount>
65 | 	<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
66 | 	<TR BGCOLOR="##CCCCFF" CLASS="TableHeadingColor">
67 | 	<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
68 | 	<B>Class Summary</B></FONT></TH>
69 | 	</TR>
70 | 
71 | 	<cfloop query="arguments.qClasses">
72 | 		<TR BGCOLOR="white" CLASS="TableRowColor">
73 | 		<TD WIDTH="15%"><B><A HREF="#name#.html" title="class in #package#">#name#</A></B></TD>
74 | 		<TD>
75 | 			<cfset meta = metadata>
76 | 			<cfif StructKeyExists(meta, "hint") and len(meta.hint) GT 0>
77 | 				#ListGetAt(meta.hint, 1, ".")#
78 | 			</cfif>
79 | 		</TD>
80 | 		</TR>
81 | 	</cfloop>
82 | 
83 | 	</TABLE>
84 | 	<p>
85 | </cfif>
86 | 
87 | 
88 | <cfmodule template="inc/nav.html"
89 | 			page="Package"
90 | 			projectTitle= "#arguments.projectTitle#"
91 | 			package = "#arguments.package#"
92 | 			file="#replace(arguments.package, '.', '/', 'all')#/package-summary"
93 | 			>
94 | 
95 | <HR>
96 | 
97 | </BODY>
98 | </HTML>
99 | </cfoutput>


--------------------------------------------------------------------------------
/strategy/uml2tools/XMIStrategy.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" hint="Strategy for generating the .uml file for Eclipse UML2Tools to generate diagrams from"
  2 | 				extends="colddoc.strategy.AbstractTemplateStrategy" >
  3 | 
  4 | <!------------------------------------------- PUBLIC ------------------------------------------->
  5 | 
  6 | <cfscript>
  7 | 	instance.static.TEMPLATE_PATH = "/colddoc/strategy/uml2tools/resources/templates";
  8 | </cfscript>
  9 | 
 10 | <cffunction name="init" hint="Constructor" access="public" returntype="XMIStrategy" output="false">
 11 | 	<cfargument name="outputFile" hint="absolute path to the output file. File should end in .uml, if it doesn' it will be added." type="string" required="Yes">
 12 | 	<cfscript>
 13 | 		super.init();
 14 | 
 15 | 		if(NOT arguments.outputFile.endsWith(".uml"))
 16 | 		{
 17 | 			arguments.outputFile &= ".uml";
 18 | 		}
 19 | 
 20 | 		setOutputFile(arguments.outputFile);
 21 | 
 22 | 		return this;
 23 | 	</cfscript>
 24 | </cffunction>
 25 | 
 26 | <cffunction name="run" hint="run this strategy" access="public" returntype="void" output="false">
 27 | 	<cfargument name="qMetadata" hint="the meta data query" type="query" required="Yes">
 28 | 	<cfscript>
 29 | 		var basePath = getDirectoryFromPath(getMetaData(this).path);
 30 | 		var args = 0;
 31 | 		var packages = buildPackageTree(arguments.qMetadata, true);
 32 | 
 33 | 		ensureDirectory(getDirectoryFromPath(getOutputFile()));
 34 | 
 35 | 		//write the index template
 36 | 		args = {path=getOutputFile()
 37 | 				,template="#instance.static.TEMPLATE_PATH#/template.uml"
 38 | 				,packages = packages
 39 | 				,qMetadata = qMetadata
 40 | 				};
 41 | 		writeTemplate(argumentCollection=args);
 42 |     </cfscript>
 43 | </cffunction>
 44 | 
 45 | <!------------------------------------------- PACKAGE ------------------------------------------->
 46 | 
 47 | <!------------------------------------------- PRIVATE ------------------------------------------->
 48 | 
 49 | <cffunction name="determineProperties" hint="We will make the assumption that is there is a get & set function with the same name, its a property" access="private" returntype="query" output="false">
 50 | 	<cfargument name="meta" hint="the metadata for a class" type="struct" required="Yes">
 51 | 	<cfargument name="package" hint="the current package" type="string" required="Yes">
 52 | 	<cfscript>
 53 | 		var qFunctions = buildFunctionMetaData(arguments.meta);
 54 | 		var qProperties = QueryNew("name, access, type, generic");
 55 | 		//is is used for boolean properties
 56 | 		var qGetters = getMetaSubQuery(qFunctions, "LOWER(name) LIKE 'get%' OR LOWER(name) LIKE 'is%'");
 57 | 		var qSetters = 0;
 58 | 		var propertyName = 0;
 59 | 		var setterMeta = 0;
 60 | 		var getterMeta = 0;
 61 | 		var generics = 0;
 62 |     </cfscript>
 63 | 	<cfloop query="qGetters">
 64 | 		<cfscript>
 65 | 			if(LCase(name).startsWith("get"))
 66 | 			{
 67 | 				propertyName = replaceNoCase(name, "get", "");
 68 | 			}
 69 | 			else
 70 | 			{
 71 | 				propertyName = replaceNoCase(name, "is", "");
 72 | 			}
 73 | 
 74 | 			qSetters = getMetaSubQuery(qFunctions, "LOWER(name) = LOWER('set#propertyName#')");
 75 | 			getterMeta = structCopy(metadata);
 76 | 
 77 | 			//lets just take getter generics, easier to do.
 78 | 			generics = getGenericTypes(metadata, arguments.package);
 79 | 
 80 | 			if(qSetters.recordCount)
 81 | 			{
 82 | 				setterMeta = qSetters.metadata;
 83 | 
 84 | 				if(structKeyExists(setterMeta, "parameters")
 85 | 					AND arrayLen(setterMeta.parameters) eq 1
 86 | 					AND setterMeta.parameters[1].type eq getterMeta.returnType
 87 | 					)
 88 | 				{
 89 | 					if(setterMeta.access eq "public" OR getterMeta.access eq "public")
 90 | 					{
 91 | 						access = "public";
 92 | 					}
 93 | 					else if(setterMeta.access eq "package" OR getterMeta.access eq "package")
 94 | 					{
 95 | 						access = "package";
 96 | 					}
 97 | 					else
 98 | 					{
 99 | 						access = "private";
100 | 					}
101 | 					queryAddRow(qProperties);
102 | 					//lower case the front
103 | 					querySetCell(qProperties, "name", rereplace(propertyName, "([A-Z]*)(.*)", "\L\1\E\2"));
104 | 					querySetCell(qProperties, "access", access);
105 | 					querySetCell(qProperties, "type", getterMeta.returntype);
106 | 					querySetCell(qProperties, "generic", generics);
107 | 				}
108 | 			}
109 |         </cfscript>
110 | 	</cfloop>
111 | 	<cfreturn qProperties />
112 | </cffunction>
113 | 
114 | <cffunction name="getOutputFile" access="private" returntype="string" output="false">
115 | 	<cfreturn instance.outputFile />
116 | </cffunction>
117 | 
118 | <cffunction name="setOutputFile" access="private" returntype="void" output="false">
119 | 	<cfargument name="outputFile" type="string" required="true">
120 | 	<cfset instance.outputFile = arguments.outputFile />
121 | </cffunction>
122 | 
123 | </cfcomponent>


--------------------------------------------------------------------------------
/strategy/uml2tools/resources/templates/template.uml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?><cfsilent>
  2 | <cfscript>
  3 | 	variables.qMetaData = arguments.qMetaData;
  4 | 
  5 | 	primitiveMap = {
  6 | 		boolean = "_q5yYQOXIEd686otsIQBbbA"
  7 | 		,String = "_q5yNUOXIEd686otsIQBbbA"
  8 | 		,Array = "_2vrXgOXyEd62aotsIQBbbA"
  9 | 		,Struct = "_3vrTgOXyEd686otsIQBbbA"
 10 | 		,Query = "_5Hv5sOXyEd686otsIQBbbA"
 11 | 		,XML = "_7UJf0OXyEd686otsIQBbbA"
 12 | 		,Numeric = "_HCt_wOXzEd686otsIQBbbA"
 13 | 		,Date = "_Hd7_wOXzEd686otsIQBbbA"
 14 | 		,binary = "_Kt9icOXzEd686otsIQBbbA"
 15 | 		,uuid = "_QHE8MOXzEd686otsIQBbbA"
 16 | 		,any = "_SLUr4OXzEd686otsIQBbbA"
 17 | 	};
 18 | 
 19 | 	assocMap = {};
 20 | </cfscript>
 21 | 
 22 | <cfsavecontent variable="primitiveTypes">
 23 | </cfsavecontent>
 24 | 
 25 | </cfsilent><cfoutput><uml:Package xmi:version="2.1" xmlns:xmi="http://schema.omg.org/spec/XMI/2.1" xmlns:uml="http://www.eclipse.org/uml2/3.0.0/UML" xmi:id="_q4YqEOXIEd686otsIQBbbA">
 26 | <!-- default primitive types -->
 27 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_q5yNUOXIEd686otsIQBbbA" name="String"/>
 28 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_q5yYQOXIEd686otsIQBbbA" name="Boolean"/>
 29 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_2vrXgOXyEd62aotsIQBbbA" name="Array"/>
 30 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_3vrTgOXyEd686otsIQBbbA" name="Struct"/>
 31 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_5Hv5sOXyEd686otsIQBbbA" name="Query"/>
 32 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_7UJf0OXyEd686otsIQBbbA" name="XML"/>
 33 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_HCt_wOXzEd686otsIQBbbA" name="Numeric"/>
 34 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_Hd7_wOXzEd686otsIQBbbA" name="Date"/>
 35 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_Kt9icOXzEd686otsIQBbbA" name="Binary"/>
 36 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_QHE8MOXzEd686otsIQBbbA" name="UUID"/>
 37 | 	<packagedElement xmi:type="uml:PrimitiveType" xmi:id="_SLUr4OXzEd686otsIQBbbA" name="Any"/>
 38 | 
 39 | 	<cfscript>
 40 | 		args.builder = createObject("java", "java.lang.StringBuilder").init();
 41 | 		visitPackageTree(arguments.packages, displayPackageStart, displayPackageEnd, args);
 42 |     </cfscript>
 43 | 
 44 | 	#args.builder.toString()#
 45 | </uml:Package>
 46 | </cfoutput>
 47 | <cfsilent>
 48 | 
 49 | <cffunction name="displayPackageStart" hint="start: displays a package" access="public" returntype="void" output="false">
 50 | 	<cfargument name="name" hint="the simple name of the package" type="string" required="Yes">
 51 | 	<cfargument name="fullname" hint="the full name of the package" type="string" required="Yes">
 52 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
 53 | 	<cfscript>
 54 | 		var xml = 0;
 55 | 		id = getPackageID(arguments.fullname);
 56 |     </cfscript>
 57 | 	<cfoutput>
 58 | 	<cfsavecontent variable="xml">
 59 | 		<packagedElement xmi:type="uml:Package" xmi:id="#id#" name="#arguments.name#">
 60 | 	</cfsavecontent>
 61 | 	</cfoutput>
 62 | 	<cfscript>
 63 | 		arguments.builder.append(xml);
 64 | 		displayClass(arguments.fullname, arguments.builder);
 65 |     </cfscript>
 66 | </cffunction>
 67 | 
 68 | <cffunction name="displayPackageEnd" hint="end: displays a package" access="public" returntype="void" output="false">
 69 | 	<cfargument name="name" hint="the simple name of the package" type="string" required="Yes">
 70 | 	<cfargument name="fullname" hint="the full name of the package" type="string" required="Yes">
 71 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
 72 | 	<cfscript>
 73 | 		arguments.builder.append('</packagedElement>');
 74 |     </cfscript>
 75 | </cffunction>
 76 | 
 77 | <cffunction name="displayClass" hint="displays a class" access="public" returntype="void" output="false">
 78 | 	<cfargument name="package" hint="the full name of the package" type="string" required="Yes">
 79 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
 80 | 	<cfscript>
 81 | 		var xml = 0;
 82 | 		var id = 0;
 83 | 		var qProperties = 0;
 84 | 		var qClasses = getMetaSubquery(qMetaData, "package = '#arguments.package#'", "name asc");
 85 |     </cfscript>
 86 | 	<cfoutput>
 87 | 	<cfloop query="qClasses">
 88 | 		<cfsavecontent variable="xml">
 89 | 			<cfset metadata = structCopy(metadata)>
 90 | 			<cfset id = getTypeId(metadata.name, arguments.package)>
 91 | 			<packagedElement xmi:type="uml:Class" xmi:id="#id#" name="#name#"<cfif isAbstractClass(name, arguments.package)> isAbstract="true"</cfif>>
 92 | 		</cfsavecontent>
 93 | 		<cfset arguments.builder.append(xml)>
 94 | 		<cfset qProperties = determineProperties(metadata, arguments.package)>
 95 | 		<cfset displayClassGeneralization(metadata, arguments.builder)>
 96 | 		<cfset displayClassProperties(metadata, qProperties, arguments.builder)>
 97 | 		<cfset displayClassFunctions(metadata, qProperties, arguments.builder)>
 98 | 		<cfset arguments.builder.append('</packagedElement>')>
 99 | 		<cfset displayClassUsage(metadata, qProperties, arguments.builder)>
100 | 		<cfset displayClassAssociations(metadata, qProperties, arguments.builder)>
101 | 	</cfloop>
102 | 	</cfoutput>
103 | </cffunction>
104 | 
105 | <cffunction name="displayClassUsage" hint="displays a class usage based on parameters" access="private" returntype="void" output="false">
106 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
107 | 	<cfargument name="qProperties" hint="the property query" type="query" required="Yes">
108 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
109 | 	<cfscript>
110 | 		var qFunctions = buildFunctionMetaData(arguments.meta);
111 | 		var param = 0;
112 | 		var package = getPackage(arguments.meta.name);
113 | 		var safeMeta = 0;
114 | 		var visited = {};
115 |     </cfscript>
116 | 	<cfloop query="qFunctions">
117 | 		<cfset safeMeta = structCopy(metadata)>
118 | 		<cfif NOT isFunctionAProperty(arguments.qProperties, name)>
119 | 			<cfloop array="#safeMeta.parameters#" index="param">
120 | 				<cfif NOT isPrimitive(param.type) AND NOT structKeyExists(visited, resolveClassName(param.type, package))>
121 | 					<cfset arguments.builder.append('<packagedElement xmi:type="uml:Usage" xmi:id="_#createUUID()#" supplier="#getTypeId(param.type, package)#" client="#getTypeId(arguments.meta.name, package)#"/>')>
122 | 					<cfset visited[resolveClassName(param.type, package)] = 1>
123 | 				</cfif>
124 | 			</cfloop>
125 | 			<cfif safeMeta.name neq "init" AND  NOT isPrimitive(safeMeta.returnType) AND NOT structKeyExists(visited, resolveClassName(safeMeta.returnType, package))>
126 | 				<cfset arguments.builder.append('<packagedElement xmi:type="uml:Usage" xmi:id="_#createUUID()#" supplier="#getTypeId(safeMeta.returnType, package)#" client="#getTypeId(arguments.meta.name, package)#"/>')>
127 | 			</cfif>
128 | 		</cfif>
129 | 	</cfloop>
130 | </cffunction>
131 | 
132 | <cffunction name="displayClassGeneralization" hint="displays a classes inheritence, if it has any" access="private" returntype="void" output="false">
133 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
134 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
135 | 	<cfscript>
136 | 		var package = getPackage(arguments.meta.name);
137 | 
138 | 		//ignore interfaces for now
139 | 		if(arguments.meta.type eq "component" and structKeyExists(arguments.meta, "extends") AND arguments.meta.extends.name neq "WEB-INF.cftags.component")
140 | 		{
141 | 			arguments.builder.append('<generalization xmi:id="_#createUUID()#"');
142 | 			if(typeExists(qMetadata, arguments.meta.extends.name, package))
143 | 			{
144 | 				arguments.builder.append(' general="#getTypeId(arguments.meta.extends.name, package)#"');
145 | 			}
146 | 			arguments.builder.append('/>');
147 | 		}
148 |     </cfscript>
149 | </cffunction>
150 | 
151 | <cffunction name="displayClassProperties" hint="displays all of a classes properties" access="private" returntype="void" output="false">
152 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
153 | 	<cfargument name="qProperties" hint="the property query" type="query" required="Yes">
154 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
155 | 	<cfscript>
156 | 		var package = getPackage(arguments.meta.name);
157 |     </cfscript>
158 | 	<cfloop query="arguments.qProperties">
159 | 		<cfset arguments.builder.append('<ownedAttribute xmi:id="_#createUUID()#" name="#name#" visibility="#access#"')>
160 | 		<cfif typeExists(qMetadata, type, package)>
161 | 			<cfset arguments.builder.append(' type="#getTypeId(type, package)#"')>
162 | 		</cfif>
163 | 		<cfset arguments.builder.append(' aggregation="shared"/>')>
164 | 	</cfloop>
165 | </cffunction>
166 | 
167 | <cffunction name="displayClassAssociations" hint="display all the class associations" access="private" returntype="void" output="false">
168 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
169 | 	<cfargument name="qProperties" hint="the property query" type="query" required="Yes">
170 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
171 | 	<cfscript>
172 | 		var fragment = 0;
173 | 		var package = 0;
174 | 		var assocID = 0;
175 | 		var endID = 0;
176 | 		var sourceID = 0;
177 | 		var genericType = 0;
178 | 		var bidirection = 0;
179 |     </cfscript>
180 | 	<cfloop query="arguments.qProperties">
181 | 		<cfscript>
182 | 			assocID = "_" & createUUID();
183 | 			endID = "_" & createUUID();
184 | 			sourceID = "_" & createUUID();
185 | 
186 | 			package = getPackage(arguments.meta.name);
187 |         </cfscript>
188 | 
189 | 		<cfif NOT isPrimitive(type)>
190 | 			<cfscript>
191 | 				bidirection = getBiderectionalAssociation(arguments.meta, type, package);
192 |             </cfscript>
193 | 
194 | 			<!--- only do it if it hasn't been done before --->
195 | 			<cfif structIsEmpty(bidirection) OR NOT bidirection.completed>
196 | 				<cfoutput>
197 | 				<cfsavecontent variable="fragment">
198 | 						<packagedElement xmi:type="uml:Association" xmi:id="#assocID#" memberEnd="#sourceID# #endID#">
199 | 							<ownedEnd xmi:id="#sourceID#" name="#name#" type="#getTypeId(arguments.meta.name, package)#" aggregation="<cfif NOT StructIsEmpty(bidirection)>shared<cfelse>none</cfif>" association="#assocID#">
200 | 						      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_#createUUID()#" value="<cfif NOT structIsEmpty(bidirection) AND listFindNoCase("array,struct", bidirection.type)>*<cfelse>1</cfif>"/>
201 | 						      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_#createUUID()#" value="<cfif NOT structIsEmpty(bidirection) AND listFindNoCase("array,struct", bidirection.type)>0<cfelse>1</cfif>"/>
202 | 						    </ownedEnd>
203 | 						    <ownedEnd xmi:id="#endID#" name="<cfif NOT StructIsEmpty(bidirection)>#bidirection.name#</cfif>" type="#getTypeId(type, package)#" aggregation="shared" association="#assocID#">
204 | 						      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_#createUUID()#" value="<cfif listFindNoCase("array,struct", type)>*<cfelse>1</cfif>"/>
205 | 						      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_#createUUID()#" value="<cfif listFindNoCase("array,struct", type)>0<cfelse>1</cfif>"/>
206 | 						    </ownedEnd>
207 | 						</packagedElement>
208 | 				</cfsavecontent>
209 | 				</cfoutput>
210 | 				<cfset arguments.builder.append(fragment)>
211 | 			</cfif>
212 | 		</cfif>
213 | 
214 | 		<cfloop array="#generic#" index="genericType">
215 | 			<cfif NOT isPrimitive(genericType)>
216 | 				<cfscript>
217 | 					assocID = "_" & createUUID();
218 | 					endID = "_" & createUUID();
219 | 					sourceID = "_" & createUUID();
220 | 
221 | 					package = getPackage(arguments.meta.name);
222 | 
223 | 					bidirection = getBiderectionalAssociation(arguments.meta, genericType, package);
224 | 		        </cfscript>
225 | 				<!--- only do it if it hasn't been done before --->
226 | 				<cfif structIsEmpty(bidirection) OR NOT bidirection.completed>
227 | 					<cfoutput>
228 | 					<cfsavecontent variable="fragment">
229 | 						<packagedElement xmi:type="uml:Association" xmi:id="#assocID#" memberEnd="#sourceID# #endID#">
230 | 							<ownedEnd xmi:id="#sourceID#" name="#name#" type="#getTypeId(arguments.meta.name, package)#" aggregation="<cfif NOT StructIsEmpty(bidirection)>shared<cfelse>none</cfif>" association="#assocID#">
231 | 							  <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_#createUUID()#" value="<cfif NOT structIsEmpty(bidirection) AND listFindNoCase("array,struct", bidirection.type)>*<cfelse>1</cfif>"/>
232 | 						      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_#createUUID()#" value="<cfif NOT structIsEmpty(bidirection) AND listFindNoCase("array,struct", bidirection.type)>0<cfelse>1</cfif>"/>
233 | 						    </ownedEnd>
234 | 						    <ownedEnd xmi:id="#endID#" name="<cfif NOT StructIsEmpty(bidirection)>#bidirection.name#</cfif>" type="#getTypeId(genericType, package)#" aggregation="shared" association="#assocID#">
235 | 						      <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_#createUUID()#" value="<cfif listFindNoCase("array,struct", type)>*<cfelse>1</cfif>"/>
236 | 						      <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_#createUUID()#" value="<cfif listFindNoCase("array,struct", type)>0<cfelse>1</cfif>"/>
237 | 						    </ownedEnd>
238 | 						</packagedElement>
239 | 					</cfsavecontent>
240 | 					</cfoutput>
241 | 					<cfset arguments.builder.append(fragment)>
242 | 				</cfif>
243 | 			</cfif>
244 | 		</cfloop>
245 | 	</cfloop>
246 | </cffunction>
247 | 
248 | <cffunction name="getBiderectionalAssociation" hint="returns an empty struct if not bidirectional association found.
249 | 												Returns a struct with keys 'name' and 'type' for the association type if it finds a bidirectional association.
250 | 												Returns the key 'completed', which has a value of 'true|false' which is true, if an association has already been set before"
251 | 			access="private" returntype="struct" output="false">
252 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
253 | 	<cfargument name="associationType" hint="the type of the association" type="string" required="Yes">
254 | 	<cfargument name="package" hint="the current package we are in" type="string" required="Yes">
255 | 	<cfscript>
256 | 		var local = {};
257 | 
258 | 		arguments.associationType = resolveClassName(arguments.associationType, arguments.package);
259 | 		local.class = resolveClassName(arguments.meta.name, arguments.package);
260 | 
261 | 		local.assocMeta = getComponentMetadata(arguments.associationType);
262 | 
263 | 		if(NOT structKeyExists(assocMap, local.class))
264 | 		{
265 | 			assocMap[local.class] = {};
266 | 		}
267 | 
268 | 		//this is to stop the other side doing the same thing
269 | 		if(structKeyExists(assocMap, arguments.associationType) AND structKeyExists(assocMap[arguments.associationType], local.class))
270 | 		{
271 | 			local.result = {completed=true};
272 | 			return local.result;
273 | 		}
274 | 
275 | 		local.qProperties = determineProperties(local.assocMeta, getPackage(local.assocMeta.name));
276 |     </cfscript>
277 | 	<cfloop query="local.qProperties">
278 | 		<cfif type eq local.class>
279 | 			<cfset assocMap[local.class][arguments.associationType] = 1>
280 | 			<cfset local.result = {name=name, type=type, completed=false}>
281 | 			<cfreturn local.result />
282 | 		</cfif>
283 | 		<cfloop array="#generic#" index="local.genericType">
284 | 			<cfif local.genericType eq local.class>
285 | 				<cfset assocMap[local.class][arguments.associationType] = 1>
286 | 				<cfset local.result = {name=name, type=type, completed=false}>
287 | 				<cfreturn local.result />
288 | 			</cfif>
289 | 		</cfloop>
290 | 	</cfloop>
291 | 	<cfreturn StructNew() />
292 | </cffunction>
293 | 
294 | <cffunction name="displayClassFunctions" hint="displays all of a classes functions" access="private" returntype="void" output="false">
295 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
296 | 	<cfargument name="qProperties" hint="the property query" type="query" required="Yes">
297 | 	<cfargument name="builder" hint="the string builder with the content" type="string" required="Yes">
298 | 	<cfscript>
299 | 		var qFunctions = buildFunctionMetaData(arguments.meta);
300 | 		var qInitFunctions = getMetaSubQuery(qFunctions, "UPPER(name)='INIT'");
301 | 		var qBodyFunctions = getMetaSubQuery(qFunctions, "UPPER(name)!='INIT'");
302 |     </cfscript>
303 | 	<!--- make sure init() comes first --->
304 | 	<cfloop query="qInitFunctions">
305 | 		<cfset arguments.builder.append(buildFunctionXML(arguments.meta, metadata))>
306 | 	</cfloop>
307 | 	<cfloop query="qBodyFunctions">
308 | 		<cfscript>
309 | 			//don't display get/set functions for properties
310 | 			if(NOT isFunctionAProperty(arguments.qProperties, name))
311 | 			{
312 | 				arguments.builder.append(buildFunctionXML(arguments.meta, metadata));
313 | 			}
314 |         </cfscript>
315 | 	</cfloop>
316 | </cffunction>
317 | 
318 | <cffunction name="isFunctionAProperty" hint="is the current function a property?" access="private" returntype="boolean" output="false">
319 | 	<cfargument name="qProperties" hint="the property query" type="query" required="Yes">
320 | 	<cfargument name="functionName" hint="the function name" type="string" required="Yes">
321 | 	<cfscript>
322 | 		var check = true;
323 | 		var property = 0;
324 | 		var qProperty = 0;
325 | 
326 | 		if(lCase(arguments.functionName).startsWith("set"))
327 | 		{
328 | 			property = replaceNoCase(arguments.functionName, "set", "");
329 | 		}
330 | 		else if(lCase(arguments.functionName).startsWith("get"))
331 | 		{
332 | 			property = replaceNoCase(arguments.functionName, "get", "");
333 | 		}
334 | 		else if(lCase(arguments.functionName).startsWith("is"))
335 | 		{
336 | 			property = replaceNoCase(arguments.functionName, "is", "");
337 | 		}
338 | 		else
339 | 		{
340 | 			return false;
341 | 		}
342 | 
343 | 		qProperty = getMetaSubQuery(arguments.qProperties, "LOWER(name) = LOWER('#property#')");
344 | 		return qProperty.recordCount;
345 |     </cfscript>
346 | </cffunction>
347 | 
348 | <cffunction name="buildFunctionXML" hint="builds the XML for a function" access="private" returntype="string" output="false">
349 | 	<cfargument name="meta" hint="the classes meta" type="struct" required="Yes">
350 | 	<cfargument name="func" hint="the functions meta" type="struct" required="Yes">
351 | 	<cfscript>
352 | 		var id= "_" & createUUID();
353 | 		var package = getPackage(arguments.meta.name);
354 | 		var param = 0;
355 |     </cfscript>
356 | 	<cfoutput>
357 | 	<cfsavecontent variable="xml">
358 |       <ownedOperation xmi:id="#id#" name="#arguments.func.name#" visibility="#arguments.func.access#">
359 |         <ownedParameter xmi:id="_#createUUID()#" <cfif arguments.func.returntype neq "void" AND typeExists(qMetaData, arguments.func.returntype, package)>type="#getTypeId(arguments.func.returntype, package)#"</cfif> direction="return"/>
360 | 		<cfif StructKeyExists(arguments.func, "parameters")>
361 | 			<cfloop array="#arguments.func.parameters#" index="param">
362 | 				<cfset safeParamMeta(param)>
363 | 				<ownedParameter xmi:id="_#createUUID()#" name="#param.name#" <cfif typeExists(qMetadata, param.type, package)>type="#getTypeId(param.type, package)#"</cfif>>
364 | 					<defaultValue xmi:type="uml:LiteralString" xmi:id="_#createUUID()#"/>
365 | 				</ownedParameter>
366 | 			</cfloop>
367 | 		</cfif>
368 |       </ownedOperation>
369 | 	</cfsavecontent>
370 | 	</cfoutput>
371 | 	<cfreturn xml />
372 | </cffunction>
373 | 
374 | <cffunction name="getPackageID" hint="returns a package ID" access="private" returntype="string" output="false">
375 | 	<cfargument name="package" hint="The package in question" type="string" required="Yes">
376 | 	<cfscript>
377 | 		return "_" &  hash("package:" & lCase(arguments.package));
378 |     </cfscript>
379 | </cffunction>
380 | 
381 | <cffunction name="getTypeId" hint="gets the id of a given type" access="private" returntype="string" output="false">
382 | 	<cfargument name="type" hint="the coldfusion type" type="string" required="Yes">
383 | 	<cfargument name="package" hint="The package in question" type="string" required="Yes">
384 | 	<cfscript>
385 | 		if(structKeyExists(primitiveMap, arguments.type))
386 | 		{
387 | 			return primitiveMap[arguments.type];
388 | 		}
389 | 
390 | 		arguments.type = resolveClassName(arguments.type, arguments.package);
391 | 
392 | 		return "_" & hash("class:"  & lcase(arguments.type));
393 |     </cfscript>
394 | </cffunction>
395 | 
396 | <!--- cleanup --->
397 | <cfscript>
398 | 	funcs = "getBiderectionalAssociation,displayPackageStart,displayPackageEnd,displayClass,displayClassFunctions,getPackageID,getTypeId,buildFunctionXML,displayClassProperties,isFunctionAProperty,displayClassUsage,displayClassAssociations";
399 | </cfscript>
400 | <cfloop list="funcs" index="func">
401 | 	<cfset structDelete(variables, func)>
402 | </cfloop>
403 | 
404 | 
405 | </cfsilent>


--------------------------------------------------------------------------------