git-semaphore 2.8.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc5612a4161eb03ad1b94d51404679d0891abb804ab119939590fc4a8f70def0
-  data.tar.gz: b35715d954910ea1de3b66bf64b7b7b0015dec42e07cdc285137e88ba9f905eb
+  metadata.gz: f5f76f2487f427528a0200987155e53304464e5402e15379c038e42bb1048a06
+  data.tar.gz: cfa81dc4e13c1b33ad0c997060fc5d07d38141dbdef3aa116f141944194111b7
 SHA512:
-  metadata.gz: 9c15afac6f253ec5b0963d54c6b34af9612c2ef60587f3de6aad38a881d4a0a5c7b6b4d1197a36bfe3acd67652ad933fa8e2eba89b2c48cf2ed9e80001166555
-  data.tar.gz: 1500b238a715722b392b31a63860ddd06f26f88dd2a56cc4e2d23960411596225820295b8ed34e2e93a6c061f95c15044e4d9cf8898f2449afaaffc5ffc8d6d3
+  metadata.gz: 7590f74d4d5ef32d38569aa13c9af475b2bc0e596955b04d558a7f69acae22c78185a374edd58cb4802942e64e053ba9237a24d23404c6b7539cf4967a797abd
+  data.tar.gz: 023405af11917e711600b888552b1cdcf9cb08bbb70ad3be684588d104893ac491580ea8189ff52974dead1fbf17ff8459a2a59d5d8837b60a9fd3afc1fa3108

data/Gemfile.lock

@@ -1,7 +1,9 @@
 PATH
   remote: .
   specs:
-    git-semaphore (2.8.0)
+    git-semaphore (3.0.0)
+      faraday (~> 0.15)
+      nitlink (~> 1.1)
       rugged (~> 0.27)
       slop (~> 4.6)
 
@@ -10,9 +12,13 @@ GEM
   specs:
     ast (2.4.0)
     coderay (1.1.2)
+    faraday (0.15.4)
+      multipart-post (>= 1.2, < 3)
     jaro_winkler (1.5.2)
     method_source (0.9.2)
     minitest (5.11.3)
+    multipart-post (2.0.0)
+    nitlink (1.1.0)
     parallel (1.14.0)
     parser (2.6.0.0)
       ast (~> 2.4.0)

data/git-semaphore.gemspec

@@ -25,6 +25,8 @@ Gem::Specification.new do |spec|
 
   spec.post_install_message = Git::Semaphore::PIM
 
+  spec.add_dependency 'faraday', '~> 0.15'
+  spec.add_dependency 'nitlink', '~> 1.1'
   spec.add_dependency 'rugged', '~> 0.27'
   spec.add_dependency 'slop', '~> 4.6'
 

data/lib/ext/faraday.rb

@@ -0,0 +1,20 @@
+module Faraday
+  class Adapter
+    class SemaphoreNetHttp < NetHttp
+      def net_http_connection(env)
+        connections = (Thread.current[:net_http_connections] ||= {})
+        env_key = [env.url.host, env.url.port, env.ssl.verify]
+        connections[env_key] ||= begin
+                                   super(env).tap { |connection|
+                                     # uncomment to enable Net::HTTP debugging
+                                     # connection.set_debug_output($stderr)
+                                     connection.use_ssl = true
+                                     connection.start
+                                   }
+                                 end
+      end
+    end
+
+    register_middleware semaphore_net_http: SemaphoreNetHttp
+  end
+end

data/lib/ext/nitlink.rb

@@ -0,0 +1,39 @@
+# pagination: "{\"total_entries\":1535,\"total_pages\":77,\"per_page\":20,\"current_page\":1,\"first_page\":true,\"last_page\":false,\"previous_page\":null,\"next_page\":2}"
+
+# {"total_entries"=>1535,
+#  "total_pages"=>77,
+#  "per_page"=>20,
+#  "current_page"=>1,
+#  "first_page"=>true,
+#  "last_page"=>false,
+#  "previous_page"=>nil,
+#  "next_page"=>2}
+
+module Semlink
+  class Parser
+    def parse(response)
+      link_collection = Nitlink::LinkCollection.new
+
+      # FIXME: url.query could be nil/""
+
+      if (pagination = response['pagination'])
+        pagination = JSON.parse(pagination)
+
+        if (next_page = pagination['next_page'])
+          next_url = response.env['url'].dup
+          next_url.query = [next_url.query, "page=#{next_page}"].join('&')
+          link_collection << Nitlink::Link.new(next_url, 'next', nil, nil)
+        end
+
+        if (prev_page = pagination['previous_page'])
+          prev_url = response.env['url'].dup
+          prev_url.query = [prev_url.query, "page=#{prev_page}"].join('&')
+          link_collection << Nitlink::Link.new(prev_url, 'previous', nil, nil)
+        end
+
+      end
+
+      link_collection
+    end
+  end
+end

