bits-installer 0.1.0

data/bin/bits

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+if __FILE__ == $0
+    lib = File.expand_path File.join('..', '..', 'lib'), $0
+
+    if File.file? File.join(lib, 'bits.rb')
+        $:.insert 0, lib
+        bin = File.expand_path File.join('..', 'bin'), lib
+        ENV['PATH']="#{bin}:#{ENV['PATH']}"
+    end
+end
+
+begin
+    require 'bits'
+rescue LoadError
+    require 'rubygems'
+    require 'bits'
+end
+
+exit Bits::main(ARGV)

data/ext/apt/Cache.cpp

@@ -0,0 +1,68 @@
+#include "Cache.h"
+
+#include <apt-pkg/cachefile.h>
+#include <apt-pkg/cacheset.h>
+
+#include "PackageVersion.h"
+#include "Package.h"
+
+Apt::PackageVersion *to_package_version(pkgCache::VerIterator iterator)
+{
+  std::string version(iterator.VerStr());
+  std::string arch(iterator.Arch());
+  std::string section(iterator.Section());
+  return new Apt::PackageVersion(version, arch, section);
+}
+
+Rice::Array Apt::Cache::policy(std::string name)
+{
+  Rice::Array result;
+
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  pkgPolicy *Plcy = CacheFile.GetPolicy();
+  pkgSourceList *SrcList = CacheFile.GetSourceList();
+
+  if (Cache == NULL || Plcy == NULL || SrcList == NULL)
+  {
+    return Qnil;
+  }
+
+  APT::CacheSetHelper helper(true, GlobalError::NOTICE);
+  APT::PackageList pkgset = APT::PackageList::FromString(CacheFile, name, helper);
+
+  for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
+  {
+    std::string full_name = Pkg.FullName(true);
+    Rice::Object current_version;
+    Rice::Object candidate_version;
+
+    if (Pkg->CurrentVer != 0) {
+      pkgCache::VerIterator current = Pkg.CurrentVer();
+      current_version = to_ruby(to_package_version(current));
+    }
+
+    pkgCache::VerIterator candidate = Plcy->GetCandidateVer(Pkg);
+
+    if (candidate.end() != true) {
+      candidate_version = to_ruby(to_package_version(candidate));
+    }
+
+    Apt::Package *package = new Apt::Package(
+        full_name, current_version, candidate_version
+    );
+
+    result.push(to_ruby(package));
+  }
+
+  return result;
+}
+
+
+extern "C"
+void Init_Apt_Cache(Rice::Module parent)
+{
+  Rice::Module rb_mAptCache = Rice::define_module_under(parent, "Cache")
+    .define_singleton_method("policy", &Apt::Cache::policy, Rice::Arg("name"))
+  ;
+}

data/ext/apt/Cache.h

@@ -0,0 +1,18 @@
+#ifndef __APT_CACHE__H__
+#define __APT_CACHE__H__
+
+#include <rice/Module.hpp>
+#include <rice/Array.hpp>
+
+namespace Apt {
+  namespace Cache {
+    /**
+     * Interface similar to apt-cache policy.
+     */
+    Rice::Array policy(std::string name);
+  } /* Cache */
+} /* Apt */
+
+extern "C" void Init_Apt_Cache(Rice::Module parent);
+
+#endif /* __APT_CACHE__H__ */

data/ext/apt/Package.cpp

