git_duplicator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c56bf9a2478b996375f297102452f577a678625f
+  data.tar.gz: c9dcca68935f1f25245686697d9e1ee191811b33
+SHA512:
+  metadata.gz: 43b7d1d5308dcfbe6b812166463282c7ad47f6d0dbcd87b550ff38dab6eefaf36c17b481210c09af1d775dde79c4a05f82b1a6168399ac06497815f058f2d41f
+  data.tar.gz: a21c7b71c3b1269b19be4593c646873f05ade3fd6cf4e1dda211ffc1586e507dec80480d9bdbf0fe637936d1c401d144415dd89651e49d077e7713a364529ea9

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.env

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=doc

data/.test.env.example

@@ -0,0 +1,13 @@
+# General
+TESTING_REPO= 
+
+# Bitbucket info
+BITBUCKET_CONSUMER_KEY= 
+BITBUCKET_CONSUMER_SECRET= 
+BITBUCKET_TOKEN= 
+BITBUCKET_TOKEN_SECRET= 
+BITBUCKET_USER= 
+
+# Github info
+GITHUB_ACCESS_TOKEN= 
+GITHUB_USER=

data/.travis.yml

@@ -0,0 +1,21 @@
+bundler_args: "--without development"
+language: ruby
+rvm:
+- 1.9.3
+- 2.0.0
+- 2.1
+- rbx-2
+- jruby-19mode
+- ruby-head
+- jruby-head
+matrix:
+  include:
+  - rvm: jruby-19mode
+    env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+  - rvm: jruby-head
+    env: JRUBY_OPTS="$JRUBY_OPTS --debug"
+  allow_failures:
+  - rvm: jruby-head
+  - rvm: rbx-2
+  - rvm: ruby-head
+  fast_finish: true

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--markup markdown
+-
+README.md
+LICENSE.md

data/Gemfile

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+group :development do
+  gem 'pry'
+end
+
+group :test do
+  gem 'coveralls', '~> 0.7', :require => false
+  gem 'rspec', '>= 2.14'
+  gem 'rspec-nc'
+  gem 'rubocop', '>= 0.2', :platforms => [:ruby_19, :ruby_20, :ruby_21]
+  gem 'simplecov', '~> 0.7.1', :require => false
+  gem 'guard', '~> 2.6'
+  gem 'guard-rspec', '~> 4.2'
+  gem 'webmock', '~> 1.1'
+  gem 'dotenv'
+end
+
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}){ |m| "spec/git_duplicator/#{m[1]}_spec.rb" }
+  watch('spec/helper.rb')  { "spec" }
+end

data/LICENSE.md

@@ -0,0 +1,16 @@
+Copyright (c) 2014 Khaled alHabache
+
+LGPL-3.0 License
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.

data/README.md

@@ -0,0 +1,70 @@
+# Git Duplicator
+
+Duplicating git repositories without forking.
+
+- [x] Duplicate any repository
+- [x] Additional Github support
+- [x] Additional Bibucket support
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'git_duplicator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install git_duplicator
+
+## Usage
+
+### Basic usage
+
+Duplicate a repository. It assumes that you have the destination repository initiated. 
+
+```ruby
+require 'git_duplicator'
+from = GitDuplicator::Repository
+.new('source repo name', 'source repo url')
+to = GitDuplicator::Repository
+.new('destination repo name', 'destination repo url')
+GitDuplicator.perform(from, to)
+
+```
+### Advanced usage
+- You can create the destination repository automatically. This needs you to provide the needed authentication credentials for the script.
+- You can set the clone working path locally for the script to work. It's a temporary workplace that will get swiped after finishing.
+
+```ruby
+require 'git_duplicator'
+from = GitDuplicator::Repository
+.new('source repo name', 'source repo url')
+to = GitDuplicator::Services::GithubRepository
+.new('destination repo name', 'destination owner', {auth2_token: 'some token'})
+GitDuplicator.perform(from, to, force_create_destination: true, clone_path: 'path/to/tmp')
+```
+
+### Available Services
+
+The script works with any repository that you have access to. However, right now, there are 2 services that are implemented to help you initiate an empty destination repository. That way, you don't need to create them manaullay before doing the duplicaton. The services are Github and Bitbucket.
+
+### Adding new Services
+
+Adding new service, if needed, should be straight forward. You can look at the source of the Bitbucket or Github services implementations, where they inherit a base abstract class that you need to inherit as well.
+
+### Running tests
+
+To be able to run the tests, specially the acceptance ones, you need to rename the `.test.env.example` to `.test.env` and add the needed credentials for your accounts.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/Startappz/git_duplicator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+require 'dotenv/tasks'
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'doc']
+end
+
+task :default => :spec

