apt_control 0.4.0 → 1.0.0

data/lib/apt_control.rb

@@ -2,16 +2,22 @@
 require 'inifile'
 require 'listen'
 require 'logger'
+require 'celluloid'
+
+# silence celluloid until we have our own logger
+Celluloid.logger = nil
 
 module AptControl
 
   require 'apt_control/exec'
+  require 'apt_control/actors'
   require 'apt_control/jabber'
+  require 'apt_control/bot'
   require 'apt_control/control_file'
   require 'apt_control/apt_site'
   require 'apt_control/build_archive'
   require 'apt_control/package_states'
-  require 'apt_control/includer'
+  require 'apt_control/commands'
 
   class Version
     include Comparable
@@ -19,7 +25,7 @@ module AptControl
     attr_reader :major, :minor, :bugfix, :debian
 
     def self.parse(string)
-      match = /([0-9]+)(?:\.([0-9]+))?(?:\.([0-9]+))?(?:-(.+))?/.match(string)
+      match = /^([0-9]+)(?:\.([0-9]+))?(?:\.([0-9]+))?(?:-(.+))?$/.match(string)
       match && new(*(1..4).map { |i| match[i] }) or raise "could not parse #{string}"
     end
 

data/lib/apt_control/actors.rb

@@ -0,0 +1,41 @@
+#
+# Explicitly proxy some objects to have actor proxies - perhaps celluloid already
+# has this facility?
+#
+# The rationale is that I want to leave the underlying objects 'clean' so I
+# can test them individually without having to worry about celluloid magic
+#
+module AptControl::Actors
+
+  module ProxiedClassMethods
+    def proxy(method)
+      proxy_class.class_eval """\
+        def #{method}(*args, &block)
+          @proxied_object.#{method}(*args, &block)
+        end
+"""
+    end
+
+    attr_reader :proxy_class
+
+  end
+
+  class ActorProxy
+    include Celluloid
+    def initialize(proxied_object)
+      @proxied_object = proxied_object
+    end
+  end
+
+  module Proxied
+    def self.included(other_class)
+      @proxy_class = Class.new(ActorProxy)
+      other_class.instance_variable_set('@proxy_class', @proxy_class)
+      other_class.extend(ProxiedClassMethods)
+    end
+
+    def actor
+      @actor_proxy ||= self.class.proxy_class.new(self)
+    end
+  end
+end

data/lib/apt_control/apt_site.rb

@@ -2,6 +2,9 @@ module AptControl
   # represents the reprepro apt site that we query and include packages in to
   class AptSite
     include Exec::Helpers
+    include Actors::Proxied
+    proxy :include!
+    proxy :included_version
 
     def initialize(apt_site_dir, logger)
       @apt_site_dir = apt_site_dir

data/lib/apt_control/bot.rb

