gemirro 0.0.1

data/lib/gemirro/source.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+module Gemirro
+  ##
+  # The Source class is used for storing information about an external source
+  # such as the name and the Gems to mirror.
+  #
+  # @!attribute [r] name
+  #  @return [String]
+  # @!attribute [r] host
+  #  @return [String]
+  # @!attribute [r] gems
+  #  @return [Array]
+  #
+  class Source
+    attr_reader :name, :host, :gems
+
+    ##
+    # @param [String] name
+    # @param [String] host
+    # @param [Array] gems
+    #
+    def initialize(name, host, gems = [])
+      @name = name.downcase.gsub(/\s+/, '_')
+      @host = host.chomp('/')
+      @gems = gems
+    end
+
+    ##
+    # Fetches a list of all the available Gems and their versions.
+    #
+    # @return [String]
+    #
+    def fetch_versions
+      Http.get(host + '/' + Configuration.versions_file).body
+    end
+
+    ##
+    # Fetches the `.gem` file of a given Gem and version.
+    #
+    # @param [String] name
+    # @param [String] version
+    # @return [String]
+    #
+    def fetch_gem(name, version)
+      Http.get(host + "/gems/#{name}-#{version}.gem").body
+    end
+
+    ##
+    # Adds a new Gem to the source.
+    #
+    # @param [String] name
+    # @param [String] requirement
+    #
+    def gem(name, requirement = nil)
+      gems << Gem.new(name, requirement)
+    end
+  end
+end

data/lib/gemirro/version.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Gemirro Version
+module Gemirro
+  VERSION = '0.0.1'
+end

data/lib/gemirro/versions_fetcher.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+module Gemirro
+  ##
+  # The VersionsFetcher class is used for retrieving the file that contains all
+  # registered Gems and their versions.
+  #
+  # @!attribute [r] source
+  # @return [Source]
+  #
+  class VersionsFetcher
+    attr_reader :source
+
+    ##
+    # @param [Source] source
+    #
+    def initialize(source)
+      @source = source
+    end
+
+    ##
+    # @return [Gemirro::VersionsFile]
+    #
+    def fetch
+      Gemirro.configuration.logger.info(
+        "Updating #{source.name} (#{source.host})"
+      )
+
+      VersionsFile.load(source.fetch_versions)
+    end
+  end
+end

data/lib/gemirro/versions_file.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+module Gemirro
+  ##
+  # The VersionsFile class acts as a small Ruby wrapper around the RubyGems
+  # file that contains all Gems and their associated versions.
+  #
+  # @!attribute [r] versions
+  #  @return [Array]
+  # @!attribute [r] versions_hash
+  #  @return [Hash]
+  #
+  class VersionsFile
+    attr_reader :versions, :versions_hash
+
+    ##
+    # Reads the versions file from the specified String.
+    #
+    # @param [String] content
+    # @return [Gemirro::VersionsFile]
+    #
+    def self.load(content)
+      buffer   = StringIO.new(content)
+      reader   = Zlib::GzipReader.new(buffer)
+      instance = new(Marshal.load(reader.read))
+
+      reader.close
+
+      instance
+    end
+
+    ##
+    # @param [Array] versions
+    #
+    def initialize(versions)
+      @versions      = versions
+      @versions_hash = create_versions_hash
+    end
+
+    ##
+    # Creates a Hash based on the Array containing all versions. This Hash is
+    # used to more easily (and faster) iterate over all the gems/versions.
+    #
+    # @return [Hash]
+    #
+    def create_versions_hash
+      hash = Hash.new { |h, k| h[k] = [] }
+
+      versions.each do |version|
+        hash[version[0]] << version
+      end
+
+      hash
+    end
+
+    ##
+    # Returns an Array containing all the available versions for a Gem.
+    #
+    # @param [String] gem
+    # @return [Array]
+    #
+    def versions_for(gem)
+      versions_hash[gem].map { |version| version[1] }
+    end
+  end
+end

