redox-engine 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2bf921674c782a330ae80681707ab75dcea8d1ce33b64377972b6ba65dcd12f2
+  data.tar.gz: e118094c8e31bff0d0df9fcfe8e3b7e7dfd01a3571624a49cdbf485815b639ab
+SHA512:
+  metadata.gz: 330cbf17a9e11f0b0d24aafef2f5c88cdeec00c7699e49c68c49e8f460a4134562cc4cc1f1da24e6ac70f4c5985f5a52e7e71f6802b73fa3afbefbac5e653483
+  data.tar.gz: 79a90d76cb1d26cab2737baa26dd609e9113841587aae749f34692babf6970e0b9cbaca630c78c15d2ea31d909ab0b85359477dd6f723a55e74ccf6c64b3d061

data/.circleci/config.yml

@@ -0,0 +1,26 @@
+version: 2
+jobs:
+  build:
+    working_directory: ~/weinfuse_api
+    docker:
+      - image: circleci/ruby:2.4
+    steps:
+      - checkout
+      - type: restore-cache
+        key: redox_{{ checksum "Gemfile.lock" }}
+        key: redox
+      - run: bundle install --path vendor/bundle --jobs 20 --retry 5
+      - type: cache-save
+        key: redox_{{ checksum "Gemfile.lock" }}
+        key: redox
+        paths:
+          - vendor/bundle
+      - type: shell
+        command: |
+          bundle exec rubocop
+      - type: shell
+        command: |
+          bundle exec rake test
+      - type: store_test_results
+        path: /tmp/test-results
+

data/.editorconfig

@@ -0,0 +1,10 @@
+root=true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/test/redox_keys.yml
+/test/vcr/
+
+*.gem

data/.rubocop.yml

@@ -0,0 +1,33 @@
+# Common configuration.
+AllCops:
+  # Include gemspec and Rakefile
+  Exclude:
+    - '**/*.gemspec'
+    - '**/*.podspec'
+    - '**/*.jbuilder'
+    - '**/*.rake'
+    - '**/*.opal'
+    - '**/Gemfile'
+    - '**/Rakefile'
+    - '**/Capfile'
+    - '**/Guardfile'
+    - '**/Podfile'
+    - '**/Thorfile'
+    - '**/Vagrantfile'
+    - '**/Berksfile'
+    - '**/Cheffile'
+    - '**/Vagabondfile'
+    - 'vendor/**/*'
+    - 'test/test_helper_methods.rb'
+
+Metrics/MethodLength:
+  Exclude:
+    - 'test/**/*'
+    
+Metrics/ClassLength:
+  Exclude:
+    - 'test/**/*'
+  
+Style/RescueModifier:
+  Exclude:
+    - 'lib/core_ext/hash.rb'

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [0.1.3] - 2018-04-04
+- Change RedoxEngine::RedoxEngine to RedoxEngine::Client
+- Refactor Module to accept configuration
+- Refactor Client to pass Rubocop linting
+- Refactor Client to accept stored token/refresh token
+- Refactor/add tests
+- Add methods:
+  - client.update_patient
+  - client.get_booked_slots
+  - client.search_patient
+  - client.get_summary_for_patient
+- Add classes:
+  - Patient
+  - Visit  
+
+# [0.1.2] - 2018-03-08
+### Added
+- CircleCI config
+- .editorconfig
+- Added rubocop as dev dependency
+
+### Changed
+- Corrected author email
+- Tweaks to pass rubocop
+
+# [0.1.1] - 2017-10-12
+### Removed
+- Redundant .gem file
+- Fix WeInfuse capitalization
+
+## 0.1.0 - 2017-10-12
+### Added
+- Initial Release
+
+[Unreleased]: https://github.com/WeInfuse/redox/compare/0.1.2...HEAD
+[0.1.2]: https://github.com/WeInfuse/redox/compare/0.1.1...0.1.2
+[0.1.1]: https://github.com/WeInfuse/redox/compare/0.1.0...0.1.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redox.gemspec
+gemspec

