revamp 1.0.0

data/lib/revamp/model/puppet-module.rb

@@ -0,0 +1,79 @@
+require 'revamp'
+require 'revamp/mapper/puppet-name-slugger'
+
+# This class describes a puppet dependency
+class Revamp::Model::PuppetDependency
+  attr_accessor :name, :version
+
+  def initialize(hash)
+    @name = hash['name']
+    versions = normalize(hash['version_requirement'])
+    @version = Gem::Requirement.new(versions)
+  end
+
+  private
+
+  def normalize(versionreq)
+    re = /^(([><=~]+)?\s*([\dx]+(?:\.[\dx]+(?:\.[\dx]+)?)?))(.*)/
+    m = re.match(versionreq.strip)
+    first = m[1].strip
+    second = m[4].strip
+    reqs = [first]
+    reqs << second unless second.empty?
+    reqs
+  end
+end
+
+# This class describes a puppet module
+class Revamp::Model::PuppetModule
+  def self.puppet_accessor(*vars)
+    @attributes ||= []
+    @attributes.concat vars
+    attr_accessor(*vars)
+  end
+
+  class << self
+    attr_reader :attributes
+  end
+
+  attr_accessor :files
+  attr_accessor :metadata
+  attr_accessor :name
+
+  puppet_accessor :dependencies
+  puppet_accessor :source
+  puppet_accessor :author
+  puppet_accessor :version
+  puppet_accessor :license
+  puppet_accessor :summary
+  puppet_accessor :project_page
+
+  def initialize
+    @files = {}
+    @metadata = nil
+    @dependencies = []
+  end
+
+  def add_file(path, content)
+    @files[path] = content
+  end
+
+  def attributes
+    self.class.attributes
+  end
+
+  def dependencies=(deps)
+    @dependencies = []
+    deps.each do |dep|
+      @dependencies << Revamp::Model::PuppetDependency.new(dep)
+    end
+  end
+
+  def slugname
+    Revamp::Mapper::PuppetNameSlugger.new.map(name)
+  end
+
+  def rawname
+    name.split('/')[-1]
+  end
+end

data/lib/revamp/parser/puppet-tarball.rb

@@ -0,0 +1,78 @@
+require 'revamp'
+require 'zlib'
+require 'json'
+require 'rubygems/package'
+require 'revamp/model/puppet-module'
+
+# This class is a parser for Puppet's tarballs format
+class Revamp::Parser::PuppetTarball
+  def initialize(tarball_file)
+    @tarball = tarball_file
+  end
+
+  def parse
+    model = nil
+    File.open(@tarball, 'rb') do |file|
+      Zlib::GzipReader.wrap(file) do |gz|
+        Gem::Package::TarReader.new(gz) do |tar|
+          model = Revamp::Model::PuppetModule.new
+          tar.each do |tarfile|
+            entry = Entry.new(tarfile)
+            parse_metadata(model, entry) if entry.metadata?
+            model.add_file(entry.name, entry.content) if entry.file?
+          end
+        end
+      end
+    end
+    normalize(model)
+  end
+
+  private
+
+  def normalize(model)
+    strip = "#{model.slugname}-#{model.version}/"
+    model.files = Hash[model.files.map { |file, content| [file.gsub(strip, ''), content] }]
+    model
+  end
+
+  def parse_metadata(model, entry)
+    data = JSON.parse(entry.content)
+    model.metadata = data
+    model.name = data['name'].tr('-', '/') if data['name']
+    model.attributes.each do |attr|
+      value = data[attr.to_s]
+      fail ArgumentError, "No #{attr} module metadata provided for #{name}" unless value
+      parse_dependencies(attr, value)
+      model.send(attr.to_s + '=', value)
+    end
+  end
+
+  def parse_dependencies(attr, value)
+    return unless attr == :dependencies
+    value.tap do |dependencies|
+      dependencies.each do |dep|
+        dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
+      end
+    end
+  end
+
+  # An entry from tarball
+  class Entry
+    attr_accessor :content
+    attr_accessor :name
+    def initialize(tarfile)
+      @tarfile = tarfile
+      @name    = tarfile.full_name
+      @content = nil
+      @content = tarfile.read unless @tarfile.directory?
+    end
+
+    def metadata?
+      !@tarfile.directory? && name.end_with?('metadata.json')
+    end
+
+    def file?
+      !content.nil?
+    end
+  end
+end