@@ -0,0 +1,121 @@
+module AptControl
+  class Bot
+
+    # as a module for testing
+    module ArgHelpers
+      def split_args(args_string)
+        # there is probably some code out there that can do this better, maybe
+        # go out and find it if it proves troublsome :)
+        args_string.scan(/[^ '"]+|'[^']+'|"[^"]+"/).map do |str|
+          str.gsub(/'|"/, '')
+        end
+      end
+    end
+
+    include ArgHelpers
+
+    module ClassMethods
+      def method_added(meth)
+        super
+        if match = /^handle_(.+)$/.match(meth.to_s)
+          handlers << match[1]
+        end
+      end
+
+      def handlers
+        @handlers ||= []
+      end
+    end
+
+    self.extend(ClassMethods)
+    include Actors::Proxied
+    proxy :on_message
+
+    def initialize(dependencies)
+      @jabber         = dependencies.fetch(:jabber)
+      @package_states = dependencies.fetch(:package_states)
+      @logger         = dependencies.fetch(:logger)
+      @command_start  = dependencies.fetch(:command_start)
+      @include_cmd    = dependencies.fetch(:include_cmd)
+      @control_file   = dependencies.fetch(:control_file)
+
+      @bot_pattern = /#{Regexp.escape(@command_start)}\: ([^ ]+)(?: (.+))?/
+      @logger.info("looking for messages starting with #{@command_start}")
+      @logger.debug("  match pattern: #{@bot_pattern}")
+    end
+
+    def on_message(text)
+      return unless match = @bot_pattern.match(text)
+
+      command, args = [match[1], match[2]]
+
+      handler = self.class.handlers.include?(command) or
+        return print_help("unknown command '#{command}'")
+
+      args = split_args(args || '')
+      begin
+        self.send("handle_#{command}", args)
+      rescue => e
+        begin ; send_message("error: #{e}") ; rescue => e ; end
+        @logger.error("error handling #{command}")
+        @logger.error(e)
+      end
+    end
+
+    def send_message(msg)
+      @jabber.async.send_message(msg)
+    end
+
+    def print_help(message)
+      send_message(message)
+      send_message("Send commands with '#{@command_start} COMMAND [ARGS...]'")
+      send_message("Available commands: #{self.class.handlers.join(' ')}")
+    end
+
+    def handle_status(args)
+      dist = args[0]
+      package_name = args[1]
+
+      found = @package_states.map do |package_state|
+        next if dist && dist != package_state.dist.name
+        next if package_name && package_name != package_state.package_name
+
+        send_message(package_state.status_line)
+        true
+      end.compact
+
+      send_message("no packages found: distribution => #{dist.inspect}, package_name => #{package_name.inspect} ") if found.empty?
+    end
+
+    def handle_include(args)
+      performed = @include_cmd.run(@package_states) do |state, version|
+        send_message("#{state.dist.name} #{state.package_name} #{state.included} => #{version}")
+        true
+      end
+
+      send_message("no packages were included") if performed.empty?
+    end
+
+    def handle_reload(args)
+      @control_file.reload!
+      send_message("control file reloaded")
+    end
+
+    def handle_set(args)
+      set_command.run(*args)
+    end
+
+    def handle_promote(args)
+      promote_command.run(*args)
+    end
+
+    def set_command
+      AptControl::Commands::Set.new(control_file: @control_file)
+    end
+
+    def promote_command
+      AptControl::Commands::Promote.new(control_file: @control_file,
+        package_states: @package_states)
+    end
+  end
+end

data/lib/apt_control/build_archive.rb

@@ -50,6 +50,7 @@ module AptControl
             rescue => e
               @logger.error("Couldn't parse version string: #{s}")
               @logger.error(e)
+              nil
             end
           }.compact
           Package.new(name, versions)
@@ -102,6 +103,7 @@ module AptControl
       end
 
       def add_version(version)
+        raise unless version.is_a?(AptControl::Version)
         @versions << version
       end
 

data/lib/apt_control/cli.rb

@@ -36,16 +36,19 @@ module AptControl
       require 'apt_control/cli/status'
       require 'apt_control/cli/watch'
       require 'apt_control/cli/include'
+      require 'apt_control/cli/set'
+      require 'apt_control/cli/promote'
     end
 
     module Common
       # FIXME tidy up with some meta magic
       def package_states ; ancestor(Root).package_states ; end
-      def includer ; ancestor(Root).includer ; end
+      def new_include_cmd(options={}) ; ancestor(Root).new_include_cmd(options) ; end
       def apt_site ; ancestor(Root).apt_site ; end
       def control_file ; ancestor(Root).control_file ; end
       def build_archive ; ancestor(Root).build_archive ; end
-      def notifier ; ancestor(Root).notifier ; end
+      def jabber ; ancestor(Root).jabber ; end
+      def jabber_enabled? ; ancestor(Root).jabber_enabled? ; end
       def notify(msg) ; ancestor(Root).notify(msg) ; end
       def validate_config! ; ancestor(Root).validate_config! ; end
       def logger ; ancestor(Root).logger ; end
@@ -71,7 +74,7 @@ module AptControl
 
       DEFAULT_CONFIG_FILE_LOCATION = '/etc/apt_control/config.yaml'
 
-      config :log_file, "File to send log output to, defaults to stdout", :required => false
+      config :log_file, "File to send log output to, defaults to /dev/null", :required => false
       config :apt_site_dir, "Directory containing apt files"
       config :control_file, "Path to control file containing inclusion rules"
       config :build_archive_dir, "Directory containing debian build files"
@@ -138,10 +141,13 @@ YAML file containing a single hash of key value/pairs for each option.
             config[key] or raise Climate::ExitException, "Error: you must supply all jabber options if jabber is enabled"
           end
         end
+
+        Celluloid.logger = logger
       end
 
       def logger
-        @logger ||= Logger.new(config[:log_file] || STDOUT).tap do |logger|
+        log_file = config[:log_file] || '/dev/null'
+        @logger ||= Logger.new(log_file == 'STDOUT' ? STDOUT : log_file).tap do |logger|
           logger.level = Logger::DEBUG
         end
       end
@@ -164,13 +170,21 @@ YAML file containing a single hash of key value/pairs for each option.
         @build_archive ||= BuildArchive.new(config[:build_archive_dir], logger)
       end
 
-      def notifier
-        @notify ||= Jabber.new(:jid => config[:jabber_id], :logger => logger,
-          :password => config[:jabber_password], :room_jid => config[:jabber_chatroom_id])
+      def jabber
+        @jabber ||= Jabber.new(:jid => config[:jabber_id], :logger => logger,
+          :password => config[:jabber_password], :room_jid => config[:jabber_chatroom_id],
+          :enabled => jabber_enabled?)
+      end
+
+      def jabber_enabled?
+        config[:jabber_enabled].to_s == 'true'
       end
 
-      def includer
-        @includer ||= Includer.new(apt_site, build_archive)
+      def new_include_cmd(options={})
+        defaults = {apt_site: apt_site, build_archive: build_archive}
+        options = options.merge(defaults)
+
+        AptControl::Commands::Include.new(options)
       end
 
       class FSListenerFactory
@@ -186,6 +200,8 @@ YAML file containing a single hash of key value/pairs for each option.
             if disable_inotify
               listener.force_polling(true)
               listener.polling_fallback_message(false)
+            else
+              listener.force_adapter(Listen::Adapters::Linux)
             end
 
             listener.change(&on_change)
@@ -200,9 +216,8 @@ YAML file containing a single hash of key value/pairs for each option.
 
       def notify(message)
         logger.info("notify: #{message}")
-        return unless config[:jabber_enabled].to_s == 'true'
         begin
-          notifier.send_message(message)
+          jabber.actor.async.send_message(message)
         rescue => e
           logger.error("Unable to send notification to jabber: #{e}")
           logger.error(e)

data/lib/apt_control/cli/include.rb

@@ -10,7 +10,8 @@ that the control file will allow"""
     def run
       validate_config!
 
-      includer.perform_for_all(package_states) do |state, version|
+
+      new_include_cmd.run(package_states) do |state, version|
         if options[:noop]
           puts "#{state.dist.name} #{state.package_name} #{state.included} => #{version}"
           false

data/lib/apt_control/cli/promote.rb

@@ -0,0 +1,29 @@
+module AptControl::CLI
+  class Promote < Climate::Command('promote')
+    include Common
+    subcommand_of Root
+    description "Promote a currently included package from one distribution to another"
+
+    arg :src_distribution,  "Name of distribution to find currently included package version"
+    arg :dest_distribution, "Name of distribution to update"
+    arg :package,           "Name of package to promote"
+
+    def run
+      validate_config!
+
+      begin
+        promote_cmd = AptControl::Commands::Promote.new(
+          control_file: control_file,
+          package_states: package_states)
+
+        begin
+          promote_cmd.run(arguments[:src_distribution],
+            arguments[:dest_distribution],
+            arguments[:package])
+        rescue ArgumentError => e
+          raise Climate::ExitException, e.message
+        end
+      end
+    end
+  end
+end

data/lib/apt_control/cli/set.rb

@@ -0,0 +1,22 @@
+module AptControl::CLI
+  class Set < Climate::Command('set')
+    include Common
+    subcommand_of Root
+    description "Set a version restriction for a package and distribution"
+
+    arg :distribution, "Name of distribution"
+    arg :package, "Name of package"
+    arg :constraint, "Version constraint, i.e. '>= 1.5'"
+
+    def run
+      validate_config!
+
+      begin
+        AptControl::Commands::Set.new(control_file: control_file).
+          run(arguments[:distribution], arguments[:package], arguments[:constraint])
+      rescue ArgumentError => e
+        raise Climate::ExitException, e.message
+      end
+    end
+  end
+end

data/lib/apt_control/cli/status.rb

@@ -11,15 +11,7 @@ module AptControl::CLI
 
       if options[:machine_readable]
         package_states.each do |state|
-          fields = [
-            state.dist.name,
-            state.package_name,
-            "(#{state.rule.restriction} #{state.rule.version})",
-            "#{state.includeable? ? 'I' : '.'}#{state.satisfied? ? 'S' : '.'}",
-            "included=#{state.included || '<none>'}",
-            "available=#{state.available? ? state.available.join(', ') : '<none>'} "
-          ]
-          puts fields.join(' ')
+          puts state.status_line
         end
       else
         last_dist = nil

data/lib/apt_control/cli/watch.rb

@@ -54,11 +54,18 @@ has the usual set of options for running as an init.d style daemon.
       at_exit { File.delete(pidfile) if File.exists?(pidfile) } if pidfile
     end
 
+    # for the watch command, we use the actor version of the apt_site so that
+    # reprepro operations are sequential
+    def new_include_cmd
+      super(apt_site: apt_site.actor)
+    end
+
     def start_watching
       threads = [
         watch_control_in_new_thread,
-        watch_build_archive_in_new_thread
-      ]
+        watch_build_archive_in_new_thread,
+        jabber_enabled? && start_aptbot_in_new_thread
+      ].compact
 
       notify("apt_control watcher is up, waiting for changes to control file and new packages...")
 
@@ -66,6 +73,25 @@ has the usual set of options for running as an init.d style daemon.
       threads.each(&:join)
     end
 
+    def start_aptbot_in_new_thread
+      Thread.new do
+        begin
+          bot = AptControl::Bot.new(
+            jabber:         jabber.actor,
+            command_start:  jabber.room_nick,
+            package_states: package_states,
+            include_cmd:    new_include_cmd,
+            control_file:   control_file,
+            logger:         logger)
+
+          jabber.add_room_listener(bot.actor)
+        rescue => e
+          puts "got an error #{e}"
+          puts e.backtrace
+        end
+      end
+    end
+
     def watch_control_in_new_thread
       # update the all the rules if the control file changes
       Thread.new do
@@ -74,7 +100,7 @@ has the usual set of options for running as an init.d style daemon.
             notify "Control file reloaded"
             # FIXME need to do some kind of locking or actor style dev for this
             # as it looks like there could be some concurrency bugs lurking
-            includer.perform_for_all(package_states) do |package_state, new_version|
+            new_include_cmd.run(package_states) do |package_state, new_version|
               notify("included package #{package_state.package_name}-#{new_version} in #{package_state.dist.name}")
               true
             end
@@ -105,7 +131,7 @@ has the usual set of options for running as an init.d style daemon.
       updated = matched_states.map do |state|
         if state.includeable_to.max == new_version
           begin
-            includer.perform_for(state, new_version, options[:noop])
+            new_include_cmd.perform_for(state, new_version, options[:noop])
             notify("included package #{package.name}-#{new_version} in #{state.dist.name}")
             state.dist.name
           rescue => e

data/lib/apt_control/commands.rb

@@ -0,0 +1,6 @@
+module AptControl::Commands
+  # general purpose command classes that can be re-used between CLI and jabber bot
+  require 'apt_control/commands/set'
+  require 'apt_control/commands/include'
+  require 'apt_control/commands/promote'
+end

data/lib/apt_control/{includer.rb → commands/include.rb}

@@ -1,22 +1,20 @@
 module AptControl
+  class Commands::Include
 
-  # Wraps the common functionality involved in including the latest includeable
-  # package in an apt site
-  class Includer
-    def initialize(apt_site, build_archive)
-      @apt_site = apt_site
-      @build_archive = build_archive
+    def initialize(dependencies)
+      @apt_site      = dependencies.fetch(:apt_site)
+      @build_archive = dependencies.fetch(:build_archive)
     end
 
-    def perform_for_all(package_states, &visitor)
-      package_states.each do |state|
+    def run(package_states, &visitor)
+      package_states.map do |state|
         next unless state.includeable?
 
         version = state.includeable_to.max
         perform = (block_given? && yield(state, version)) || true
 
-        perform_for(state, version) if perform
-      end
+        perform_for(state, version) && [state, version] if perform
+      end.compact
     end
 
     def perform_for(state, version, noop=false)

data/lib/apt_control/commands/promote.rb

@@ -0,0 +1,28 @@
+module AptControl
+  class Commands::Promote
+
+    def initialize(dependencies)
+      @control_file   = dependencies.fetch(:control_file)
+      @package_states = dependencies.fetch(:package_states)
+    end
+
+    def run(src_name, dest_name, pkg_name)
+      source_dist = @control_file[src_name] or
+        raise ArgumentError, "source distribution '#{src_name}' does not exist"
+
+      dest_dist = @control_file[dest_name] or
+        raise ArgumentError, "destination distribution '#{dest_name}' does not exist"
+
+      src_state = @package_states.find_state(src_name, pkg_name) or
+        raise ArgumentError, "package '#{pkg_name}' does not exist in distribution '#{src_name}'"
+
+      if not src_state.included?
+        raise ArgumentError, "no '#{pkg_name}' package included in '#{src_name}' to promote"
+      end
+      new_constraint = "= #{src_state.included.to_s}"
+      dest_dist[pkg_name] = new_constraint
+
+      @control_file.write
+    end
+  end
+end

data/lib/apt_control/commands/set.rb

@@ -0,0 +1,24 @@
+module AptControl
+  class Commands::Set
+
+    def initialize(dependencies)
+      @control_file = dependencies.fetch(:control_file)
+    end
+
+    def run(distribution_name, package_name, constraint)
+      distribution = @control_file[distribution_name] or
+        raise ArgumentError, "no such distribution: #{distribution_name}"
+
+      package_rule = distribution[package_name] or
+        raise ArgumentError, "no such package: #{package_name}"
+
+      begin
+        package_rule.constraint = constraint
+      rescue => e
+        raise ArgumentError, "could not set constraint: #{e}"
+      end
+
+      @control_file.write
+    end
+  end
+end

data/lib/apt_control/control_file.rb

@@ -4,20 +4,35 @@ module AptControl
 
   # Loads and models the contents of a control.ini file
   # see example-control.ini in root of project for an example
+  #
+  # TODO some sort of actor wrapper that provides sequential write access to
+  # the data model
   class ControlFile
 
     def initialize(path, logger)
       @logger = logger
       @watch_mutex = Mutex.new
       @path = path
-      inifile = IniFile.load(@path)
-      @distributions = parse!(inifile)
+      @distributions =
+        if File.exists?(@path)
+          inifile = IniFile.load(@path)
+          parse!(inifile)
+        else
+          []
+        end
     end
 
     def distributions
+      # not sure that this is strictly necessary - there is no true concurrency
+      # in MRI/YARV, but that doesn't mean a thread couldn't be interrupted half
+      # way through initialising a variable, does it?
       @watch_mutex.synchronize { @distributions }
     end
 
+    def [](dist_name)
+      distributions.find {|d| d.name == dist_name }
+    end
+
     def dump
       @watch_mutex.synchronize do
         @distributions.each do |d|
@@ -29,6 +44,22 @@ module AptControl
       end
     end
 
+    def write
+      IniFile.new.tap do |inifile|
+        inifile.filename = @path
+        distributions.each do |distribution|
+          inifile[distribution.name] = distribution.inject({}) do |hash, rule|
+            hash.tap do |h|
+              # quote the restriction, as inifile doesn't do this for you
+              # https://github.com/TwP/inifile/pull/16
+              h[rule.package_name] = '"' + rule.restriction_string + '"'
+            end
+          end
+        end
+        inifile.write
+      end
+    end
+
     def parse!(inifile)
       inifile.sections.map do |section|
         rules = inifile[section].map do |key, value|
@@ -38,6 +69,15 @@ module AptControl
       end
     end
 
+    def reload!
+      inifile = IniFile.load(@path)
+      distributions = parse!(inifile)
+
+      @watch_mutex.synchronize do
+        @distributions = distributions
+      end
+    end
+
     # Watch the control file for changes, rebuilding
     # internal data structures when it does
     def watch(fs_listener_factory, &block)
@@ -48,14 +88,9 @@ module AptControl
       fs_listener_factory.new(dir, /#{Regexp.quote(fname)}/) do |modified, added, removed|
         begin
           @logger.info("Change to control file detected...")
-          inifile = IniFile.load(path)
-          distributions = parse!(inifile)
-
-          @watch_mutex.synchronize do
-            @distributions = distributions
-          end
-          @logger.info("...rebuilt")
+          reload!
           yield if block_given?
+          @logger.info("...rebuilt")
         rescue => e
           @logger.error("Error reloading changes: #{e}")
           @logger.error(e)
@@ -75,6 +110,10 @@ module AptControl
 
       def initialize(name, constraint)
         @package_name = name
+        self.constraint = constraint
+      end
+
+      def constraint=(constraint)
         version = nil
         constraint.split(" ").tap do |split|
           @restriction, version = if split.size == 1
@@ -121,22 +160,47 @@ module AptControl
       def includeable_to(available)
         available.select {|a| satisfied_by?(a) }
       end
+
+      def restriction_string
+        "#{@restriction} #{@version}"
+      end
+
+      # FIXME to_s should include the package name
+      alias :to_s :restriction_string
     end
 
     # represents a set of rules mapped to a particular distribution, i.e.
     # squeeze is a distribution
     class Distribution
+      include Enumerable
+
       def initialize(name, rules)
         @name = name
         @package_rules = rules
       end
+
       attr_reader :name
       attr_reader :package_rules
 
+      def each(&block)
+        (@package_rules || []).each do |rule|
+          yield(rule)
+        end
+      end
+
       # find a PackageRule by package name
       def [](package_name)
         package_rules.find {|rule| rule.package_name == package_name }
       end
+
+      def []=(package_name, new_constraint)
+        existing_rule = self[package_name]
+        if existing_rule
+          existing_rule.constraint = new_constraint
+        else
+          package_rules << PackageRule.new(package_name, new_constraint)
+        end
+      end
     end
   end
 end

data/lib/apt_control/jabber.rb

@@ -8,15 +8,26 @@ module AptControl
     include ::Jabber
 
     def initialize(options)
+      @enabled  = options[:enabled]
       @jid      = options[:jid]
       @password = options[:password]
       @room_jid = options[:room_jid]
       @logger   = options[:logger]
 
-      swallow_errors { connect! } unless options[:defer_connect]
+      if @enabled
+        @room_nick = @room_jid && @room_jid.split('/').last
+        @room_listeners = []
+
+        swallow_errors { connect! } unless options[:defer_connect]
+      end
     end
 
+    def enabled?  ; @enabled   ; end
+    def room_nick ; @room_nick ; end
+
     def send_message(msg)
+      return unless enabled?
+
       if not_connected?
         connect!
       end
@@ -52,6 +63,13 @@ module AptControl
 
     def not_connected? ; ! connected? ; end
 
+    def add_room_listener(listener)
+      @room_listeners << listener
+    end
+
+    include Actors::Proxied
+    proxy :send_message
+
     private
 
     def attempt_reconnect(&block)
@@ -85,11 +103,36 @@ module AptControl
         @muc = Jabber::MUC::SimpleMUCClient.new(@client)
         @muc.join(JID.new(@room_jid))
         @logger.info("joined room #{@room_jid}")
+        setup_muc_callbacks
       rescue JabberError => e
         raise ConnectionError.new("error joining room", e)
       end
     end
 
+    def setup_muc_callbacks
+      @muc.on_message do |time, nick, text|
+        next if time # skip history
+        next if @room_nick == nick
+        notify_room_listeners(text)
+      end
+    end
+
+    def notify_room_listeners(text)
+      @room_listeners.each do |l|
+        begin
+          if l.is_a? Celluloid
+            l.async.on_message(text)
+          else
+            l.on_message(text)
+          end
+        rescue => e
+          @logger.error("listener #{l} raised error: #{e}")
+          @logger.error(e)
+        end
+      end
+    end
+
+
     # Thank you to http://rubyforge.org/projects/nestegg for the pattern
     class Error < StandardError
 
@@ -114,4 +157,7 @@ module AptControl
     class ConnectionError < Error ; end
     class SendError < Error ; end
   end
+
+
+
 end

data/lib/apt_control/package_states.rb

@@ -17,6 +17,12 @@ module AptControl
         end
       end
     end
+
+    def find_state(dist_name, package_name)
+      find do |state|
+        state.dist.name == dist_name && state.package_name == package_name
+      end
+    end
   end
 
   # Brings together the state of a particular package in a particular
@@ -55,5 +61,17 @@ module AptControl
     def includeable_to
       rule.includeable_to(available)
     end
+
+    def status_line
+      [
+        dist.name,
+        package_name,
+        "(#{rule.restriction} #{rule.version})",
+        "#{includeable? ? 'I' : '.'}#{satisfied? ? 'S' : '.'}",
+        "included=#{included || '<none>'}",
+        "available=#{available? ? available.join(', ') : '<none>'} "
+      ].join(' ')
+    end
+
   end
 end

data/lib/apt_control/version.rb

@@ -1,3 +1,3 @@
 module AptControl
-  VERSION = '0.4.0'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apt_control
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: popen4
@@ -82,7 +82,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -90,7 +90,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rb-inotify
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +107,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -150,15 +166,22 @@ files:
 - bin/apt_control
 - lib/apt_control.rb
 - lib/apt_control/jabber.rb
+- lib/apt_control/commands.rb
 - lib/apt_control/package_states.rb
+- lib/apt_control/actors.rb
+- lib/apt_control/bot.rb
 - lib/apt_control/cli.rb
 - lib/apt_control/version.rb
-- lib/apt_control/includer.rb
 - lib/apt_control/exec.rb
+- lib/apt_control/cli/set.rb
 - lib/apt_control/cli/watch.rb
+- lib/apt_control/cli/promote.rb
 - lib/apt_control/cli/include.rb
 - lib/apt_control/cli/status.rb
 - lib/apt_control/build_archive.rb
+- lib/apt_control/commands/set.rb
+- lib/apt_control/commands/promote.rb
+- lib/apt_control/commands/include.rb
 - lib/apt_control/apt_site.rb
 - lib/apt_control/control_file.rb
 homepage: http://github.com/playlouder/apt_control