data/README.md

@@ -0,0 +1,114 @@
+# RedoxEngine
+Ruby API wrapper for [RedoxEngine Engine](https://www.redoxengine.com)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'redox'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redox
+
+## Usage
+
+In an initializer file:
+```ruby
+RedoxEngine.configure do |redox|
+  redox.api_key = #{Your API Key}
+  redox.secret = #{Your secret}
+end
+```
+
+```ruby
+source = {
+  Name: 'RedoxEngine Dev Tools',
+  ID: ENV['REDOX_SRC_ID']
+}
+
+destinations = [
+  {
+    Name: 'RedoxEngine EMR',
+    ID: ENV['REDOX_DEST_ID']
+  }
+]
+
+redox = RedoxEngine::Client.new(
+  source: source,
+  destinations: destinations,
+  test: true
+)
+
+redox.add_patient(
+  Identifiers: [...],
+  Demographics: {
+    FirstName: 'Joe'
+    ...
+  }
+)
+```
+
+Initializing with a persisted access token (check if it's expired, client will load naively)
+```ruby
+c = RedoxEngine::Client.new(
+  source: source,
+  destinations: destinations,
+  test: true,
+  token: <Existing access token>
+)
+```
+
+Initializing with a persisted refresh token (client will get a new access token)
+```ruby
+c = RedoxEngine::Client.new(
+  source: source,
+  destinations: destinations,
+  test: true,
+  refresh_token: <Existing refresh token>
+)
+c.access_token # => returns new token
+```
+
+## Testing
+To run the test suite, save the following in redox_keys.yml in the test/directory (already in the .gitignore for your convenience):
+
+```yaml
+api_key: <Your RedoxEngine API Key>
+secret: <Your RedoxEngine API Secret>
+
+source_data:
+  Name: <RedoxEngine Source Name>
+  ID: <RedoxEngine Source ID>
+
+destinations_data:
+  ClinicalSummary: 
+    Name: <Destination Name>
+    ID: <Destination ID>
+  PatientAdmin:
+    Name: <Destination Name>
+    ID: <Destination ID>
+  Scheduling:
+    Name: <Destination Name>
+    ID: <Destination ID>
+  PatientSearch:
+    Name: <Destination Name>
+    ID: <Destination ID>
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/WeInfuse/redox.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'redox'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/core_ext/hash.rb

@@ -0,0 +1,53 @@
+# Help us deal with hashes with various key shapes/types
+class Hash
+  # recursively transform keys/values according to a given block
+  def transform_keys(&block)
+    map do |key, value|
+      [
+        yield(key),
+        transform_value(value, &block)
+      ]
+    end.to_h
+  end
+
+  # recursively transform values that contain a data structure,
+  # return the value if it isn't a hash
+  def transform_value(value, &block)
+    if value.respond_to?(:each_index)
+      value.map do |elem|
+        elem.transform_keys(&block) rescue elem
+      end
+    else
+      value.transform_keys(&block) rescue value
+    end
+  end
+
+  # Rails method, find at
+  # activesupport/lib/active_support/core_ext/hash/keys.rb, line 50
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # transform camel_case (symbol) keys to RedoxCase string keys
+  def redoxify_keys
+    transform_keys do |key|
+      key = key[0..-1]
+      next 'IDType' if %w[id_type IDType].include? key
+      next key if key =~ /^([A-Z]{1}[a-z]+)+/
+      next key.upcase if key =~ /^[A-Za-z]{2,3}$/
+      key.split('_').map(&:capitalize).join
+    end
+  end
+
+  # transform RedoxCase string keys to ruby symbol keys
+  def rubyize_keys
+    transform_keys do |key|
+      key
+        .to_s
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase
+        .to_sym
+    end
+  end
+end

data/lib/redox-engine.rb

@@ -0,0 +1,24 @@
+require 'core_ext/hash'
+require 'redox-engine/version'
+require 'redox-engine/util'
+require 'redox-engine/request_helpers'
+require 'redox-engine/exceptions'
+require 'redox-engine/client'
+require 'redox-engine/patient'
+require 'redox-engine/visit'
+require 'json'
+require 'net/http'
+require 'uri'
+
+# a set of Ruby classes for RedoxEngine HTTP API interactions
+module RedoxEngine
+  API_URL = URI.parse('https://api.redoxengine.com/')
+  class << self
+    attr_accessor :api_key, :secret
+  end
+
+  def self.configure
+    yield self
+    true
+  end
+end

data/lib/redox-engine/client.rb

@@ -0,0 +1,154 @@
+module RedoxEngine
+  # RedoxEngine API client
+  class Client
+    include RequestHelpers
+
+    attr_reader(
+      :source, :destinations, :test,
+      :access_token, :refresh_token, :response
+    )
+    # Instantiates a new RedoxEngine Client object
+    #
+    # @param [Hash] source source information
+    # @param [Array<Hash>] destinations list of destinations
+    # @param [Boolean] test_mode whether to use test mode
+    # @param [String] access_token Optional param to provide an existing Access
+    #                 Token
+    # @param [String] refresh_token Optional param to provide an existing
+    #                 Refresh Token
+    # @example
+    #   redox = RedoxEngine::Client.new(
+    #     source: source,
+    #     destinations: destinations,
+    #     test_mode: true,
+    #     OPTIONAL: (If tokens/refresh_tokens are being persisted elsewhere)
+    #     token: (existing access token),
+    #     refresh_token: (existing refresh token)
+    #   )
+    def initialize(
+      source:, destinations:, test_mode: true, token: nil, refresh_token: nil
+    )
+      raise APIKeyError if [RedoxEngine.api_key, RedoxEngine.secret].any?(&:nil?)
+      @refresh_token = refresh_token
+      @access_token = token || fetch_access_token
+
+      @source = source
+      @destinations = destinations
+      @test = test_mode
+    end
+
+    # Send PatientAdmin#NewPatient message
+    #
+    # @param [Hash] patient_params data to send in the Patient JSON object
+    # @return [Hash] parsed response object
+    # @example
+    #   RedoxEngine::Client.new(*connection_params).add_patient(
+    #     Identifiers: [],
+    #     Demographics: {
+    #       FirstName: 'Joe'
+    #     }
+    #   )
+    def add_patient(patient_params)
+      request_body = request_meta(
+        data_model: 'PatientAdmin',
+        event_type: 'NewPatient'
+      ).merge(Patient: patient_params.redoxify_keys)
+      handle_request(request_body, 'Error in Patient New.')
+    end
+
+    # Send PatientAdmin#PatientUpdate message
+    #
+    # @param [Hash] patient_params data to send in the Patient JSON object
+    # @return [Hash] parsed response object
+    # @example
+    #   RedoxEngine::Client.new(*connection_params).update_patient(
+    #     Identifiers: [],
+    #     Demographics: {
+    #       FirstName: 'Joe'
+    #     }
+    #   )
+    def update_patient(patient_params)
+      request_body = request_meta(
+        data_model: 'PatientAdmin',
+        event_type: 'PatientUpdate'
+      ).merge(Patient: patient_params.redoxify_keys)
+      handle_request(request_body, 'Error updating Patient.')
+    end
+
+    # Send PatientSearch#Query message
+    #
+    # @param [Hash] patient_params data to send in the Patient JSON object
+    # @return [Hash] parsed response object
+    # @example
+    #   RedoxEngine::Client.new(*connection_params).search_patient(
+    #     demographics: {
+    #       FirstName: 'Joe'
+    #       ...
+    #     }
+    #   )
+    def search_patient(patient_params)
+      request_body = request_meta(
+        data_model: 'PatientSearch',
+        event_type: 'Query'
+      ).merge(Patient: patient_params.redoxify_keys)
+      handle_request(request_body, 'Error in Patient Search.')
+    end
+
+    # Send ClinicalSummary#PatientQuery message
+    #
+    # @param [Hash] patient_params data to send in the Patient JSON object
+    # @return [Hash] parsed response object
+    # @example
+    #   RedoxEngine::Client.new(*connection_params).search_patient(
+    #     identifiers: [
+    #       {
+    #         id: '4681'
+    #         id_type: 'AthenaNet Enterprise ID'
+    #       }
+    #     ]
+    #   )
+    def get_summary_for_patient(patient_params)
+      request_body = request_meta(
+        data_model: 'Clinical Summary',
+        event_type: 'PatientQuery'
+      ).merge(Patient: patient_params.redoxify_keys)
+      handle_request(
+        request_body,
+        'Error fetching Patient Clinical Summary'
+      )
+    end
+
+    # Send Scheduling#BookedSlots message
+    #
+    # @param [Hash] visit data to send in the Visit JSON object
+    # @param [String|Time] start_time datetime to search from
+    # @params [String|Time] end_time datetime to search until
+    # @return [Hash] parsed response object
+    # @example
+    #   RedoxEngine::Client.new(*connection_params).get_booked_slots(
+    #     visit: {
+    #       reason?: string
+    #       attending_providers: Provider[]
+    #       location: {
+    #         type: string
+    #         facility: string
+    #         department: string | number
+    #         room: string | number
+    #       }
+    #     }
+    #    start_time?: Time | String (ISO-8601 Time String)
+    #    end_time?: Time | String (ISO-8601 Time String)
+    # )
+    def get_booked_slots(visit:, start_time: nil, end_time: nil)
+      request_body = scheduling_query(
+        visit: visit,
+        start_time: start_time,
+        end_time: end_time
+      )
+      handle_request(
+        request_body,
+        'Error fetching Booked Slots'
+      )
+    end
+  end
+end

data/lib/redox-engine/exceptions.rb

@@ -0,0 +1,9 @@
+module RedoxEngine
+  # Exceptions used in this gem will be defined here
+
+  # raise this on errors obtaining an access token
+  class TokenError < StandardError; end
+
+  # raise this on RedoxEngine::Client.new without setting api_key/secret
+  class APIKeyError < StandardError; end
+end

data/lib/redox-engine/patient.rb

@@ -0,0 +1,9 @@
+module RedoxEngine
+  # Serialize the Patient response object from RedoxEngine
+  class Patient
+    include Util
+    def initialize(patient_hash)
+      map_hash_to_attributes(patient_hash.rubyize_keys)
+    end
+  end
+end

data/lib/redox-engine/request_helpers.rb

@@ -0,0 +1,91 @@
+module RedoxEngine
+  # module to abstract request helper methods out of the client class
+  module RequestHelpers
+    private
+
+    def handle_request(request_body, error_message)
+      request = Net::HTTP::Post.new('/endpoint', auth_header)
+      request.body = request_body.to_json
+      @response = connection.request(request)
+      body = JSON.parse(response.body).rubyize_keys
+      if @response.code == '400'
+        $stdout.print error_message
+        return body[:meta]
+      end
+
+      body
+    end
+
+    def auth_header
+      {
+        'Authorization' => "Bearer #{access_token}",
+        'Content-Type' => 'application/json'
+      }
+    end
+
+    def request_meta(data_model:, event_type:)
+      {
+        meta: {
+          data_model: data_model,
+          event_type: event_type,
+          event_date_time: Time.now.iso8601,
+          test: @test,
+          source: @source,
+          destinations: find_destination(data_model)
+        }
+      }.redoxify_keys
+    end
+
+    def scheduling_query(visit:, start_time: nil, end_time: nil)
+      start_time = start_time ? Time.parse(start_time.to_s) : Time.now
+      end_time = end_time ? Time.parse(end_time.to_s) : start_time + 864_000
+      request_meta(data_model: 'Scheduling', event_type: 'Booked')
+        .merge(
+          visit: visit,
+          start_date_time: start_time.iso8601,
+          end_date_time: end_time.iso8601
+        )
+        .redoxify_keys
+    end
+
+    def login_request(refresh_token = nil)
+      req_url = refresh_token ? '/auth/refreshToken' : '/auth/authenticate'
+      req = Net::HTTP::Post.new(req_url, 'Content-Type' => 'application/json')
+      req_body = { apiKey: RedoxEngine.api_key }
+      if refresh_token
+        req_body[:refreshToken] = refresh_token
+      else
+        req_body[:secret] = RedoxEngine.secret
+      end
+      req.body = req_body.to_json
+      req
+    end
+
+    def fetch_access_token
+      return @access_token if defined? @access_token
+
+      response = connection.request(login_request(@refresh_token))
+      code = response.code.to_i
+      raise TokenError, 'Error obtaining token' unless code >= 200 && code < 400
+      body = JSON.parse(response.body)
+      @refresh_token = body['refreshToken']
+
+      body['accessToken']
+    end
+
+    def connection
+      return @connection if defined? @connection
+
+      http = Net::HTTP.new(API_URL.host, API_URL.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.verify_depth = 5
+
+      @connection = http
+    end
+
+    def find_destination(destination_name)
+      [@destinations[destination_name.split(' ').join.to_sym]]
+    end
+  end
+end

data/lib/redox-engine/util.rb

@@ -0,0 +1,13 @@
+module RedoxEngine
+  # utility methods for serializing responses
+  module Util
+    def map_hash_to_attributes(hash)
+      hash.map do |key, val|
+        define_singleton_method(key.to_sym) do
+          val
+        end
+        map_hash_to_attributes(val) if val.respond_to? :each_key
+      end
+    end
+  end
+end

data/lib/redox-engine/version.rb

@@ -0,0 +1,3 @@
+module RedoxEngine
+  VERSION = '0.1.3'.freeze
+end

data/lib/redox-engine/visit.rb

@@ -0,0 +1,9 @@
+module RedoxEngine
+  # Serialize the Visit response object from RedoxEngine
+  class Visit
+    include Util
+    def initialize(visit_hash)
+      map_hash_to_attributes(visit_hash.rubyize_keys)
+    end
+  end
+end

data/redox-engine.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redox-engine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'redox-engine'
+  spec.version       = RedoxEngine::VERSION
+  spec.authors       = ['Alexander Clark (forked from)', 'Pedro De Ona']
+  spec.email         = ['p.deona2005@gmail.com']
+  spec.licenses      = ['MIT']
+  spec.summary       = 'Ruby wrapper for the RedoxEngine Engine API'
+  spec.homepage      = 'https://github.com/pdeona/redox'
+
+  # Prevent pushing this gem to RubyGems.org.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.1'
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rubocop', '~> 0.5'
+  spec.add_development_dependency 'vcr', '~> 4.0'
+  spec.add_development_dependency 'webmock', '~> 3.1'
+  spec.add_development_dependency 'yard', '~> 0.9'
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: redox-engine
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Alexander Clark (forked from)
+- Pedro De Ona
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email:
+- p.deona2005@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".editorconfig"
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/core_ext/hash.rb
+- lib/redox-engine.rb
+- lib/redox-engine/client.rb
+- lib/redox-engine/exceptions.rb
+- lib/redox-engine/patient.rb
+- lib/redox-engine/request_helpers.rb
+- lib/redox-engine/util.rb
+- lib/redox-engine/version.rb
+- lib/redox-engine/visit.rb
+- redox-engine.gemspec
+homepage: https://github.com/pdeona/redox
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for the RedoxEngine Engine API
+test_files: []