ruby-linstor-client 1.0.0

data/generator/template/model_doc.mustache

@@ -0,0 +1,12 @@
+{{#models}}
+{{#model}}
+{{#oneOf}}
+{{#-first}}
+{{>partial_oneof_module_doc}}
+{{/-first}}
+{{/oneOf}}
+{{^oneOf}}
+{{>partial_model_generic_doc}}
+{{/oneOf}}
+{{/model}}
+{{/models}}

data/generator/template/model_test.mustache

@@ -0,0 +1,77 @@
+=begin
+{{> api_info}}
+=end
+
+require 'spec_helper'
+require 'json'
+require 'date'
+
+# Unit tests for {{moduleName}}::{{classname}}
+# Automatically generated by openapi-generator (https://openapi-generator.tech)
+# Please update as you see appropriate
+{{#models}}
+{{#model}}
+describe {{moduleName}}::{{classname}} do
+{{^oneOf}}
+  let(:instance) { {{moduleName}}::{{classname}}.new }
+
+  describe 'test an instance of {{classname}}' do
+    it 'should create an instance of {{classname}}' do
+      expect(instance).to be_instance_of({{moduleName}}::{{classname}})
+    end
+  end
+{{#vars}}
+  describe 'test attribute "{{{name}}}"' do
+    it 'should work' do
+      {{#isEnum}}
+      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+      # validator = Petstore::EnumTest::EnumAttributeValidator.new('{{{dataType}}}', [{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}}])
+      # validator.allowable_values.each do |value|
+      #   expect { instance.{{name}} = value }.not_to raise_error
+      # end
+      {{/isEnum}}
+      {{^isEnum}}
+      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+      {{/isEnum}}
+    end
+  end
+
+{{/vars}}
+{{/oneOf}}
+{{#oneOf}}
+{{#-first}}
+  describe '.openapi_one_of' do
+    it 'lists the items referenced in the oneOf array' do
+      expect(described_class.openapi_one_of).to_not be_empty
+    end
+  end
+
+  {{#discriminator}}
+  {{#propertyName}}
+  describe '.openapi_discriminator_name' do
+    it 'returns the value of the "discriminator" property' do
+      expect(described_class.openapi_discriminator_name).to_not be_empty
+    end
+  end
+
+  {{/propertyName}}
+  {{#mappedModels}}
+  {{#-first}}
+  describe '.openapi_discriminator_mapping' do
+    it 'returns the key/values of the "mapping" property' do
+      expect(described_class.openapi_discriminator_mapping.values.sort).to eq(described_class.openapi_one_of.sort)
+    end
+  end
+
+  {{/-first}}
+  {{/mappedModels}}
+  {{/discriminator}}
+  describe '.build' do
+    it 'returns the correct model' do
+    end
+  end
+{{/-first}}
+{{/oneOf}}
+end
+{{/model}}
+{{/models}}

data/generator/template/partial_model_enum_class.mustache

@@ -0,0 +1,20 @@
+  class {{classname}}{{#allowableValues}}{{#enumVars}}
+    {{{name}}} = {{{value}}}.freeze{{/enumVars}}
+
+{{/allowableValues}}
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def self.build_from_hash(value)
+      new.build_from_hash(value)
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def build_from_hash(value)
+      constantValues = {{classname}}.constants.select { |c| {{classname}}::const_get(c) == value }
+      raise "Invalid ENUM value #{value} for class #{{{classname}}}" if constantValues.empty?
+      value
+    end
+  end

data/generator/template/partial_model_generic.mustache

@@ -0,0 +1,371 @@
+  {{#description}}
+  # {{{.}}}
+  {{/description}}
+  class {{classname}}{{#parent}} < {{{.}}}{{/parent}}
+  {{#vars}}
+    {{#description}}
+    # {{{.}}}
+    {{/description}}
+    attr_accessor :{{{name}}}
+
+  {{/vars}}
+{{#hasEnums}}
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+{{/hasEnums}}
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        {{#vars}}
+        :'{{{name}}}' => :'{{{baseName}}}'{{^-last}},{{/-last}}
+        {{/vars}}
+      }
+    end
+
+    # Returns all the JSON keys this model knows about{{#parent}}, including the ones defined in its parent(s){{/parent}}
+    def self.acceptable_attributes
+      {{^parent}}
+      attribute_map.values
+      {{/parent}}
+      {{#parent}}
+      attribute_map.values.concat(superclass.acceptable_attributes)
+      {{/parent}}
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        {{#vars}}
+        :'{{{name}}}' => :'{{{dataType}}}'{{^-last}},{{/-last}}
+        {{/vars}}
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        {{#vars}}
+        {{#isNullable}}
+        :'{{{name}}}'{{^-last}},{{/-last}}
+        {{/isNullable}}
+        {{/vars}}
+      ])
+    end
+
+    {{#anyOf}}
+    {{#-first}}
+    # List of class defined in anyOf (OpenAPI v3)
+    def self.openapi_any_of
+      [
+    {{/-first}}
+      :'{{{.}}}'{{^-last}},{{/-last}}
+    {{#-last}}
+      ]
+    end
+
+    {{/-last}}
+    {{/anyOf}}
+    {{#allOf}}
+    {{#-first}}
+    # List of class defined in allOf (OpenAPI v3)
+    def self.openapi_all_of
+      [
+    {{/-first}}
+      :'{{{.}}}'{{^-last}},{{/-last}}
+    {{#-last}}
+      ]
+    end
+
+    {{/-last}}
+    {{/allOf}}
+    {{#discriminator}}
+    {{#propertyName}}
+    # discriminator's property name in OpenAPI v3
+    def self.openapi_discriminator_name
+      :'{{{.}}}'
+    end
+
+    {{/propertyName}}
+    {{/discriminator}}
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `{{{moduleName}}}::{{{classname}}}` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `{{{moduleName}}}::{{{classname}}}`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+      {{#parent}}
+
+      # call parent's initialize
+      super(attributes)
+      {{/parent}}
+      {{#vars}}
+
+      if attributes.key?(:'{{{name}}}')
+        {{#isArray}}
+        if (value = attributes[:'{{{name}}}']).is_a?(Array)
+          self.{{{name}}} = value
+        end
+        {{/isArray}}
+        {{#isMap}}
+        if (value = attributes[:'{{{name}}}']).is_a?(Hash)
+          self.{{{name}}} = value
+        end
+        {{/isMap}}
+        {{^isContainer}}
+        self.{{{name}}} = attributes[:'{{{name}}}']
+        {{/isContainer}}
+      {{#defaultValue}}
+      else
+        self.{{{name}}} = {{{defaultValue}}}
+      {{/defaultValue}}
+      end
+      {{/vars}}
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = {{^parent}}Array.new{{/parent}}{{#parent}}super{{/parent}}
+      {{#vars}}
+      {{^isNullable}}
+      {{#required}}
+      if @{{{name}}}.nil?
+        invalid_properties.push('invalid value for "{{{name}}}", {{{name}}} cannot be nil.')
+      end
+
+      {{/required}}
+      {{/isNullable}}
+      {{#hasValidation}}
+      {{#maxLength}}
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.to_s.length > {{{maxLength}}}
+        invalid_properties.push('invalid value for "{{{name}}}", the character length must be smaller than or equal to {{{maxLength}}}.')
+      end
+
+      {{/maxLength}}
+      {{#minLength}}
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.to_s.length < {{{minLength}}}
+        invalid_properties.push('invalid value for "{{{name}}}", the character length must be great than or equal to {{{minLength}}}.')
+      end
+
+      {{/minLength}}
+      {{#maximum}}
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}} >{{#exclusiveMaximum}}={{/exclusiveMaximum}} {{{maximum}}}
+        invalid_properties.push('invalid value for "{{{name}}}", must be smaller than {{^exclusiveMaximum}}or equal to {{/exclusiveMaximum}}{{{maximum}}}.')
+      end
+
+      {{/maximum}}
+      {{#minimum}}
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}} <{{#exclusiveMinimum}}={{/exclusiveMinimum}} {{{minimum}}}
+        invalid_properties.push('invalid value for "{{{name}}}", must be greater than {{^exclusiveMinimum}}or equal to {{/exclusiveMinimum}}{{{minimum}}}.')
+      end
+
+      {{/minimum}}
+      {{#pattern}}
+      pattern = Regexp.new({{{pattern}}})
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}} !~ pattern
+        invalid_properties.push("invalid value for \"{{{name}}}\", must conform to the pattern #{pattern}.")
+      end
+
+      {{/pattern}}
+      {{#maxItems}}
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.length > {{{maxItems}}}
+        invalid_properties.push('invalid value for "{{{name}}}", number of items must be less than or equal to {{{maxItems}}}.')
+      end
+
+      {{/maxItems}}
+      {{#minItems}}
+      if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.length < {{{minItems}}}
+        invalid_properties.push('invalid value for "{{{name}}}", number of items must be greater than or equal to {{{minItems}}}.')
+      end
+
+      {{/minItems}}
+      {{/hasValidation}}
+      {{/vars}}
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      {{#vars}}
+      {{^isNullable}}
+      {{#required}}
+      return false if @{{{name}}}.nil?
+      {{/required}}
+      {{/isNullable}}
+      {{#isEnum}}
+      {{^isContainer}}
+      {{{name}}}_validator = EnumAttributeValidator.new('{{{dataType}}}', [{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}}])
+      return false unless {{{name}}}_validator.valid?(@{{{name}}})
+      {{/isContainer}}
+      {{/isEnum}}
+      {{#hasValidation}}
+      {{#maxLength}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.to_s.length > {{{maxLength}}}
+      {{/maxLength}}
+      {{#minLength}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.to_s.length < {{{minLength}}}
+      {{/minLength}}
+      {{#maximum}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}} >{{#exclusiveMaximum}}={{/exclusiveMaximum}} {{{maximum}}}
+      {{/maximum}}
+      {{#minimum}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}} <{{#exclusiveMinimum}}={{/exclusiveMinimum}} {{{minimum}}}
+      {{/minimum}}
+      {{#pattern}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}} !~ Regexp.new({{{pattern}}})
+      {{/pattern}}
+      {{#maxItems}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.length > {{{maxItems}}}
+      {{/maxItems}}
+      {{#minItems}}
+      return false if {{^required}}!@{{{name}}}.nil? && {{/required}}@{{{name}}}.length < {{{minItems}}}
+      {{/minItems}}
+      {{/hasValidation}}
+      {{/vars}}
+      {{#anyOf}}
+      {{#-first}}
+      _any_of_found = false
+      self.class.openapi_any_of.each do |_class|
+        _any_of = {{moduleName}}.const_get(_class).build_from_hash(self.to_hash)
+        if _any_of.valid?
+          _any_of_found = true
+        end
+      end
+
+      if !_any_of_found
+        return false
+      end
+
+      {{/-first}}
+      {{/anyOf}}
+      true{{#parent}} && super{{/parent}}
+    end
+
+    {{#vars}}
+    {{#isEnum}}
+    {{^isContainer}}
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] {{{name}}} Object to be assigned
+    def {{{name}}}=({{{name}}})
+      validator = EnumAttributeValidator.new('{{{dataType}}}', [{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}}])
+      unless validator.valid?({{{name}}})
+        fail ArgumentError, "invalid value for \"{{{name}}}\", must be one of #{validator.allowable_values}."
+      end
+      @{{{name}}} = {{{name}}}
+    end
+
+    {{/isContainer}}
+    {{/isEnum}}
+    {{^isEnum}}
+    {{#hasValidation}}
+    # Custom attribute writer method with validation
+    # @param [Object] {{{name}}} Value to be assigned
+    def {{{name}}}=({{{name}}})
+      {{^isNullable}}
+      {{#required}}
+      if {{{name}}}.nil?
+        fail ArgumentError, '{{{name}}} cannot be nil'
+      end
+
+      {{/required}}
+      {{/isNullable}}
+      {{#maxLength}}
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}}.to_s.length > {{{maxLength}}}
+        fail ArgumentError, 'invalid value for "{{{name}}}", the character length must be smaller than or equal to {{{maxLength}}}.'
+      end
+
+      {{/maxLength}}
+      {{#minLength}}
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}}.to_s.length < {{{minLength}}}
+        fail ArgumentError, 'invalid value for "{{{name}}}", the character length must be great than or equal to {{{minLength}}}.'
+      end
+
+      {{/minLength}}
+      {{#maximum}}
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}} >{{#exclusiveMaximum}}={{/exclusiveMaximum}} {{{maximum}}}
+        fail ArgumentError, 'invalid value for "{{{name}}}", must be smaller than {{^exclusiveMaximum}}or equal to {{/exclusiveMaximum}}{{{maximum}}}.'
+      end
+
+      {{/maximum}}
+      {{#minimum}}
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}} <{{#exclusiveMinimum}}={{/exclusiveMinimum}} {{{minimum}}}
+        fail ArgumentError, 'invalid value for "{{{name}}}", must be greater than {{^exclusiveMinimum}}or equal to {{/exclusiveMinimum}}{{{minimum}}}.'
+      end
+
+      {{/minimum}}
+      {{#pattern}}
+      pattern = Regexp.new({{{pattern}}})
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}} !~ pattern
+        fail ArgumentError, "invalid value for \"{{{name}}}\", must conform to the pattern #{pattern}."
+      end
+
+      {{/pattern}}
+      {{#maxItems}}
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}}.length > {{{maxItems}}}
+        fail ArgumentError, 'invalid value for "{{{name}}}", number of items must be less than or equal to {{{maxItems}}}.'
+      end
+
+      {{/maxItems}}
+      {{#minItems}}
+      if {{^required}}!{{{name}}}.nil? && {{/required}}{{{name}}}.length < {{{minItems}}}
+        fail ArgumentError, 'invalid value for "{{{name}}}", number of items must be greater than or equal to {{{minItems}}}.'
+      end
+
+      {{/minItems}}
+      @{{{name}}} = {{{name}}}
+    end
+
+    {{/hasValidation}}
+    {{/isEnum}}
+    {{/vars}}
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class{{#vars}} &&
+          {{name}} == o.{{name}}{{/vars}}{{#parent}} && super(o){{/parent}}
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [{{#vars}}{{name}}{{^-last}}, {{/-last}}{{/vars}}].hash
+    end
+
+{{> base_object}}
+  end

data/generator/template/partial_model_generic_doc.mustache

@@ -0,0 +1,28 @@
+# {{moduleName}}::{{classname}}
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+{{#vars}}
+| **{{name}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}[**{{dataType}}**]({{complexType}}.md){{/isPrimitiveType}} | {{description}} | {{^required}}[optional]{{/required}}{{#isReadOnly}}[readonly]{{/isReadOnly}}{{#defaultValue}}[default to {{.}}]{{/defaultValue}} |
+{{/vars}}
+
+## Example
+
+```ruby
+require '{{{gemName}}}'
+
+{{^vars}}
+instance = {{moduleName}}::{{classname}}.new()
+{{/vars}}
+{{#vars}}
+{{#-first}}
+instance = {{moduleName}}::{{classname}}.new(
+{{/-first}}
+  {{name}}: {{example}}{{^-last}},{{/-last}}
+{{#-last}}
+)
+{{/-last}}
+{{/vars}}
+```

data/generator/template/partial_oneof_module.mustache

@@ -0,0 +1,137 @@
+  {{#description}}
+  # {{{.}}}
+  {{/description}}
+  module {{classname}}
+    class << self
+      {{#oneOf}}
+      {{#-first}}
+      # List of class defined in oneOf (OpenAPI v3)
+      def openapi_one_of
+        [
+      {{/-first}}
+          :'{{{.}}}'{{^-last}},{{/-last}}
+      {{#-last}}
+        ]
+      end
+
+      {{/-last}}
+      {{/oneOf}}
+      {{#discriminator}}
+      {{#propertyName}}
+      # Discriminator's property name (OpenAPI v3)
+      def openapi_discriminator_name
+        :'{{{.}}}'
+      end
+
+      {{/propertyName}}
+      {{#mappedModels}}
+      {{#-first}}
+      # Discriminator's mapping (OpenAPI v3)
+      def openapi_discriminator_mapping
+        {
+      {{/-first}}
+          :'{{{mappingName}}}' => :'{{{modelName}}}'{{^-last}},{{/-last}}
+      {{#-last}}
+        }
+      end
+
+      {{/-last}}
+      {{/mappedModels}}
+      {{/discriminator}}
+      # Builds the object
+      # @param [Mixed] Data to be matched against the list of oneOf items
+      # @return [Object] Returns the model or the data itself
+      def build(data)
+      {{#discriminator}}
+        discriminator_value = data[openapi_discriminator_name]
+        return nil unless discriminator_value
+      {{#mappedModels}}
+      {{#-first}}
+
+        klass = openapi_discriminator_mapping[discriminator_value.to_sym]
+        return nil unless klass
+
+        {{moduleName}}.const_get(klass).build_from_hash(data)
+      {{/-first}}
+      {{/mappedModels}}
+      {{^mappedModels}}
+        {{moduleName}}.const_get(discriminator_value).build_from_hash(data)
+      {{/mappedModels}}
+      {{/discriminator}}
+      {{^discriminator}}
+        # Go through the list of oneOf items and attempt to identify the appropriate one.
+        # Note:
+        # - We do not attempt to check whether exactly one item matches.
+        # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
+        #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
+        # - TODO: scalar values are de facto behaving as if they were nullable.
+        # - TODO: logging when debugging is set.
+        openapi_one_of.each do |klass|
+          begin
+            next if klass == :AnyType # "nullable: true"
+            typed_data = find_and_cast_into_type(klass, data)
+            return typed_data if typed_data
+          rescue # rescue all errors so we keep iterating even if the current item lookup raises
+          end
+        end
+
+        openapi_one_of.include?(:AnyType) ? data : nil
+      {{/discriminator}}
+      end
+      {{^discriminator}}
+
+      private
+
+      SchemaMismatchError = Class.new(StandardError)
+
+      # Note: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
+      def find_and_cast_into_type(klass, data)
+        return if data.nil?
+
+        case klass.to_s
+        when 'Boolean'
+          return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
+        when 'Float'
+          return data if data.instance_of?(Float)
+        when 'Integer'
+          return data if data.instance_of?(Integer)
+        when 'Time'
+          return Time.parse(data)
+        when 'Date'
+          return Date.parse(data)
+        when 'String'
+          return data if data.instance_of?(String)
+        when 'Object' # "type: object"
+          return data if data.instance_of?(Hash)
+        when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
+          if data.instance_of?(Array)
+            sub_type = Regexp.last_match[:sub_type]
+            return data.map { |item| find_and_cast_into_type(sub_type, item) }
+          end
+        when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
+          if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
+            sub_type = Regexp.last_match[:sub_type]
+            return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
+          end
+        else # model
+          const = {{moduleName}}.const_get(klass)
+          if const
+            if const.respond_to?(:openapi_one_of) # nested oneOf model
+              model = const.build(data)
+              return model if model
+            else
+              # raise if data contains keys that are not known to the model
+              raise unless (data.keys - const.acceptable_attributes).empty?
+              model = const.build_from_hash(data)
+              return model if model && model.valid?
+            end
+          end
+        end
+
+        raise # if no match by now, raise
+      rescue
+        raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
+      end
+      {{/discriminator}}
+    end
+  end