public CharacterBuilder WithClass(IClassTemplate classTemplate) { return(WithClassId(classTemplate.Id)); }
public StubClassFileTemplate(IClassModel classModel, IClassTemplate classTemplate) : base(classModel, classTemplate) { }
public CSharpClassFileTemplate(IClassModel classModel, IClassTemplate classTemplate) : base(classModel, classTemplate) { }
public ProtoClassFileTemplate(IClassModel classModel, IClassTemplate classTemplate) : base(classModel, classTemplate) { }
/// <summary> /// Generate the file name to be used for the implementation of given class template. /// </summary> /// <param name="extension">The extension this class template is defined in.</param> /// <param name="classTemplate">The class template itself.</param> /// <returns>The file name to be used for the implementation of given class template.</returns> public string GetExtbaseImplementationFileName( Extension extension, IClassTemplate classTemplate ) { Debug.Assert( classTemplate is IControllerTemplate ); return NameHelper.GetExtbaseControllerImplementationFileName( extension, classTemplate as IControllerTemplate ); }
protected ClassFileTemplate(IClassModel classModel, IClassTemplate classTemplate) { ClassModel = classModel; ClassTemplate = classTemplate; }
/// <summary> /// Generates a class proxy. /// This is a class that defines stubs for all actions, references to repositories and so forth and calls into the users own implementation upon invokation. /// </summary> /// <param name="classTemplate">The class template that should be used to generate the class proxy.</param> /// <param name="namingStrategy">The naming strategy that should be used to generate names for all the entities the class uses.</param> /// <param name="classDirectory">Into which subdirectory the files should be placed.</param> /// <param name="addDependencies">Should dependencies be placed in the class proxy? If true, the class will contain references and injectors to all repositories in the extension.</param> /// <exception cref="GeneratorException">Implementation does not exist.</exception> public void GenerateClassProxy( IClassTemplate classTemplate, INamingStrategy namingStrategy, string classDirectory, bool addDependencies ) { string className = namingStrategy.GetExtbaseClassName( Subject, classTemplate ); Log.InfoFormat( "Generating class '{0}'...", className ); #region Generate Methods StringBuilder methods = new StringBuilder(); const string methodTemplate = "/**\n" + "{_phpDoc}" + "*/\n" + "public function {_methodName}{_methodSuffix}({_parameters}) {{ return $this->getImplementation()->{_methodName}{_methodSuffix}({_callParameters}); }}\n"; foreach( Action method in classTemplate.Actions ) { // Start building up the PHPDoc for this action string phpDoc = string.Empty; foreach( string requirement in method.Requirements ) { string typeName = "mixed"; // See if the name of the requirement matches the name of a defined model, // if so, we assume the user wants to reference that model. DataModel requiredModel = Subject.Models.SingleOrDefault( m => m.Name.ToLower() == requirement ); if( requiredModel != null ) { typeName = NameHelper.GetExtbaseDomainModelClassName( Subject, requiredModel ); Log.InfoFormat( "Assuming requirement '{0}' for method '{1}:{2}' to be of type '{3}'.", requirement, classTemplate.Name, method.Name, typeName ); } phpDoc = phpDoc + ( "* @param " + typeName + " $" + requirement + "\n" ); } // Prefix each parameter with a $ and join them together with , in between. StringBuilder parameters = new StringBuilder(); StringBuilder callParameters = new StringBuilder(); foreach( string requirement in method.Requirements ) { parameters.Append( ( Regex.Replace( requirement, @"(?<name>[\w][^ ]+)$", @"$$${name}" ) + ( ( requirement != method.Requirements.Last() ) ? "," : string.Empty ) ) ); callParameters.Append( "$" + ( Regex.Match( requirement, @"(?<name>[\w][^ ]+)$" ).Groups[ "name" ].ToString() + ( ( requirement != method.Requirements.Last() ) ? "," : string.Empty ) ) ); } var methodData = new { _phpDoc = phpDoc, _methodSuffix = namingStrategy.MethodSuffix, _methodName = method.Name, _parameters = parameters, _callParameters = callParameters }; methods.Append( methodTemplate.FormatSmart( methodData ) ); } #endregion #region Handle External Implementations bool isExternallyImplemented = false; string implementationClassname = string.Empty; string implementationFilename = string.Empty; if( !string.IsNullOrEmpty( classTemplate.Implementation ) ) { isExternallyImplemented = true; implementationClassname = namingStrategy.GetExtbaseImplementationClassName( Subject, classTemplate ); implementationFilename = namingStrategy.GetExtbaseImplementationFileName( Subject, classTemplate ); } if( isExternallyImplemented ) { if( !File.Exists( classTemplate.Implementation ) ) { throw new GeneratorException( string.Format( "Implementation '{0}' for '{1}' does not exist.", classTemplate.Implementation, classTemplate.Name ), classTemplate.SourceFragment.SourceDocument ); } Log.InfoFormat( "Merging implementation '{0}'...", classTemplate.Implementation ); string serviceImplementationContent = File.ReadAllText( classTemplate.Implementation ); if( !Regex.IsMatch( serviceImplementationContent, String.Format( "class {0} ?({{|extends|implements)", implementationClassname ) ) ) { Log.WarnFormat( "The class name of your implementation for '{1}' MUST be '{0}'!", implementationClassname, classTemplate.Name ); } WriteFile( classDirectory + implementationFilename, serviceImplementationContent, DateTime.UtcNow ); } else { if( classTemplate.Actions.Count > 0 ) { Log.WarnFormat( "Proxy '{0}' defines actions, but has no implementation provided. If any of these actions is invoked by TYPO3, a PHP error will be generated!", classTemplate.Name ); } } #endregion #region Generate Properties StringBuilder propertiesList = new StringBuilder(); if( Subject.Models != null && addDependencies ) { foreach( DataModel dataModel in Subject.Models ) { const string memberTemplate = "/**\n" + "* {0}Repository\n" + "* @var {1}\n" + "*/\n" + "protected ${0}Repository;\n"; // Check if the repository is internally implemented. // An example for an internally implemented repository would be Tx_Extbase_Domain_Repository_FrontendUserRepository Repository repository = Subject.Repositories.SingleOrDefault( r => r.TargetModelName == dataModel.Name ); if( null != repository && PurelyWrapsInternalType( repository ) ) { propertiesList.Append( String.Format( memberTemplate, dataModel.Name, repository.InternalType ) ); } else { propertiesList.Append( String.Format( memberTemplate, dataModel.Name, NameHelper.GetExtbaseDomainModelRepositoryClassName( Subject, dataModel ) ) ); } const string injectorTemplate = "/**\n" + "* inject{0}Repository\n" + "* @param {1} ${2}Repository\n" + "*/\n" + "public function inject{0}Repository({1} ${2}Repository) {{\n" + " $this->{2}Repository = ${2}Repository;\n" + "}}\n"; // Check again if the repository is internally implemented. // An example for an inernally implemented repository would be Tx_Extbase_Domain_Repository_FrontendUserRepository string injector = string.Empty; if( null != repository && PurelyWrapsInternalType( repository ) ) { injector = String.Format( injectorTemplate, NameHelper.UpperCamelCase( dataModel.Name ), repository.InternalType, dataModel.Name ); } else { injector = String.Format( injectorTemplate, NameHelper.UpperCamelCase( dataModel.Name ), NameHelper.GetExtbaseDomainModelRepositoryClassName( Subject, dataModel ), dataModel.Name ); } propertiesList.Append( injector ); } } #endregion string implementationTemplate = "private $implementation;" + "private function getImplementation() {{" + " if( null == $this->implementation ) {{" + " $this->implementation = new {_implClassname}($this);" + " }}" + " return $this->implementation;" + "}}" + "function __construct() {{" + ( ( !String.IsNullOrEmpty( namingStrategy.Extends ) ) ? "parent::__construct();" : string.Empty ) + "}}\n"; string serviceImplementation = implementationTemplate.FormatSmart( new { _implClassname = implementationClassname } ); const string template = "class {_className} {_extends} {_implements} {{" + "{_properties}" + "{_actions}" + "}}" + "{_requireImplementation}"; string serviceResult = template.FormatSmart( new { _className = namingStrategy.GetExtbaseClassName( Subject, classTemplate ), _extends = namingStrategy.Extends, _implements = namingStrategy.Implements, _properties = (( isExternallyImplemented ) ? serviceImplementation : string.Empty) + propertiesList, _actions = methods.ToString(), _requireImplementation = ( isExternallyImplemented ) ? string.Format( "require_once('{0}');", implementationFilename ) : string.Empty } ); WritePhpFile( Path.Combine( classDirectory, namingStrategy.GetExtbaseFileName( Subject, classTemplate ) ), serviceResult, DateTime.UtcNow ); }
/// <summary> /// Generate the file name to be used for the implementation of given class template. /// </summary> /// <param name="extension">The extension this class template is defined in.</param> /// <param name="classTemplate">The class template itself.</param> /// <returns>The file name to be used for the implementation of given class template.</returns> public string GetExtbaseImplementationFileName( Extension extension, IClassTemplate classTemplate ) { Debug.Assert( classTemplate is Task ); return NameHelper.GetTaskImplementationFileName( extension, classTemplate as Task ); }
public DefaultClass(int level, IClassTemplate classTemplate) { Level = level; ClassTemplate = classTemplate; }
/// <summary> /// Generate the file name to be used for the given class template. /// </summary> /// <param name="extension">The extension this class template is defined in.</param> /// <param name="classTemplate">The class template itself.</param> /// <returns>The file name to be used for the given class template.</returns> public string GetExtbaseFileName( Extension extension, IClassTemplate classTemplate ) { Debug.Assert( classTemplate is TaskFields ); return NameHelper.GetTaskFieldsFileName( extension, classTemplate as TaskFields ); }
/// <summary> /// Generate the class name to be used for the implementation of given class template. /// </summary> /// <param name="extension">The extension this class template is defined in.</param> /// <param name="classTemplate">The class template itself.</param> /// <returns>The class name to be used for the implementation of given class template.</returns> public string GetExtbaseImplementationClassName( Extension extension, IClassTemplate classTemplate ) { Debug.Assert( classTemplate is Service ); return NameHelper.GetExtbaseServiceImplementationClassName( extension, classTemplate as Service ); }