data/git_duplicator.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'git_duplicator/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "git_duplicator"
+  gem.version       = GitDuplicator::Version
+  gem.authors       = ["Khaled alHabache"]
+  gem.email         = ["khellls@gmail.com"]
+  gem.summary       = %q{Duplicating git repositories without forking.}
+  gem.description   = %q{Duplicating git repositories without forking.}
+  gem.homepage      = "https://github.com/Startappz/git_duplicator"
+  gem.license       = 'LGPL-3'
+  gem.required_ruby_version = '>= 1.9.3'
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files = Dir.glob('gem/**/*')
+  gem.require_paths = ['lib']
+  gem.add_dependency 'http', '~> 0.6'
+  gem.add_dependency 'git', '~> 1.2'
+  gem.add_dependency 'simple_oauth', '~> 0.2'
+end

data/lib/git_duplicator/duplicator.rb

@@ -0,0 +1,66 @@
+require 'fileutils'
+require_relative 'null_logger'
+
+module GitDuplicator
+  class Duplicator
+    attr_accessor :from, :to, :logger, :clone_path, :force_create_destination
+
+    # @param [GitDuplicator::Repository, GitDuplicator::ServiceRepository]
+    #  from repository to mirror
+    # @param [GitDuplicator::Repository, GitDuplicator::ServiceRepository]
+    #  to repository to mirror to
+    # @param [Hash] options
+    # @option options [String] :clone_path
+    #   path to clone the repository to
+    # @option options [Boolean] :force_create_destination
+    #  delete the exisiting service repo then create it
+    # @option options [#info] :logger log what's going on
+    def initialize(from, to, options = {})
+      self.from = from
+      self.to = to
+      self.clone_path = options.fetch(:clone_path) { '/tmp' }
+      self.force_create_destination =
+        options.fetch(:force_create_destination) { false }
+      self.logger = options.fetch(:logger) { NullLogger.new }
+    end
+
+    # Perform the duplication
+    def perform
+      recreate_destination
+      clone_source
+      mirror
+    ensure
+      clean_up
+    end
+
+    private
+
+    attr_accessor :source_cloned
+
+    def recreate_destination
+      return unless force_create_destination
+      logger.info("Deleting existing destination repo: #{to.url}")
+      to.delete
+      logger.info("Creating destination repo: #{to.url}")
+      to.create
+    end
+
+    def clone_source
+      logger.info("Cloning bare Gitorious repo: #{from.url}")
+      from.bare_clone(clone_path)
+      self.source_cloned = true
+    end
+
+    def mirror
+      logger.info("Mirroring Gitorious to Bitbucket: #{from.url}")
+      from.mirror(to.url)
+    end
+
+    def clean_up
+      return unless source_cloned
+      logger.info 'Clean local source repo'
+      FileUtils.rm_rf("#{clone_path}/#{from.name}")
+      @cloned = nil
+    end
+  end
+end

data/lib/git_duplicator/errors.rb

@@ -0,0 +1,11 @@
+module GitDuplicator
+  class MigrationError < StandardError; end
+
+  class RepositoryDeletionError < MigrationError; end
+
+  class RepositoryCreationError < MigrationError; end
+
+  class RepositoryCloningError < MigrationError; end
+
+  class RepositoryMirorringError < MigrationError; end
+end

data/lib/git_duplicator/helpers/authorization_header.rb