data/lib/revamp/persister/rpm-spec.erb

@@ -0,0 +1,28 @@
+Name: <%= name %>
+Version: <%= model.version %>
+Release: <%= release %>
+Summary: <%= model.summary %>
+Source0: <%= rpm %>.tar.gz
+License: <%= model.license %>
+Group: Development
+BuildArch: noarch
+Provides: puppetmodule(<%= model.slugname %>)
+<% if has_requirements %>Requires: <%= requirements %><% end %>
+%description
+<%= model.summary %>
+%prep
+%setup
+%build
+%install
+rm -rf $RPM_BUILD_ROOT
+mkdir -p ${RPM_BUILD_ROOT}/etc/puppet/modules
+cp -r %{_builddir}/<%= rpm %> ${RPM_BUILD_ROOT}%{_sysconfdir}/puppet/modules
+mv ${RPM_BUILD_ROOT}%{_sysconfdir}/puppet/modules/<%= rpm %> ${RPM_BUILD_ROOT}%{_sysconfdir}/puppet/modules/<%= model.rawname %>
+%clean
+%post
+%files
+%dir %{_sysconfdir}/puppet
+%dir %{_sysconfdir}/puppet/modules
+%dir %{_sysconfdir}/puppet/modules/<%= model.rawname %>
+<% filenames.each do |file| %>%{_sysconfdir}/puppet/modules/<%= model.rawname %>/<%= file %>
+<% end %>

data/lib/revamp/persister/rpm.rb