data/lib/git/semaphore.rb

@@ -6,8 +6,13 @@ require 'openssl'
 require 'net/http'
 require 'fileutils'
 
+require 'faraday'
+require 'nitlink'
 require 'rugged'
 
+require 'ext/faraday'
+require 'ext/nitlink'
+
 module Rugged
   class Repository
     def owner()     File.basename(File.dirname(workdir)); end
@@ -81,6 +86,8 @@ end
 
 require 'git/semaphore/version'
 
+require 'semaphore_ci/api'
+
 require 'git/semaphore/api'
 require 'git/semaphore/api_cache'
 require 'git/semaphore/api_enrich'

data/lib/git/semaphore/api.rb

@@ -2,158 +2,99 @@ module Git
   module Semaphore
     class API
 
-      def self.projects(auth_token)
-        get_json projects_uri(auth_token)
+      def self.projects
+        get_json projects_uri
       end
 
-      def self.branches(project_hash_id, auth_token)
-        get_json branches_uri(project_hash_id, auth_token)
+      def self.branches(project_hash_id)
+        get_json branches_uri(project_hash_id)
       end
 
-      def self.status(project_hash_id, branch_id, auth_token)
-        get_json status_uri(project_hash_id, branch_id, auth_token)
+      def self.status(project_hash_id, branch_id)
+        get_json status_uri(project_hash_id, branch_id)
       end
 
-      def self.history(project_hash_id, branch_id, auth_token)
-        get_paginated_response(history_uri(project_hash_id, branch_id, auth_token)) do |previous_page, next_page|
-          previous_page['builds'] += next_page['builds']
-        end
+      def self.history(project_hash_id, branch_id)
+        get_json history_uri(project_hash_id, branch_id)
       end
 
-      def self.information(project_hash_id, branch_id, build_number, auth_token)
-        get_json information_uri(project_hash_id, branch_id, build_number, auth_token)
+      def self.information(project_hash_id, branch_id, build_number)
+        get_json information_uri(project_hash_id, branch_id, build_number)
       end
 
-      def self.log(project_hash_id, branch_id, build_number, auth_token)
-        get_json log_uri(project_hash_id, branch_id, build_number, auth_token)
+      def self.log(project_hash_id, branch_id, build_number)
+        get_json log_uri(project_hash_id, branch_id, build_number)
       end
 
-      def self.rebuild(project_hash_id, branch_id, auth_token)
-        get_json last_revision_uri(project_hash_id, branch_id, auth_token), :post
+      def self.rebuild(project_hash_id, branch_id)
+        get_json last_revision_uri(project_hash_id, branch_id), :post
       end
 
+      #
       # private helper functions
+      #
 
-      def self.projects_uri(auth_token)
+      def self.get_json(uri)
+        @client ||= SemaphoreCI::API::V1.new(Git::Semaphore.auth_token)
+        @client.get(uri)
+      end
+
+      def self.projects_uri
         # https://semaphoreci.com/docs/projects-api.html
         # GET /api/v1/projects
-        request_uri(auth_token, path: File.join('projects'))
+        File.join('/projects')
       end
 
       private_class_method :projects_uri
 
-      def self.branches_uri(project_hash_id, auth_token)
+      def self.branches_uri(project_hash_id)
         # https://semaphoreci.com/docs/branches-and-builds-api.html#project_branches
         # GET /api/v1/projects/:hash_id/branches
-        request_uri(auth_token, path: File.join('projects', project_hash_id, 'branches'))
+        File.join('/projects', project_hash_id, 'branches')
       end
 
       private_class_method :branches_uri
 