@@ -0,0 +1,63 @@
+#include "Package.h"
+#include "PackageVersion.h"
+
+#include <rice/Class.hpp>
+#include <rice/Constructor.hpp>
+
+namespace Apt {
+  Package::Package(
+    std::string name,
+    Rice::Object current,
+    Rice::Object candidate
+  )
+    : name_(name)
+    , current_(current)
+    , candidate_(candidate)
+  {
+  }
+
+  Package::~Package()
+  { }
+
+  std::string Package::name()
+  {
+    return name_;
+  }
+
+  Rice::Object Package::current()
+  {
+    return current_;
+  }
+
+  Rice::Object Package::candidate()
+  {
+    return candidate_;
+  }
+
+  std::string Package::to_s()
+  {
+    std::stringstream ss;
+
+    ss << "<Package"
+       << " name=" << name_
+       << " current=" << current_
+       << " candidate=" << candidate_
+       << ">";
+
+    return ss.str();
+  }
+} /* Apt */
+
+extern "C"
+void Init_Apt_Package(Rice::Module parent)
+{
+  Rice::Class rb_cPackage = 
+    Rice::define_class_under<Apt::Package>(parent, "Package")
+      .define_constructor(Rice::Constructor<Apt::Package, std::string, Rice::Object, Rice::Object>())
+      .define_method("name", &Apt::Package::name)
+      .define_method("current", &Apt::Package::current)
+      .define_method("candidate", &Apt::Package::candidate)
+      .define_method("current", &Apt::Package::current)
+      .define_method("to_s", &Apt::Package::to_s)
+  ;
+}

data/ext/apt/Package.h

@@ -0,0 +1,30 @@
+#ifndef __APT_PACKAGE__H__
+#define __APT_PACKAGE__H__
+
+#include <rice/Object.hpp>
+#include <rice/Module.hpp>
+
+
+namespace Apt {
+  class Package {
+  public:
+    Package(
+      std::string name,
+      Rice::Object current,
+      Rice::Object candidate
+    );
+    ~Package();
+    std::string name();
+    Rice::Object current();
+    Rice::Object candidate();
+    std::string to_s();
+  private:
+    std::string name_;
+    Rice::Object current_;
+    Rice::Object candidate_;
+  };
+} /* Apt */
+
+extern "C" void Init_Apt_Package(Rice::Module parent);
+
+#endif /* __APT_PACKAGE__H__ */

data/ext/apt/PackageVersion.cpp

@@ -0,0 +1,49 @@
+#include "PackageVersion.h"
+
+#include <rice/Constructor.hpp>
+
+namespace Apt {
+  PackageVersion::PackageVersion(std::string version, std::string arch, std::string section)
+    : version_(version)
+    , arch_(arch)
+    , section_(section)
+  {
+  }
+
+  PackageVersion::~PackageVersion()
+  { }
+
+  std::string PackageVersion::version()
+  {
+    return version_;
+  }
+
+  std::string PackageVersion::arch()
+  {
+    return arch_;
+  }
+
+  std::string PackageVersion::section()
+  {
+    return section_;
+  }
+
+  std::string PackageVersion::to_s() {
+    std::stringstream ss;
+    ss << "<PackageVersion version=" << version_ << ">";
+    return ss.str();
+  }
+} /* Apt */
+
+extern "C"
+void Init_Apt_PackageVersion(Rice::Module parent)
+{
+  Rice::Class rb_cPackageVersion = 
+    Rice::define_class_under<Apt::PackageVersion>(parent, "PackageVersion")
+      .define_constructor(Rice::Constructor<Apt::PackageVersion, std::string, std::string, std::string>())
+      .define_method("version", &Apt::PackageVersion::version)
+      .define_method("arch", &Apt::PackageVersion::arch)
+      .define_method("section", &Apt::PackageVersion::section)
+      .define_method("to_s", &Apt::PackageVersion::to_s)
+  ;
+}

data/ext/apt/PackageVersion.h

@@ -0,0 +1,24 @@
+#ifndef __APT_PACKAGE_VERSION__H__
+#define __APT_PACKAGE_VERSION__H__
+
+#include <rice/Module.hpp>
+
+namespace Apt {
+  class PackageVersion {
+  public:
+    PackageVersion(std::string version, std::string arch, std::string section);
+    ~PackageVersion();
+    std::string version();
+    std::string arch();
+    std::string section();
+    std::string to_s();
+  private:
+    std::string version_;
+    std::string arch_;
+    std::string section_;
+  };
+} /* Apt */
+
+extern "C" void Init_Apt_PackageVersion(Rice::Module parent);
+
+#endif /* __APT_PACKAGE_VERSION__H__ */

data/ext/apt/apt_ext.cpp

@@ -0,0 +1,38 @@
+#include "apt_ext.h"
+
+#include <rice/Module.hpp>
+
+#include <apt-pkg/init.h>
+
+#include "Cache.h"
+#include "PackageVersion.h"
+#include "Package.h"
+
+
+namespace Apt {
+  bool initialize()
+  {
+    if (!pkgInitConfig(*_config)) {
+      return false;
+    }
+
+    if (!pkgInitSystem(*_config, _system)) {
+      return false;
+    }
+
+    return true;
+  }
+} /* Apt */
+
+
+extern "C"
+void Init_apt_ext()
+{
+  Rice::Module rb_mApt = Rice::define_module("Apt")
+    .define_singleton_method("initialize", &Apt::initialize)
+  ;
+
+  Init_Apt_Cache(rb_mApt);
+  Init_Apt_Package(rb_mApt);
+  Init_Apt_PackageVersion(rb_mApt);
+}

data/ext/apt/apt_ext.h

@@ -0,0 +1,4 @@
+#ifndef __APT_EXT__H__
+#define __APT_EXT__H__
+
+#endif /* __APT_EXT__H__ */

data/ext/apt/extconf.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'mkmf-rice'
+
+reqs = []
+reqs << have_library('apt-pkg')
+
+if not reqs.all? then
+  File.open('Makefile', 'w').write "all:\n\t@echo \"Not building APT extension\""
+  exit 0
+end
+
+create_makefile 'apt/apt_ext'

data/lib/bits/backend/join.rb

@@ -0,0 +1,26 @@
+require 'bits/backend'
+require 'bits/logging'
+require 'bits/exceptions'
+
+module Bits
+  class JoinBackend < Backend
+    include Bits::Logging
+
+    def initialize(backends)
+      @backends = backends
+    end
+
+    # no need to fetch
+    def fetch(atom)
+      @backends.each do |backend|
+        begin
+          return backend.fetch atom
+        rescue MissingBit
+          next
+        end
+      end
+
+      raise MissingBit.new atom
+    end
+  end
+end

data/lib/bits/backend/local.rb

@@ -0,0 +1,24 @@
+require 'bits/backend'
+require 'bits/logging'
+require 'bits/exceptions'
+
+require 'bits/bit_reader/local'
+
+module Bits
+  class LocalBackend < Backend
+    include Bits::Logging
+
+    def initialize(path, ext='yml')
+      @path = path
+      @ext = ext
+    end
+
+    # no need to fetch
+    def fetch(atom)
+      path = File.join @path, "#{atom}.#{@ext}"
+      raise MissingBit.new atom unless File.file? path
+      log.debug "bit from local path: #{path}"
+      BitReaderLocal.new path
+    end
+  end
+end

data/lib/bits/backend.rb

@@ -0,0 +1,9 @@
+module Bits
+  class Backend
+    # Get a bit corresponding to the specified atom and return BitReader that
+    # can read the contents of it.
+    def fetch(atom)
+      raise "not implemented: fetch"
+    end
+  end
+end

data/lib/bits/bit.rb

@@ -0,0 +1,33 @@
+module Bits
+  # Class containing data for a single bit.
+  class Bit
+    attr_accessor :atom, :dependencies
+
+    def initialize(atom, provider_data, dependencies)
+      @atom = atom
+      @provider_data = provider_data
+      @dependencies = dependencies
+    end
+
+    def to_s
+      "<Bit atom=#{atom} dependencies=#{dependencies.inspect} provider_data=#{@provider_data.inspect}>"
+    end
+
+    def has_provider?(provider_id)
+      @provider_data.has_key? provider_id
+    end
+
+    def get_provider_data(provider_id)
+      unless has_provider? provider_id
+        raise "#{self} not provided by #{provider_id}"
+      end
+
+      @provider_data[provider_id]
+    end
+
+    def self.eval(reader, atom)
+      decl = BitDeclaration.eval reader
+      self.new atom, decl.provider_data, decl.dependencies
+    end
+  end
+end

data/lib/bits/bit_declaration.rb

@@ -0,0 +1,143 @@
+require 'yaml'
+
+module Bits
+  class BitReference
+    attr_reader :atom
+
+    def initialize(atom)
+      @atom = atom
+    end
+
+    def to_s
+      "<BitReference #{@atom}>"
+    end
+  end
+
+  class BitParameters
+    attr_reader :parameters
+
+    def initialize(parameters)
+      @parameters = parameters
+    end
+
+    def to_s
+      "<BitParameters #{@parameters}>"
+    end
+  end
+
+  # Class used to manage state of a bit declaration file.
+  class BitDeclaration
+    attr_accessor :provider_data, :dependencies
+
+    def initialize(data)
+      @provider_data = parse_provider_data data
+      @dependencies = parse_dependencies data
+    end
+
+    def parse_provider_data(data)
+      h = Hash.new
+
+      provided_for = data[:provided_for]
+      provided_by = data[:provided_by]
+
+      unless provided_by.nil?
+        unless provided_by.kind_of? Hash
+          raise "Expected Hash but got '#{provided_by.inspect}'"
+        end
+
+        provided_by.each do |provider_id, parameters|
+          unless parameters.kind_of? Hash
+            raise "Expected Hash but got '#{parameters.inspect}'"
+          end
+
+          unless provider_id.kind_of? Symbol
+            raise "Expected Symbol but got '#{provider_id.inspect}'"
+          end
+
+          unless h[provider_id].nil?
+            raise "Provider already defined '#{provider_id}'"
+          end
+
+          h[provider_id] = BitParameters.new parameters
+        end
+      end
+
+      unless provided_for.nil?
+        unless provided_for.kind_of? Hash
+          raise "Expected Hash but got '#{provided_for.inspect}'"
+        end
+
+        provided_for.each do |provider_id, reference|
+          unless reference.kind_of? String
+            raise "Expected String but got '#{reference.inspect}'"
+          end
+
+          unless provider_id.kind_of? Symbol
+            raise "Expected Symbol but got '#{provider_id.inspect}'"
+          end
+
+          unless h[provider_id].nil?
+            raise "Provider already defined '#{provider_id}'"
+          end
+
+          h[provider_id] = BitReference.new reference
+        end
+      end
+
+      h
+    end
+
+    def parse_dependencies(data)
+      h = Hash.new
+
+      depends = data[:depends]
+
+      unless depends.nil?
+        unless depends.kind_of? Array
+          raise "Expected Array but got '#{depends.inspect}'"
+        end
+
+        depends.each do |item|
+          unless item.kind_of? Hash
+            raise "Expected Hash but got '#{item.inspect}'"
+          end
+
+          atom = item[:atom]
+
+          if atom.nil?
+            raise "Expected :atom to be not null in dependency"
+          end
+
+          h[atom] = BitParameters.new item
+        end
+      end
+
+      h
+    end
+
+    # Used inside bit declaration.
+    def provided_by(provider_id, params={})
+      @provider_data[provider_id] = BitParameters.new params
+    end
+
+    # Used inside bit declaration.
+    # Defines that the following set of providers are provided by another bit.
+    def provided_for(params={})
+      params.each do |key, value|
+        key = key.to_sym
+        @provider_data[key] = BitReference.new value
+      end
+    end
+
+    def depends(atom, params={})
+      @dependencies[atom] = params
+    end
+
+    def self.eval(reader)
+      data = YAML.load reader.read
+      decl = self.new data
+      decl
+    end
+  end
+
+end