gitomator 0.1.1

data/lib/gitomator/context.rb

@@ -0,0 +1,132 @@
+require 'gitomator'
+
+
+module Gitomator
+
+
+  #
+  # Register service-factories, and create services.
+  #
+  class BaseContext
+
+    #
+    # @param config [Hash]
+    #
+    def initialize(config)
+      @config = config
+      @service2factory = {}
+      @services = {}
+
+      config.select { |_,v| v.is_a?(Hash) && v.has_key?('provider')}
+        .each do |service, service_config|
+          register_service(service.to_sym) do |config|
+            self.send("create_#{config['provider']}_#{service}_service", config || {})
+          end
+        end
+
+    end
+
+
+    #
+    # @param service [Symbol] The service's name.
+    # @param block [Proc<Hash> -> Object] Given a config, create a service object.
+    #
+    def register_service(service, &block)
+      @service2factory[service] = block
+
+      # Create a lazy-loader getter for the service
+      unless self.respond_to? service
+        self.class.send(:define_method, service) do
+          @services[service] ||= @service2factory[service].call(@config[service.to_s] || {})
+        end
+      end
+    end
+
+  end
+
+
+  #=============================================================================
+
+
+  class Context < BaseContext
+
+    #
+    # Convenience function to create Context instances from configuration files.
+    # @param config_file [String/File] - YAML configuration file.
+    #
+    def self.from_file(config_file)
+      return new(Gitomator::Util.load_config(config_file))
+    end
+
+    #---------------------------------------------------------------------------
+
+
+    DEFAULT_CONFIG = {
+      'git'     => { 'provider' => 'shell'},
+      'hosting' => { 'provider' => 'local'}
+    }
+
+    def initialize(config={})
+      super(DEFAULT_CONFIG.merge(config))
+    end
+
+
+    def create_local_hosting_service(config)
+      require 'gitomator/service/hosting'
+      require 'gitomator/service_provider/hosting_local'
+      require 'tmpdir'
+
+      dir = config['dir'] || Dir.mktmpdir('Gitomator_')
+      return Gitomator::Service::Hosting.new (
+        Gitomator::ServiceProvider::HostingLocal.new(git, dir)
+      )
+    end
+
+
+    def create_shell_git_service(_)
+      require 'gitomator/service/git'
+      require 'gitomator/service_provider/git_shell'
+      Gitomator::Service::Git.new(Gitomator::ServiceProvider::GitShell.new())
+    end
+
+
+    #---------------------------------------------------------------------------
+
+    # Services from here onwards should have really been plug-ins.
+    # Unfortuantely, I don't know of a clean way to do that in Ruby.
+
+
+    def create_github_hosting_service(config)
+      require 'gitomator/service/hosting'
+      require 'gitomator/github/hosting_provider'
+
+      return Gitomator::Service::Hosting.new (
+        Gitomator::GitHub::HostingProvider.from_config(config))
+    end
+
+
+    def create_travis_ci_service(config)
+      require 'gitomator/service/ci'
+      require 'gitomator/travis/ci_provider'
+
+      return Gitomator::Service::CI.new(
+        Gitomator::Travis::CIProvider.from_config(config))
+    end
+
+    def create_travis_pro_ci_service(config)
+      create_travis_ci_service(config)
+    end
+
+
+    def create_github_tagging_service(config)
+      require 'gitomator/service/tagging'
+      require 'gitomator/github/tagging_provider'
+
+      return Gitomator::Service::Tagging.new (
+        Gitomator::GitHub::TaggingProvider.from_config(config))
+    end
+
+
+
+  end
+end

data/lib/gitomator/exceptions.rb

@@ -0,0 +1,21 @@
+module Gitomator
+  module Exception
+
+    #
+    # This error will be thrown when a valid service method is called, but
+    # the underlying provider does not implement the given method.
+    #
+    class UnsupportedProviderMethod < StandardError
+      attr_reader :provider, :method
+
+      def initialize(provider, method)
+        @provider = provider
+        @method   = method
+
+        provider_name = provider.respond_to?(:name) ? provider.name : 'Unknown'
+        super("#{provider_name} provider does not support the #{method} method.")
+      end
+    end
+
+  end
+end

data/lib/gitomator/service/ci.rb