-      def self.status_uri(project_hash_id, branch_id, auth_token)
+      def self.status_uri(project_hash_id, branch_id)
         # https://semaphoreci.com/docs/branches-and-builds-api.html#branch_status
         # GET /api/v1/projects/:hash_id/:id/status
-        request_uri(auth_token, path: File.join('projects', project_hash_id, branch_id, 'status'))
+        File.join('/projects', project_hash_id, branch_id, 'status')
       end
 
       private_class_method :status_uri
 
-      def self.history_uri(project_hash_id, branch_id, auth_token, page = 1)
+      def self.history_uri(project_hash_id, branch_id)
         # https://semaphoreci.com/docs/branches-and-builds-api.html#branch_history
         # GET /api/v1/projects/:hash_id/:id
-        request_uri(auth_token, path: File.join('projects', project_hash_id, branch_id), page: page)
+        File.join('/projects', project_hash_id, branch_id)
       end
 
       private_class_method :history_uri
 
-      def self.information_uri(project_hash_id, branch_id, build_number, auth_token)
+      def self.information_uri(project_hash_id, branch_id, build_number)
         # https://semaphoreci.com/docs/branches-and-builds-api.html#build_information
         # GET /api/v1/projects/:hash_id/:id/builds/:number
-        request_uri(auth_token, path: File.join('projects', project_hash_id, branch_id, 'builds', build_number))
+        File.join('/projects', project_hash_id, branch_id, 'builds', build_number)
       end
 
       private_class_method :information_uri
 
-      def self.log_uri(project_hash_id, branch_id, build_number, auth_token)
+      def self.log_uri(project_hash_id, branch_id, build_number)
         # https://semaphoreci.com/docs/branches-and-builds-api.html#build_log
         # GET /api/v1/projects/:hash_id/:id/builds/:number/log
-        request_uri(auth_token, path: File.join('projects', project_hash_id, branch_id, 'builds', build_number, 'log'))
+        File.join('/projects', project_hash_id, branch_id, 'builds', build_number, 'log')
       end
 
       private_class_method :log_uri
 
-      def self.last_revision_uri(project_hash_id, branch_id, auth_token)
+      def self.last_revision_uri(project_hash_id, branch_id)
         # https://semaphoreci.com/docs/branches-and-builds-api.html#rebuild
         # POST /api/v1/projects/:project_hash_id/:branch_id/build
-        request_uri(auth_token, path: File.join('projects', project_hash_id, branch_id, 'build'))
+        File.join('/projects', project_hash_id, branch_id, 'build')
       end
 
       private_class_method :last_revision_uri
 
-      # more private helper functions
-
-      def self.get_response(uri, action = :get)
-        response = ::Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == 'https'), verify_mode: ::OpenSSL::SSL::VERIFY_NONE) do |net_http|
-          case action
-          when :get
-            net_http.get uri.request_uri
-          when :post
-            net_http.post uri.request_uri, uri.query
-          else
-            raise 'Unsupported action'
-          end
-        end
-
-        def response.json_body
-          # "application/json; charset=utf-8"
-          raise 'JSON body expected' \
-            unless self['content-type'] =~ %r{\Aapplication/json}
-          JSON.parse(body)
-        end
-
-        response
-      end
-
-      private_class_method :get_response
-
-      def self.get_paginated_response(uri, action = :get)
-        response = get_response(uri, action)
-        body = response.json_body
-        loop do
-          pagination_header = response['Pagination']
-          break unless pagination_header
-          pagination = JSON.parse(pagination_header)
-          break if pagination['last_page']
-          uri.query = uri.query.sub(/page=(\d+)/, "page=#{pagination['next_page']}")
-          response = get_response(uri, action)
-          yield(body, response.json_body)
-        end
-        body
-      end
-
-      private_class_method :get_paginated_response
-
-      def self.get_json(uri, action = :get)
-        get_response(uri, action).json_body
-      end
-
-      private_class_method :get_json
-
-      # https://semaphoreci.com/docs/
-      SEMAPHORE_API_HOST = 'semaphoreci.com'.freeze
-      SEMAPHORE_API_URI = '/api/v1/'.freeze
-
-      def self.request_uri(auth_token, options = {})
-        page = options.delete(:page) # API pagination
-        options[:host] ||= SEMAPHORE_API_HOST
-        options[:path].prepend SEMAPHORE_API_URI
-        options[:query] = "auth_token=#{auth_token}"
-        options[:query] << "&page=#{page}" if page
-        URI::HTTPS.build(options)
-      end
-
-      private_class_method :request_uri
-
     end
   end
 end