@@ -0,0 +1,156 @@
+require 'revamp'
+require 'tmpdir'
+require 'erb'
+require 'ostruct'
+require 'rbconfig'
+require 'revamp/filter/puppetver2rpmreq'
+
+# A main RPM persister
+class Revamp::Persister::Rpm
+  def initialize
+    @options = nil
+  end
+
+  attr_accessor :options
+
+  def persist(model)
+    dir = File.expand_path('~')
+    workdir = Pathname.new(dir).join('rpmbuild')
+    builder = Builder.new(model, workdir, options)
+    builder.make_structure
+    builder.write_spec
+    builder.write_sources
+    produced = builder.produce
+    builder.cleanup if options[:cleanup]
+    produced
+  end
+
+  # A command line executor for command line
+  class CommandLine
+    class << self
+      def execute(command, directory, verbose)
+        Revamp.logger.debug("Executing: '#{command}' in directory: '#{directory}'")
+        out = '/dev/null'
+        out = $stdout if verbose
+        pid = Process.spawn(command, chdir: directory, out: out, err: out)
+        Process.wait pid
+        $? # rubocop:disable SpecialGlobalVars
+      end
+    end
+  end
+
+  # A builder for RPM's packages
+  class Builder
+    SOURCES = 'SOURCES'
+    SPECS   = 'SPECS'
+    RPMS    = 'RPMS'
+    SELFDIR = Pathname.new(__FILE__).dirname
+    ATTRS   = [
+      :name, :version, :filename, :rpm,
+      :model, :tmpdir, :release, :filenames,
+      :specfile, :has_requirements,
+      :requirements, :options
+    ]
+    ATTRS.each { |attr| attr_accessor(attr) }
+
+    def initialize(model, dir, options)
+      @options   = options
+      @name      = "puppetmodule_#{model.slugname}"
+      @release   = options[:release]
+      @version   = model.version
+      @filename  = "#{name}-#{version}-#{release}.noarch.rpm"
+      @rpm       = "#{name}-#{version}"
+      @specfile  = rpm + '.spec'
+      @model     = model
+      @tmpdir    = dir
+      @filenames = model.files.keys
+      @has_requirements = model.dependencies.any?
+      @requirements     = configure_rpm_requirements_line
+    end
+
+    def configure_rpm_requirements_line
+      req = []
+      model.dependencies.each do |dep|
+        req += Revamp::Filter::PuppetVerToRpmReq.new.filter(dep)
+      end
+      req.join(', ')
+    end
+
+    def make_structure
+      FileUtils.mkdir_p(tmpdir.join(SOURCES))
+      FileUtils.mkdir_p(tmpdir.join(SPECS))
+    end
+
+    def erbize(template, vars)
+      values = OpenStruct.new(vars).instance_eval { binding }
+      ERB.new(template).result(values)
+    end
+
+    def write_spec
+      tpl = SELFDIR.join('rpm-spec.erb')
+      values = Hash[ATTRS.map { |key| [key, send(key)] }]
+      spec = erbize(tpl.read, values)
+      File.open(specfile_path, 'w') { |file| file.write(spec) }
+    end
+
+    def write_sources
+      pathsufix = Pathname.new(rpm)
+      File.open(sources_tgz_path, 'wb') do |tgz|
+        Zlib::GzipWriter.wrap(tgz) do |gz|
+          Gem::Package::TarWriter.new(gz) do |tar|
+            model.files.each do |file, content|
+              full = pathsufix.join(file).to_s
+              tar.add_file_simple(full, 0644, content.length) { |io| io.write(content) }
+            end
+          end
+        end
+      end
+    end
+
+    def sources_tgz_path
+      sources = tmpdir.join(SOURCES)
+      sources.join("#{rpm}.tar.gz")
+    end
+
+    def specfile_path
+      tmpdir.join(SPECS).join(specfile)
+    end
+
+    def target
+      outdir = options[:outdir]
+      Pathname.new(outdir).join(filename)
+    end
+
+    def produce
+      Revamp.logger.info("Converting to RPM package #{target}...")
+      cmd = "rpmbuild -ba #{SPECS}/#{specfile}"
+      verbose = options[:verbose]
+      ret = Revamp::Persister::Rpm::CommandLine.execute(cmd, tmpdir, verbose)
+      fail "RPM Build failed with retcode = #{ret.exitstatus}" unless ret.success?
+      move_produced
+      target
+    end
+
+    def move_produced
+      produced = tmpdir.join(RPMS).join('noarch').join(filename)
+      Revamp.logger.debug("Produced RPM in build dir: #{produced}")
+      FileUtils.mv(produced, target)
+    end
+
+    def cleanup
+      arch = RbConfig::CONFIG['arch'].gsub('-linux', '')
+      cleanup_files [
+        sources_tgz_path, specfile_path, tmpdir.join('BUILD').join(rpm),
+        tmpdir.join('BUILDROOT').join("#{rpm}-#{release}.#{arch}")
+      ]
+    end
+
+    def cleanup_files(files)
+      Revamp.logger.debug("Files to be cleaned up: #{files}")
+      readable = files.reject { |path| !path.readable? }
+      readable.each do |path|
+        path.directory? ? FileUtils.rm_r(path) : path.unlink
+      end
+    end
+  end
+end

data/lib/revamp/version.rb

@@ -0,0 +1,35 @@
+# Top level module for Revamp
+module Revamp
+  # Prepare version
+  #
+  # @param desired [String] a desired version
+  # @return [String] a prepared version
+  def self.version_prep(desired)
+    version = desired
+    if desired.match(/[^0-9\.]+/)
+      git = `git describe --tags --dirty --always`
+      version += '.' + git.tr('-', '.')
+    end
+    version.strip
+  end
+
+  # Version for Herald
+  VERSION     = version_prep '1.0.0'
+  # Lincense for Herald
+  LICENSE     = 'Apache-2.0'
+  # Project name
+  NAME        = 'Revamp'
+  # Package (gem) for Herald
+  PACKAGE     = 'revamp'
+  # A summary info
+  SUMMARY     = 'Converts puppet module file to valid RPM or DEB package'
+  # A homepage for Herald
+  HOMEPAGE    = 'https://github.com/coi-gov-pl/gem-revamp'
+  # A description info
+  DESCRIPTION = <<-eos
+  This module can convert standard puppet module file in form of tarball to
+  valid RPM or DEB package with all dependencies as references to other
+  system packages. The dependencies can be packaged inside the final system
+  package or just referenced as dependencies.
+  eos
+end