@@ -0,0 +1,71 @@
+require 'base64'
+require 'simple_oauth'
+
+module GitDuplicator
+  module Helpers
+    # Generates authentication header
+    class AuthorizationHeader
+      OAUTH2_KEYS = [:oauth2_token]
+      OAUTH_KEYS = [:consumer_key, :consumer_secret, :token, :token_secret]
+      BASIC_KEYS = [:username, :password]
+
+      # @param [Hash] credentials
+      # @option credentials [Symbol] :oauth2_token used in oAuth2 authentication
+      # @option credentials [Symbol] :consumer_key used in oAuth authentication
+      # @option credentials [Symbol] :consumer_secret used in oAuth authentication
+      # @option credentials [Symbol] :token used in oAuth authentication
+      # @option credentials [Symbol] :token_secret used in oAuth authentication
+      # @option credentials [Symbol] :username used in basic authentication
+      # @option credentials [Symbol] :password used in basic authentication
+      # @param [Hash] request used in generating oauth headers
+      # @option request [Symbol] :method
+      # @option request [String] :url
+      # @option request [Array] :params
+      def initialize(credentials, request)
+        self.credentials = credentials
+        self.request_method = request.fetch(:method)
+        self.request_url = request.fetch(:url)
+        self.request_params = request.fetch(:params) { [] }
+      end
+
+      # Generate the header
+      def generate
+        if exists?(self.class::OAUTH2_KEYS)
+          oauth2_header
+        elsif exists?(self.class::OAUTH_KEYS)
+          oauth_header
+        elsif exists?(self.class::BASIC_KEYS)
+          basic_authenticaion_header
+        else
+          fail ArgumentError, 'Proper authentication keys are missing'
+        end
+      end
+
+      private
+
+      attr_accessor :credentials, :request_method, :request_url, :request_params
+
+      def exists?(list)
+        list.all? { |value| credentials.keys.include?(value) }
+      end
+
+      def oauth2_header
+        "token #{credentials[:oauth2_token]}"
+      end
+
+      def basic_authenticaion_header
+        "Basic #{base64_username_password}"
+      end
+
+      def oauth_header
+        SimpleOAuth::Header.new(request_method, request_url,
+                                request_params, credentials).to_s
+      end
+
+      def base64_username_password
+        Base64.encode64("#{credentials[:username]}" \
+                        ":#{credentials[:password]}")
+      end
+    end
+  end
+end

data/lib/git_duplicator/null_logger.rb

@@ -0,0 +1,14 @@
+module GitDuplicator
+  # Default logger
+  class NullLogger
+    def debug(*); end
+
+    def info(*); end
+
+    def warn(*); end
+
+    def error(*); end
+
+    def fatal(*); end
+  end
+end

data/lib/git_duplicator/repositories.rb

@@ -0,0 +1,3 @@
+require_relative 'errors'
+require_relative 'repository/repository'
+require_relative 'repository/service_repository'

data/lib/git_duplicator/repository/repository.rb

@@ -0,0 +1,41 @@
+require 'git'
+
+module GitDuplicator
+  # Basic Repostiroy
+  class Repository
+    attr_accessor :name, :url
+    attr_reader :repo
+
+    # Initializer
+    # @param [String] name name of the repository
+    # @param [String] url URL of the repository
+    def initialize(name, url)
+      self.name = name
+      self.url = url
+    end
+
+    # Repository attribute setter
+    # @param [Git::Base] repository
+    def repo=(repository)
+      fail(TypeError) unless repository.is_a?(Git::Base)
+      @repo = repository
+    end
+
+    # Bare clone the repository
+    # @param [String] path_to_repo path to clone the repository to
+    def bare_clone(path_to_repo)
+      self.repo = Git.clone(url, name, bare: true, path: path_to_repo)
+    rescue => exception
+      raise RepositoryCloningError, exception.message
+    end
+
+    # Mirror the repository
+    # @param [String] destination_url URL of destination repository 
+    def mirror(destination_url)
+      fail('No local repo defined. Set the "repo" attribute') unless repo
+      repo.push(destination_url, '--mirror')
+    rescue => exception
+      raise RepositoryMirorringError, exception.message
+    end
+  end
+end