@@ -0,0 +1,35 @@
+require 'gitomator/service'
+
+module Gitomator
+  module Service
+    class CI < Gitomator::BaseService
+
+
+      def initialize(provider, opts = {})
+        super(provider, opts)
+      end
+
+
+      def sync(blocking=false, opts={})
+        service_call(__callee__, blocking, opts)
+      end
+
+      def syncing?(opts={})
+        service_call(__callee__, opts)
+      end
+
+      def enable_ci(repo, opts={})
+        service_call(__callee__, repo, opts)
+      end
+
+      def disable_ci(repo, opts={})
+        service_call(__callee__, repo, opts)
+      end
+
+      def ci_enabled?(repo)
+        service_call(__callee__, repo)
+      end
+
+    end
+  end
+end

data/lib/gitomator/service/git.rb

@@ -0,0 +1,48 @@
+require 'gitomator/service'
+
+module Gitomator
+  module Service
+    class Git < Gitomator::BaseService
+
+
+      def initialize(provider, opts = {})
+        super(provider, opts)
+      end
+
+      # ----------------------------------------------------------------------
+
+      def clone(repo_url, local_repo_root, opts={})
+        service_call(__callee__, repo_url, local_repo_root, opts)
+      end
+
+      def init(local_repo_root, opts={})
+        service_call(__callee__, local_repo_root, opts)
+      end
+
+      def add(local_repo_root, path, opts={})
+        service_call(__callee__, local_repo_root, path, opts)
+      end
+
+      def commit(local_repo_root, message, opts={})
+        service_call(__callee__, local_repo_root, message, opts)
+      end
+
+      def checkout(local_repo_root, branch, opts={})
+        service_call(__callee__, local_repo_root, branch, opts)
+      end
+
+      def set_remote(local_repo_root, remote, url, opts={})
+        service_call(__callee__, local_repo_root, remote, url, opts)
+      end
+
+      def push(local_repo_root, remote, opts={})
+        service_call(__callee__, local_repo_root, remote, opts)
+      end
+
+      def command(local_repo_root, command)
+        service_call(__callee__, local_repo_root, command)
+      end
+
+    end
+  end
+end

data/lib/gitomator/service/hosting.rb

@@ -0,0 +1,204 @@
+require 'gitomator/service'
+require 'gitomator/util/repo/name_resolver'
+
+module Gitomator
+  module Service
+    class Hosting < Gitomator::BaseService
+
+
+      def initialize(provider, opts = {})
+        super(provider, opts)
+        @name_resolver = Gitomator::Util::Repo::NameResolver.new(
+          provider.respond_to?(:namespace) ? provider.namespace : nil)
+      end
+
+      # ---------------------------- Name resolution ---------------------------
+
+      def resolve_namespace(name)
+        @name_resolver.namespace(name)
+      end
+
+      def resolve_repo_name(name)
+        @name_resolver.name_only(name)
+      end
+
+      def resolve_branch(name)
+        @name_resolver.branch(name)
+      end
+
+      # ----------------------- CRUD operations on repos -----------------------
+
+      def create_repo(name, opts={})
+        service_call(__callee__, name, opts)
+      end
+
+      def read_repo(name)
+        service_call(__callee__, name)
+      end
+
+      def update_repo(name, opts={})
+        service_call(__callee__, name, opts)
+      end
+
+      def delete_repo(name)
+        service_call(__callee__, name)
+      end
+
+      def search_repos(query, opts={})
+        service_call(__callee__, query, opts)
+      end
+
+      # ----------------------- CRUD operations on teams ---------------------
+
+      def create_team(name, opts={})
+        service_call(__callee__, name, opts)
+      end
+
+      def read_team(name)
+        service_call(__callee__, name)
+      end
+
+      def update_team(name, opts={})
+        service_call(__callee__, name, opts)
+      end
+
+      def delete_team(name)
+        service_call(__callee__, name)
+      end
+
+      def search_teams(query, opts={})
+        service_call(__callee__, query, opts)
+      end
+
+      # ----------------------------------------------------------------------
+
+      def search_users(query, opts={})
+        service_call(__callee__, query, opts)
+      end
+
+      # ------------ CRUD operations on team_memberships -----------------------
+
+
+      #
+      # @param team_name [String]
+      # @param user_name [String]
+      # @param role [String]
+      #
+      def create_team_membership(team_name, user_name, role=nil)
+        # The if/else block is here so that different providers can implement
+        # the `create_team_membership` with a default value for the role argument.
+        if role.nil?
+          service_call(__callee__, team_name, user_name)
+        else
+          service_call(__callee__, team_name, user_name, role)
+        end
+
+      end
+
+      #
+      # @param team_name [String]
+      # @param user_name [String]
+      #
+      # @return [String] The current role of `user_name` in `team_name`, or nil (if the user is not a member of the team)
+      #
+      def read_team_membership(team_name, user_name)
+        service_call(__callee__, team_name, user_name)
+      end
+
+      #
+      # @param team_name [String]
+      # @param user_name [String]
+      # @param role [String]
+      #
+      def update_team_membership(team_name, user_name, role)
+        service_call(__callee__, team_name, user_name, role)
+      end
+
+      #
+      # @param team_name [String]
+      # @param user_name [String]
+      #
+      def delete_team_membership(team_name, user_name)
+        service_call(__callee__, team_name, user_name)
+      end
+
+      # --------------- CRUD operations on permissions -----------------------
+
+      #
+      # @param user (String) username
+      # @param repo (String) Repo name (full name, or repo-only)
+      # @param permission (Symbol) Either :read or :write or nil
+      #
+      def set_user_permission(user, repo, permission)
+        service_call(__callee__, user, repo, permission)
+      end
+
+      #
+      # @param user (String) username
+      # @param team (String) Team name
+      # @param permission (Symbol) Either :read or :write or nil
+      #
+      def set_team_permission(team, repo, permission)
+        service_call(__callee__, team, repo, permission)
+      end
+
+      # ----------------------------------------------------------------------
+
+
+      # ------------------- CRUD operations on pull-requests -----------------
+      #
+      # We assume that pull-requests have id's, and that id's are
+      # unique within a repo.
+      # That is, the pair (dest_repo, id) uniquely identifies a pull-request.
+      #
+
+
+
+      def create_pull_request(src, dst, opts = {})
+        service_call(__callee__, src, dst, opts)
+      end
+
+
+
+      def read_pull_request(dst_repo, id)
+        service_call(__callee__, dst_repo, id)
+      end
+
+      def read_pull_requests(dst_repo, opts = {})
+        service_call(__callee__, dst_repo, opts)
+      end
+
+
+      # Pull-request update methods:
+
+
+      def merge_pull_request(dst_repo, id, message='')
+        service_call(__callee__, dst_repo, id, message)
+      end
+
+      def close_pull_request(dst_repo, id)
+        service_call(__callee__, dst_repo, id)
+      end
+
+      def open_pull_request(dst_repo, id)
+        service_call(__callee__, dst_repo, id)
+      end
+
+
+      #
+      # A "general-purpose" update method for pull-requests.
+      #
+      def update_pull_request(dst_repo, id, opts)
+        service_call(__callee__, dst_repo, id)
+      end
+
+
+
+      def delete_pull_request(dst_repo, id)
+        service_call(__callee__, dst_repo, id)
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/service/tagging.rb

