private void SerializeMethod(StringBuilder sb, Method method, int indentation)
        {
            sb.AppendLine((method.Verb + ":").Indent(indentation));
            RamlSerializerHelper.SerializeDescriptionProperty(sb, method.Description, indentation + 2);
            //SerializeType(sb, method.Type, indentation + 2);

            if (method.Headers != null)
            {
                sb.AppendLine("headers:".Indent(indentation + 2));
                foreach (var header in method.Headers)
                {
                    sb.AppendLine(header.Key + ":".Indent(indentation + 4));
                    RamlSerializerHelper.SerializeParameterProperties(sb, header.Value, indentation + 6);
                }
            }

            SerializeArrayProperty(sb, "is", method.Is, indentation + 2);
            SerializeProtocols(sb, method.Protocols, indentation + 2);
            SerializeArrayProperty(sb, "securedBy", method.SecuredBy, indentation + 2);
            SerializeParameters(sb, "baseUriParameters", method.BaseUriParameters, indentation + 2);
            SerializeParameters(sb, "queryParameters", method.QueryParameters, indentation + 2);
            SerializeBody(sb, method.Body, indentation + 2);
            SerializeResponses(sb, method.Responses, indentation + 2);
            raml1TypesSerializer.SerializeAnnotations(sb, method.Annotations, indentation + 2);
        }
 private void SerializeArrayProperties(StringBuilder sb, int indentation, ArrayType arrayType)
 {
     RamlSerializerHelper.SerializeProperty(sb, "minItems", arrayType.MinItems, indentation);
     RamlSerializerHelper.SerializeProperty(sb, "maxItems", arrayType.MaxItems, indentation);
     RamlSerializerHelper.SerializeProperty(sb, "uniqueItems", arrayType.UniqueItems, indentation);
     SerializeCommonProperties(sb, arrayType.Items, indentation);
 }
        private void SerializeParameter(StringBuilder sb, KeyValuePair <string, Parameter> parameter, int indentation)
        {
            sb.AppendFormat("{0}:".Indent(indentation), parameter.Key);
            sb.AppendLine();

            RamlSerializerHelper.SerializeParameterProperties(sb, parameter.Value, indentation);
        }
 private void SerializeScalar(StringBuilder sb, RamlType ramlType, int indentation)
 {
     RamlSerializerHelper.SerializeCommonParameterProperties(sb, ramlType.Scalar, indentation);
     RamlSerializerHelper.SerializeProperty(sb, "multipleOf", ramlType.Scalar.MultipleOf, indentation);
     RamlSerializerHelper.SerializeListProperty(sb, "fileTypes", ramlType.Scalar.FileTypes, indentation);
     SerializeFormat(sb, indentation, ramlType.Scalar.Format);
     SerializeAnnotations(sb, ramlType.Scalar.Annotations, indentation);
 }
 private void SerializeObject(StringBuilder sb, RamlType ramlType, int indentation)
 {
     RamlSerializerHelper.SerializeProperty(sb, "maxProperties", ramlType.Object.MaxProperties, indentation + 4);
     RamlSerializerHelper.SerializeProperty(sb, "minProperties", ramlType.Object.MinProperties, indentation + 4);
     RamlSerializerHelper.SerializeProperty(sb, "discriminator", ramlType.Object.Discriminator as string, indentation + 4);
     RamlSerializerHelper.SerializeProperty(sb, "discriminatorValue", ramlType.Object.DiscriminatorValue, indentation + 4);
     SerializeObjectProperties(sb, ramlType.Object.Properties, indentation + 4);
 }
 private void SerializeMimeType(StringBuilder sb, KeyValuePair <string, MimeType> mimeType, int indentation)
 {
     sb.AppendLine((mimeType.Key + ":").Indent(indentation));
     RamlSerializerHelper.SerializeDescriptionProperty(sb, mimeType.Value.Description, indentation + 2);
     RamlSerializerHelper.SerializeProperty(sb, "type", mimeType.Value.Type, indentation + 2);
     SerializeParameters(sb, "formParameters", mimeType.Value.FormParameters, indentation + 2);
     RamlSerializerHelper.SerializeProperty(sb, "schema", mimeType.Value.Schema, indentation + 2);
     RamlSerializerHelper.SerializeProperty(sb, "example", mimeType.Value.Example, indentation + 2);
     raml1TypesSerializer.SerializeAnnotations(sb, mimeType.Value.Annotations, indentation + 2);
 }
        private static void SerializeCommonProperties(StringBuilder sb, RamlType ramlType, int indentation)
        {
            RamlSerializerHelper.SerializeProperty(sb, "description", ramlType.Description, indentation + 4);

            RamlSerializerHelper.SerializeProperty(sb, "displayName", ramlType.DisplayName, indentation + 4);

            RamlSerializerHelper.SerializeProperty(sb, "example", ramlType.Example, indentation + 4);

            SerializeFacets(sb, ramlType.Facets, indentation + 4);
        }
        private static void SerializeExternal(StringBuilder sb, RamlType ramlType, int indentation)
        {
            if (!string.IsNullOrWhiteSpace(ramlType.External.Schema))
            {
                RamlSerializerHelper.SerializeSchema(sb, "schema", ramlType.External.Schema, indentation + 4);
            }

            if (!string.IsNullOrWhiteSpace(ramlType.External.Xml))
            {
                RamlSerializerHelper.SerializeSchema(sb, "schema", ramlType.External.Xml, indentation + 4);
            }
        }
        private void SerializeSchemas(StringBuilder sb, IEnumerable <IDictionary <string, string> > schemas)
        {
            if (schemas == null || !schemas.Any() || schemas.All(x => !x.Any()))
            {
                return;
            }

            sb.AppendLine("schemas:");
            foreach (var kv in schemas.SelectMany(schemaDic => schemaDic))
            {
                RamlSerializerHelper.SerializeSchema(sb, kv.Key, kv.Value, 2);
            }
        }
 private void SerializeResource(StringBuilder sb, Resource resource, int indentation)
 {
     sb.AppendLine((resource.RelativeUri + ":").Indent(indentation));
     SerializeParameters(sb, "baseUriParameters", resource.BaseUriParameters, indentation + 2);
     RamlSerializerHelper.SerializeDescriptionProperty(sb, resource.Description, indentation + 2);
     RamlSerializerHelper.SerializeProperty(sb, "displayName", resource.DisplayName, indentation + 2);
     SerializeProtocols(sb, resource.Protocols, indentation + 2);
     SerializeParameters(sb, "uriParameters", resource.UriParameters, indentation + 2);
     SerializeMethods(sb, resource.Methods, indentation + 2);
     //SerializeType(sb, resource.Type, indentation + 2);
     SerializeResources(sb, resource.Resources, indentation + 2);
     raml1TypesSerializer.SerializeAnnotations(sb, resource.Annotations, indentation + 2);
 }
 private void SerializeAnnotationType(StringBuilder sb, AnnotationType annotationType)
 {
     RamlSerializerHelper.SerializeProperty(sb, "description", annotationType.Description, 8);
     RamlSerializerHelper.SerializeProperty(sb, "displayName", annotationType.DisplayName, 8);
     RamlSerializerHelper.SerializeProperty(sb, "allowMultiple", annotationType.AllowMultiple, 8);
     RamlSerializerHelper.SerializeProperty(sb, "usage", annotationType.Usage, 8);
     SerializeArrayProperty(sb, "allowedTargets", annotationType.AllowedTargets, 8);
     foreach (var parameter in annotationType.Parameters)
     {
         SerializeParameter(sb, parameter, 8);
     }
     raml1TypesSerializer.SerializeAnnotations(sb, annotationType.Annotations, 8);
 }
        private void SerializeSecurityScheme(StringBuilder sb, IDictionary <string, SecurityScheme> scheme, int indent)
        {
            foreach (var securityScheme in scheme)
            {
                sb.AppendLine(("- " + securityScheme.Key + ":").Indent(indent));
                RamlSerializerHelper.SerializeDescriptionProperty(sb, securityScheme.Value.Description, indent + 4);
                if (securityScheme.Value.Type != null && securityScheme.Value.Type.Any())
                {
                    RamlSerializerHelper.SerializeProperty(sb, "type", securityScheme.Value.Type.First().Key, indent + 4);
                }

                SerializeSecurityDescriptor(sb, securityScheme.Value.DescribedBy, indent + 4);
                SerializeSecuritySettings(sb, securityScheme.Value.Settings, indent + 4);
            }
        }
        private void SerializeSecuritySettings(StringBuilder sb, SecuritySettings settings, int indent)
        {
            if (settings == null)
            {
                return;
            }

            sb.AppendLine("settings:".Indent(indent));
            RamlSerializerHelper.SerializeProperty(sb, "accessTokenUri", settings.AccessTokenUri, indent + 2);
            RamlSerializerHelper.SerializeProperty(sb, "authorizationUri", settings.AuthorizationUri, indent + 2);
            RamlSerializerHelper.SerializeProperty(sb, "requestTokenUri", settings.RequestTokenUri, indent + 2);
            RamlSerializerHelper.SerializeProperty(sb, "tokenCredentialsUri", settings.TokenCredentialsUri, indent + 2);
            SerializeArrayProperty(sb, "authorizationGrants", settings.AuthorizationGrants, indent + 2);
            RamlSerializerHelper.SerializeListProperty(sb, "scopes", settings.Scopes, indent + 2);
        }
        public static void SerializeDescriptionProperty(StringBuilder sb, string description, int indentation)
        {
            if (string.IsNullOrWhiteSpace(description))
            {
                return;
            }

            if (description.Contains(Environment.NewLine) || description.Contains("\r\n") || description.Contains("\n") || description.Contains("\r"))
            {
                RamlSerializerHelper.SerializeMultilineProperty(sb, "description", description, indentation);
                return;
            }

            sb.AppendFormat("{0}: {1}".Indent(indentation), "description", "\"" + description.Replace("\"", string.Empty) + "\"");
            sb.AppendLine();
        }
        public string Serialize(RamlDocument ramlDocument)
        {
            var sb = new StringBuilder(ramlDocument.Resources.Count + ramlDocument.Resources.Sum(r => r.Resources.Count) * 20);

            sb.AppendLine("#%RAML " + (ramlDocument.RamlVersion == RamlVersion.Version08 ? "0.8" : "1.0"));

            RamlSerializerHelper.SerializeProperty(sb, "title", ramlDocument.Title);

            RamlSerializerHelper.SerializeProperty(sb, "baseUri", ramlDocument.BaseUri);

            RamlSerializerHelper.SerializeProperty(sb, "version", ramlDocument.Version);

            RamlSerializerHelper.SerializeProperty(sb, "mediaType", ramlDocument.MediaType);

            SerializeArrayProperty(sb, "securedBy", ramlDocument.SecuredBy);

            SerializeProtocols(sb, ramlDocument.Protocols);

            SerializeParameters(sb, "uriParameters", ramlDocument.BaseUriParameters);

            if (ramlDocument.Documentation.Any())
            {
                sb.AppendLine("documentation:");
                foreach (var docItem in ramlDocument.Documentation)
                {
                    RamlSerializerHelper.SerializeProperty(sb, "- title", docItem.Title, 2);
                    RamlSerializerHelper.SerializeMultilineProperty(sb, "content", docItem.Content, 4);
                    raml1TypesSerializer.SerializeAnnotations(sb, docItem.Annotations, 4);
                }
                sb.AppendLine();
            }

            SerializeSecuritySchemes(sb, ramlDocument.SecuritySchemes);

            raml1TypesSerializer.Serialize(sb, ramlDocument.Types);

            SerializeSchemas(sb, ramlDocument.Schemas);

            SerializeResources(sb, ramlDocument.Resources);

            SerializeAnnotationTypes(sb, ramlDocument.AnnotationTypes);

            raml1TypesSerializer.SerializeAnnotations(sb, ramlDocument.Annotations);

            return(sb.ToString());
        }
 private static void SerializeTypeProperty(StringBuilder sb, int indentation, string type)
 {
     RamlSerializerHelper.SerializeProperty(sb, "type", type, indentation + 4);
 }
 private void SerializeResponse(StringBuilder sb, Response response, int indentation)
 {
     sb.AppendLine(response.Code.Indent(indentation) + ":");
     RamlSerializerHelper.SerializeDescriptionProperty(sb, response.Description, indentation + 2);
     SerializeBody(sb, response.Body, indentation + 2);
 }