data/lib/git_duplicator/repository/service_repository.rb

@@ -0,0 +1,29 @@
+module GitDuplicator
+  # Abstract class to use when defining new Git service provider
+  class ServiceRepository < Repository
+    attr_accessor :owner
+
+    # Initializer
+    # @param [String] name name of the repository
+    # @param [String] owner owner of the repository
+    def initialize(name, owner)
+      self.owner = owner
+      super(name, url)
+    end
+
+    # URL of the repositroy
+    def url
+      fail NotImplementedError
+    end
+
+    # Create the repositroy
+    def create
+      fail NotImplementedError
+    end
+
+    # Delete the repositroy
+    def delete
+      fail NotImplementedError
+    end
+  end
+end

data/lib/git_duplicator/services/bitbucket.rb

@@ -0,0 +1,67 @@
+require 'http'
+require_relative '../helpers/authorization_header'
+
+module GitDuplicator
+  module Services
+    # Bitbucket based repository
+    class BitbucketRepository < ServiceRepository
+      BASE_URI = 'https://api.bitbucket.org/2.0'
+
+      attr_accessor :credentials, :options
+
+      # Initializer
+      # @param [String] name name of the repository
+      # @param [String] owner owner of the repository
+      # @param [Hash] credentials
+      # @option credentials [Symbol] :consumer_key used in oAuth authentication
+      # @option credentials [Symbol] :consumer_secret used in oAuth authentication
+      # @option credentials [Symbol] :token used in oAuth authentication
+      # @option credentials [Symbol] :token_secret used in oAuth authentication
+      # @option credentials [Symbol] :username used in basic authentication
+      # @option credentials [Symbol] :password used in basic authentication
+      # @param [Hash] options options for creation
+      # @see https://confluence.atlassian.com/display/BITBUCKET/repository+Resource#repositoryResource-POSTanewrepository
+      def initialize(name, owner, credentials = {}, options = {})
+        super(name, owner)
+        self.credentials = credentials
+        self.options = options
+      end
+
+      # URL of the repositroy
+      def url
+        "git@bitbucket.org:#{owner}/#{name}.git"
+      end
+
+      # Create the repositroy
+      # @see https://confluence.atlassian.com/display/BITBUCKET/repository+Resource#repositoryResource-POSTanewrepository
+      def create
+        request_url = BASE_URI + "/repositories/#{owner}/#{name}"
+        response = HTTP.with(headers(:post, request_url))
+        .post(request_url, json: options)
+        code, body = response.code.to_i, response.body
+        fail(RepositoryCreationError, body) unless 200 == code
+      end
+
+      # Delete the repositroy
+      # @see https://confluence.atlassian.com/display/BITBUCKET/repository+Resource#repositoryResource-DELETEarepository
+      def delete
+        request_url = BASE_URI + "/repositories/#{owner}/#{name}"
+        response = HTTP.with(headers(:delete, request_url)).delete(request_url)
+        code, body = response.code.to_i, response.body
+        fail(RepositoryDeletionError, body) unless [204, 404].include?(code)
+      end
+
+      private
+
+      def headers(method, url)
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' =>
+          Helpers::AuthorizationHeader.new(
+            credentials, method: method, url: url
+          ).generate
+        }
+      end
+    end
+  end
+end

data/lib/git_duplicator/services/github.rb

