git-semaphore 2.1.0 → 2.2.0

data/lib/git/semaphore/api.rb

@@ -2,98 +2,98 @@ module Git
   module Semaphore
     class API
 
-      def self.projects auth_token
+      def self.projects(auth_token)
         get_json projects_uri(auth_token)
       end
 
-      def self.branches project_hash_id, auth_token
+      def self.branches(project_hash_id, auth_token)
         get_json branches_uri(project_hash_id, auth_token)
       end
 
-      def self.status project_hash_id, branch_id, auth_token
+      def self.status(project_hash_id, branch_id, auth_token)
         get_json status_uri(project_hash_id, branch_id, auth_token)
       end
 
-      def self.history project_hash_id, branch_id, auth_token
+      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
       end
 
-      def self.information project_hash_id, branch_id, build_number, auth_token
+      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)
       end
 
-      def self.log project_hash_id, branch_id, build_number, auth_token
+      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)
       end
 
-      def self.rebuild project_hash_id, branch_id, auth_token
+      def self.rebuild(project_hash_id, branch_id, auth_token)
         get_json last_revision_uri(project_hash_id, branch_id, auth_token), :post
       end
 
       # private helper functions
 
-      def self.projects_uri auth_token
+      def self.projects_uri(auth_token)
         # https://semaphoreci.com/docs/projects-api.html
         # GET /api/v1/projects
-        request_uri(auth_token, :path => File.join('projects'))
+        request_uri(auth_token, path: 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, auth_token)
         # 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'))
+        request_uri(auth_token, path: 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, auth_token)
         # 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'))
+        request_uri(auth_token, path: 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, auth_token, page = 1)
         # 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)
+        request_uri(auth_token, path: File.join('projects', project_hash_id, branch_id), page: page)
       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, auth_token)
         # 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))
+        request_uri(auth_token, path: 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, auth_token)
         # 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'))
+        request_uri(auth_token, path: 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, auth_token)
         # 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'))
