microsoft-graph-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 681f5c337d3be9042df1a0bc986a4dab043d9ce4710e802542f04a6f08dcf0f9
+  data.tar.gz: 0bfd2956c6f8cef9c213d0a6ffb5f24760ae36156491586446d1464cdb7fdd88
+SHA512:
+  metadata.gz: d3ac2c34280ba8befb56971b92815e2373a4d9e7f76565a8b28e5c590814a587faec2abecaf41585e020a2c87b2ab30bba1058ab0ee2cff351a352d7dcc0aa9d
+  data.tar.gz: 3e0525b30a394e7084369ae8bfd6acd24cdbef1597c74ff80570797981bf7a42c68f494f5be4a946cb63816b7633556556d00edae5b7bab5f7b636e82fcb17de

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,39 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: enable
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/RegexpLiteral:
+  EnforcedStyle: slashes
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 30
+  CountAsOne: ['array', 'hash', 'heredoc']
+
+Layout/FirstArgumentIndentation:
+  EnforcedStyle: consistent
+
+Layout/FirstHashElementIndentation:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120

data/.ruby-gemset

@@ -0,0 +1 @@
+microsoft-graph

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.0.1

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 3.0.1
+before_install: gem install bundler -v 2.2.15

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2021-09-16
+- Initial release
+- Supports batched and single calls to the Graph API

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in microsoft-graph.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "httparty"
+gem "rubocop", "~> 1.7"
+
+group :test do
+  gem "awesome_print"
+  gem "vcr"
+  gem "webmock"
+end