@@ -0,0 +1,63 @@
+require 'http'
+require_relative '../helpers/authorization_header'
+
+module GitDuplicator
+  module Services
+    class GithubRepository < ServiceRepository
+      BASE_URI = 'https://api.github.com'
+
+      attr_accessor :credentials, :options
+
+      # Initializer
+      # @param [String] name name of the repository
+      # @param [String] owner owner of the repository
+      # @param [Hash] credentials
+      # @option credentials [Symbol] :oauth2_token used in oAuth2 authentication
+      # @option credentials [Symbol] :username used in basic authentication
+      # @option credentials [Symbol] :password used in basic authentication
+      # @param [Hash] options options for creation
+      # @see https://developer.github.com/v3/repos/#create
+      def initialize(name, owner, credentials = {}, options = {})
+        super(name, owner)
+        self.credentials = credentials
+        self.options = options
+      end
+
+      # URL of the repositroy
+      def url
+        "git@github.com:#{owner}/#{name}.git"
+      end
+
+      # Create the repository
+      # @see https://developer.github.com/v3/repos/#create
+      def create
+        request_url = BASE_URI + '/user/repos'
+        response = HTTP.with(headers(:post, request_url))
+        .post(request_url, json: options.merge(name: name))
+        code, body = response.code.to_i, response.body
+        fail(RepositoryCreationError, body) unless 201 == code
+      end
+
+      # Delete the repositroy
+      # @see https://developer.github.com/v3/repos/#delete-a-repository
+      def delete
+        request_url = BASE_URI + "/repos/#{owner}/#{name}"
+        response = HTTP.with(headers(:delete, request_url)).delete(request_url)
+        code, body = response.code.to_i, response.body
+        fail(RepositoryDeletionError, body) unless [204, 404].include?(code)
+      end
+
+      private
+
+      def headers(method, url)
+        {
+          'Accept' => 'application/vnd.github.v3+json',
+          'Authorization' =>
+          Helpers::AuthorizationHeader.new(
+            credentials, method: method, url: url
+          ).generate
+        }
+      end
+    end
+  end
+end

data/lib/git_duplicator/services.rb

@@ -0,0 +1,15 @@
+module GitDuplicator
+  # Load all implemented services
+  module Services
+    Dir[File.dirname(__FILE__) + '/services/**/*.rb'].each do |file|
+      # Get camelized class name
+      filename = File.basename(file, '.rb')
+      # Add _gateway suffix
+      gateway_name = filename + '_repository'
+      # Camelize the string to get the class name
+      gateway_class = gateway_name.split('_').map(&:capitalize).join
+      # Register for autoloading
+      autoload gateway_class, file
+    end
+  end
+end

data/lib/git_duplicator/version.rb

@@ -0,0 +1,15 @@
+module GitDuplicator
+  # Gem's version
+  class Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+
+    class << self
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH].compact.join('.')
+      end
+    end
+  end
+end

data/lib/git_duplicator.rb

@@ -0,0 +1,15 @@
+require_relative 'git_duplicator/version'
+require_relative 'git_duplicator/duplicator'
+require_relative 'git_duplicator/repositories'
+require_relative 'git_duplicator/services'
+
+# Main module
+module GitDuplicator
+  class << self
+    # Perform the duplication
+    # @see GitDuplicator::Duplicator
+    def perform(from, to, options)
+      Duplicator.new(from, to, options).perform
+    end
+  end
+end

data/spec/git_duplicator/duplicator_spec.rb

@@ -0,0 +1,82 @@
+require_relative '../helper'
+
+describe GitDuplicator::Duplicator do
+  let(:path) { '/somepath' }
+  let(:from) do
+    double(name: 'somename', bare_clone: nil, mirror: nil, url: 'somewhere1')
+  end
+  let(:to) { double(delete: nil, create: nil, url: 'somewhere2') }
+  let(:duplicator) { GitDuplicator::Duplicator.new(from, to, options) }
+
+  describe '#perform' do
+    context 'force_create_destination is set' do
+      let(:options) { { clone_path: path, force_create_destination: true } }
+
+      it 'deletes existing destination repo' do
+        expect(to).to receive(:delete)
+        duplicator.perform
+      end
+
+      it 'creates the destination repo' do
+        expect(to).to receive(:create)
+        duplicator.perform
+      end
+
+      it 'bare clones the source repo' do
+        expect(from).to receive(:bare_clone).with(path)
+        duplicator.perform
+      end
+
+      it 'mirrors from bare clone to destination' do
+        expect(from).to receive(:mirror).with(to.url)
+        duplicator.perform
+      end
+
+      it 'cleans up' do
+        expect(FileUtils).to receive(:rm_rf)
+        .with("#{duplicator.clone_path}/#{from.name}")
+        duplicator.perform
+      end
+
+      it 'logs 5 times' do
+        expect(duplicator.logger).to receive(:info).exactly(5).times
+        duplicator.perform
+      end
+    end
+
+    context 'force_create_destination is false' do
+      let(:options) { { clone_path: path } }
+
+      it 'deletes existing destination repo' do
+        expect(to).not_to receive(:delete)
+        duplicator.perform
+      end
+
+      it 'creates the destination repo' do
+        expect(to).not_to receive(:create)
+        duplicator.perform
+      end
+
+      it 'bare clones the source repo' do
+        expect(from).to receive(:bare_clone).with(path)
+        duplicator.perform
+      end
+
+      it 'mirrors from bare clone to destination' do
+        expect(from).to receive(:mirror).with(to.url)
+        duplicator.perform
+      end
+
+      it 'cleans up' do
+        expect(FileUtils).to receive(:rm_rf)
+        .with("#{duplicator.clone_path}/#{from.name}")
+        duplicator.perform
+      end
+
+      it 'logs 3 times' do
+        expect(duplicator.logger).to receive(:info).exactly(3).times
+        duplicator.perform
+      end
+    end
+  end
+end