data/lib/revamp.rb

@@ -0,0 +1,61 @@
+require 'logger'
+
+begin
+  require 'pry'
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+  # Do nothing here
+end
+
+# Top level module for Revamp
+module Revamp
+  @logger = Logger.new($stdout)
+  @logger.formatter = proc { |severity, _datetime, _progname, msg| "#{severity}: #{msg}\n" }
+  class << self
+    # Logger for CLI interface
+    # @return [Logger] logger for CLI
+    attr_reader :logger
+
+    # Reports a bug in desired format
+    #
+    # @param ex [Exception] an exception that was thrown
+    # @return [Hash] a hash with info about bug to be displayed to user
+    def bug(ex)
+      file = Tempfile.new(['revamp-bug', '.log'])
+      filepath = file.path
+      file.close
+      file.unlink
+      message = "v#{Revamp::VERSION}-#{ex.class}: #{ex.message}"
+      contents = message + "\n\n" + ex.backtrace.join("\n") + "\n"
+      File.write(filepath, contents)
+      bugo = {
+        message: message,
+        homepage: Revamp::HOMEPAGE,
+        bugfile: filepath,
+        help: "Please report this bug to #{Revamp::HOMEPAGE} by passing contents of bug file: #{filepath}"
+      }
+      bugo
+    end
+  end
+end
+
+# A module for modeles
+module Revamp::Model
+end
+
+# A module for mapper
+module Revamp::Mapper
+end
+
+# A module for persister
+module Revamp::Persister
+end
+
+# Parser module
+module Revamp::Parser
+end
+
+# A module for filters of persiters
+module Revamp::Filter
+end
+
+require 'revamp/version'

data/revamp.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'revamp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = Revamp::PACKAGE
+  spec.version       = Revamp::VERSION
+  spec.authors       = [
+    'Centralny Ośrodek Informatyki',
+    'Suszyński Krzysztof'
+  ]
+  spec.email         = ['krzysztof.suszynski@coi.gov.pl']
+  spec.summary       = Revamp::SUMMARY
+  spec.description   = Revamp::DESCRIPTION
+  spec.homepage      = Revamp::HOMEPAGE
+  spec.license       = Revamp::LICENSE
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_runtime_dependency 'micro-optparse', '~> 1.2.0'
+
+  spec.required_ruby_version = '>= 1.9'
+end

data/spec/file_matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_readable_file do
+  match do |actual|
+    File.readable?(actual)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'rspec/its'
+
+begin
+gem 'simplecov'
+  require 'simplecov'
+  formatters = []
+  formatters << SimpleCov::Formatter::HTMLFormatter
+
+  begin
+    gem 'coveralls'
+    require 'coveralls'
+    formatters << Coveralls::SimpleCov::Formatter if ENV['TRAVIS']
+  rescue Gem::LoadError
+    # do nothing
+  end
+
+  begin
+    gem 'codeclimate-test-reporter'
+    require 'codeclimate-test-reporter'
+    formatters << CodeClimate::TestReporter::Formatter if (ENV['TRAVIS'] and ENV['CODECLIMATE_REPO_TOKEN'])
+  rescue Gem::LoadError
+    # do nothing
+  end
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_filter "/.vendor/"
+    add_filter "/vendor/"
+    add_filter "/gems/"
+    minimum_coverage 95
+    refuse_coverage_drop
+  end
+rescue Gem::LoadError
+  # do nothing
+end
+
+begin
+  gem 'pry'
+  require 'pry'
+rescue Gem::LoadError
+  # do nothing
+end
+
+RSpec.configure do |c|
+  c.tty = true unless ENV['JENKINS_URL'].nil?
+  c.mock_with :rspec do |mock|
+    mock.syntax = [:expect]
+  end
+end