data/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    microsoft-graph-client (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.2)
+    awesome_print (1.9.2)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.4.4)
+    hashdiff (1.0.1)
+    httparty (0.19.0)
+      mime-types (~> 3.0)
+      multi_xml (>= 0.5.2)
+    mime-types (3.3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2021.0901)
+    multi_xml (0.6.0)
+    parallel (1.21.0)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    public_suffix (4.0.6)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    rubocop (1.21.0)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.9.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.11.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.1.0)
+    vcr (6.0.0)
+    webmock (3.14.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-darwin-20
+
+DEPENDENCIES
+  awesome_print
+  httparty
+  microsoft-graph-client!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.7)
+  vcr
+  webmock
+
+BUNDLED WITH
+   2.2.15

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Kirill Klimuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,215 @@
+# Microsoft::Graph
+
+This is a [Microsoft Graph](https://docs.microsoft.com/en-us/graph/overview) client gem, since the official client library is [not supported](https://github.com/microsoftgraph/msgraph-sdk-ruby).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "microsoft-graph-client"
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install microsoft-graph
+
+## Usage
+
+The gem supports both individual calls to the API. To issue either of these calls, it's important to initialize the Graph 
+with the access token.
+
+To get the authentication token, it's recommended to use the [Windows Azure Active Directory Authentication Library](https://github.com/AzureAD/azure-activedirectory-library-for-ruby) (ADAL) if you're building a console app.
+You will have to [register the app](https://docs.microsoft.com/en-us/azure/active-directory/develop/quickstart-v2-netcore-daemon#register-and-download-the-app) and add permissions.
+
+Here's some sample code to get you started:
+
+```ruby
+username      = 'admin@tenant.onmicrosoft.com'
+password      = 'xxxxxxxxxxxx'
+client_id     = 'xxxxx-xxxx-xxx-xxxxxx-xxxxxxx'
+client_secret = 'xxxXXXxxXXXxxxXXXxxXXXXXXXXxxxxxx='
+tenant        = 'tenant.onmicrosoft.com'
+user_cred     = ADAL::UserCredential.new(username, password)
+client_cred   = ADAL::ClientCredential.new(client_id, client_secret)
+context       = ADAL::AuthenticationContext.new(ADAL::Authority::WORLD_WIDE_AUTHORITY, tenant)
+resource      = "https://graph.microsoft.com"
+tokens        = context.acquire_token_for_user(resource, client_cred, user_cred)
+
+graph = Microsoft::Graph.new(token: tokens.access_token)
+```
+
+### Individual API Calls
+To make individual calls, you can use the `#call` instance method on `Microsoft::Graph`:
+
+`Microsoft::Graph#call(endpoint, method: "GET", headers: {}, params: nil, body: nil)`
+- `endpoint` - the URL of the API without the version as a string. For example: `/me`.
+- `method` - the preferred HTTP method as a string.
+- `headers` - a hash of additional headers. `Microsoft::Graph` adds the appropriate JSON headers.
+- `body` - the body, as a hash. The keys of the body will be converted from snake-case to camel-case when sent (i.e. `number_format` to `numberFormat`). 
+
+As a syntactic sugar, `Microsoft::Graph` exposes the 5 HTTP methods as instance methods:
+- `GET` - `#get`
+- `POST`- `#post`
+- `PUT`- `#put`
+- `PATCH`- `#patch`
+- `DELETE`- `#delete`
+
+There are two additional quality of life features for Ruby
+- You can pass the request body's keys in snake-case.
+- The response will convert the API's camel-cased response to snake-case.
+
+Below are a couple of examples:
+```ruby
+# Get a signed in user
+# https://docs.microsoft.com/en-us/graph/api/user-get?view=graph-rest-1.0&tabs=http
+graph.get("/me")
+# alternatively
+graph.call("/me", method: "GET")
+
+# sample response - Microsoft::Graph converts the response keys to be snake-cased
+# Microsoft::Graph::JSONStruct {
+#   "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users/$entity",
+#   display_name: "Kirill Klimuk",
+#   surname: "Klimuk",
+#   given_name: "Kirill",
+#   id: "89d5fafe0adc70ee",
+#   user_principal_name: "kklimuk@gmail.com" 
+# }
+```
+
+```ruby
+# update an excel worksheet
+# https://docs.microsoft.com/en-us/graph/api/range-update?view=graph-rest-1.0&tabs=http
+graph.patch("/me/drive/items/89D5FAFE0ADC70EA!106/workbook/worksheets/Sheet1/range(address='A56:B57')", body: {
+  values: [%w[Hello 100], ["1/1/2016", nil]],
+  formulas: [[nil, nil], [nil, "=B56*2"]],
+  number_format: [[nil, nil], ["m-ddd", nil]] # in the API docs, this is described as numberFormat, but Microsoft::Graph allows you to use snake-cased keys
+})
+# alternatively
+graph.call(
+  "/me/drive/items/89D5FAFE0ADC70EA!106/workbook/worksheets/Sheet1/range(address='A56:B57')", 
+  method: "PATCH",
+  body: {
+    values: [%w[Hello 100], ["1/1/2016", nil]],
+    formulas: [[nil, nil], [nil, "=B56*2"]],
+    number_format: [[nil, nil], ["m-ddd", nil]] # in the API docs, this is described as numberFormat, but Microsoft::Graph allows you to use snake-cased keys
+  }
+)
+
+# sample response - Microsoft::Graph converts the response keys to be snake-cased
+# Microsoft::Graph::JSONStruct {
+#   "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#workbookRange",
+#   "@odata.type": "#microsoft.graph.workbookRange",
+#   "@odata.id": "/users('kklimuk%40gmail.com')/drive/items('89D5FAFE0ADC70EA%21106')/workbook/worksheets(%27%7B84FABE00-2D27-A843-B953-03E854DFA415%7D%27)/range(address=%27A56:B57%27)",
+#   address: "Sheet1!A56:B57",
+#   address_local: "Sheet1!A56:B57",
+#   column_count: 2,
+#   cell_count: 4,
+#   column_hidden: false,
+#     row_hidden: false,
+#     number_format: [
+#     %w[General General],
+#     %w[m-ddd General]
+#   ],
+#   column_index: 0,
+#   text: [
+#     %w[Hello 100],
+#     %w[1-Fri 200]
+#   ],
+#   formulas: [
+#     [
+#       "Hello",
+#       100
+#     ],
+#     [
+#       42_370,
+#       "=B56*2"
+#     ]
+#   ],
+#   formulas_local: [
+#     [
+#       "Hello",
+#       100
+#     ],
+#     [
+#       42_370,
+#       "=B56*2"
+#     ]
+#   ],
+#   formulas_r1c1: [
+#     [
+#       "Hello",
+#       100
+#     ],
+#     [
+#       42_370,
+#       "=R[-1]C*2"
+#     ]
+#   ],
+#   hidden: false,
+#     row_count: 2,
+#   row_index: 55,
+#   value_types: [
+#     %w[String Double],
+#     %w[Double Double]
+#   ],
+#   values: [
+#     [
+#       "Hello",
+#       100
+#     ],
+#     [
+#       42_370,
+#       200
+#     ]
+#   ]
+# }
+```
+
+If an error occurs, an error will be thrown. You can inspect the error via its `response` method.
+
+### Batched API Calls
+Microsoft has rolled out a way to send the graph [multiple requests in one](https://docs.microsoft.com/en-us/graph/json-batching).
+As a result, this client library supports it out of the box with the `#batch` instance method.
+
+Here's an example that combines both of our individual calls into a single batched call.
+```ruby
+graph.batch do |batch|
+    batch.add("/me", id: "abc", method: "GET")
+    batch.add(
+      "/me/drive/items/89D5FAFE0ADC70EA!106/workbook/worksheets/Sheet1/range(address='A56:B57')",
+      id: "def",
+      method: "PATCH",
+      body: {
+        values: [%w[Hello 100], ["1/1/2016", nil]],
+        formulas: [[nil, nil], [nil, "=B56*2"]],
+        number_format: [[nil, nil], ["m-ddd", nil]]
+      }
+    )
+end
+```
+
+Please note: the current maximum number of calls in a single request is 20 according to Microsoft's docs.
+The `#batch` method will group requests into batches of 20 to not violate this rule.
+
+The output of the request will be an array of `Microsoft::Graph::Batch::Result`, which have both a `request` and `result` properties.
+You can find the relevant result by searching for the request `id` you have passed in. 
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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 the created tag, 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/kklimuk/microsoft-graph.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "microsoft/graph"
+
+# 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(__FILE__)

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/microsoft/graph/batch.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Microsoft
+  class Graph
+    class Batch
+      attr_reader :requests
+
+      def initialize(graph, token:, size: 20)
+        @graph = graph
+        @requests = []
+        @token = token
+        @size = size
+      end
+
+      def add(endpoint, id: SecureRandom.uuid, method: "GET", headers: {}, params: nil, body: nil, depends_on: nil)
+        @requests << Request.new(
+          endpoint,
+          id: id,
+          method: method,
+          headers: headers,
+          params: params,
+          body: body,
+          depends_on: depends_on
+        )
+      end
+
+      def call
+        @requests.each_slice(@size).flat_map do |group|
+          requests_by_id = group.group_by(&:id).transform_values(&:first)
+          group.first.depends_on = nil
+
+          response = @graph.call("/$batch", method: "POST", token: @token, body: { requests: group.map(&:to_h) })
+          response.responses.map do |current|
+            Result.new(request: requests_by_id[current.id], response: current)
+          end
+        end
+      end
+
+      class Request
+        def self.parser
+          @parser ||= URI::Parser.new
+        end
+
+        def self.body_formatter
+          @body_formatter ||= Microsoft::Graph::BodyFormatter.new
+        end
+
+        attr_reader :id, :endpoint, :method, :headers, :body
+        attr_accessor :depends_on
+
+        def initialize(endpoint, id:, method:, headers:, params:, body:, depends_on:)
+          @id = id
+          @endpoint = "#{self.class.parser.escape(endpoint)}#{params ? "?#{params.to_query}" : ""}"
+          @method = method.upcase
+          @headers = headers
+          @headers[:Accept] = "application/json" if body
+          @headers[:"Content-Type"] = "application/json" if body
+          @body = body
+          @depends_on = depends_on
+        end
+
+        def to_h
+          hash = {
+            id: @id,
+            url: @endpoint,
+            method: @method
+          }
+          hash[:headers] = @headers unless @headers.empty?
+          hash[:body] = self.class.body_formatter.call(@body, method: @method) if @body
+          hash[:dependsOn] = [@depends_on] if @depends_on
+
+          hash
+        end
+      end
+
+      class Result
+        attr_reader :request, :response
+
+        def initialize(request:, response:)
+          @request = request
+          @response = response
+        end
+      end
+    end
+  end
+end

data/lib/microsoft/graph/body_formatter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Microsoft
+  class Graph
+    class BodyFormatter
+      def call(body, method:)
+        return nil unless Microsoft::Graph::BODY_METHODS.include?(method)
+        return nil unless body
+
+        body.transform_keys(&method(:camelize))
+      end
+
+      private
+
+      def camelize(key)
+        string = key.to_s
+        return string unless string.include?("_")
+
+        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/, &:downcase)
+        string.gsub(%r{(?:_|(/))([a-z\d]*)}) do
+          "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}"
+        end.gsub("/", "::")
+      end
+    end
+  end
+end

data/lib/microsoft/graph/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Microsoft
+  class Graph
+    VERSION = "0.1.0"
+  end
+end

data/lib/microsoft/graph.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "securerandom"
+require_relative "graph/version"
+require_relative "graph/batch"
+require_relative "graph/body_formatter"
+
+module Microsoft
+  class Graph
+    GRAPH_HOST = "https://graph.microsoft.com"
+    BODY_METHODS = %w[POST PUT PATCH].freeze
+    ALLOWED_METHODS = [*BODY_METHODS, "GET", "DELETE"].freeze
+
+    def initialize(token: nil, error_handler: method(:error_handler), version: "1.0")
+      @token = token
+      @parser = URI::Parser.new
+      @body_formatter = Microsoft::Graph::BodyFormatter.new
+      @error_handler = error_handler
+      @version = version
+    end
+
+    # stubs
+    def get(*); end
+
+    def post(*); end
+
+    def put(*); end
+
+    def patch(*); end
+
+    def delete(*); end
+
+    ALLOWED_METHODS.each do |method|
+      define_method(method.downcase) { |*args, **kwargs| call(*args, method: method, **kwargs) }
+    end
+
+    def call(endpoint, token: @token, method: "GET", headers: {}, params: nil, body: nil)
+      method = method.upcase
+      raise ArgumentError, "`#{method}` is not a valid HTTP method." unless ALLOWED_METHODS.include?(method)
+
+      url = URI.join(GRAPH_HOST, @parser.escape("v#{@version}/#{endpoint.gsub(%r{^/}, "")}"))
+      headers = headers.merge(
+        Authorization: "Bearer #{token}",
+        Accept: "application/json"
+      )
+      headers[:"Content-Type"] = "application/json" if BODY_METHODS.include?(method)
+
+      response = HTTParty.send(
+        method.downcase,
+        url,
+        headers: headers,
+        query: params,
+        body: @body_formatter.call(body, method: method).to_json,
+        parser: InstanceParser
+      )
+
+      case response.code
+      when 200...400
+        response.parsed_response
+      when 400...600
+        error = Error.new(
+          "Received status code: #{response.code}. Check the `response` attribute for more details.",
+          response.parsed_response,
+          response.code
+        )
+        @error_handler.call(error)
+      else
+        raise "Unknown status code: #{response.code}"
+      end
+    end
+
+    def batch(token: @token)
+      batch = Batch.new(self, token: token)
+      yield batch
+      batch.call
+    end
+
+    def error_handler(error)
+      raise error
+    end
+
+    class Error < StandardError
+      attr_reader :response
+
+      def initialize(message, response = nil, _code = nil)
+        @response = response
+        super message
+      end
+    end
+
+    class InstanceParser < HTTParty::Parser
+      def parse
+        return nil unless body
+
+        JSON.parse(body, object_class: JSONStruct)
+      end
+    end
+
+    class JSONStruct < OpenStruct
+      def self.format(key)
+        HTTParty::Response.underscore(key.to_s).to_sym
+      end
+
+      def initialize(hash = {})
+        super nil
+        hash.each do |key, value|
+          self[key] = value
+        end
+      end
+
+      def []=(key, value)
+        formatted_key = self.class.format(key)
+        super formatted_key, value
+      end
+    end
+  end
+end

data/microsoft-graph.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/microsoft/graph/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "microsoft-graph-client"
+  spec.version = Microsoft::Graph::VERSION
+  spec.authors = ["Kirill Klimuk"]
+  spec.email = ["kklimuk@gmail.com"]
+
+  spec.summary = "Access the Microsoft Graph API."
+  # spec.description   = "TODO: Write a longer description or delete this line."
+  # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: microsoft-graph-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kirill Klimuk
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-09-21 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- kklimuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/microsoft/graph.rb
+- lib/microsoft/graph/batch.rb
+- lib/microsoft/graph/body_formatter.rb
+- lib/microsoft/graph/version.rb
+- microsoft-graph.gemspec
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: Access the Microsoft Graph API.
+test_files: []