Refresh onfido-ruby after onfido-openapi-spec update (38a8740)

.github/workflows/ruby.yml

@@ -28,8 +28,7 @@ jobs:
           bundler-cache: true
       - name: Run integration tests
         if: ${{ matrix.ruby-version == '3.2' &&
-          github.repository_owner == 'onfido' &&
-          github.actor != 'dependabot[bot]' }}
+          github.repository_owner == 'onfido' }}
         run: bundle exec rspec spec
         env:
           ONFIDO_API_TOKEN: ${{ secrets.ONFIDO_API_TOKEN }}
@@ -42,9 +41,12 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     needs: integration-tests
+    environment: delivery
     if: github.event_name == 'release'
     steps:
       - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GH_ACTION_ACCESS_TOKEN }}
       - name: Set up Ruby 2.7
         uses: ruby/setup-ruby@v1
         with:
@@ -60,3 +62,31 @@ jobs:
           gem push *.gem
         env:
           GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"
+      - name: Update CHANGELOG.md
+        run: |
+          TMP_FILE=$(mktemp)
+
+          RELEASE_VERSION=$(jq -r '.release' .release.json)
+          RELEASE_DATE=`date +'%dth %B %Y' | sed -E 's/^0//;s/^([2,3]?)1th/\11st/;s/^([2]?)2th/\12nd/;s/^([2]?)3th/\13rd/'`
+
+          SPEC_COMMIT_SHA=$(jq -r '.source.short_sha' .release.json)
+          SPEC_COMMIT_URL=$(jq -r '.source.repo_url + "/commit/" + .source.long_sha' .release.json)
+          SPEC_RELEASE_VERSION=$(jq -r '.source.version' .release.json)
+          SPEC_RELEASE_URL=$(jq -r '.source.repo_url + "/releases/tag/" + .source.version' .release.json)
+
+          echo -e "# Changelog\n\n## $RELEASE_VERSION $RELEASE_DATE\n\n" >| $TMP_FILE
+          echo -en "${{ github.event.release.body }}\nBased on Onfido OpenAPI spec " >> $TMP_FILE
+
+          if [ -z $SPEC_RELEASE_VERSION ]; then
+            echo "up to commit [$SPEC_COMMIT_SHA](${SPEC_COMMIT_URL})." >> $TMP_FILE
+          else
+            echo "version [$SPEC_RELEASE_VERSION](${SPEC_RELEASE_URL})." >> $TMP_FILE
+          fi
+
+          grep -v "^# Changelog" CHANGELOG.md >> $TMP_FILE
+          mv $TMP_FILE CHANGELOG.md
+
+          git config user.name "GitHub Actions Bot"
+          git config user.email "<>"
+          git commit -m "Update CHANGELOG.md after library release" CHANGELOG.md
+          git push

.release.json

@@ -0,0 +1,9 @@
+{
+  "source": {
+    "repo_url": "https://github.com/onfido/onfido-openapi-spec",
+    "short_sha": "38a8740",
+    "long_sha": "38a87401552386cb0b17aae28385c5e2f4af7bfc",
+    "version": ""
+  },
+  "release": "v3.0.0"
+}

CHANGELOG.md

@@ -1,10 +1,5 @@
 # Changelog
 
