akabei 0.1.0

data/lib/akabei/package_info.rb

@@ -0,0 +1,68 @@
+require 'akabei/error'
+
+module Akabei
+  class PackageInfo
+    # See write_pkginfo() in /usr/bin/makepkg
+    ARRAY_ATTRIBUTES = %w[
+      license
+      replaces
+      group
+      conflict
+      provides
+      backup
+      depend
+      optdepend
+      makedepend
+      checkdepend
+
+      makepkgopt
+    ].freeze
+
+    ATTRIBUTES = %w[
+      pkgname
+      pkgbase
+      pkgver
+      pkgdesc
+      url
+      builddate
+      packager
+      size
+      arch
+    ].freeze
+
+    attr_accessor *ARRAY_ATTRIBUTES
+    attr_accessor *ATTRIBUTES
+
+    def initialize
+      ARRAY_ATTRIBUTES.each do |attr|
+        send("#{attr}=", [])
+      end
+    end
+
+    def self.parse(data)
+      info = new
+      data.each_line do |line|
+        line.strip!
+        next if line.start_with?('#')
+        if m = line.match(/\A(\w+)\s*=\s*(.+)\z/)
+          key = m[1]
+          val = m[2]
+          if ARRAY_ATTRIBUTES.include?(key)
+            info.send(key) << val
+          elsif ATTRIBUTES.include?(key)
+            if v = info.send(key)
+              raise Error.new("Duplicated entry #{key}: #{v} and #{val}")
+            else
+              info.send("#{key}=", val)
+            end
+          else
+            raise Error.new("Unknown attribute: #{key}: #{val}")
+          end
+        else
+          raise Error.new("Malformed line: #{line}")
+        end
+      end
+      info
+    end
+  end
+end

data/lib/akabei/repository.rb

@@ -0,0 +1,156 @@
+require 'akabei/archive_utils'
+require 'akabei/error'
+require 'akabei/package_entry'
+require 'forwardable'
+require 'pathname'
+require 'tmpdir'
+
+module Akabei
+  class Repository
+    attr_accessor :signer, :include_files
+
+    def initialize
+      @db = {}
+      @include_files = false
+    end
+
+    extend Forwardable
+    include Enumerable
+    def_delegator(:@db, :each)
+
+    def [](package_name)
+      @db.each do |_, entry|
+        if entry.name == package_name
+          return entry
+        end
+      end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        signer == other.signer &&
+        include_files == other.include_files &&
+        @db == other.instance_variable_get(:@db)
+    end
+
+    def load(path)
+      path = Pathname.new(path)
+      return unless path.readable?
+      verify!(path)
+      ArchiveUtils.each_entry(path) do |entry, archive|
+        pkgname, key = *entry.pathname.split('/', 2)
+        if key.include?('/')
+          raise Error.new("Malformed repository database: #{path}: #{entry.pathname}")
+        end
+        @db[pkgname] ||= PackageEntry.new
+        case key
+        when ''
+          # Ignore
+        when 'desc', 'depends', 'files'
+          load_entries(@db[pkgname], archive.read_data)
+        else
+          raise Error.new("Unknown repository database key: #{key}")
+        end
+      end
+      nil
+    end
+
+    def self.load(path)
+      new.tap do |repo|
+        repo.load(path)
+      end
+    end
+
+    def load_entries(entry, data)
+      key = nil
+      data.each_line do |line|
+        line.strip!
+        if m = line.match(/\A%([A-Z0-9]+)%\z/)
+          key = m[1].downcase
+        elsif line.empty?
+          key = nil
+        else
+          entry.add(key, line)
+        end
+      end
+    end
+
+    def add(package)
+      @db[package.db_name] = package.to_entry
+    end
+
+    def remove(pkgname)
+      @db.keys.each do |key|
+        if @db[key].name == pkgname
+          @db.delete(key)
+          return true
+        end
+      end
+      false
+    end
+
+    def verify!(path)
+      if signer && File.readable?("#{path}.sig")
+        signer.verify!(path)
+        true
+      else
+        false
+      end
+    end
+
+    def save(path)
+      Archive::Writer.open_filename(path.to_s, Archive::COMPRESSION_GZIP, Archive::FORMAT_TAR) do |archive|
+        Dir.mktmpdir do |dir|
+          dir = Pathname.new(dir)
+          store_tree(dir)
+          create_db(dir, archive)
+        end
+      end
+      if signer
+        signer.detach_sign(path)
+      end
+      nil
+    end
+
+    def store_tree(topdir)
+      @db.each do |db_name, pkg_entry|
+        pkgdir = topdir.join(db_name)
+        pkgdir.mkpath
+        pkgdir.join('desc').open('w') do |f|
+          pkg_entry.write_desc(f)
+        end
+        pkgdir.join('depends').open('w') do |f|
+          pkg_entry.write_depends(f)
+        end
+        if @include_files
+          pkgdir.join('files').open('w') do |f|
+            pkg_entry.write_files(f)
+          end
+        end
+      end
+    end
+
+    def create_db(topdir, archive)
+      @db.keys.sort.each do |db_name|
+        pkg_entry = @db[db_name]
+        archive.new_entry do |entry|
+          entry.pathname = "#{db_name}/"
+          entry.copy_stat(topdir.join(entry.pathname).to_s)
+          archive.write_header(entry)
+        end
+        %w[desc depends files].each do |fname|
+          pathname = "#{db_name}/#{fname}"
+          path = topdir.join(pathname)
+          if path.readable?
+            archive.new_entry do |entry|
+              entry.pathname = pathname
+              entry.copy_stat(path.to_s)
+              archive.write_header(entry)
+              archive.write_data(path.read)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akabei/signer.rb

@@ -0,0 +1,75 @@
+require 'akabei/error'
+require 'gpgme'
+
+module Akabei
+  class Signer
+    class KeyNotFound < Error
+      attr_reader :key_name
+      def initialize(key)_name
+        @key_name = key_name
+        super("No such GPG key: #{key_name}")
+      end
+    end
+
+    class AmbiguousKey < Error
+      attr_reader :key_name, :found_keys
+      def initialize(key_name, found_keys)
+        @key_name = key_name
+        @found_keys = found_keys
+        super("Ambiguous GPG key: #{key_name}: #{formatted_keys}")
+      end
+
+      def formatted_keys
+        @found_keys.map do |key|
+          subkey = key.primary_subkey
+          "#{subkey.length}#{subkey.pubkey_algo_letter}/#{subkey.fingerprint[-8 .. -1]}"
+        end
+      end
+    end
+
+    class InvalidSignature < Error
+      attr_reader :path, :from
+      def initialize(path, from)
+        @path = path
+        @from = from
+        super("Invalid signature from #{from}: #{path}")
+      end
+    end
+
+    def initialize(gpg_key, crypto = GPGME::Crypto.new)
+      @gpg_key = find_secret_key(gpg_key)
+      @crypto = crypto
+    end
+
+    def detach_sign(path)
+      File.open(path) do |inp|
+        File.open("#{path}.sig", 'w') do |out|
+          @crypto.detach_sign(inp, signer: @gpg_key, output: out)
+        end
+      end
+    end
+
+    def verify!(path)
+      File.open("#{path}.sig") do |sig|
+        File.open(path) do |f|
+          @crypto.verify(sig, signed_text: f) do |signature|
+            unless signature.valid?
+              raise InvalidSignature.new(path, signature.from)
+            end
+          end
+        end
+      end
+    end
+
+    def find_secret_key(key_name)
+      keys = GPGME::Key.find(:secret, key_name, :sign)
+      if keys.empty?
+        raise KeyNotFound.new(key_name)
+      elsif keys.size > 1
+        raise AmbiguousKey.new(key_name, keys)
+      else
+        keys.first
+      end
+    end
+  end
+end

data/lib/akabei/thor_handler.rb

@@ -0,0 +1,14 @@
+require 'thor'
+
+module Akabei
+  module ThorHandler
+    module_function
+    def wrap(&block)
+      block.call
+      0
+    rescue Thor::Error => e
+      $stderr.puts e.message
+      10
+    end
+  end
+end

data/lib/akabei/version.rb

@@ -0,0 +1,3 @@
+module Akabei
+  VERSION = "0.1.0"
+end

data/spec/akabei/abs_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'akabei/abs'
+require 'akabei/archive_utils'
+
+describe Akabei::Abs do
+  let(:repo_name) { 'test' }
+  let(:abs_path) { test_dest('abs.tar.gz') }
+  let(:abs) { described_class.new(abs_path, repo_name) }
+
+  describe '#add' do
+    let(:builder) { double('Builder') }
+    let(:dir) { double('dir') }
+    let(:srcpkg) { test_input('nkf.tar.gz') }
+
+    before do
+      allow(builder).to receive(:with_source_package).and_yield(srcpkg)
+    end
+
+    context 'with a new tarball' do
+      it 'adds a new source tree' do
+        abs.add(dir, builder)
+        expect(abs_path).to be_file
+        files = Akabei::ArchiveUtils.list_paths(abs_path)
+        expect(files).to include('test/nkf/PKGBUILD')
+      end
+    end
+
+    context 'with an existing tarball' do
+      before do
+        FileUtils.cp(test_input('abs.tar.gz').to_s, abs_path)
+      end
+
+      it 'adds a new source tree' do
+        old_files = Akabei::ArchiveUtils.list_paths(abs_path)
+        expect(old_files).to_not include('test/nkf/PKGBUILD')
+        abs.add(dir, builder)
+        new_files = Akabei::ArchiveUtils.list_paths(abs_path)
+        expect(new_files.to_set).to be_superset(old_files.to_set)
+        expect(new_files).to include('test/nkf/PKGBUILD')
+      end
+
+      context 'with an existing package' do
+        let(:srcpkg) { test_input('htop-vi.tar.gz') }
+
+        it 'replaces the package' do
+          old_files = Akabei::ArchiveUtils.list_paths(abs_path)
+          abs.add(dir, builder)
+          new_files = Akabei::ArchiveUtils.list_paths(abs_path)
+          expect(new_files).to match_array(old_files)
+        end
+      end
+    end
+  end
+
+  describe '#remove' do
+    context 'without tarbal' do
+      it 'raises an error' do
+        expect { abs.remove('htop-vi') }.to raise_error(Akabei::Error, /#{Regexp.escape(abs_path.to_s)}/)
+      end
+    end
+
+    context 'with tarball' do
+      before do
+        FileUtils.cp(test_input('abs.tar.gz').to_s, abs_path.to_s)
+      end
+
+      context 'with valid repository name' do
+        it 'removes the package' do
+          old_files = Akabei::ArchiveUtils.list_paths(abs_path)
+          expect(old_files).to include('test/htop-vi/PKGBUILD')
+          abs.remove('htop-vi')
+          new_files = Akabei::ArchiveUtils.list_paths(abs_path)
+          expect(new_files.to_set).to be_subset(old_files.to_set)
+          expect(new_files).to_not include('test/htop-vi/PKGBUILD')
+        end
+
+        context 'without the package' do
+          it 'does nothing' do
+            old_files = Akabei::ArchiveUtils.list_paths(abs_path)
+            expect(old_files).to include('test/htop-vi/PKGBUILD')
+            abs.remove('nkf')
+            new_files = Akabei::ArchiveUtils.list_paths(abs_path)
+            expect(new_files).to match_array(old_files)
+          end
+        end
+      end
+      context 'with invalid repository name' do
+        let(:repo_name) { 'vim-latest' }
+        it 'raises an error' do
+          expect { abs.remove('htop-vi') }.to raise_error(Akabei::Error, /vim-latest/)
+        end
+      end
+    end
+  end
+end

data/spec/akabei/archive_utils_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'akabei/archive_utils'
+
+describe Akabei::ArchiveUtils do
+  let(:archive_path) { test_input('htop-vi.tar.gz') }
+
+  def list_tree(dir)
+    Akabei::ArchiveUtils.list_tree_paths(dir).map { |path| path.relative_path_from(dir).to_s }
+  end
+
+  describe '.list_paths' do
+    it 'acts like tar -t' do
+      expect(described_class.list_paths(archive_path)).to match_array(tar('tf', archive_path.to_s))
+    end
+  end
+
+  describe '.extract_all' do
+    let(:dest) { test_dest('got').tap(&:mkpath) }
+    let(:tar_dest) { test_dest('expected').tap(&:mkpath) }
+
+    it 'acts like tar -x -C' do
+      described_class.extract_all(archive_path, dest)
+      tar('xf', archive_path.to_s, '-C', tar_dest.to_s)
+      expect(list_tree(dest)).to match_array(list_tree(tar_dest))
+    end
+  end
+
+  describe '.archive_all' do
+    let(:dest) { test_dest('got.tar.gz') }
+    let(:tar_dest) { test_dest('expected.tar.gz') }
+    let(:src_path) { test_input('htop-vi.tar.gz') }
+    let(:tree_path) { test_dest('tree').tap(&:mkpath) }
+
+    before do
+      tar('xf', src_path.to_s, '-C', tree_path.to_s)
+    end
+
+    it 'acts like tar -c -C' do
+      described_class.archive_all(tree_path, dest, Archive::COMPRESSION_GZIP, Archive::FORMAT_TAR)
+      tar('cf', tar_dest.to_s, '-C', tree_path.to_s, 'htop-vi')
+      expect(tar('tf', dest.to_s)).to match_array(tar('tf', tar_dest.to_s))
+    end
+  end
+end