data/spec/gemirro/cli_spec.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'gemirro/cli'
+require 'gemirro/mirror_file'
+require 'slop'
+
+# Gemirro tests
+module Gemirro
+  # CLI tests
+  module CLI
+    describe 'CLI' do
+      include FakeFS::SpecHelpers
+
+      it 'should return options' do
+        options = CLI.options
+        expect(options).to be_a(::Slop)
+        expect(options.config[:strict]).to be_truthy
+        expect(options.config[:banner])
+          .to eq('Usage: gemirro [COMMAND] [OPTIONS]')
+        expect(options.to_s)
+          .to match(/-v, --version(\s+)Shows the current version/)
+        expect(options.to_s)
+          .to match(/-h, --help(\s+)Display this help message./)
+
+        version = options.fetch_option(:v)
+        expect(version.short).to eq('v')
+        expect(version.long).to eq('version')
+        expect(version.call).to be_nil
+      end
+
+      it 'should retrieve version information' do
+        expect(CLI.version_information).to eq(
+          "gemirro v#{VERSION} on #{RUBY_DESCRIPTION}"
+        )
+      end
+
+      it 'should raise SystemExit if file does not exists' do
+        CLI.should_receive(:abort)
+          .with('The configuration file /config.rb does not exist')
+          .and_raise SystemExit
+        expect { CLI.load_configuration('config.rb') }.to raise_error SystemExit
+      end
+
+      it 'should raise LoadError if content isn\'t ruby' do
+        file = MirrorFile.new('./config.rb')
+        file.write('test')
+        expect { CLI.load_configuration('config.rb') }.to raise_error LoadError
+      end
+    end
+  end
+end

data/spec/gemirro/configuration_spec.rb

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'gemirro/mirror_directory'
+require 'gemirro/configuration'
+require 'gemirro/source'
+
+# Configuration tests
+module Gemirro
+  describe 'Configuration' do
+    include FakeFS::SpecHelpers
+
+    it 'should return configuration' do
+      expect(Gemirro.configuration).to be_a Configuration
+    end
+
+    it 'should return logger' do
+      expect(Gemirro.configuration.logger).to be_a Logger
+    end
+
+    it 'should return template directory' do
+      FakeFS::FileSystem.clone(
+        File.expand_path(
+          './',
+          Pathname.new(__FILE__).realpath
+        )
+      )
+      expect(Configuration.template_directory).to eq(
+        File.expand_path(
+          '../../../template',
+          Pathname.new(__FILE__).realpath
+        )
+      )
+    end
+
+    it 'should return default config file' do
+      expect(Configuration.default_configuration_file).to eq('/config.rb')
+    end
+
+    it 'should return marshal identifier' do
+      expect(Configuration.marshal_identifier).to match(/Marshal\.(\d+)\.(\d+)/)
+    end
+
+    it 'should return versions file' do
+      expect(Configuration.versions_file).to match(/specs\.(\d+)\.(\d+).gz/)
+    end
+
+    it 'should return marshal file' do
+      expect(Configuration.marshal_version).to eq(
+        "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
+      )
+    end
+  end
+
+  describe 'Configuration::instance' do
+    before(:each) do
+      @config = Configuration.new
+    end
+
+    it 'return mirror directory' do
+      @config.should_receive(:gems_directory).once.and_return('/tmp')
+      expect(@config.mirror_directory).to be_a(MirrorDirectory)
+      expect(@config.mirror_directory.path).to eq('/tmp')
+    end
+
+    it 'should return gems directory' do
+      @config.should_receive(:destination).once.and_return('/tmp')
+      expect(@config.gems_directory).to eq('/tmp/gems')
+    end
+
+    it 'should return ignored gems' do
+      expect(@config.ignored_gems).to eq(Hash.new)
+      expect(@config.ignore_gem?('rake', '1.0.0')).to be_falsy
+      expect(@config.ignore_gem('rake', '1.0.0')).to eq(['1.0.0'])
+      expect(@config.ignored_gems).to eq('rake' => ['1.0.0'])
+      expect(@config.ignore_gem?('rake', '1.0.0')).to be_truthy
+    end
+
+    it 'should add and return source' do
+      expect(@config.source).to eq(nil)
+      result = @config.define_source('RubyGems', 'https://rubygems.org') do
+      end
+      expect(result).to be_a(Source)
+      expect(result.gems).to eq([])
+      expect(result.host).to eq('https://rubygems.org')
+      expect(result.name).to eq('rubygems')
+    end
+  end
+end

data/spec/gemirro/gem_spec.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'gemirro/gem'
+
+# Gem tests
+module Gemirro
+  describe 'Gem' do
+    before(:each) do
+      @gem = Gem.new('gemirro', '0.0.1')
+    end
+
+    it 'should be initialized with string' do
+      gem = Gem.new('gemirro', '0.0.1')
+      expect(gem.name).to eq('gemirro')
+      expect(gem.requirement).to eq(::Gem::Requirement.new(['= 0.0.1']))
+    end
+
+    it 'should be initialized with ::Gem::Requirement' do
+      requirement = ::Gem::Requirement.new('0.0.1')
+      gem = Gem.new('gemirro', requirement)
+      expect(gem.name).to eq('gemirro')
+      expect(gem.requirement).to be(requirement)
+    end
+
+    it 'should return version' do
+      expect(@gem.version).to eq(::Gem::Version.new('0.0.1'))
+    end
+
+    it 'should check version' do
+      expect(@gem.version?).to be_truthy
+    end
+
+    it 'should return gem filename' do
+      expect(@gem.filename).to eq('gemirro-0.0.1.gem')
+    end
+  end
+end

