semaphore_client 2.0.6

data/lib/semaphore_client/exceptions.rb

@@ -0,0 +1,6 @@
+class SemaphoreClient
+  class Exceptions
+    class AttributeNotAvailable < StandardError; end
+    class RequestFailed < StandardError; end
+  end
+end

data/lib/semaphore_client/http_client.rb

@@ -0,0 +1,58 @@
+require "faraday"
+
+class SemaphoreClient
+  class HttpClient
+    class RouteNotSupported < StandardError; end
+
+    def initialize(auth_token, api_url, api_version)
+      @auth_token = auth_token
+      @api_url = api_url
+      @api_version = api_version
+    end
+
+    def get(route_elements)
+      route = route(route_elements)
+
+      connection.get(route)
+    end
+
+    def post(route_elements, content = nil)
+      route = route(route_elements)
+
+      if content
+        connection.post(route, content)
+      else
+        connection.post(route)
+      end
+    end
+
+    def patch(route_elements, content = nil)
+      route = route(route_elements)
+
+      if content
+        connection.patch(route, content)
+      else
+        connection.patch(route)
+      end
+    end
+
+    def delete(route_elements)
+      route = route(route_elements)
+
+      connection.delete(route)
+    end
+
+    private
+
+    def route(route_elements)
+      ["", @api_version, *route_elements].compact.join("/")
+    end
+
+    def connection
+      @connection ||= Faraday.new(
+        :url => @api_url,
+        :headers => { "Authorization" => "Token #{@auth_token}" }
+      )
+    end
+  end
+end

data/lib/semaphore_client/model/config_file.rb

@@ -0,0 +1,61 @@
+class SemaphoreClient
+  module Model
+    class ConfigFile
+      attr_reader :id, :url, :shared, :encrypted, :created_at, :updated_at
+      attr_accessor :path, :content
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @id = attributes[:id] if attributes.key?(:id)
+        @path = attributes[:path] if attributes.key?(:path)
+        @url = attributes[:url] if attributes.key?(:url)
+        @content = attributes[:content] if attributes.key?(:content)
+        @shared = attributes[:shared] if attributes.key?(:shared)
+        @encrypted = attributes[:encrypted] if attributes.key?(:encrypted)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+
+        self
+      end
+
+      def update(attributes)
+        attributes = symbolize_keys(attributes)
+
+        updatable_keys = [:path, :content]
+
+        if (attributes.keys - updatable_keys).any?
+          raise SemaphoreClient::Exceptions::AttributeNotAvailable
+        end
+
+        @path = attributes[:path] if attributes.key?(:path)
+        @content = attributes[:content] if attributes.key?(:content)
+
+        self
+      end
+
+      def serialize
+        object_hash = {
+          "path" => @path,
+          "content" => @content,
+        }
+
+        object_hash.delete_if { |_, value| value.nil? }
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end

data/lib/semaphore_client/model/env_var.rb

@@ -0,0 +1,61 @@
+class SemaphoreClient
+  module Model
+    class EnvVar
+      attr_reader :id, :url, :shared, :encrypted, :created_at, :updated_at
+      attr_accessor :name, :content
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @id = attributes[:id] if attributes.key?(:id)
+        @name = attributes[:name] if attributes.key?(:name)
+        @url = attributes[:url] if attributes.key?(:url)
+        @content = attributes[:content] if attributes.key?(:content)
+        @shared = attributes[:shared] if attributes.key?(:shared)
+        @encrypted = attributes[:encrypted] if attributes.key?(:encrypted)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+
+        self
+      end
+
+      def update(attributes)
+        attributes = symbolize_keys(attributes)
+
+        updatable_keys = [:name, :content]
+
+        if (attributes.keys - updatable_keys).any?
+          raise SemaphoreClient::Exceptions::AttributeNotAvailable
+        end
+
+        @name = attributes[:name] if attributes.key?(:name)
+        @content = attributes[:content] if attributes.key?(:content)
+
+        self
+      end
+
+      def serialize
+        object_hash = {
+          "name" => @name,
+          "content" => @content,
+        }
+
+        object_hash.delete_if { |_, value| value.nil? }
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end

data/lib/semaphore_client/model/org.rb

@@ -0,0 +1,46 @@
+class SemaphoreClient
+  module Model
+    class Org
+      attr_reader :projects_url, :teams_url, :name, :username, :updated_at, :id, :url, :shared_configs_url, :users_url, :created_at
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @projects_url = attributes[:projects_url] if attributes.key?(:projects_url)
+        @teams_url = attributes[:teams_url] if attributes.key?(:teams_url)
+        @name = attributes[:name] if attributes.key?(:name)
+        @username = attributes[:username] if attributes.key?(:username)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+        @id = attributes[:id] if attributes.key?(:id)
+        @url = attributes[:url] if attributes.key?(:url)
+        @shared_configs_url = attributes[:shared_configs_url] if attributes.key?(:shared_configs_url)
+        @users_url = attributes[:users_url] if attributes.key?(:users_url)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+
+        self
+      end
+
+      def update(attributes)
+        self
+      end
+
+      def serialize
+        {}
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end

