spearly-sdk-ruby 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ea587fbe14cca4cebc1b12a299ee8ddaa5c64df3c50f51ff4989b1d18094990
-  data.tar.gz: 14e9537659004b0e52c193a4f0708407b31d2d9f77909352326351fb8f87329c
+  metadata.gz: ffd3333dfa37f250288b37eb593db42db89846aa436397371c403a20ec9fe5e9
+  data.tar.gz: d1b0eeab87ff53e34bbd1b7c00b8b691e679823c2b09ad5df713003691349d7a
 SHA512:
-  metadata.gz: 60dae3572451b45f445cd4ee7487ddeec830bc274e9dead7264a007babc6491732fb4bd1cac5e11e5caa2c2a8a5a8e5fca7f7086bd729dbe356e918113e3b16c
-  data.tar.gz: 94a932fdc203d988badf93296cef0fd808d08abe0856903ffc85aca5210d58f28e1d5de6bbc1cb19447696cbebca0e9c10ef3f91462684fc2d99854ca18498ce
+  metadata.gz: 0e1a2419d6013bac9e3adbb347afd731fc04a9b1a85c87c41e11c7fbec6ade89db3ca2b3d54adfe5c9a1720a680e22968a1df5960901e2cf76cc29d2e1bf9b85
+  data.tar.gz: 3c19e93be4e91f9cc17333a5d4a7d7233f678a4a5b9db393bb5122c26ea1a5d2d4df3d2a3848b177097e606938270519a3e2a3ede0b232af40219bda848e39aa

data/.github/workflows/main.yml

@@ -1,16 +1,21 @@
 name: Ruby
-on: [push]
+on:
+  push:
+    branches:
+      - '**'
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Setup Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.7.7
+        ruby-version: 3.1.4
+
     - name: Run the default task
       run: |
-        gem install bundler -v 2.3.26
         bundle install
         bundle exec rake

data/.rubocop.yml

@@ -2,7 +2,7 @@ require:
   - rubocop-rspec
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 2.7
+  TargetRubyVersion: 3.1
   Exclude:
     - 'bin/**/*'
 Layout/EmptyLineBetweenDefs:
@@ -16,6 +16,8 @@ Metrics/ClassLength:
   Enabled: false
 Metrics/MethodLength:
   Enabled: false