data/spec/git_duplicator/git_duplicator_spec.rb

@@ -0,0 +1,102 @@
+require_relative '../helper'
+
+def random_name
+  rand(36**5).to_s(36)
+end
+
+describe GitDuplicator do
+  before(:each) { WebMock.allow_net_connect! }
+  let(:clone_path) { '/tmp' }
+
+  describe '#perform' do
+
+    let(:credentials) do
+      { consumer_key: ENV['BITBUCKET_CONSUMER_KEY'],
+        consumer_secret: ENV['BITBUCKET_CONSUMER_SECRET'],
+        token: ENV['BITBUCKET_TOKEN'],
+        token_secret: ENV['BITBUCKET_TOKEN_SECRET'] }
+    end
+
+    it 'mirrors from service to service without ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Services::GithubRepository
+      .new('naught', 'avdi')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], credentials)
+      to.create
+      GitDuplicator.perform(from, to, clone_path: clone_path)
+      mirrored_name = random_name
+      result_name = random_name
+
+      # Exercise
+      mirrored = Git.clone(from.url, mirrored_name, path: clone_path)
+      result = Git.clone(from.url, result_name, path: clone_path)
+
+      # Verify
+      expect(result.object('HEAD^').to_s).to eq(mirrored.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      FileUtils.rm_rf("#{clone_path}/#{result_name}")
+      to.delete
+    end
+
+    it 'mirrors from service to service with ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Services::GithubRepository
+      .new('naught', 'avdi')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], credentials)
+      GitDuplicator.perform(from, to,
+                            clone_path: clone_path,
+                            force_create_destination: true)
+      mirrored_name = random_name
+      result_name = random_name
+
+      # Exercise
+      mirrored = Git.clone(from.url, mirrored_name, path: clone_path)
+      result = Git.clone(from.url, result_name, path: clone_path)
+
+      # Verify
+      expect(result.object('HEAD^').to_s).to eq(mirrored.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      FileUtils.rm_rf("#{clone_path}/#{result_name}")
+      to.delete
+    end
+
+    it 'mirrors from basic to service with ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Repository
+      .new('naught', 'https://github.com/avdi/naught.git')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], credentials)
+      GitDuplicator.perform(from, to,
+                            clone_path: clone_path,
+                            force_create_destination: true)
+      mirrored_name = random_name
+      result_name = random_name
+
+      # Exercise
+      mirrored = Git.clone(from.url, mirrored_name, path: clone_path)
+      result = Git.clone(from.url, result_name, path: clone_path)
+
+      # Verify
+      expect(result.object('HEAD^').to_s).to eq(mirrored.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      FileUtils.rm_rf("#{clone_path}/#{result_name}")
+      to.delete
+    end
+
+  end
+
+end

data/spec/git_duplicator/repository/repository_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../helper'
+
+describe GitDuplicator::Repository do
+  let(:path) { 'somepath' }
+  let(:name) { 'something' }
+  let(:url) { 'someurl' }
+  let(:to_url) { 'someurl' }
+  let(:repo) { described_class.new(name, url) }
+
+  describe '#repo=' do
+    it 'assignes the attribute in case of Git::Base type' do
+      val = Git::Base.new
+      repo.repo = val
+      expect(repo.repo).to eq(val)
+    end
+
+    it 'raise ArgumentError in case the attribute type is not Git::Base' do
+      expect { repo.repo = 1 }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#bare_clone' do
+    before(:each) { allow(repo).to receive(:repo=) }
+    it 'clones a repo' do
+      expect(Git).to receive(:clone).with(url, name, path: path, bare: true)
+      repo.bare_clone(path)
+    end
+
+    it 'raises an exception in case of failure' do
+      expect { repo.bare_clone('') }
+      .to raise_error(GitDuplicator::RepositoryCloningError)
+    end
+  end
+
+  describe '#mirror' do
+    it 'mirrors a repo' do
+      repo.repo = Git::Base.new
+      expect(repo.repo).to receive(:push).with(to_url, '--mirror')
+      repo.mirror(to_url)
+    end
+
+    it 'raises an exception in case of failure' do
+      expect { repo.mirror('') }
+      .to raise_error(GitDuplicator::RepositoryMirorringError)
+    end
+  end
+end

data/spec/git_duplicator/repository/service_repository_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../../helper'
+
+describe GitDuplicator::ServiceRepository do
+  let(:name) { 'something' }
+  let(:owner) { 'someone' }
+  let(:repo) { described_class.new(name, owner) }
+
+  describe '#delete' do
+    it 'raises an exception in case of not defined' do
+      expect { repo.delete }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#create' do
+    it 'raises an exception in case of not defined' do
+      expect { repo.create }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#url' do
+    it 'raises an exception in case of not defined' do
+      expect { repo.url }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/git_duplicator/services/bitbucket_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../../helper'
+
+describe GitDuplicator::Services::BitbucketRepository do
+  let(:credentials) do
+    { consumer_key: ENV['BITBUCKET_CONSUMER_KEY'],
+      consumer_secret: ENV['BITBUCKET_CONSUMER_SECRET'],
+      token: ENV['BITBUCKET_TOKEN'],
+      token_secret: ENV['BITBUCKET_TOKEN_SECRET'] }
+  end
+  let(:name) { ENV['TESTING_REPO'] }
+  let(:owner) { ENV['BITBUCKET_USER'] }
+  let(:options) do
+    { scm: 'git', is_private: true, fork_policy: 'no_public_forks' }
+  end
+  let(:repo) { described_class.new(name, owner, credentials, options) }
+
+  describe '#delete' do
+    it 'deletes the repo in case it exists' do
+      stub_request(:delete, described_class::BASE_URI +
+                   "/repositories/#{owner}/#{name}")
+      .to_return(body: '', status: 204)
+      expect { repo.delete }.not_to raise_error
+    end
+    it 'raises an exception in case of unknow problem' do
+      stub_request(:delete, described_class::BASE_URI +
+                   "/repositories/#{owner}/#{name}")
+      .to_return(body: 'something wrong', status: 401)
+      expect { repo.delete }
+      .to raise_error(GitDuplicator::RepositoryDeletionError, /something wrong/)
+    end
+  end
+
+  describe '#create' do
+    it 'creates the repository in case of not defined' do
+      stub_request(:post, described_class::BASE_URI +
+                   "/repositories/#{owner}/#{name}")
+      .with(body: options.to_json)
+      .to_return(body: '', status: 200)
+      expect { repo.create }.not_to raise_error
+    end
+
+    it 'raises an exception in case of errors' do
+      stub_request(:post, described_class::BASE_URI +
+                   "/repositories/#{owner}/#{name}")
+      .with(body: options.to_json)
+      .to_return(body: 'something wrong', status: 401)
+      expect { repo.create }
+      .to raise_error(GitDuplicator::RepositoryCreationError, /something wrong/)
+    end
+  end
+end

data/spec/git_duplicator/services/github_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../../helper'
+
+describe GitDuplicator::Services::GithubRepository do
+  let(:credentials) do
+    { oauth2_token: ENV['GITHUB_ACCESS_TOKEN'] }
+  end
+  let(:name) { ENV['TESTING_REPO'] }
+  let(:owner) { ENV['GITHUB_USER'] }
+  let(:options) do
+    { has_issues: false, has_wiki: false }
+  end
+  let(:repo) { described_class.new(name, owner, credentials, options) }
+
+  describe '#delete' do
+    it 'deletes the repo in case it exists' do
+      stub_request(:delete, described_class::BASE_URI +
+                   "/repos/#{owner}/#{name}")
+      .with(
+        headers: { 'Authorization' => "token #{credentials[:oauth2_token]}" }
+      )
+      .to_return(body: '', status: 204)
+      expect { repo.delete }.not_to raise_error
+    end
+    it 'raises an exception in case of unknow problem' do
+      stub_request(:delete, described_class::BASE_URI +
+                   "/repos/#{owner}/#{name}")
+      .to_return(body: 'something wrong', status: 401)
+      expect { repo.delete }
+      .to raise_error(GitDuplicator::RepositoryDeletionError)
+    end
+  end
+
+  describe '#create' do
+    it 'creates the repository in case of not defined' do
+      stub_request(:post, described_class::BASE_URI + '/user/repos')
+      .with(
+        body: options.merge(name: name).to_json,
+        headers: { 'Authorization' => "token #{credentials[:oauth2_token]}" }
+      )
+      .to_return(body: '', status: 201)
+      expect { repo.create }.not_to raise_error
+    end
+
+    it 'raises an exception in case of errors' do
+      stub_request(:post, described_class::BASE_URI + '/user/repos')
+      .with(body: options.merge(name: name).to_json)
+      .to_return(body: 'something wrong', status: 401)
+      expect { repo.create }
+      .to raise_error(GitDuplicator::RepositoryCreationError)
+    end
+  end
+end

data/spec/git_duplicator/version_spec.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+describe GitDuplicator do
+
+  it 'must be defined' do
+    expect(GitDuplicator::Version).to be
+  end
+
+end

data/spec/helper.rb

@@ -0,0 +1,33 @@
+require 'rspec'
+require 'webmock/rspec'
+require 'simplecov'
+require 'coveralls'
+require 'dotenv'
+
+Dotenv.load File.expand_path(
+  File.join(File.dirname(__FILE__), '../', '.test.env')
+)
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter '/spec/'
+  minimum_coverage(95.0)
+end
+
+require_relative '../lib/git_duplicator.rb'
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  # --seed 1234
+  config.order = 'random'
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: git_duplicator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Khaled alHabache
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: simple_oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Duplicating git repositories without forking.
+email:
+- khellls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".test.env.example"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- Guardfile
+- LICENSE.md
+- README.md
+- Rakefile
+- git_duplicator.gemspec
+- lib/git_duplicator.rb
+- lib/git_duplicator/duplicator.rb
+- lib/git_duplicator/errors.rb
+- lib/git_duplicator/helpers/authorization_header.rb
+- lib/git_duplicator/null_logger.rb
+- lib/git_duplicator/repositories.rb
+- lib/git_duplicator/repository/repository.rb
+- lib/git_duplicator/repository/service_repository.rb
+- lib/git_duplicator/services.rb
+- lib/git_duplicator/services/bitbucket.rb
+- lib/git_duplicator/services/github.rb
+- lib/git_duplicator/version.rb
+- spec/git_duplicator/duplicator_spec.rb
+- spec/git_duplicator/git_duplicator_spec.rb
+- spec/git_duplicator/repository/repository_spec.rb
+- spec/git_duplicator/repository/service_repository_spec.rb
+- spec/git_duplicator/services/bitbucket_spec.rb
+- spec/git_duplicator/services/github_spec.rb
+- spec/git_duplicator/version_spec.rb
+- spec/helper.rb
+homepage: https://github.com/Startappz/git_duplicator
+licenses:
+- LGPL-3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Duplicating git repositories without forking.
+test_files: []
+has_rdoc: