git-semaphore 0.0.9 → 1.0.0

data/lib/git/semaphore/api.rb

@@ -0,0 +1,133 @@
+module Git
+  module Semaphore
+    class API
+
+      def self.projects auth_token
+        get_json projects_uri(auth_token)
+      end
+
+      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
+        get_json status_uri(project_hash_id, branch_id, auth_token)
+      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
+      end
+
+      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
+        # https://semaphoreci.com/docs/projects-api.html
+        # GET /api/v1/projects
+        request_uri(auth_token, :path => File.join('projects'))
+      end
+
+      private_class_method :projects_uri
+
+      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'))
+      end
+
+      private_class_method :branches_uri
+
+      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'))
+      end
+
+      private_class_method :status_uri
+
+      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)
+      end
+
+      private_class_method :history_uri
+
+      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'))
+      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
+          raise "JSON response expected" unless self['content-type'] =~ %r{application/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

@@ -0,0 +1,59 @@
+module Git
+  module Semaphore
+    class API
+      class Cache
+
+        def self.projects auth_token
+          @projects ||= Git::Semaphore.from_json_cache(projects_cache) 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
+            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
+            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
+            API::Enrich.history project_hash_id, branch_id, auth_token
+          end
+        end
+
+        # private helper functions
+
+        def self.projects_cache
+          File.join(Git::Semaphore.cache_dir, 'projects.json')
+        end
+
+        private_class_method :projects_cache
+
+        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
+          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
+          File.join(Git::Semaphore.cache_dir_for(project_hash_id), "#{branch_id}_history.json")
+        end
+
+        private_class_method :history_cache
+
+      end
+    end
+  end
+end

data/lib/git/semaphore/api_enrich.rb

@@ -0,0 +1,40 @@
+module Git
+  module Semaphore
+    class API
+      class Enrich
+
+        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'
+              project['full_name']  = [project['owner'], project['name']].join('/')
+              # https://semaphoreci.com/pvdb/git-semaphore -> https://github.com/pvdb/git-semaphore
+              project['github_url'] = project['html_url'].sub(/semaphoreci\.com/, 'github.com')
+            end
+          end
+        end
+
+        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
+              build['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),
+              }
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/git/semaphore/app.rb

@@ -0,0 +1,121 @@
+class Git::Semaphore::App
+
+  attr_writer :project_name
+  attr_writer :branch_name
+  attr_writer :commit_sha
+
+  attr_reader :branch_url
+
+  def initialize auth_token, git_repo, config = ENV
+    @auth_token = auth_token
+    @git_repo   = git_repo
+
+    self.project_name = config['SEMAPHORE_PROJECT_NAME']
+    self.branch_name  = config['SEMAPHORE_BRANCH_NAME']
+    self.commit_sha   = config['SEMAPHORE_COMMIT_SHA']
+  end
+
+  def to_json
+    {
+      semaphore_auth_token:   @auth_token,
+      semaphore_project_name: self.project_name,
+      semaphore_branch_name:  self.branch_name,
+      semaphore_commit_sha:   self.commit_sha,
+    }.to_json
+  end
+
+  def project_name
+    return @project_name unless @project_name.nil?
+    File.basename @git_repo.git.work_tree if @git_repo
+  end
+
+  def branch_name
+    return @branch_name unless @branch_name.nil?
+    @git_repo.head.name if @git_repo
+  end
+
+  def commit_sha
+    return @commit_sha unless @commit_sha.nil?
+    @git_repo.head.commit.id if @git_repo
+  end
+
+  def projects
+    Git::Semaphore::API::Cache.projects(@auth_token)
+  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 rebuild
+    Git::Semaphore::API.rebuild(project_hash_id, branch_id, @auth_token)
+  end
+
+  def branch_url
+    branch_hash = project_hash['branches'].find { |hash|
+      hash['branch_name'] == branch_name
+    }
+    branch_hash['branch_url']
+  end
+
+  private
+
+  def project_hash_for project_name
+    projects.find { |project_hash|
+      project_hash['name'] == project_name
+    }
+  end
+
+  def project_hash
+    project_hash_for(project_name)
+  end
+
+  def project_hash_id_for project_name
+    project_hash_for(project_name)['hash_id']
+  end
+
+  def project_hash_id
+    project_hash_id_for(project_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
+
+  def build_statuses
+    history['builds']
+  end
+
+  def build_status_for commit_sha
+    build_statuses.find { |build_status|
+      build_status['commit']['id'] == commit_sha
+    }
+  end
+
+  def build_status
+    build_status_for(commit_sha)
+  end
+
+end

data/lib/{git-semaphore → git/semaphore}/copyright.rb

@@ -1,6 +1,6 @@
 module Git
   module Semaphore
     # TODO replace hard-coded details with data retrieved from the gemspec
-    COPYRIGHT = "git-semaphore v#{Git::Semaphore::VERSION} Copyright (c) 2012-2015 Peter Vandenberk"
+    COPYRIGHT = "git-semaphore v#{Git::Semaphore::VERSION} Copyright (c) 2012-2016 Peter Vandenberk"
   end
 end

data/lib/{git-semaphore → git/semaphore}/version.rb

@@ -1,5 +1,5 @@
 module Git
   module Semaphore
-    VERSION = "0.0.9"
+    VERSION = "1.0.0"
   end
 end

data/lib/git/semaphore.rb

@@ -0,0 +1,77 @@
+require 'uri'
+require 'json'
+require 'openssl'
+require 'net/http'
+require 'fileutils'
+
+require 'grit'
+
+module Git
+  module Semaphore
+
+    def self.home_dir
+      @home_dir ||= begin
+        ENV['HOME'] || File.expand_path("~#{Etc.getlogin}")
+      end
+    end
+
+    def self.cache_dir
+      @cache_dir ||= begin
+        File.join(self.home_dir, '.git', 'semaphore').tap do |cache_dir|
+          FileUtils.mkdir_p(cache_dir)
+        end
+      end
+    end
+
+    def self.cache_dir_for identifier
+      File.join(self.cache_dir, identifier).tap do |cache_dir|
+        FileUtils.mkdir_p(cache_dir)
+      end
+    end
+
+    def self.empty_cache_dir
+      FileUtils.rm_r Dir.glob(File.join(self.cache_dir, '*'))
+    end
+
+    def self.from_json_cache path
+      if File.exists? path
+        JSON.parse(File.read(path))
+      else
+        yield.tap do |content|
+          File.open(path, 'w') { |file| file.write content.to_json }
+        end
+      end
+    end
+
+    def self.git_repo
+      @git_repo ||= begin
+        Grit::Repo.new(Dir.pwd)
+      rescue Grit::InvalidGitRepositoryError
+        nil
+      end
+    end
+
+    def self.env_auth_token
+      @env_auth_token ||= ENV['SEMAPHORE_AUTH_TOKEN']
+    end
+
+    def self.git_auth_token
+      git_repo && git_repo.config['semaphore.authtoken']
+    end
+
+    def self.auth_token
+      git_auth_token || env_auth_token
+    end
+
+  end
+end
+
+require 'git/semaphore/version'
+require 'git/semaphore/banner'
+require 'git/semaphore/copyright'
+
+require 'git/semaphore/api'
+require 'git/semaphore/api_cache'
+require 'git/semaphore/api_enrich'
+
+require 'git/semaphore/app'