+Naming/AccessorMethodName:
+  Enabled: false
 RSpec/BeNil:
   EnforcedStyle: 'be'
 RSpec/ExampleLength:

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.11.1] - 2023-09-27
+
+- Implement a reader for `Spearly::Auth::Client#token` [#18](https://github.com/unimal-jp/spearly-sdk-ruby/pull/18)
+
+## [0.11.0] - 2023-09-23
+
+- Throw errors `from Spearly::Auth` methods [#15](https://github.com/unimal-jp/spearly-sdk-ruby/pull/15)
+- `Spearly::Auth::Client` refactors [#14](https://github.com/unimal-jp/spearly-sdk-ruby/pull/14)
+- Upgrade Ruby to 3.1.4 [#13](https://github.com/unimal-jp/spearly-sdk-ruby/pull/13)
+- Remove deprecated classes and helpers [#12](https://github.com/unimal-jp/spearly-sdk-ruby/pull/12)
+
 ## [0.10.0] - 2022-12-05
 
 - `Spearly::Auth::Client#get_team_subscriptions()`

data/Gemfile

@@ -3,4 +3,11 @@
 source 'https://rubygems.org'
 gemspec
 
-gem 'rails', '>= 6.0', '< 7.1'
+group :development do
+  gem 'bundler-audit', '~> 0.9'
+  gem 'fuubar', '~> 2.5'
+  gem 'pry', '~> 0.13'
+  gem 'rspec', '~> 3.10'
+  gem 'rubocop', '~> 1.15'
+  gem 'rubocop-rspec', '~> 2.3'
+end

data/README.md

@@ -50,7 +50,7 @@ git push origin --tags
 ## Publish
 ### Build
 ```sh
-rake build
+bundle exec rake build
 ```
 
 ### Push to RubyGems

data/Rakefile

@@ -7,6 +7,8 @@ RSpec::Core::RakeTask.new(:spec)
 
 require 'rubocop/rake_task'
 
-RuboCop::RakeTask.new
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['--autocorrect-all']
+end
 
 task default: %i[spec rubocop]

data/lib/spearly/auth/authorizer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'signet/oauth_2/client'
-require 'active_support/core_ext/hash/indifferent_access'
 
 module Spearly
   module Auth

data/lib/spearly/auth/client.rb

@@ -1,176 +1,53 @@
 # frozen_string_literal: true
 
+require_relative 'team_member'
+require_relative 'team_subscription'
+require_relative 'team'
+require_relative 'token'
+require_relative 'user'
+
 module Spearly
   module Auth
     class Client
-      def initialize(token)
-        @token = token
-      end
-
-      def get_user(user_id)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/users/#{user_id}"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(uri_parsed,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        if res.status == 200
-          JSON.parse(res.body)['data']
-        else
-          {}
-        end
-      end
-
-      def create_team(params)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.post(uri_parsed,
-                          params.as_json,
-                          'Accept' => 'application/vnd.spearly.v2+json',
-                          'Authorization' => @token)
-
-        case res.status
-        when 201
-          JSON.parse(res.body)['data']
-        when 422
-          JSON.parse(res.body)
-        else
-          {}
-        end
-      end
-
-      def get_team(team_id)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(uri_parsed,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        if res.status == 200
-          JSON.parse(res.body)['data']
-        else
-          {}
-        end
-      end
-
-      def get_teams(params = {})
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(uri_parsed,
-                         params.as_json,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        if res.status == 200
-          JSON.parse(res.body)['data']
-        else
-          []
-        end
-      end
-
-      def update_team(team_id, params)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.put(uri_parsed,
-                         params.as_json,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        return unless res.status == 200
-
-        JSON.parse(res.body)['data']
-      end
-
-      def regenerate_team_api_access_token(team_id)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}/regenerate_api_access_token"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.post(uri_parsed,
-                          nil,
-                          'Accept' => 'application/vnd.spearly.v2+json',
-                          'Authorization' => @token)
-
-        return unless res.status == 200
-
-        JSON.parse(res.body)['data']
-      end
-
-      def invite_user_to_team(team_id, params)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}/invite"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
+      include Team
+      include TeamMember
+      include TeamSubscription
+      include Token
+      include User
 
-        res = client.post(uri_parsed,
-                          params.as_json,
-                          'Accept' => 'application/vnd.spearly.v2+json',
-                          'Authorization' => @token)
+      attr_reader :token
 
-        return unless res.status == 201
+      def initialize(token)
+        @token = token
 
-        JSON.parse(res.body)['data']
+        base_url = ENV.fetch('SPEARLY_API_URL', nil)
+        @client = Faraday.new(base_url)
       end
 
-      def get_team_members(team_id)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}/members"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
+      def run_request(method:, path:, params: nil)
+        path_parsed = Addressable::URI.parse(path).normalize.to_s
 
-        res = client.get(uri_parsed,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        if res.status == 200
-          JSON.parse(res.body)['data']
-        else
-          []
-        end
+        @client.run_request(method.to_sym,
+                            path_parsed,
+                            params,
+                            'Accept' => 'application/vnd.spearly.v2+json',
+                            'Authorization' => @token)
+      rescue Faraday::ConnectionFailed => e
+        raise ServerError, e.message
       end
 
-      def get_team_features(team_id)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}/features"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(uri_parsed,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        if res.status == 200
-          JSON.parse(res.body)['data']
-        else
-          {}
-        end
-      end
-
-      def get_team_subscriptions(team_id, params)
-        uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams/#{team_id}/subscriptions"
-        uri_parsed = Addressable::URI.parse(uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(uri_parsed,
-                         params.as_json,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        if res.status == 200
-          JSON.parse(res.body)
+      def process_response(response)
+        case response.status
+        when 200, 201, 422
+          JSON.parse(response.body)
+        when 401
+          raise AuthorizationError, 'Unauthorized'
+        when 404
+          raise NotFoundError, 'Not Found'
+        when 503
+          raise ServiceUnavailableError, 'Service Unavailable'
         else
-          []
+          raise ServerError, 'Server Error'
         end
       end
     end

data/lib/spearly/auth/team.rb

@@ -2,27 +2,58 @@
 
 module Spearly
   module Auth
-    class Team
-      attr_reader :data
+    module Team
+      # POST /teams
+      def create_team(params)
+        response = run_request(
+          :method => :post,
+          path: '/teams',
+          params: params
+        )
 
-      def initialize(data)
-        @data = data
+        process_response(response)
       end
 
-      def method_missing(name, *_args)
-        @data[name.to_s]
+      # GET /teams/:team_id
+      def get_team(team_id)
+        response = run_request(
+          :method => :get,
+          path: "/teams/#{team_id}"
+        )
+
+        process_response(response)
       end
 
-      def respond_to_missing?(_name, *_args)
-        true
+      # GET /teams
+      def get_teams(params)
+        response = run_request(
+          :method => :get,
+          path: '/teams',
+          params: params
+        )
+
+        process_response(response)
       end
 
-      def to_json(*_args)
-        @data.to_json
+      # PUT /teams/:team_id
+      def update_team(team_id, params)
+        response = run_request(
+          :method => :put,
+          path: "/teams/#{team_id}",
+          params: params
+        )
+
+        process_response(response)
       end
 
-      def as_json
-        @data.as_json
+      # GET /teams/:team_id/regenerate_api_access_token
+      def regenerate_team_api_access_token(team_id)
+        response = run_request(
+          :method => :get,
+          path: "/teams/#{team_id}/regenerate_api_access_token"
+        )
+
+        process_response(response)
       end
     end
   end

data/lib/spearly/auth/team_member.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Spearly
+  module Auth
+    module TeamMember
+      # POST /teams/:team_id/invite
+      def invite_user_to_team(team_id, params)
+        response = run_request(
+          :method => :post,
+          path: "/teams/#{team_id}/invite",
+          params: params
+        )
+
+        process_response(response)
+      end
+
+      # GET /teams/:team_id/members
+      def get_team_members(team_id)
+        response = run_request(
+          :method => :get,
+          path: "/teams/#{team_id}/members"
+        )
+
+        process_response(response)
+      end
+    end
+  end
+end

data/lib/spearly/auth/team_subscription.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Spearly
+  module Auth
+    module TeamSubscription
+      # GET /teams/:team_id/subscriptions
+      def get_team_subscriptions(team_id, params)
+        response = run_request(
+          :method => :get,
+          path: "/teams/#{team_id}/subscriptions",
+          params: params
+        )
+
+        process_response(response)
+      end
+    end
+  end
+end

data/lib/spearly/auth/token.rb

@@ -1,61 +1,29 @@
 # frozen_string_literal: true
 
-require 'addressable/uri'
-require 'faraday'
-
 module Spearly
   module Auth
-    class Token
-      attr_reader :data, :token
-
-      def initialize(token)
-        @token = token
-      end
-
-      def method_missing(name, *_args)
-        @data[name.to_s]
+    module Token
+      # GET /oauth/token/info
+      def get_token_info
+        response = run_request(
+          :method => :get,
+          path: '/oauth/token/info'
+        )
+
+        process_response(response)
       end
 
-      def respond_to_missing?(_name, *_args)
-        true
-      end
-
-      def info
-        token_info_uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/oauth/token/info"
-        url = Addressable::URI.parse(token_info_uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(url,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        return unless res.status == 200
+      # POST /oauth/revoke
+      def revoke_token(params)
+        params[:token] = @token.gsub(/^Bearer /i, '')
 
-        @data = JSON.parse(res.body)
-      end
-
-      def revoke(params)
-        token_revoke_uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/oauth/revoke"
-        url = Addressable::URI.parse(token_revoke_uri).normalize.to_s
-        client = Faraday.default_connection
-
-        bearer_token = @token.gsub(/^Bearer /i, '')
-
-        client.post(url,
-                    {
-                      client_id: params[:client_id],
-                      client_secret: params[:client_secret],
-                      token: bearer_token
-                    })
-      end
-
-      def to_json(*_args)
-        @data.to_json
-      end
+        response = run_request(
+          :method => :post,
+          path: '/oauth/revoke',
+          params: params
+        )
 
-      def as_json
-        @data.as_json
+        process_response(response)
       end
     end
   end

data/lib/spearly/auth/user.rb

@@ -1,65 +1,27 @@
 # frozen_string_literal: true
 
-require 'addressable/uri'
-require 'faraday'
-
 module Spearly
   module Auth
-    class User
-      attr_reader :data
-
-      def initialize(token)
-        @token = token
-      end
-
-      def method_missing(name, *_args)
-        @data[name.to_s]
-      end
-
-      def respond_to_missing?(_name, *_args)
-        true
-      end
-
-      def find
-        user_profile_uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/profile"
-        url = Addressable::URI.parse(user_profile_uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(url,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        return unless res.status == 200
-
-        @data = JSON.parse(res.body)['data']
+    module User
+      # GET /users/:user_id
+      # requires SPEARLY_API_ACCESS_TOKEN as token
+      def get_user(user_id)
+        response = run_request(
+          :method => :get,
+          path: "/users/#{user_id}"
+        )
+
+        process_response(response)
       end
 
-      def teams
-        teams_uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/teams"
-        url = Addressable::URI.parse(teams_uri).normalize.to_s
-        client = Faraday.default_connection
-
-        res = client.get(url,
-                         nil,
-                         'Accept' => 'application/vnd.spearly.v2+json',
-                         'Authorization' => @token)
-
-        return [] unless res.status == 200
-
-        team_hashes = JSON.parse(res.body)['data']
-
-        team_hashes.map do |team_hash|
-          Spearly::Auth::Team.new(team_hash)
-        end
-      end
-
-      def to_json(*_args)
-        @data.to_json
-      end
+      # GET /profile
+      def get_profile
+        response = run_request(
+          :method => :get,
+          path: '/profile'
+        )
 
-      def as_json
-        @data.as_json
+        process_response(response)
       end
     end
   end

data/lib/spearly/auth.rb

@@ -2,20 +2,13 @@
 
 require_relative 'auth/authorizer'
 require_relative 'auth/client'
-require_relative 'auth/engine'
-require_relative 'auth/oauth_user'
-require_relative 'auth/team'
-require_relative 'auth/token'
-require_relative 'auth/user'
 
 module Spearly
   module Auth
     class Error < StandardError; end
     class AuthorizationError < Error; end
+    class NotFoundError < Error; end
     class ServerError < Error; end
-
-    module Rails
-      autoload :Helpers, 'spearly/auth/rails/helpers'
-    end
+    class ServiceUnavailableError < Error; end
   end
 end

data/lib/spearly/cloud/client.rb

@@ -7,13 +7,13 @@ module Spearly
         @token = token
       end
 
-      def get_sites(params = {})
+      def get_sites(params)
         uri = "#{ENV.fetch('SPEARLY_API_URL', nil)}/sites"
         uri_parsed = Addressable::URI.parse(uri).normalize.to_s
         client = Faraday.default_connection
 
         res = client.get(uri_parsed,
-                         params.as_json,
+                         params,
                          'Accept' => 'application/vnd.spearly.v2+json',
                          'Authorization' => @token)
 

data/lib/spearly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spearly
-  VERSION = '0.10.0'
+  VERSION = '0.11.1'
 end