Module: SwaggerModel::SwaggerV2

Defined in:

lib/swagger_model.rb,
lib/swagger_model/links.rb,
lib/swagger_model/model.rb,
lib/swagger_model/included.rb,
lib/swagger_model/relation.rb,
lib/swagger_model/attributes.rb,
lib/swagger_model/error_model.rb,
lib/swagger_model/relation_data.rb,
lib/swagger_model/relationships.rb,
lib/swagger_model/error_model_meta.rb,
lib/swagger_model/relation_data_array.rb

Defined Under Namespace

Classes: Attributes, ErrorModel, ErrorModelMeta, Included, Links, Model, Relation, RelationData, RelationDataArray, Relationships

Class Method Summary

• .create_from_json(params) ⇒ Object
• .date_time_valid?(str) ⇒ Boolean
• .get_property(key, value, model, root_key) ⇒ Object
• .parse_array(items, model, root_key) ⇒ Object
• .parse_array_with_multi_model(items, model, root_key) ⇒ Object
• .parse_object(res, model, root_key) ⇒ Object
• .result_to_yaml(result) ⇒ Object

Class Method Details

.create_from_json(params) ⇒ Object

# File 'lib/swagger_model.rb', line 321

def self.create_from_json(params)
  response = {}.to_json
  json_string = params[:json_string]
  if !json_string.nil?
    response = JSON.load(json_string)
  else
    json_file_path = params[:json_file_path] || gets
    json = open(json_file_path) do |io|
      JSON.load(io)
    end
    response = json
  end
  response_name = params[:response_name] || gets
  response_model = {}
  response_model[response_name] = {}
  response_model[response_name]['type'] = "object"
  response_model[response_name]['properties'] = {}
  model = {}

  # For validate
  modelData = []

  # Create response data
  if response.has_key?('data')
    data = response['data']
    case data.class.to_s
    when 'Hash'
      m = Model.new(data)
      modelData.push(m)
      response_model[response_name]['properties']['data'] = m.to_swagger_hash(model)
    when 'Array'
      m = Model.new(data.first)
      modelData.push(m)
      response_model[response_name]['properties']['data'] = {
        'type' => 'array',
        'items' => m.to_swagger_hash(model)
      }
    end
  end

  # Create included key models but not add included key to response
  if response.has_key?('included')
    included = Included.new(response['included'])
    modelData.concat(included.models)
    included.models_to_swagger_hash(model)
  end

  # Create links from template
  if response.has_key?('links')
    links = {}
    links['$ref'] = '#/definitions/Links'
    response_model[response_name]['properties']['links'] = links
    if response_model['Links'].nil?
      response_model['Links'] = Links.template
    end
  end

  # Create Meta
  if response.has_key?('meta')
    meta_name = response_name + 'Meta'
    meta = Attributes.new(response['meta'], meta_name, '')
    meta.to_swagger_hash(response_model)
    meta = {}
    meta['$ref'] = '#/definitions/' + meta_name
    response_model[response_name]['properties']['meta'] = meta
  end

  # Create Error
  if response.has_key?('errors')
    response_model[response_name] = {
      'type' => 'object',
      'properties' => {
        'errors' => {
          'type' => 'array',
          'items' => {
            '$ref' => '#/definitions/ErrorModel'
          }
        }
      }
    }
    response_model['ErrorModel'] = ErrorModel.new().to_swagger_hash
    response_model['ErrorModelMeta'] = ErrorModelMeta.new().to_swagger_hash
  end

  # validate models
  modelTypes = modelData.map { |e| e.type  }
  modelData.each do |m|
    next if m.relationships.nil?
    next if m.relationships.relationships.empty?
    m.relationships.relationships.each do |e|
      next if ![SwaggerModel::SwaggerV2::RelationDataArray, SwaggerModel::SwaggerV2::RelationData].include?(e['data'].class)
      next if e['data'].relation.nil?
      next if e['data'].relation.type.nil?
      type = e['data'].relation.type
      if !modelTypes.include?(type)
        newModel = Model.new({
          'id' => '',
          'type' => type
          })
        newModel.to_swagger_hash(model)
      end
    end
  end

  # Set required
  response_model[response_name]['required'] = response_model[response_name]['properties'].keys

  # add example
  response_model[response_name]['example'] = response

  keys = model.keys
  unless params[:output_path].nil?
    output_path = params[:output_path]
    output_path_responses = File.join(output_path, 'Responses/')
    output_path_models = File.join(output_path, 'Models/')

    FileUtils::mkdir_p output_path_responses
    FileUtils::mkdir_p output_path_models

    File.write(File.join(output_path_responses, "#{response_name}.yaml"), response_model.to_yaml)

    for key in keys do
      File.write(File.join(output_path_models, "#{key}.yaml"), model[key].to_yaml)
    end
  end

  models = {}
  for key in keys do
    models[key] = model[key]
  end
  result = {
    "responses" => response_model,
    "models" => models
  }
end

.date_time_valid?(str) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/swagger_model.rb', line 201

def self.date_time_valid?(str)
  if (!! Date.parse(str) rescue false)
    date = Date._parse(str)
    !date[:zone].nil? && !date[:hour].nil? && !date[:min].nil? && !date[:sec].nil? && !date[:year].nil? && !date[:mon].nil?
  else
    false
  end
end

.get_property(key, value, model, root_key) ⇒ Object

# File 'lib/swagger_model.rb', line 210

def self.get_property(key, value, model, root_key)
  type_class = value.class.to_s
  obj = {}
  case type_class
  when 'Hash'
    if value.has_key?('id') && value.has_key?('type')
      model_name = ActiveSupport::Inflector.classify(value['type'].gsub('-', '_'))
      model[model_name] = {}
      object = parse_object(value, model, model_name)
      properties = object['properties']
      newProperties = {}
      newProperties['type'] = 'object'
      if object['required'].size > 0
          newProperties['required'] = object['required']
      end
      newProperties['properties'] = properties
      model[model_name][model_name] = newProperties
      obj['$ref'] = '#/definitions/' + model_name
    elsif key == 'attributes'
      object = parse_object(value, model, root_key)
      properties = object['properties']
      model_name = root_key + 'Attributes'
      model[root_key][model_name] = {}
      model[root_key][model_name]['type'] = 'object'
      model[root_key][model_name]['properties'] = properties
      if object['required'].size > 0
        model[root_key][model_name]['required'] = object['required']
      end
      obj['$ref'] = '#/definitions/' + model_name
    elsif key == 'relationships'
      relationships = Relationships.new(value)
      obj = relationships.to_swagger_hash(model, root_key)
    else
      object = parse_object(value, model, root_key)
      properties = object['properties']
      obj['type'] = 'object'
      obj['properties'] = properties
      if object['required'].size > 0
        obj['required'] = object['required']
      end
    end
  when 'Array'
    obj['type'] = 'array'
    obj['items'] = parse_array(value, model, root_key)
  when 'String'
    obj['type'] = 'string'
    obj['example'] = value
    if date_time_valid?(value)
      obj['format'] = 'date-time'
    end
  when 'Fixnum'
    obj['type'] = 'integer'
    obj['example'] = value
  when 'TrueClass', 'FalseClass'
    obj['type'] = 'boolean'
    obj['example'] = value
  when 'Float'
    obj['type'] = 'number'
    obj['format'] = 'float'
    obj['example'] = value
  else
    @logger.warn("Unrecognized Type of `#{key}`. [key: #{key}, root_key: #{root_key}]")
    obj['type'] = ''
    obj['example'] = ''
  end
  obj
end

.parse_array(items, model, root_key) ⇒ Object

# File 'lib/swagger_model.rb', line 278

def self.parse_array(items, model, root_key)
  m = {}
  value = items.first
  get_property(nil, value, model, root_key)
end

.parse_array_with_multi_model(items, model, root_key) ⇒ Object

# File 'lib/swagger_model.rb', line 284

def self.parse_array_with_multi_model(items, model, root_key)
  types = []
  refs = []
  items.each do |value|
    property = get_property(nil, value, model, root_key)
    if !refs.include?(property['$ref'])
      types.push(get_property(nil, value, model, root_key))
      refs.push(property['$ref'])
    end
  end
  types
end

.parse_object(res, model, root_key) ⇒ Object

# File 'lib/swagger_model.rb', line 297

def self.parse_object(res, model, root_key)
  keys = res.keys
  m = {}
  required = []
  for key in keys do
    value = res[key]
    m[key] = get_property(key, value, model, root_key)
    if m[key]['type'] != ''
      required.push(key)
    end
  end
  obj = {}
  obj['properties'] = m
  obj['required'] = required
  obj
end

.result_to_yaml(result) ⇒ Object

# File 'lib/swagger_model.rb', line 313

def self.result_to_yaml(result)
  models = {}
  result['models'].each { |key, value| models.merge!(value) }
  data = {
    'definitions' => result['responses'].merge(models)
  }
  data.to_yaml
end