data/lib/git/semaphore/api_cache.rb

@@ -3,39 +3,39 @@ module Git
     class API
       class Cache
 
-        def self.projects(refresh, auth_token)
+        def self.projects(refresh)
           @projects ||= Git::Semaphore.from_json_cache(projects_cache, refresh) do
-            API::Enrich.projects auth_token
+            API::Enrich.projects
           end
         end
 
-        def self.branches(project_hash_id, refresh, auth_token)
+        def self.branches(project_hash_id, refresh)
           @branches ||= Git::Semaphore.from_json_cache(branches_cache(project_hash_id), refresh) do
-            API.branches project_hash_id, auth_token
+            API.branches project_hash_id
           end
         end
 
-        def self.status(project_hash_id, branch_id, refresh, auth_token)
+        def self.status(project_hash_id, branch_id, refresh)
           @status ||= Git::Semaphore.from_json_cache(status_cache(project_hash_id, branch_id), refresh) do
-            API::Enrich.status project_hash_id, branch_id, auth_token
+            API::Enrich.status project_hash_id, branch_id
           end
         end
 
-        def self.history(project_hash_id, branch_id, refresh, auth_token)
+        def self.history(project_hash_id, branch_id, refresh)
           @history ||= Git::Semaphore.from_json_cache(history_cache(project_hash_id, branch_id), refresh) do
-            API::Enrich.history project_hash_id, branch_id, auth_token
+            API::Enrich.history project_hash_id, branch_id
           end
         end
 
-        def self.information(project_hash_id, branch_id, build_number, refresh, auth_token)
+        def self.information(project_hash_id, branch_id, build_number, refresh)
           @information ||= Git::Semaphore.from_json_cache(information_cache(project_hash_id, branch_id, build_number), refresh) do
-            API.information project_hash_id, branch_id, build_number, auth_token
+            API.information project_hash_id, branch_id, build_number
           end
         end
 
-        def self.log(project_hash_id, branch_id, build_number, refresh, auth_token)
+        def self.log(project_hash_id, branch_id, build_number, refresh)
           @log ||= Git::Semaphore.from_json_cache(log_cache(project_hash_id, branch_id, build_number), refresh) do
-            API.log project_hash_id, branch_id, build_number, auth_token
+            API.log project_hash_id, branch_id, build_number
           end
         end
 

data/lib/git/semaphore/api_enrich.rb

@@ -3,8 +3,8 @@ module Git
     class API
       class Enrich
 
-        def self.projects(auth_token)
-          API.projects(auth_token).tap do |results|
+        def self.projects
+          API.projects.tap do |results|
             results.each do |project|
               # full repository name on github.com: 'pvdb/git-semaphore'
               project['full_name']  = [project['owner'], project['name']].join('/')
@@ -14,16 +14,16 @@ module Git
           end
         end
 
-        def self.history(project_hash_id, branch_id, auth_token)
-          API.history(project_hash_id, branch_id, auth_token).tap do |history|
+        def self.history(project_hash_id, branch_id)
+          API.history(project_hash_id, branch_id).tap do |history|
             history['builds'].each do |build|
               enrich(build)
             end
           end
         end
 
-        def self.status(project_hash_id, branch_id, auth_token)
-          API.status(project_hash_id, branch_id, auth_token).tap do |status|
+        def self.status(project_hash_id, branch_id)
+          API.status(project_hash_id, branch_id).tap do |status|
             enrich(status)
           end
         end

data/lib/git/semaphore/project.rb

@@ -110,7 +110,7 @@ module Git
       #
 
       def self.all(refresh = false)
-        Git::Semaphore::API::Cache.projects(refresh, Git::Semaphore.auth_token)
+        Git::Semaphore::API::Cache.projects(refresh)
       end
 
       class << self
@@ -118,27 +118,27 @@ module Git
       end
 
       def branches(refresh = false)
-        Git::Semaphore::API::Cache.branches(project_hash_id, refresh, @auth_token)
+        Git::Semaphore::API::Cache.branches(project_hash_id, refresh)
       end
 
       def status(refresh = false)
-        Git::Semaphore::API::Cache.status(project_hash_id, branch_id, refresh, @auth_token)
+        Git::Semaphore::API::Cache.status(project_hash_id, branch_id, refresh)
       end
 
       def history(refresh = false)
-        Git::Semaphore::API::Cache.history(project_hash_id, branch_id, refresh, @auth_token)
+        Git::Semaphore::API::Cache.history(project_hash_id, branch_id, refresh)
       end
 
       def information(refresh = false)
-        Git::Semaphore::API::Cache.information(project_hash_id, branch_id, build_number, refresh, @auth_token)
+        Git::Semaphore::API::Cache.information(project_hash_id, branch_id, build_number, refresh)
       end
 
       def log(refresh = false)
-        Git::Semaphore::API::Cache.log(project_hash_id, branch_id, build_number, refresh, @auth_token)
+        Git::Semaphore::API::Cache.log(project_hash_id, branch_id, build_number, refresh)
       end
 
       def rebuild
-        Git::Semaphore::API.rebuild(project_hash_id, branch_id, @auth_token)
+        Git::Semaphore::API.rebuild(project_hash_id, branch_id)
       end
 
       def browse

data/lib/git/semaphore/version.rb

@@ -1,7 +1,7 @@
 module Git
   module Semaphore
     NAME = 'git-semaphore'.freeze
-    VERSION = '2.8.0'.freeze
+    VERSION = '3.0.0'.freeze
 
     def self.version
       "#{NAME} v#{VERSION}"

data/lib/semaphore_ci/api.rb

@@ -0,0 +1,72 @@
+module SemaphoreCI
+  module API
+    class Client
+      def initialize(token, url, prefix, link_parser_class)
+        @token = token
+        @url = url
+        @prefix = prefix
+        @link_parser = link_parser_class.new
+
+        @conn = Faraday.new(url: @url) do |conn|
+          # uncomment to enable Faraday debugging
+          # conn.response :logger
+          # conn.token_auth token # FIXME: make we work for V2 API
+          conn.adapter :semaphore_net_http
+        end
+      end
+
+      def get(path)
+        response = @conn.get(path.prepend(@prefix), auth_token: @token)
+        result = json_from(response)
+
+        while (next_link = @link_parser.parse(response).by_rel('next'))
+          response = @conn.get(next_link.target.to_s)
+          next_result = json_from(response)
+
+          case [result.class, next_result.class]
+          when [Array, Array]
+            # V2 pagination
+            result.concat(next_result)
+          when [Hash, Hash]
+            # V1 pagination
+            next_result.each do |key, value|
+              if value.is_a? Array
+                result[key].concat(value)
+              elsif value.is_a? Hash
+                result[key].merge(value)
+              else
+                result[key] = value
+              end
+            end
+          else raise 'Unsupported API response'
+          end
+        end
+
+        result
+      end
+
+      private
+
+      def json_from(response)
+        if (content_type = response['content-type'])
+          # should be something like "application/json; charset=utf-8"
+          content_type['application/json'] || raise('JSON body expected')
+        end
+
+        JSON.parse(response.body)
+      end
+    end
+
+    class V1 < Client
+      def initialize(token)
+        super(token, 'https://semaphoreci.com/', '/api/v1', Semlink::Parser)
+      end
+    end
+
+    class V2 < Client
+      def initialize(token)
+        super(token, 'https://api.semaphoreci.com/', '/v2', Nitlink::Parser)
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: git-semaphore
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Peter Vandenberk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-14 00:00:00.000000000 Z
+date: 2019-03-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: nitlink
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rugged
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +158,8 @@ files:
 - bin/setup
 - exe/git-semaphore
 - git-semaphore.gemspec
+- lib/ext/faraday.rb
+- lib/ext/nitlink.rb
 - lib/git/semaphore.rb
 - lib/git/semaphore/api.rb
 - lib/git/semaphore/api_cache.rb
@@ -137,6 +167,7 @@ files:
 - lib/git/semaphore/gemspec.rb
 - lib/git/semaphore/project.rb
 - lib/git/semaphore/version.rb
+- lib/semaphore_ci/api.rb
 homepage: https://github.com/pvdb/git-semaphore
 licenses:
 - MIT