data/spec/unit/revamp/cli_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'revamp/cli'
+require 'revamp/application'
+require 'stringio'
+
+describe Revamp::CLI do
+  let(:instance) { described_class.new }
+  describe '.run!' do
+    before :each do
+      @level = Revamp.logger.level
+      Revamp.logger.level = 100
+    end
+    after :each do
+      Revamp.logger.level = @level
+    end
+    context 'while ARGV is equal to' do
+      let (:argv) { self.class.description.split(/\s+/) }
+      subject { instance.run!(argv) }
+      describe '--invalid-option' do
+        it do
+          expect { subject }.to raise_error(SystemExit, 'exit') { |error|
+            expect(error).not_to be_success
+          }
+        end
+      end
+      context 'while catching STDOUT' do
+        before :each do
+          @stringio = StringIO.new
+          $stdout = @stringio
+        end
+        after :each do
+          $stdout = STDOUT
+        end
+        describe '--help' do
+          it do
+            begin
+              subject
+            rescue SystemExit
+            end
+            expect(@stringio.string).to include('Revamp v', 'Usage:', '-h, --help')
+          end
+          it do
+            expect { subject }.to raise_error(SystemExit, 'exit') { |error|
+              expect(error).to be_success
+            }
+          end
+        end
+        describe '--version' do
+          it do
+            begin
+              subject
+            rescue SystemExit
+            end
+            expect(@stringio.string).to match(/^\d+\.\d+\.\d+/)
+          end
+          it do
+            expect { subject }.to raise_error(SystemExit, 'exit') { |error|
+              expect(error).to be_success
+            }
+          end
+        end
+      end
+
+      context 'mocking to return' do
+        before :each do
+          app = Revamp::Application.new({})
+          expect(app).to receive(:run!).and_return(:mock_return)
+          expect(Revamp::Application).to receive(:new).and_return(app)
+        end
+        describe '-f spec/fixtures/coi-sample-0.1.1.tar.gz' do
+          it { expect(subject).to eq(0) }
+        end
+      end
+      context 'mocking to raise error' do
+        before :each do
+          app = Revamp::Application.new({})
+          expect(app).to receive(:run!).and_raise(StandardError, 'mock-ex')
+          expect(Revamp::Application).to receive(:new).and_return(app)
+        end
+        describe '-f spec/fixtures/coi-sample-0.1.1.tar.gz' do
+          it { expect(subject).to eq(1) }
+        end
+      end
+      context 'performing real operation' do
+        before :each do
+          require 'revamp/persister/rpm'
+          ret = double(success?: true)
+          expect(Revamp::Persister::Rpm::CommandLine).to receive(:execute).and_return(ret)
+          expect(FileUtils).to receive(:mv)
+        end
+        describe '-f spec/fixtures/coi-sample-0.1.1.tar.gz -o /tmp' do
+          it { expect(subject).to eq(0) }
+        end
+      end
+    end
+  end
+
+  describe '.parse' do
+    let (:argv) { eval(self.class.description) }
+    subject { instance.send(:parse, argv) }
+    describe([].inspect) do
+      it { expect { subject }.to raise_error(ArgumentError, /You must pass filenames with `-f`/) }
+    end
+    describe(['-f', 'abc-lib-1.0.0.tar.gz'].inspect) do
+      it { expect { subject }.to raise_error(ArgumentError, 'Can\'t read file given: abc-lib-1.0.0.tar.gz') }
+    end
+    describe(['-f', 'spec/fixtures/coi-sample-0.1.1.tar.gz', '-o', Dir.tmpdir].inspect) do
+      it do
+        expect(subject).to eq({
+          release:   "1",
+          epoch:     "6",
+          outdir:    "/tmp",
+          filenames: ["spec/fixtures/coi-sample-0.1.1.tar.gz"],
+          verbose:   false,
+          cleanup:   true
+        })
+      end
+    end
+  end
+end