scalingo 3.4.0 → 4.0.beta1

data/lib/scalingo/regional/environment.rb

@@ -2,82 +2,11 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Environment < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variables) { response }
-    end
-
-    def create(app_id, payload = {}, headers = nil, &block)
-      data = {variable: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variable) { response }
-    end
-
-    def update(app_id, variable_id, value, headers = nil, &block)
-      data = {variable: {value: value}}
-
-      response = connection.patch(
-        "apps/#{app_id}/variables/#{variable_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variable) { response }
-    end
-
-    def destroy(app_id, variable_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/variables/#{variable_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def bulk_update(app_id, variables, headers = nil, &block)
-      data = {variables: variables}
-
-      response = connection.put(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variables) { response }
-    end
-
-    def bulk_destroy(app_id, variable_ids, headers = nil, &block)
-      data = {variable_ids: variable_ids}
-
-      response = connection.delete(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "apps/{app_id}/variables"
+    post :create, "apps/{app_id}/variables", root_key: :variable
+    put :update, "apps/{app_id}/variables/{id}", root_key: :variable
+    delete :delete, "apps/{app_id}/variables/{id}"
+    put :bulk_update, "apps/{app_id}/variables", root_key: :variables
+    delete :bulk_destroy, "apps/{app_id}/variables", root_key: :variable_ids, params_as_body: true
   end
 end

data/lib/scalingo/regional/events.rb

@@ -1,55 +1,10 @@
 module Scalingo
   class Regional::Events < API::Endpoint
-    def all(payload = {}, headers = nil, &block)
-      data = payload.compact
-
-      response = connection.get(
-        "events",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:events) { response }
-    end
-
-    def for(app_id, payload = {}, headers = nil, &block)
-      data = payload.compact
-
-      response = connection.get(
-        "apps/#{app_id}/events",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:events) { response }
-    end
-
-    def types(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "event_types",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:event_types) { response }
-    end
-
-    def categories(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "event_categories",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:event_categories) { response }
+    get :list, "events{?query*}", optional: [:app_id, :query] do |req, params|
+      # Can't rely on URI templates if we need a static part depending on a dynamic one
+      req.path = "apps/#{params[:app_id]}/#{req.path}" if params[:app_id]
     end
+    get :types, "event_types"
+    get :categories, "event_categories"
   end
 end

data/lib/scalingo/regional/logs.rb

@@ -1,38 +1,20 @@
 module Scalingo
   class Regional::Logs < API::Endpoint
-    def get(url, payload = {}, headers = nil, &block)
-      data = payload.compact
+    get :archives, "apps/{app_id}/logs_archives"
 
-      response = connection(fallback_to_guest: true).get(
-        url,
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def archives(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/logs_archives",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:archives) { response }
+    def fetch(url, **params, &block)
+      request(:get, url, **params) do |req|
+        block&.call(req, params)
+        req.params[:n] = params[:n] if params[:n].present?
+      end
     end
 
     ## Helper method to avoid having to manually chain two operations
-    def for(app_id, payload = {}, headers = nil, &block)
-      logs_response = scalingo.apps.logs_url(app_id)
-
-      return logs_response unless logs_response.successful?
+    def find(**params, &block)
+      params[:id] = params.delete(:app_id) if params[:app_id].present?
+      logs_response = client.apps.logs_url(**params)
 
-      get(logs_response.data, payload, headers, &block)
+      fetch(logs_response.body, **params, &block)
     end
   end
 end

data/lib/scalingo/regional/metrics.rb

@@ -4,39 +4,7 @@ require "active_support/core_ext/hash/indifferent_access"
 
 module Scalingo
   class Regional::Metrics < API::Endpoint
-    def for(app_id, payload = {}, headers = nil, &block)
-      payload = payload.with_indifferent_access
-      data = payload.except(:metric, :container_type, :container_index).compact
-
-      metric = payload[:metric]
-      url = "apps/#{app_id}/stats/#{metric}"
-
-      if payload[:container_type]
-        url = "#{url}/#{payload[:container_type]}"
-        url = "#{url}/#{payload[:container_index]}" if payload[:container_index]
-      end
-
-      response = connection.get(
-        url,
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def types(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "features/metrics",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:metrics) { response }
-    end
+    get :list, "/apps/{app_id}/stats/{metric}{/container_type}{/container_index}", optional: [:container_type, :container_index]
+    get :types, "/features/metrics"
   end
 end

data/lib/scalingo/regional/notifiers.rb

@@ -2,95 +2,12 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Notifiers < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/notifiers",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:notifiers) { response }
-    end
-
-    def find(app_id, notifier_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/notifiers/#{notifier_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:notifier) { response }
-    end
-
-    def create(app_id, payload = {}, headers = nil, &block)
-      data = {notifier: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/notifiers",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:notifier) { response }
-    end
-
-    def update(app_id, notifier_id, payload = {}, headers = nil, &block)
-      data = {notifier: payload}
-
-      response = connection.patch(
-        "apps/#{app_id}/notifiers/#{notifier_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:notifier) { response }
-    end
-
-    def destroy(app_id, notifier_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/notifiers/#{notifier_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def test(app_id, notifier_id, headers = nil, &block)
-      data = nil
-
-      response = connection.post(
-        "apps/#{app_id}/notifiers/#{notifier_id}/test",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def platforms(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "notification_platforms",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:notification_platforms) { response }
-    end
+    get :list, "/apps/{app_id}/notifiers"
+    get :find, "/apps/{app_id}/notifiers/{id}"
+    post :create, "/apps/{app_id}/notifiers", root_key: :notifier
+    put :update, "/apps/{app_id}/notifiers/{id}", root_key: :notifier
+    delete :delete, "/apps/{app_id}/notifiers/{id}"
+    get :platforms, "/notification_platforms"
+    post :test, "/apps/{app_id}/notifiers/{id}/test"
   end
 end

data/lib/scalingo/regional/operations.rb

@@ -2,25 +2,12 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Operations < API::Endpoint
-    def find(app_id, operation_id, headers = nil, &block)
-      get(
-        "apps/#{app_id}/operations/#{operation_id}",
-        headers,
-        &block
-      )
-    end
-
-    def get(url, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        url,
-        data,
-        headers,
-        &block
-      )
+    get :find, "/apps/{app_id}/operations/{id}"
 
-      unpack(:operation) { response }
+    def fetch(url, **params, &block)
+      request(:get, url, **params) do |req|
+        block&.call(req, params)
+      end
     end
   end
 end

data/lib/scalingo/regional/scm_repo_links.rb

@@ -2,108 +2,13 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::ScmRepoLinks < API::Endpoint
-    def show(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/scm_repo_link",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_repo_link) { response }
-    end
-
-    def create(app_id, payload = {}, headers = nil, &block)
-      data = {scm_repo_link: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/scm_repo_link",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_repo_link) { response }
-    end
-
-    def update(app_id, payload = {}, headers = nil, &block)
-      data = {scm_repo_link: payload}
-
-      response = connection.patch(
-        "apps/#{app_id}/scm_repo_link",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_repo_link) { response }
-    end
-
-    def destroy(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/scm_repo_link",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_repo_link) { response }
-    end
-
-    def deploy(app_id, branch, headers = nil, &block)
-      data = {branch: branch}
-
-      response = connection.post(
-        "apps/#{app_id}/scm_repo_link/manual_deploy",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:deployment) { response }
-    end
-
-    def review_app(review_app, pull_request_id, headers = nil, &block)
-      data = {pull_request_id: pull_request_id}
-
-      response = connection.post(
-        "apps/#{app_id}/scm_repo_link/manual_review_app",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:review_app) { response }
-    end
-
-    def branches(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/scm_repo_link/branches",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:branches) { response }
-    end
-
-    def pulls(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/scm_repo_link/pulls",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:pulls) { response }
-    end
+    get :find, "/apps/{app_id}/scm_repo_link"
+    post :create, "/apps/{app_id}/scm_repo_link", root_key: :scm_repo_link
+    put :update, "/apps/{app_id}/scm_repo_link", root_key: :scm_repo_link
+    delete :delete, "/apps/{app_id}/scm_repo_link"
+    get :branches, "/apps/{app_id}/scm_repo_link/branches"
+    get :pulls, "/apps/{app_id}/scm_repo_link/pulls"
+    post :deploy, "/apps/{app_id}/scm_repo_link/manual_deploy"
+    post :review_app, "/apps/{app_id}/scm_repo_link/manual_review_app"
   end
 end

data/lib/scalingo/regional.rb

@@ -31,7 +31,7 @@ module Scalingo
       metrics: Metrics,
       notifiers: Notifiers,
       operations: Operations,
-      scm_repo_links: ScmRepoLinks,
+      scm_repo_links: ScmRepoLinks
     )
   end
 end

data/lib/scalingo/token_holder.rb

@@ -4,59 +4,14 @@ module Scalingo
   module TokenHolder
     def self.included(base)
       base.attr_reader :token
-      base.attr_reader :database_tokens
     end
 
     def token=(input)
-      @token = bearer_token(input)
-    end
-
-    def add_database_token(database_id, token)
-      @database_tokens ||= {}
-      @database_tokens[database_id] = bearer_token(token)
+      @token = input.is_a?(BearerToken) ? input : BearerToken.new(input.to_s)
     end
 
     def authenticated?
-      valid?(token)
-    end
-
-    def authenticated_for_database?(database_id)
-      return false if database_tokens.nil?
-      return false unless database_tokens.has_key?(database_id)
-
-      valid?(database_tokens[database_id])
-    end
-
-    def authenticate_with_bearer_token(bearer_token, expires_at:, raise_on_expired_token:)
-      self.token = build_bearer_token(bearer_token, expires_at: expires_at, raise_on_expired_token: raise_on_expired_token)
-    end
-
-    def authenticate_database_with_bearer_token(database_id, bearer_token, expires_at:, raise_on_expired_token:)
-      bearer_token = build_bearer_token(bearer_token, expires_at: expires_at, raise_on_expired_token: raise_on_expired_token)
-
-      add_database_token(database_id, bearer_token)
-    end
-
-    private
-
-    def valid?(token)
       token.present? && !token.expired?
     end
-
-    def bearer_token(token)
-      token.is_a?(BearerToken) ? token : BearerToken.new(token.to_s, raise_on_expired: config.raise_on_expired_token)
-    end
-
-    def build_bearer_token(bearer_token, expires_at:, raise_on_expired_token:)
-      return bearer_token unless expires_at
-
-      token = bearer_token.is_a?(BearerToken) ? bearer_token.value : bearer_token.to_s
-
-      BearerToken.new(
-        token,
-        expires_at: expires_at,
-        raise_on_expired: raise_on_expired_token,
-      )
-    end
   end
 end

data/lib/scalingo/version.rb

@@ -1,3 +1,3 @@
 module Scalingo
-  VERSION = "3.4.0"
+  VERSION = "4.0.beta1"
 end

data/scalingo.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
     "changelog_uri" => "https://github.com/Scalingo/scalingo-ruby-api/blob/master/CHANGELOG.md",
     "documentation_uri" => "https://developers.scalingo.com/",
     "homepage_uri" => "https://www.scalingo.com/",
-    "source_code_uri" => "https://github.com/Scalingo/scalingo-ruby-api",
+    "source_code_uri" => "https://github.com/Scalingo/scalingo-ruby-api"
   }
 
   # Specify which files should be added to the gem when it is released.
@@ -32,18 +32,18 @@ Gem::Specification.new do |s|
   s.executables = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.test_files = Dir["spec/**/*_spec.rb"]
-
+  s.add_dependency "addressable", [">= 2.8.0", "< 3"]
   s.add_dependency "activesupport", [">= 5", "< 8"]
-  s.add_dependency "faraday", "~> 1.0"
-  s.add_dependency "faraday_middleware", "~> 1.0"
+  s.add_dependency "faraday", "~> 2.0"
   s.add_dependency "multi_json", ">= 1.0.3", "~> 1.0"
+  s.add_dependency "jwt"
 
   s.add_development_dependency "bundler", "~> 2.0"
+  s.add_development_dependency "dotenv"
   s.add_development_dependency "rake", "~> 13.0"
   s.add_development_dependency "rspec", "~> 3.0"
-  s.add_development_dependency "standard", "~> 1.1.0"
+  s.add_development_dependency "standard", "~> 1.32"
   s.add_development_dependency "rubocop-rspec"
   s.add_development_dependency "pry", "~> 0.14.1"
-  s.add_development_dependency "webmock", "~> 3.12.2"
+  s.add_development_dependency "webmock", "~> 3.19"
 end