class Jekyll::ResourcePage

Public Class Methods

new(site, base, web_root, dir, resource, traits, securitySchemes) click to toggle source
Calls superclass method Jekyll::GeneratedPage::new
# File lib/raml-generate.rb, line 76
def initialize(site, base, web_root, dir, resource, traits, securitySchemes)
  # Sandbox our resource, and do nothing with child resources
  resource = resource.dup
  resource.delete('resources')

  resource['title'] = dir.sub('resource', '') if not resource.include?('title')
  super(site, base, web_root, dir, resource)

  # Add security data to the resource
  resource.fetch('methods', []).each do |method|
    if method.include?('securedBy')
      for scheme in method['securedBy']
        for attr in ['headers', 'queryParameters', 'responses']
          method[attr] = {} if not method.include?(attr)
          method[attr].merge!(securitySchemes[scheme].fetch('describedBy', {}).fetch(attr, {}))
        end
      end
    end
  end

  # Add trait data to the resource
  resource.fetch('methods', []).each do |method|
    if method.include?('is')
      for trait in method['is']
        merge_method_trait(method, traits[trait])
      end
    end
  end

  # Compile JSON Schema that use $ref references
  jsc = Jekyll::JsonSchemaCompiler.new
  jsc.compile(resource['methods'])

  # Generate new schema based on existing formParameters
  schema_generator = Jekyll::RamlSchemaGenerator.new(site, resource['title'])
  schema_generator.insert_schemas(resource['methods'])

  # Support a better presentation of the schema
  resource = add_schema_hashes(resource) 

  # Transform descriptions via Markdown
  resource = transform_resource_descriptions(resource)

  # Make all this available to Liquid templates
  self.data['methods'] = resource['methods']
end

Private Instance Methods

add_schema_hashes(obj, key=nil) click to toggle source

Adds a 'schema_hash' attribute to bodies with 'schema', which allows for the generation of schema table views

# File lib/raml-generate.rb, line 154
def add_schema_hashes(obj, key=nil)
  if obj.is_a?(Array)
    obj.map! { |method| add_schema_hashes(method) }
  elsif obj.is_a?(Hash)
    obj.each { |k, v| obj[k] = add_schema_hashes(v, k)}

    if obj.include?("schema")
      
      case key
        when 'application/json'
          obj['schema_hash'] = JSON.parse(obj['schema'])

          refactor_object = lambda do |lam_obj|
            lam_obj['properties'].each do |name, param|
              param['displayName'] = name
              param['required'] = true if lam_obj.fetch('required', []).include?(name)

              if param.include?('example') and ['object', 'array'].include?(param['type'])
                param['example'] = JSON.pretty_generate(JSON.parse(param['example']))
              elsif param.include?('properties')
                param['properties'] = JSON.pretty_generate(param['properties'])
              elsif param.include?('items')
                param['items'] = JSON.pretty_generate(param['items'])
              end

              lam_obj['properties'][name] = param
            end
            lam_obj
          end

          if obj['schema_hash'].include?('properties')
            obj['schema_hash'] = refactor_object.call(obj['schema_hash'])
          end

          if obj['schema_hash'].include?('items') and obj['schema_hash']['items'].include?('properties')
            obj['schema_hash']['items'] = refactor_object.call(obj['schema_hash']['items'])
          end
      end
    end
  end

  obj
end
merge_method_trait(method, trait) click to toggle source
# File lib/raml-generate.rb, line 124
def merge_method_trait(method, trait)
  merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
  method.merge(trait, &merger)

  if method.include?('description')
    method['description'] = "#{method['description']}\n\n#{trait['description']}"
  else
    method['description'] = trait['description']
  end
  method
end
transform_resource_descriptions(resource) click to toggle source
# File lib/raml-generate.rb, line 136
def transform_resource_descriptions(resource)
  if resource.include?('description')
      resource['description'] = transform_md(resource['description'])
  end

  resource.each_key do |key|
    if resource[key].is_a?(Hash)
      resource[key] = transform_resource_descriptions(resource[key])
    end
    if resource[key].is_a?(Array)
      resource[key].map!{|h| h.is_a?(Hash) ? transform_resource_descriptions(h) : h }
    end
  end

  resource
end