@@ -0,0 +1,99 @@
+require 'gitomator/service'
+
+module Gitomator
+  module Service
+    class Tagging < Gitomator::BaseService
+
+
+      #
+      # Add `tag` to object (the object with the given `id_or_name` in the
+      # given `namespace`)
+      #
+      # @param namespace  [String]
+      # @param id_or_name [String/Number]
+      # @param tags [*String]
+      #
+      def add_tags(namespace, id_or_name, *tags)
+        service_call(__callee__, namespace, id_or_name, *tags)
+      end
+
+
+      #
+      # Remove tag from object.
+      #
+      # @param namespace  [String]
+      # @param id_or_name [String/Number]
+      # @param tag [String]
+      #
+      def remove_tag(namespace, id_or_name, tag)
+        service_call(__callee__, namespace, id_or_name, tag)
+      end
+
+
+      #
+      # Get all tags associated with the specified object.
+      #
+      # @param namespace  [String]
+      # @param id_or_name [String/Number]
+      #
+      # @return [Array<String>]
+      #
+      def tags(namespace, id_or_name)
+        service_call(__callee__, namespace, id_or_name)
+      end
+
+
+      #
+      # Search for objects by tag(s).
+      #
+      # @param namespace  [String]
+      # @param query [String/Hash] - Either a single tag (String) or a query (Hash).
+      #
+      # @return Enumerable of object identifiers.
+      #
+      def search(namespace, query)
+        service_call(__callee__, namespace, query)
+      end
+
+
+      #
+      # Get the metadata associated with the given tag in the given namespace.
+      # If a `tag` is not specified, get metadata for all tags in the namespace.
+      #
+      # @param namespace  [String]
+      # @param tag  [String]
+      #
+      # @return [Hash<String,Object>] The tag's metadata. If no tag was specified, return a Hash that maps each tag to its metadata.
+      #
+      def metadata(namespace, tag=nil)
+        service_call(__callee__, namespace, tag)
+      end
+
+
+      #
+      # Add the given metadata to the given tag (in the given namespace).
+      # You can remove metadata properties by updating their value to nil.
+      #
+      # @param namespace  [String]
+      # @param tag  [String]
+      # @param metadata  [String]
+      #
+      def set_metadata(namespace, tag, metadata)
+        service_call(__callee__, namespace, tag, metadata)
+      end
+
+
+      #
+      # Delete all metadata associated with the given tag (in the given namespace).
+      #
+      # @param namespace  [String]
+      # @param tag  [String]
+      #
+      def delete_metadata(namespace, tag)
+        service_call(__callee__, namespace, tag)
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/service.rb