data/spec/gemirro/gems_fetcher_spec.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'gemirro/source'
+require 'gemirro/gem'
+require 'gemirro/versions_file'
+require 'gemirro/mirror_file'
+require 'gemirro/gems_fetcher'
+
+# GemsFetcher tests
+module Gemirro
+  describe 'GemsFetcher' do
+    include FakeFS::SpecHelpers
+
+    before(:each) do
+      @source = Source.new('RubyGems', 'https://rubygems.org')
+      @versions_file = VersionsFile.new(['0.0.1'])
+      @fetcher = GemsFetcher.new(@source, @versions_file)
+    end
+
+    it 'should be initialized' do
+      expect(@fetcher.source).to be(@source)
+      expect(@fetcher.versions_file).to be(@versions_file)
+    end
+
+    it 'should return configuration' do
+      expect(@fetcher.configuration).to be(Gemirro.configuration)
+    end
+
+    it 'should return logger' do
+      expect(@fetcher.logger).to be(Gemirro.configuration.logger)
+    end
+
+    it 'should test if gem exists' do
+      @fetcher.configuration.destination = './'
+      expect(@fetcher.gem_exists?('test')).to be_falsy
+      MirrorDirectory.new('./').add_directory('gems')
+      MirrorFile.new('gems/test').write('content')
+      expect(@fetcher.gem_exists?('test')).to be_truthy
+    end
+
+    it 'should ignore gem' do
+      expect(@fetcher.ignore_gem?('gemirro', '0.0.1')).to be_falsy
+      @fetcher.configuration.ignore_gem('gemirro', '0.0.1')
+      expect(@fetcher.ignore_gem?('gemirro', '0.0.1')).to be_truthy
+    end
+
+    it 'should log error when fetch gem failed' do
+      gem = Gem.new('gemirro')
+      version = ::Gem::Version.new('0.0.1')
+      @source.should_receive(:fetch_gem)
+        .once.with('gemirro', version).and_raise(ArgumentError)
+      @fetcher.logger.should_receive(:error)
+        .once.with(/Failed to retrieve/)
+      @fetcher.logger.should_receive(:debug)
+        .once.with(/Adding (.*) to the list of ignored Gems/)
+
+      expect(@fetcher.fetch_gem(gem, version)).to be_nil
+      expect(@fetcher.ignore_gem?('gemirro', '0.0.1')).to be_truthy
+    end
+
+    it 'should fetch gem' do
+      gem = Gem.new('gemirro')
+      version = ::Gem::Version.new('0.0.1')
+      @source.should_receive(:fetch_gem)
+        .once.with('gemirro', version).and_return('gemirro')
+
+      expect(@fetcher.fetch_gem(gem, version)).to eq('gemirro')
+    end
+
+    it 'should retrieve versions for specific gem' do
+      gem = Gem.new('gemirro', '0.0.2')
+      @versions_file.should_receive(:versions_for)
+        .once.with('gemirro').and_return(['0.0.1', '0.0.2'])
+      expect(@fetcher.versions_for(gem)).to eq([::Gem::Version.new('0.0.2')])
+    end
+
+    it 'should fetch all gems and log debug if gem is not satisfied' do
+      gem = Gem.new('gemirro', '0.0.1')
+      gem.requirement.should_receive(:satisfied_by?)
+        .once.with(nil).and_return(false)
+      @fetcher.source.gems << gem
+      @fetcher.logger.should_receive(:debug)
+        .once.with('Skipping gemirro-0.0.1.gem')
+      expect(@fetcher.fetch).to eq([gem])
+    end
+
+    it 'should fetch all gems' do
+      gem = Gem.new('gemirro', '0.0.2')
+      @fetcher.source.gems << gem
+      @fetcher.should_receive(:versions_for).once.and_return(['0.0.2'])
+      gem.requirement.should_receive(:satisfied_by?)
+        .once.with('0.0.2').and_return(true)
+      @fetcher.should_receive(:fetch_gem)
+        .once.with(gem, '0.0.2').and_return('gemfile')
+      @fetcher.configuration.should_receive(:ignore_gem)
+        .once.with('gemirro', '0.0.2')
+      @fetcher.logger.should_receive(:info)
+        .once.with('Fetching gemirro-0.0.2.gem')
+      @fetcher.configuration.mirror_directory.should_receive(:add_file)
+        .once.with('gemirro-0.0.2.gem', 'gemfile')
+      expect(@fetcher.fetch).to eq([gem])
+    end
+  end
+end