+        request_uri(auth_token, path: 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|
+      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
@@ -105,7 +105,9 @@ module Git
         end
 
         def response.json_body
-          raise "JSON response expected" unless self['content-type'] =~ %r{application/json}
+          unless self['content-type'].match?(%r{application/json})
+            raise 'JSON response expected'
+          end
           JSON.parse(body)
         end
 
@@ -114,7 +116,7 @@ module Git
 
       private_class_method :get_response
 
-      def self.get_paginated_response uri, action = :get
+      def self.get_paginated_response(uri, action = :get)
         response = get_response(uri, action)
         body = response.json_body
         loop do
@@ -131,7 +133,7 @@ module Git
 
       private_class_method :get_paginated_response
 
-      def self.get_json uri, action = :get
+      def self.get_json(uri, action = :get)
         get_response(uri, action).json_body
       end
 
@@ -141,7 +143,7 @@ module Git
       SEMAPHORE_API_HOST = 'semaphoreci.com'.freeze
       SEMAPHORE_API_URI = '/api/v1/'.freeze
 
-      def self.request_uri auth_token, options = {}
+      def self.request_uri(auth_token, options = {})
         page = options.delete(:page) # API pagination
         options[:host] ||= SEMAPHORE_API_HOST
         options[:path].prepend SEMAPHORE_API_URI

data/lib/git/semaphore/api_cache.rb

@@ -3,38 +3,38 @@ module Git
     class API
       class Cache
 
-        def self.projects auth_token
-          @projects ||= Git::Semaphore.from_json_cache(projects_cache) do
+        def self.projects(refresh, auth_token)
+          @projects ||= Git::Semaphore.from_json_cache(projects_cache, refresh) do
             API::Enrich.projects auth_token
           end
         end
 
-        def self.branches project_hash_id, auth_token
-          @branches ||= Git::Semaphore.from_json_cache(branches_cache(project_hash_id)) do
+        def self.branches(project_hash_id, refresh, auth_token)
+          @branches ||= Git::Semaphore.from_json_cache(branches_cache(project_hash_id), refresh) do
             API.branches project_hash_id, auth_token
           end
         end
 
-        def self.status project_hash_id, branch_id, auth_token
-          @status ||= Git::Semaphore.from_json_cache(status_cache(project_hash_id, branch_id)) do
+        def self.status(project_hash_id, branch_id, refresh, auth_token)
+          @status ||= Git::Semaphore.from_json_cache(status_cache(project_hash_id, branch_id), refresh) do
             API.status project_hash_id, branch_id, auth_token
           end
         end
 
-        def self.history project_hash_id, branch_id, auth_token
-          @history ||= Git::Semaphore.from_json_cache(history_cache(project_hash_id, branch_id)) do
+        def self.history(project_hash_id, branch_id, refresh, auth_token)
+          @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
           end
         end
 
-        def self.information project_hash_id, branch_id, build_number, auth_token
-          @information ||= Git::Semaphore.from_json_cache(information_cache(project_hash_id, branch_id, build_number)) do
+        def self.information(project_hash_id, branch_id, build_number, refresh, auth_token)
+          @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
           end
         end
 
-        def self.log project_hash_id, branch_id, build_number, auth_token
-          @log ||= Git::Semaphore.from_json_cache(log_cache(project_hash_id, branch_id, build_number)) do
+        def self.log(project_hash_id, branch_id, build_number, refresh, auth_token)
+          @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
           end
         end
@@ -47,31 +47,31 @@ module Git
 
         private_class_method :projects_cache
 
-        def self.branches_cache project_hash_id
+        def self.branches_cache(project_hash_id)
           File.join(Git::Semaphore.cache_dir_for(project_hash_id), 'branches.json')
         end
 
         private_class_method :branches_cache
 
-        def self.status_cache project_hash_id, branch_id
+        def self.status_cache(project_hash_id, branch_id)
           File.join(Git::Semaphore.cache_dir_for(project_hash_id), "#{branch_id}_status.json")
         end
 
         private_class_method :status_cache
 
-        def self.history_cache project_hash_id, branch_id
+        def self.history_cache(project_hash_id, branch_id)
           File.join(Git::Semaphore.cache_dir_for(project_hash_id), "#{branch_id}_history.json")
         end
 
         private_class_method :history_cache
 
-        def self.information_cache project_hash_id, branch_id, build_number
+        def self.information_cache(project_hash_id, branch_id, build_number)
           File.join(Git::Semaphore.cache_dir_for(project_hash_id), "#{branch_id}_#{build_number}_information.json")
         end
 
         private_class_method :information_cache
 
-        def self.log_cache project_hash_id, branch_id, build_number
+        def self.log_cache(project_hash_id, branch_id, build_number)
           File.join(Git::Semaphore.cache_dir_for(project_hash_id), "#{branch_id}_#{build_number}_log.json")
         end
 

data/lib/git/semaphore/api_enrich.rb

@@ -3,7 +3,7 @@ module Git
     class API
       class Enrich
 
-        def self.projects auth_token
+        def self.projects(auth_token)
           API.projects(auth_token).tap do |results|
             results.each do |project|
               # full repository name on github.com: 'pvdb/git-semaphore'
@@ -14,21 +14,21 @@ module Git
           end
         end
 
-        def self.history project_hash_id, branch_id, auth_token
+        def self.history(project_hash_id, branch_id, auth_token)
           API.history(project_hash_id, branch_id, auth_token).tap do |results|
             results['builds'].each do |build|
               # build['result'] = "passed", "failed", "stopped" or "pending"
-              next unless started_at  = build['started_at']
-              next unless finished_at = build['finished_at']
-              started_at  = DateTime.parse(started_at).to_time
-              finished_at = DateTime.parse(finished_at).to_time
+              next unless (started_at  = build['started_at'])
+              next unless (finished_at = build['finished_at'])
+              started_at  = Time.parse(started_at)
+              finished_at = Time.parse(finished_at)
               build['date'] = {
-                :started_at  =>  started_at.to_date,
-                :finished_at => finished_at.to_date,
+                started_at:  started_at.to_date,
+                finished_at: finished_at.to_date,
               }
               build['duration'] = {
-                :seconds => (finished_at - started_at).to_i,
-                :minutes => "%0.2f" % ((finished_at - started_at) / 60),
+                seconds: (finished_at - started_at).to_i,
+                minutes: format('%0.2f', (finished_at - started_at) / 60).to_f,
               }
             end
           end

data/lib/git/semaphore/gemspec.rb

@@ -0,0 +1,13 @@
+module Git
+  module Semaphore
+    PIM = <<~"PIM".freeze
+
+      The only required setting for \033[1mgit semaphore\33[0m is:
+
+      \tgit config --global --add \033[1msemaphore.authtoken\033[0m <your_semaphore_auth_token>
+
+      Thanks for using \033[1mgit semaphore\033[0m ... the ultimate Semaphore utility for git!
+
+    PIM
+  end
+end

data/lib/git/semaphore/project.rb

@@ -1,176 +1,189 @@
-class Git::Semaphore::Project
-
-  def self.env_overrides
-    ENV.to_h.select { |key, _| key.start_with? 'SEMAPHORE_' }
-  end
-
-  def self.from_repo git_repo
-    self.from_config({
-      'SEMAPHORE_PROJECT_NAME' => git_repo.full_name,
-      'SEMAPHORE_BRANCH_NAME'  => git_repo.head.name.split('/').last,
-      'SEMAPHORE_COMMIT_SHA'   => git_repo.head.target.oid,
-      'SEMAPHORE_BUILD_NUMBER' => nil
-    }.merge(env_overrides))
-  end
-
-  def self.from_config config
-    self.new(
-      config['SEMAPHORE_PROJECT_NAME'],
-      config['SEMAPHORE_BRANCH_NAME'],
-      {
-        commit_sha:   config['SEMAPHORE_COMMIT_SHA'],
-        build_number: config['SEMAPHORE_BUILD_NUMBER'],
-      }
-    )
-  end
-
-  def initialize full_name, branch_name = nil, options = {}
-    @auth_token   = Git::Semaphore.auth_token
-    @full_name    = full_name
-    @owner, @name = full_name.split('/')
-    @branch_name  = branch_name || 'master'
-    @commit_sha   = options[:commit_sha]
-    @build_number = options[:build_number]
-  end
-
-  def settings
-    {
-      auth_token:   @auth_token,
-      project_name: @full_name,
-      branch_name:  @branch_name,
-      commit_sha:   @commit_sha,
-      build_number: @build_number,
-    }
-  end
-
-  def internals
-    settings.merge({
-      project: {
-        owner:      @owner,
-        name:       @name,
-        full_name:  @full_name,
-        hash_id:    project_hash_id,
-        url:        project_url,
-      },
-      branch: {
-        name:       @branch_name,
-        id:         branch_id,
-        url:        branch_url,
-      },
-      build: {
-        number:     build_number,
-        result:     build_result,
-        url:        build_url,
-      },
-    })
-  end
-
-  #
-  # build-related queries: default to latest one...
-  #
-
-  def build_number
-    @build_number ||= history['builds'].first['build_number'].to_s
-  end
-
-  def build_result
-    @build_result ||= history['builds'].first['result']
-  end
-
-  #
-  # direct links to semaphore.ci
-  #
-
-  def project_url
-    project_hash['html_url']
-  end
-
-  def branch_url
-    branch_hash = project_hash['branches'].find { |hash|
-      hash['branch_name'] == @branch_name
-    }
-    branch_hash['branch_url']
-  end
-
-  def build_url
-    build_hash = history['builds'].find { |hash|
-      hash['build_number'].to_s == @build_number
-    }
-    build_hash['build_url']
-  end
-
-  #
-  # API related queries
-  #
-
-  def self.all
-    Git::Semaphore::API::Cache.projects(Git::Semaphore.auth_token)
-  end
-
-  class << self
-    alias_method :projects, :all
-  end
-
-  def branches
-    Git::Semaphore::API::Cache.branches(project_hash_id, @auth_token)
-  end
-
-  def status
-    Git::Semaphore::API::Cache.status(project_hash_id, branch_id, @auth_token)
-  end
-
-  def history
-    Git::Semaphore::API::Cache.history(project_hash_id, branch_id, @auth_token)
-  end
-
-  def information
-    Git::Semaphore::API::Cache.information(project_hash_id, branch_id, build_number, @auth_token,)
+module Git
+  module Semaphore
+    class Project
+
+      def self.env_overrides
+        ENV.to_h.select { |key, _| key.start_with? 'SEMAPHORE_' }
+      end
+
+      def self.from_repo(git_repo)
+        from_config({
+          'SEMAPHORE_PROJECT_NAME' => git_repo.full_name,
+          'SEMAPHORE_BRANCH_NAME'  => git_repo.head.name.split('/').last,
+          'SEMAPHORE_COMMIT_SHA'   => git_repo.head.target.oid,
+          'SEMAPHORE_BUILD_NUMBER' => nil
+        }.merge(env_overrides))
+      end
+
+      def self.from_config(config)
+        new(
+          config['SEMAPHORE_PROJECT_NAME'],
+          config['SEMAPHORE_BRANCH_NAME'],
+          commit_sha:   config['SEMAPHORE_COMMIT_SHA'],
+          build_number: config['SEMAPHORE_BUILD_NUMBER'],
+        )
+      end
+
+      attr_accessor :owner, :name, :full_name
+
+      def initialize(full_name, branch_name = nil, options = {})
+        @auth_token   = Git::Semaphore.auth_token
+        @full_name    = full_name
+        @owner, @name = full_name&.split('/')
+        @branch_name  = branch_name || 'master'
+        @commit_sha   = options[:commit_sha]
+        @build_number = options[:build_number]
+      end
+
+      def exist?
+        !project_hash.nil?
+      end
+
+      def settings
+        {
+          auth_token:   @auth_token,
+          project_name: @full_name,
+          branch_name:  @branch_name,
+          commit_sha:   @commit_sha,
+          build_number: @build_number,
+        }
+      end
+
+      def internals
+        settings.merge(
+          project: {
+            owner:      @owner,
+            name:       @name,
+            full_name:  @full_name,
+            hash_id:    project_hash_id,
+            url:        project_url,
+          },
+          branch: {
+            name:       @branch_name,
+            id:         branch_id,
+            url:        branch_url,
+          },
+          build: {
+            number:     build_number,
+            result:     build_result,
+            url:        build_url,
+          },
+        )
+      end
+
+      #
+      # build-related queries: default to latest one...
+      #
+
+      def build_number
+        @build_number ||= history['builds'].first['build_number'].to_s
+      end
+
+      def build_result
+        @build_result ||= history['builds'].first['result']
+      end
+
+      #
+      # direct links to semaphore.ci
+      #
+
+      def project_url
+        project_hash['html_url']
+      end
+
+      def branch_url
+        branch_hash = project_hash['branches'].find { |hash|
+          hash['branch_name'] == @branch_name
+        }
+        branch_hash['branch_url']
+      end
+
+      def build_url
+        build_hash = history['builds'].find { |hash|
+          hash['build_number'].to_s == @build_number
+        }
+        build_hash['build_url']
+      end
+
+      #
+      # API related queries
+      #
+
+      def self.all(refresh = false)
+        Git::Semaphore::API::Cache.projects(refresh, Git::Semaphore.auth_token)
+      end
+
+      class << self
+        alias_method :projects, :all
+      end
+
+      def branches(refresh = false)
+        Git::Semaphore::API::Cache.branches(project_hash_id, refresh, @auth_token)
+      end
+
+      def status(refresh = false)
+        Git::Semaphore::API::Cache.status(project_hash_id, branch_id, refresh, @auth_token)
+      end
+
+      def history(refresh = false)
+        Git::Semaphore::API::Cache.history(project_hash_id, branch_id, refresh, @auth_token)
+      end
+
+      def information(refresh = false)
+        Git::Semaphore::API::Cache.information(project_hash_id, branch_id, build_number, refresh, @auth_token)
+      end
+
+      def log(refresh = false)
+        Git::Semaphore::API::Cache.log(project_hash_id, branch_id, build_number, refresh, @auth_token)
+      end
+
+      def rebuild
+        Git::Semaphore::API.rebuild(project_hash_id, branch_id, @auth_token)
+      end
+
+      def browse
+        `open #{branch_url}`
+        { url: branch_url }
+      end
+
+      private
+
+      def project_hash_for(owner, name)
+        self.class.projects.find { |project_hash|
+          project_hash['owner'] == owner && project_hash['name'] == name
+        }
+      end
+
+      def project_hash
+        project_hash_for(@owner, @name)
+      end
+
+      def project_hash_id_for(owner, name)
+        project_hash_for(owner, name)['hash_id']
+      end
+
+      def project_hash_id
+        project_hash_id_for(@owner, @name)
+      end
+
+      def branch_hash_for(branch_name)
+        branches.find { |branch_hash|
+          branch_hash['name'] == branch_name
+        }
+      end
+
+      def branch_hash
+        branch_hash_for(@branch_name)
+      end
+
+      def branch_id_for(branch_name)
+        branch_hash_for(branch_name)['id'].to_s
+      end
+
+      def branch_id
+        branch_id_for(@branch_name)
+      end
+
+    end
   end
-
-  def log
-    Git::Semaphore::API::Cache.log(project_hash_id, branch_id, build_number, @auth_token,)
-  end
-
-  def rebuild
-    Git::Semaphore::API.rebuild(project_hash_id, branch_id, @auth_token)
-  end
-
-  private
-
-  def project_hash_for owner, name
-    self.class.projects.find { |project_hash|
-      project_hash['owner'] == owner && project_hash['name'] == name
-    }
-  end
-
-  def project_hash
-    project_hash_for(@owner, @name)
-  end
-
-  def project_hash_id_for owner, name
-    project_hash_for(owner, name)['hash_id']
-  end
-
-  def project_hash_id
-    project_hash_id_for(@owner, @name)
-  end
-
-  def branch_hash_for branch_name
-    branches.find { |branch_hash|
-      branch_hash['name'] == branch_name
-    }
-  end
-
-  def branch_hash
-    branch_hash_for(@branch_name)
-  end
-
-  def branch_id_for branch_name
-    branch_hash_for(branch_name)['id'].to_s
-  end
-
-  def branch_id
-    branch_id_for(@branch_name)
-  end
-
 end