data/lib/semaphore_client/model/project.rb

@@ -0,0 +1,44 @@
+class SemaphoreClient
+  module Model
+    class Project
+      attr_reader :id, :name, :users_url, :shared_configs_url, :env_vars_url, :config_files_url, :updated_at, :created_at
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @id = attributes[:id] if attributes.key?(:id)
+        @name = attributes[:name] if attributes.key?(:name)
+        @users_url = attributes[:users_url] if attributes.key?(:users_url)
+        @shared_configs_url = attributes[:shared_configs_url] if attributes.key?(:shared_configs_url)
+        @env_vars_url = attributes[:env_vars_url] if attributes.key?(:env_vars_url)
+        @config_files_url = attributes[:config_files_url] if attributes.key?(:config_files_url)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+
+        self
+      end
+
+      def update(attributes)
+        self
+      end
+
+      def serialize
+        {}
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end

data/lib/semaphore_client/model/shared_config.rb

@@ -0,0 +1,63 @@
+class SemaphoreClient
+  module Model
+    class SharedConfig
+      attr_reader :projects_url, :teams_url, :config_files_url, :updated_at, :env_vars_url, :id, :url, :created_at
+      attr_accessor :name, :description
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @description = attributes[:description] if attributes.key?(:description)
+        @projects_url = attributes[:projects_url] if attributes.key?(:projects_url)
+        @teams_url = attributes[:teams_url] if attributes.key?(:teams_url)
+        @name = attributes[:name] if attributes.key?(:name)
+        @config_files_url = attributes[:config_files_url] if attributes.key?(:config_files_url)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+        @env_vars_url = attributes[:env_vars_url] if attributes.key?(:env_vars_url)
+        @id = attributes[:id] if attributes.key?(:id)
+        @url = attributes[:url] if attributes.key?(:url)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+
+        self
+      end
+
+      def update(attributes)
+        attributes = symbolize_keys(attributes)
+
+        updatable_keys = [:name, :description]
+
+        if (attributes.keys - updatable_keys).any?
+          raise SemaphoreClient::Exceptions::AttributeNotAvailable
+        end
+
+        @name = attributes[:name] if attributes.key?(:name)
+        @description = attributes[:description] if attributes.key?(:description)
+
+        self
+      end
+
+      def serialize
+        object_hash = {
+          "name" => @name,
+          "description" => @description,
+        }
+
+        object_hash.delete_if { |_, value| value.nil? }
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end

data/lib/semaphore_client/model/team.rb

@@ -0,0 +1,65 @@
+class SemaphoreClient
+  module Model
+    class Team
+      attr_reader :projects_url, :updated_at, :id, :url, :shared_configs_url, :users_url, :created_at
+      attr_accessor :name, :permission, :description
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @description = attributes[:description] if attributes.key?(:description)
+        @projects_url = attributes[:projects_url] if attributes.key?(:projects_url)
+        @permission = attributes[:permission] if attributes.key?(:permission)
+        @name = attributes[:name] if attributes.key?(:name)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+        @id = attributes[:id] if attributes.key?(:id)
+        @url = attributes[:url] if attributes.key?(:url)
+        @shared_configs_url = attributes[:shared_configs_url] if attributes.key?(:shared_configs_url)
+        @users_url = attributes[:users_url] if attributes.key?(:users_url)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+
+        self
+      end
+
+      def update(attributes)
+        attributes = symbolize_keys(attributes)
+
+        updatable_keys = [:name, :permission, :description]
+
+        if (attributes.keys - updatable_keys).any?
+          raise SemaphoreClient::Exceptions::AttributeNotAvailable
+        end
+
+        @name = attributes[:name] if attributes.key?(:name)
+        @permission = attributes[:permission] if attributes.key?(:permission)
+        @description = attributes[:description] if attributes.key?(:description)
+
+        self
+      end
+
+      def serialize
+        object_hash = {
+          "name" => @name,
+          "permission" => @permission,
+          "description" => @description,
+        }
+
+        object_hash.delete_if { |_, value| value.nil? }
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end

data/lib/semaphore_client/model/user.rb

@@ -0,0 +1,41 @@
+class SemaphoreClient
+  module Model
+    class User
+      attr_reader :uid, :username, :name, :created_at, :updated_at
+
+      def self.load(attributes)
+        new.load(attributes)
+      end
+
+      def self.create(attributes)
+        new.update(attributes)
+      end
+
+      def load(attributes)
+        attributes = symbolize_keys(attributes)
+
+        @uid = attributes[:uid] if attributes.key?(:uid)
+        @username = attributes[:username] if attributes.key?(:username)
+        @name = attributes[:name] if attributes.key?(:name)
+        @created_at = attributes[:created_at] if attributes.key?(:created_at)
+        @updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+
+        self
+      end
+
+      def update(attributes)
+        self
+      end
+
+      def serialize
+        {}
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.map { |key, value| [key.to_sym, value] }.to_h
+      end
+    end
+  end
+end