@@ -0,0 +1,64 @@
+require 'gitomator'
+require 'gitomator/exceptions'
+
+module Gitomator
+  class BaseService
+
+    attr_reader :provider
+
+    def initialize(provider, opts = {})
+      @provider = provider
+      @blocks  = { :before => [], :after => [], :error => [] }
+    end
+
+    #---------------------------------------------------------------------------
+    # Inject blocks that do pre/post processing (e.g. logging)
+    # Note: The blocks are bound to the service instance (i.e. in the block,
+    #   self refers to the service instance)
+
+    #
+    # @param block [ Proc (String method_name, Array<Object> args) => nil ]
+    #
+    def before_each_service_call(&block)
+      @blocks[:before].push block
+    end
+
+    #
+    # @param block [ Proc (String method_name, Array<Object> args, Object result) => nil ]
+    #
+    def after_each_service_call(&block)
+      @blocks[:after].push block
+    end
+
+    #
+    # @param block [ Proc (String method_name, Array<Object> args, Error error) => nil ]
+    #
+    def on_service_call_error(&block)
+      @blocks[:error].push block
+    end
+
+    #---------------------------------------------------------------------------
+
+
+    def service_call(method, *args)
+      result = nil
+      @blocks[:before].each {|block| self.instance_exec(method, args, &block) }
+
+      begin
+        if provider.respond_to?(method)
+          result = @provider.send(method, *args)
+        else
+          raise Gitomator::Exception::UnsupportedProviderMethod.new(@provider, method)
+        end
+      rescue Exception => e
+        @blocks[:error].each {|block| self.instance_exec(method, args, e, &block) }
+        raise e
+      end
+
+      @blocks[:after].each {|block| self.instance_exec(method, args, result, &block) }
+      return result
+    end
+
+
+  end
+end

data/lib/gitomator/service_provider/git_shell.rb

@@ -0,0 +1,68 @@
+module Gitomator
+  module ServiceProvider
+    class GitShell
+
+      def clone(repo_url, local_repo_root, opts)
+        _run_command("git clone #{repo_url} #{local_repo_root}", opts = {})
+      end
+
+      def init(local_repo_root, opts = {})
+        Dir.mkdir(local_repo_root) unless Dir.exists?(local_repo_root)
+        _run_git_command("init", local_repo_root)
+      end
+
+      def add(local_repo_root, path, opts={})
+        _run_git_command("add #{path}", local_repo_root, opts)
+      end
+
+      def commit(local_repo_root, message, opts={})
+        cmd = "commit -m \"#{message.gsub('"', '\\\"')}\""
+        _run_git_command(cmd, local_repo_root, opts)
+      end
+
+      def checkout(local_repo_root, branch, opts)
+        cmd = 'checkout '
+        if opts[:is_new]
+          cmd += '-b '
+        end
+        cmd += branch
+        if opts[:is_remote]
+          cmd += " origin/#{branch}"
+        end
+
+        _run_git_command(cmd, local_repo_root, {})
+      end
+
+      def set_remote(local_repo_root, remote, url, opts)
+        cmd = "remote #{opts[:create] ? 'add' : 'set-url'} #{remote} #{url}"
+        opts.delete :create
+        _run_git_command(cmd, local_repo_root, opts)
+      end
+
+      def push(local_repo_root, remote, opts)
+        raise "Unsupported"
+      end
+
+
+      def command(local_repo_root, command)
+        _run_git_command(command, local_repo_root, opts = {})
+      end
+
+      #=====================================================================
+
+
+      def _run_command(cmd, opts = {})
+        system({}, cmd, opts)
+      end
+
+      def _run_git_command(cmd, local_repo_root, opts = {})
+        opts[:chdir] = local_repo_root
+        unless cmd.strip.start_with? 'git'
+          cmd = 'git ' + cmd
+        end
+        _run_command(cmd, opts)
+      end
+
+    end
+  end
+end