-## v3.0.0 14th Jun 2024
-
-- Make library auto-generated and based on [Onfido OpenAPI spec](https://github.com/onfido/onfido-openapi-spec)
-- Refresh library up to commit: [169dd4d](https://github.com/onfido/onfido-openapi-spec/commit/169dd4d6598dab5d9822c9b87e7f0f16b3aef5dc)
-
 ## v2.9.0 24 November 2023
 
 - Added `signed_evidence_file` method for WorkflowRuns

README.md

@@ -86,7 +86,7 @@ Webhook events payload needs to be verified before it can be accessed. Library a
 
 ## Contributing
 
-This library is automatically generated using [OpenAPI Generator](https://openapi-generator.tech) - version: 7.6.0; therefore all the contributions, except tests files, should target [Onfido OpenAPI specification repository](https://github.com/onfido/onfido-openapi-spec/tree/master) instead of this repository.
+This library is automatically generated using [OpenAPI Generator](https://openapi-generator.tech) (version: 7.6.0); therefore all the contributions, except tests files, should target [Onfido OpenAPI specification repository](https://github.com/onfido/onfido-openapi-spec/tree/master) instead of this repository.
 
 For contributions to the tests instead, please follow the steps below:
 
@@ -97,11 +97,27 @@ For contributions to the tests instead, please follow the steps below:
 5. Push to the branch (`git push origin my-new-feature`)
 6. Create a new Pull Request
 
+## Versioning policy
+
+[Semantic Versioning](https://semver.org) policy is used for library versioning, following guidelines and limitations below:
+
+- MAJOR versions (x.0.0) might:
+  - target a new API version
+  - include non-backward compatible change
+- MINOR versions (0.x.0) might:
+  - add a new functionality, non-mandatory parameter or property
+  - deprecate an old functionality
+  - include non-backward compatible change to a functionality which is:
+    - labelled as alpha or beta
+    - completely broken and not usable
+- PATCH version (0.0.x) might:
+  - fix a bug
+  - include backward compatible changes only
+
 ## More documentation
 
 More documentation and code examples can be found at <https://documentation.onfido.com>.
 
 ## Support
 
-Should you encounter any technical issues during integration, please contact Onfido's Customer Support team
-via the [Customer Experience Portal](https://public.support.onfido.com/) which also includes support documentation.
+Should you encounter any technical issues during integration, please contact Onfido's Customer Support team via the [Customer Experience Portal](https://public.support.onfido.com/) which also includes support documentation.

lib/onfido.rb

@@ -127,6 +127,7 @@
 require 'onfido/models/facial_similarity_motion_breakdown_visual_authenticity'
 require 'onfido/models/facial_similarity_motion_breakdown_visual_authenticity_breakdown'
 require 'onfido/models/facial_similarity_motion_breakdown_visual_authenticity_breakdown_spoofing_detection'
+require 'onfido/models/facial_similarity_motion_properties'
 require 'onfido/models/facial_similarity_motion_report'
 require 'onfido/models/facial_similarity_photo_breakdown'
 require 'onfido/models/facial_similarity_photo_breakdown_face_comparison'
@@ -145,7 +146,9 @@
 require 'onfido/models/facial_similarity_photo_fully_auto_breakdown_image_integrity'
 require 'onfido/models/facial_similarity_photo_fully_auto_breakdown_image_integrity_breakdown'
 require 'onfido/models/facial_similarity_photo_fully_auto_breakdown_image_integrity_breakdown_source_integrity'
+require 'onfido/models/facial_similarity_photo_fully_auto_properties'
 require 'onfido/models/facial_similarity_photo_fully_auto_report'
+require 'onfido/models/facial_similarity_photo_properties'
 require 'onfido/models/facial_similarity_photo_report'
 require 'onfido/models/facial_similarity_video_breakdown'
 require 'onfido/models/facial_similarity_video_breakdown_face_comparison'
@@ -157,6 +160,7 @@
 require 'onfido/models/facial_similarity_video_breakdown_visual_authenticity_breakdown'
 require 'onfido/models/facial_similarity_video_breakdown_visual_authenticity_breakdown_liveness_detected'
 require 'onfido/models/facial_similarity_video_breakdown_visual_authenticity_breakdown_spoofing_detection'
+require 'onfido/models/facial_similarity_video_properties'
 require 'onfido/models/facial_similarity_video_report'
 require 'onfido/models/id_number'
 require 'onfido/models/id_photo'

lib/onfido/models/facial_similarity_motion_properties.rb

@@ -0,0 +1,215 @@
+=begin
+#Onfido API v3.6
+
+#The Onfido API (v3.6)
+
+The version of the OpenAPI document: v3.6
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.6.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Onfido
+  class FacialSimilarityMotionProperties
+    # A floating point number between 0 and 1. The closer the score is to 0, the more likely it is to be a spoof (i.e. videos of digital screens, masks or print-outs). Conversely, the closer it is to 1, the less likely it is to be a spoof. 
+    attr_accessor :score
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'score' => :'score'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'score' => :'Float'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # 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 `Onfido::FacialSimilarityMotionProperties` 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 `Onfido::FacialSimilarityMotionProperties`. 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
+      }
+
+      if attributes.key?(:'score')
+        self.score = attributes[:'score']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      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?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          score == o.score
+    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
+      [score].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = Onfido.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end