zypper 0.2.0

data/CHANGELOG

@@ -0,0 +1,16 @@
+0.0.9 (2012-06-26)
+------------------
+* Split into smaller one-task libraries
+* Added plural aliases for for accessing subclasses (patch -> patches,
+  package -> packages, ...)
+* Generic package search
+* Extended Patch with applicable?() and install() methods
+* Added testsuites
+* Packaging into gem
+
+0.0.1 (2012-06-20)
+------------------
+* Initial implementation using POpen4
+* Added Services and Repositories handling
+* Added Packages and Packages handling
+* Added documentation

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2012 Lukas Ocilka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.markdown

@@ -0,0 +1,421 @@
+# Zypper Library #
+
+This library provides Ruby access to libzypp using the
+`zypper` command.
+
+## License ##
+
+Distributed under the MIT license, see LICENSE file.
+
+## Features ###
+
+* Easy-to-use API
+* Running zypper in chroot or running your system zypper over a different root directory
+* Handling packages, repositories and patches
+* Easy to extend
+
+## Usage ##
+
+Require the library
+
+```ruby
+require "zypper"
+```
+
+Initialize new access to the library methods
+
+```ruby
+zypper = Zypper.new()
+```
+
+Add a new repository
+
+```ruby
+zypper.repository.add(:url => 'http://example.org/new/repo', :alias => 'Repo_at_Example_Org')
+```
+
+## Public Methods ##
+
+### Global ###
+
+#### Constructor ###
+
+```ruby
+zypper = Zypper.new(parameters)
+# or
+config = Zypper::Config.new(parameters)
+zypper = Zypper.new(config)
+```
+
+All parameters are optional, using their default value if not set.
+
+Possible parameters in hash:
+* :root => '/changed-root' - defaults to '/'
+* :chroot_method => 'local' (calls local zypper with changed root) or 'chroot' (calls zypper in chroot)
+* :refresh_repo => true or false - default for all newly added repositories
+* :auto_agree_with_licenses => true or false - default for installing packages, applying patches...
+
+Example:
+```ruby
+zypper = Zypper.new(:chroot => '/some-chroot-dir', :chroot_method => 'chroot')
+```
+
+#### Zypper Output ####
+
+These methods work after calling all API functions:
+
+* last_message - unparsed STDOUT of the last zypper call
+* last_error_message - unparsed STDERR of the last zypper call
+* last_exit_status - exit code (integer) of the last zypper call
+
+Example:
+```ruby
+zypper.last_message
+```
+
+#### Zypper Version ####
+
+```ruby
+version
+
+# returns
+{:major=>1, :minor=>3, :revision=>7}
+```
+
+#### Caches Cleanup ####
+
+```ruby
+clean_caches
+
+# returns
+true or false
+```
+
+#### Importing All used GPG Keys ####
+
+```ruby
+auto_import_keys
+
+# returns
+true or false
+```
+
+### Repositories ###
+
+You can access the repositories class either with
+```ruby
+zypper = Zypper.new
+zypper.repository
+# or
+zypper.repositories
+```
+or
+```ruby
+Zypper::Repository.new
+```
+
+#### Listing repositories ####
+
+```ruby
+zypper.repositories.all
+
+# returns
+[
+  { "enabled"=>"1", "autorefresh"=>"1", "name"=>"SLES11-SP1-x68_64", "url"=>["http://repo/URI"],
+    "type"=>"rpm-md", "alias"=>"repository_alias", "gpgcheck"=>"1" },
+  { ... },
+  ...
+]
+```
+
+#### Adding a Repository ####
+
+```ruby
+zypper.repository.add(:url => 'http://repository/URI', :alias => 'repository_alias')
+
+# returns
+true or false
+```
+
+Example:
+```ruby
+Zypper.new.repository.add(:url => 'http://repository/URI', :alias => 'repository_alias')
+# or
+Zypper::Repository.new.add(:url => 'http://repository/URI', :alias => 'repository_alias')
+```
+
+#### Removing a Repository ####
+
+```ruby
+zypper.repository.remove(:alias => 'repository_alias')
+
+# returns
+true or false
+```
+
+#### Refreshing Repositories ####
+
+```ruby
+zypper.repository.refresh(parameters)
+
+# returns
+true or false
+```
+
+Possible optional parameters:
+* :force - forces a complete refresh
+* :force_build - forces rebuild of the database
+
+### Services ###
+
+You can access the services class either with
+```ruby
+zypper = Zypper.new
+zypper.service
+# or
+zypper.services
+```
+or
+```ruby
+Zypper::Service.new
+```
+
+#### Listing Services ####
+
+```ruby
+zypper.services.all
+```
+
+Example:
+```ruby
+Zypper.new.services.all
+# or
+Zypper::Services.new.all
+```
+
+#### Refreshing Services ####
+
+```ruby
+zypper.services.refresh
+
+# returns
+true or false
+```
+
+### Packages ###
+
+#### Installing Packages ####
+
+You can access the packages class either with
+```ruby
+zypper = Zypper.new
+zypper.package
+# or
+zypper.packages
+```
+or
+```ruby
+Zypper::Package.new
+```
+
+```ruby
+zypper.packages.install(:packages => ['package', 'package', ...])
+
+# returns
+true or false
+```
+
+`package` string can consist of NAME[.ARCH][OP<VERSION>], where OP is one
+of <, <=, =, >=, >, for example:
+
+```ruby
+zypper.package.install :packages => ['less.x86_64=424b-10.22']
+```
+
+#### Removing Packages ####
+
+```ruby
+zypper.packages.remove(:packages => ['package', 'package', ...])
+
+# returns
+true or false
+```
+
+`package` string can consist of NAME[.ARCH][OP<VERSION>], where OP is one
+of <, <=, =, >=, >, for example:
+
+```ruby
+zypper.package.remove :packages => ['less.x86_64=424b-10.22']
+```
+
+#### Installed Packages ####
+
+Lists all installed packages. 
+
+```ruby
+zypper.packages.installed
+
+# returns
+[
+  {
+    :type=>"package", :status=>:installed, :summary=>"Package, Patch, Pattern, and Product Management",
+    :name=>"libzypp"
+  },
+  { ... },
+  ...
+]
+```
+
+#### Available Packages ####
+
+```ruby
+zypper.packages.available
+
+# returns
+[
+  {
+    :type=>"package", :status=>:available, :summary=>"Helper that makes writing ...",
+    :name=>"zypp-plugin-python"
+  },
+  { ... },
+  ...
+]
+```
+
+#### Packages Search ####
+
+```ruby
+zypper.packages.find
+
+# returns
+[
+  ... list of packages ...
+]
+```
+
+Example
+```ruby
+# All packages with name 'kernel-default'
+zypper.packages.find(:name => 'kernel-default')
+
+# All available packages matching zypp*
+zypper.packages.find(:name => 'zypp*', :status => :available)
+
+# All installed packages
+zypper.packages.find(:status => :installed)
+```
+
+#### Package Info ####
+
+```ruby
+zypper.package.info(:package => 'package')
+
+# Returns, e.g.
+{
+  :status=>"not installed", :version=>"424b-10.22",
+  :summary=>"Text File Browser and Pager Similar to more", :arch=>"x86_64",
+  :repository=>"SLES11-SP1-x68_64", :size=>"266.0 KiB",
+  :vendor=>"SUSE LINUX Products GmbH, Nuernberg, Germany",
+  :name=>"less", :installed=>"No", :level=>"Level 3"
+}
+```
+
+#### Package Installed? ####
+
+```ruby
+zypper.package.installed?(:package => 'package')
+
+# returns
+true or false
+```
+
+### Patches ###
+
+You can access the patches class either with
+
+```ruby
+zypper = Zypper.new
+zypper.patch
+# or
+zypper.patches
+```
+or
+```ruby
+Zypper::patch.new
+```
+
+#### Listing Patches ####
+
+All known patches
+
+```ruby
+zypper.patches.all
+```
+
+#### Searching for Patches ####
+
+```ruby
+zypper.patches.find(filter_parameters)
+
+# returns
+[
+  { :status=>'Needed', :category=>'Recommended', :name=>'patch-name',
+    :version=>'patch-version', :catalog=>"repository-name"
+  },
+  { ... },
+  ...
+]
+```
+All parameters are optional and can be combined, using their default value if not set.
+
+Possible parameters in hash:
+
+* :status => 'Status' (see Zypper::Patch::Status class constants)
+* :category => 'Category' (See Zypper::Patch::Category class constants)
+* :name => 'Exact-Name'
+* :version => 'Exact-Version'
+* :catalog => 'Alias-of-the-repo'
+
+Example:
+```ruby
+zypper.patches.all(
+  :status => Zypper::Patch::Status::INSTALLED,
+  :category => Zypper::Patch::Category::RECOMMENDED
+)
+```
+
+#### Applicable Patches ####
+
+Lists all applicable patches. All filter parameters are optional and can
+be used the same as for the `find()` method.
+
+```ruby
+zypper.patches.applicable(filter_parameters)
+```
+
+#### Any Applicable Patches? ####
+
+Returns whether there are any applicable patches present.
+All filter parameters are optional and can be used the same as for the
+`find()` method.
+
+```ruby
+zypper.patches.applicable?(filter_parameters)
+```
+
+#### Installed Patches
+
+Lists all installed patches. All filter parameters are optional and can
+be used the same as for the `find()` method.
+
+```ruby
+zypper.patches.installed(filter_parameters)
+```
+
+#### Install Patches ####
+
+Installs all applicable patches.
+
+```ruby
+zypper.patches.install
+```

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/zypper.rb

@@ -0,0 +1,55 @@
+require 'zypper/utils'
+
+require 'zypper/repository'
+require 'zypper/service'
+require 'zypper/package'
+require 'zypper/patch'
+
+class Zypper
+  include ZypperUtils
+
+  attr_reader :repository, :service, :package, :patch
+
+  alias :repositories :repository
+  alias :services     :service
+  alias :packages     :package
+  alias :patches      :patch
+
+  def initialize(params = {})
+    super(params)
+
+    self.repository = Zypper::Repository.new config
+    self.service    = Zypper::Service.new    config
+    self.package    = Zypper::Package.new    config
+    self.patch      = Zypper::Patch.new      config
+  end
+
+  # Returns the current zypper version
+  def version(options = {})
+    if (run(build_command('version', options = {})))
+      version_number(last_message, options)
+    end
+  end
+
+  # Cleans the libzypp cache
+  def clean_caches(options = {})
+    run build_command('clean', options)
+  end
+
+  # Auto-imports all GPG keys from repositories
+  def auto_import_keys(options = {})
+    previous_auto_import_gpg = config.auto_import_gpg
+    ret = repositories.refresh
+    config.auto_import_gpg = previous_auto_import_gpg
+    ret
+  end
+
+  private
+
+  attr_writer :repository, :service, :package, :patch
+
+  def version_number(version_string, options)
+    version = version_string.gsub(/[^0-9\.]/, '').split('.')
+    {:major => version[0].to_i, :minor => version[1].to_i, :revision => version[2].to_i}
+  end
+end

data/lib/zypper/config.rb

@@ -0,0 +1,91 @@
+require 'rubygems'
+require 'fileutils'
+
+class Zypper
+  class Config
+
+    DEFAULT_ROOT = '/'
+    DEFAULT_IMPORT_GPG = true
+    DEFAULT_REFRESH_REPO = true
+    DEFAULT_AUTO_AGREE_WITH_LICENSES = true
+    DEFAULT_CHROOT_METHOD = 'local'
+
+    CHROOT_METHOD_LOCAL  = 'local'
+    CHROOT_METHOD_CHROOT = 'chroot'
+    KNOWN_CHROOT_METHODS = [CHROOT_METHOD_LOCAL, CHROOT_METHOD_CHROOT]
+
+    # Constructor
+    #
+    # Possible parameters
+    #   (string)  :root
+    #             Defines the changed root environment, default '/'
+    #   (boolean) :auto_import_gpg
+    #             Automatically trust (and import) new GPG keys, default true
+    #   (boolean) :refresh_repo
+    #             Adds new repositories with autorefresh flag, default true
+    #   (string)  :chroot_method
+    #             Defines which zypper is used; 'local' uses the local zypper with
+    #             changed root directory specified as --root parameter whereas
+    #             'chroot' uses chroot binary and calls zypper directly in the
+    #             :root directory. This can be ignored if changed :root is not
+    #             defined
+    #   (boolean  :auto_agree_with_licenses
+    #             automatically accept all licenses, otherwise such packages
+    #             cannot be installed
+    def initialize(params = {})
+      self.root = (params[:root] || DEFAULT_ROOT)
+      self.chroot_method = (params[:chroot_method] || DEFAULT_CHROOT_METHOD)
+
+      @auto_import_gpg = (params[:auto_import_gpg] || DEFAULT_IMPORT_GPG)
+      @refresh_repo = (params[:refresh_repo] || DEFAULT_REFRESH_REPO)
+      @auto_agree_with_licenses = (params[:auto_agree_with_licenses] || DEFAULT_AUTO_AGREE_WITH_LICENSES)
+    end
+
+    attr_accessor :auto_import_gpg
+
+    attr_reader :root, :chroot_method
+
+    # Changes the current root directory, the directory must exist
+    def root=(new_root)
+      if ! File.exists? new_root
+        raise "Directory #{new_root} does not exist"
+      elsif ! File.directory? new_root
+        raise "#{new_root} is not a directory"
+      end
+
+      @root = new_root
+    end
+
+    # Changes the current chroot method, see constructor for possible values
+    def chroot_method=(new_chroot_method)
+      unless KNOWN_CHROOT_METHODS.include? new_chroot_method
+        raise "Unknown chroot method #{new_chroot_method}, possible are #{KNOWN_CHROOT_METHODS.join(', ')}"
+      end
+
+      @chroot_method = new_chroot_method
+    end
+
+    # Using chroot command
+    def chrooted?
+      chroot_method == CHROOT_METHOD_CHROOT
+    end
+
+    # Using zypper --root of the root is actually different
+    def changed_root?
+      root != DEFAULT_ROOT && chroot_method == CHROOT_METHOD_LOCAL
+    end
+
+    def auto_import_gpg?
+      @auto_import_gpg
+    end
+
+    def auto_agree_with_licenses?
+      @auto_agree_with_licenses
+    end
+
+    def refresh_repo?
+      @refresh_repo
+    end
+
+  end
+end

data/lib/zypper/package.rb

@@ -0,0 +1,115 @@
+require 'zypper/utils'
+
+class Zypper
+  class Package
+    include ZypperUtils
+
+    class Status
+      INSTALLED = :installed
+      AVAILABLE = :uninstalled
+    end
+
+    PACKAGE_STATUSES = {
+      ''  => Status::AVAILABLE,
+      'i' => Status::INSTALLED,
+    }
+
+    # Installs packages given as parmeter
+    #   (array) :packages
+    def install(options = {})
+      run build_command('install', options)
+    end
+
+    # Removes packages given as parmeter
+    #   (array) :packages
+    def remove(options = {})
+      run build_command('remove', options)
+    end
+
+    # Returns hash of information on a package given as parameter
+    #   (string) :package
+    def info(options = {})
+      if (run(build_command('info', options)))
+        convert_info(last_message)
+      end
+    end
+
+    # returns whether a package given as parameter is installed
+    #   (string) :package
+    def installed?(options = {})
+      info(options).fetch(Status::INSTALLED, 'No') == 'Yes'
+    end
+
+    # Returns packages found using given parameters
+    #
+    # @param (Hash) of options
+    #   (string) :name - exact name of a package
+    #   (symbol) :status - See Zypper::Package::Status class constants
+    def find(options = {})
+      additional_options = {:cmd_options => ['--type package'], :quiet => true}
+
+      if (run (build_command('search', options.merge(additional_options))))
+        convert_packages(last_message)
+      end
+    end
+
+    # Returns all installed packages
+    def installed(options = {})
+      find(options.merge(:status => Status::INSTALLED))
+    end
+
+    # Returns all available packages (that are not installed yet)
+    def available(options = {})
+      find(options.merge(:status => Status::AVAILABLE))
+    end
+
+    private
+
+    def status(status)
+      return PACKAGE_STATUSES[status] if PACKAGE_STATUSES[status]
+
+      raise "Unknown package status '#{status}'"
+    end
+
+    # SLE11 zypper doesn't support XML output for packages
+    # FIXME: merge with 'convert_patches'
+    def convert_packages(packages)
+      out = []
+      table_index = 0
+      package = {}
+
+      packages.split("\n").each {|line|
+        table_index = table_index + 1
+        # Skip the first two - table header
+        next if table_index < 3
+
+        line.gsub!(/ +\| +/, '|')
+        line.gsub!(/^ +/, '')
+        line.gsub!(/ +$/, '')
+        package = line.split '|'
+
+        out.push(
+          :status  => status(package[0]),
+          :name    => package[1],
+          :summary => package[2],
+          :type    => package[3]
+        )
+      }
+
+      out
+    end
+
+    def convert_info(info)
+      out = {}
+
+      info.split("\n").each do |line|
+        if /([[:alnum:]]+): (.+)/.match(line)
+          out[$1.downcase.to_sym] = $2
+        end
+      end
+
+      out
+    end
+
+  end
+end

data/lib/zypper/patch.rb

@@ -0,0 +1,113 @@
+require 'zypper/utils'
+
+class Zypper
+  class Patch
+    class Status
+      NEEDED         = 'Needed'
+      INSTALLED      = 'Installed'
+      NOT_APPLICABLE = 'Not Applicable'
+    end
+
+    class Category
+      SECURITY    = 'security'
+      RECOMMENDED = 'recommended'
+      FEATURE     = 'feature'
+      OPTIONAL    = 'optional'
+    end
+
+    include ZypperUtils
+
+    FILTER_OPTIONS = [:repository, :name, :version, :category, :status]
+
+    # Lists all patches
+    #
+    # @param Hash with optional key :where (Hash)
+    #        that can consist of one or more parameters from
+    #        :repository, :name, :version, :category, and :status.
+    #        Logical AND is always applied for all the options present
+    #
+    # @example
+    #   all(:status => 'Installed')
+    def find(options = {})
+      additional_options = {:quiet => true}
+
+      if (run(build_command('patches', options.merge(additional_options))))
+        apply_filters(convert_patches(last_message), options)
+      end
+    end
+
+    # Lists all known patches
+    def all(options = {})
+      find
+    end
+
+    # All applicable patches
+    def applicable(options = {})
+      find(options.merge(:status => Status::NEEDED))
+    end
+
+    # Are there any applicable patches present?
+    def applicable?(options = {})
+      applicable(options).size > 0
+    end
+
+    # Installs all applicable patches
+    def install(options = {})
+
+      run(build_command('patch', options))
+    end
+
+    # All installed patches
+    def installed(options = {})
+      find(options.merge(:status => Status::INSTALLED))
+    end
+
+    private
+
+    # Current libzypp doesn't support XML output for patches
+    def convert_patches(patches)
+      out = []
+      table_index = 0
+      patch = {}
+
+      patches.split("\n").each {|line|
+        table_index = table_index + 1
+        # Skip the first two - table header
+        next if table_index < 3
+
+        line.gsub!(/ +\| +/, '|')
+        line.gsub!(/^ +/, '')
+        line.gsub!(/ +$/, '')
+        patch = line.split '|'
+
+        out.push(
+          :repository => patch[0],
+          :name       => patch[1],
+          :version    => patch[2],
+          :category   => patch[3],
+          :status     => patch[4]
+        )
+      }
+
+      out
+    end
+
+    # Filters patches according to given parameters
+    #
+    # @param (Array) patches
+    # @param (Hash)  filters criteria, possible keys are :repository, :name, :version, :category and :status
+    #
+    # @example
+    #   apply_patch_filters(patches, { :status => 'Needed' })
+    #   apply_patch_filters(patches, { :version' => '1887', :repository => 'SLES11-SP1-Update' })
+    def apply_filters(patches = [], filters = {})
+      filters.each {|filter_key, filter_value|
+        raise "Unknown filter parameter '#{filter_key}'" unless FILTER_OPTIONS.include? filter_key
+
+        patches = patches.select{|patch| patch[filter_key] == filter_value}
+      }
+      patches
+    end
+
+  end
+end

data/lib/zypper/repository.rb

@@ -0,0 +1,35 @@
+require 'zypper/utils'
+
+class Zypper
+  class Repository
+    include ZypperUtils
+
+    # Refreshes repositories
+    #   @param (optional) options
+    #     :force - to force the refresh
+    #     :force_rebuild - forces rebuilding the libzypp database
+    def refresh(options = {})
+      run build_command('refresh', options)
+    end
+
+    # Lists all known repositories
+    def all(options = {})
+      out = xml_run build_command('repos', options.merge(:get => XML_COMMANDS_GET))
+      out.fetch('repo-list', []).fetch(0, {}).fetch('repo', [])
+    end
+
+    # Adds a new repository defined by options
+    #  (string) :url URL/URL
+    #  (string) :alias
+    def add(options = {})
+      run build_command('addrepo', options)
+    end
+
+    # Removes a repository defined by options
+    #  (string) :alias
+    def remove(options = {})
+      run build_command('removerepo', options)
+    end
+
+  end
+end

data/lib/zypper/service.rb

@@ -0,0 +1,19 @@
+require 'zypper/utils'
+
+class Zypper
+  class Service
+    include ZypperUtils
+
+    # Refreshes services
+    def refresh(options = {})
+      run build_command('refresh-services', options)
+    end
+
+    # Lists all known services
+    def all(options = {})
+      out = xml_run build_command('services', options.merge(:get => XML_COMMANDS_GET))
+      out.fetch('service-list', []).fetch(0, {}).fetch('service', [])
+    end
+
+  end
+end

data/lib/zypper/utils.rb

@@ -0,0 +1,197 @@
+module ZypperUtils
+  require 'rubygems'
+  require 'shellwords'
+  require 'popen4'
+  require 'xmlsimple'
+
+  require 'zypper/config'
+
+  XML_COMMANDS_GET = 'xml'
+
+  # Only getters are public
+  attr_reader :last_message, :last_error_message, :last_exit_status, :config
+
+  # Constructor
+  #
+  # @param either instance of Zypper::Config class
+  #        or hash of options for new Zypper::Config class
+  #
+  # See Zypper::Config new() for more info
+  def initialize(params = {})
+    # Config is the given parameter
+    if (params.instance_of?(Zypper::Config))
+      self.config = params
+    # Called directly
+    elsif (params.is_a?(Hash))
+      self.config = Zypper::Config.new params
+    # Unknown call method
+    else
+      raise "Parameters #{params.inspect} is neither Zypper::Config nor Hash with options"
+    end
+  end
+
+  private
+
+  # Setters are private
+  attr_writer :last_message, :last_error_message, :last_exit_status, :config
+
+  def check_mandatory_options_set(zypper_action, options, mandatory)
+    mandatory.each {|option|
+      raise "Missing '#{option}' parameter in '#{zypper_action}' action" if options[option].nil?
+    }
+  end
+
+  def check_mandatory_options(zypper_action, options)
+    case zypper_action
+      when 'addrepo'
+        check_mandatory_options_set(zypper_action, options, [:url, :alias])
+        # FIXME: check that :url or :alias do not contain any spaces (or special characters)
+      when 'removerepo'
+        check_mandatory_options_set(zypper_action, options, [:alias])
+        # FIXME: check that :url or :alias do not contain any spaces (or special characters)
+      when 'install'
+        # FIXME: check that :packages do not contain any spaces (or special characters)
+        check_mandatory_options_set(zypper_action, options, [:packages])
+      when 'remove'
+        # FIXME: check that :packages do not contain any spaces (or special characters)
+        check_mandatory_options_set(zypper_action, options, [:packages])
+      when 'info'
+        # FIXME: check that :package does not contain any spaces (or special characters)
+        check_mandatory_options_set(zypper_action, options, [:package])
+      # No checks:
+      #   * 'search' used also just with command-line parameters but no particular
+      #              object to search for
+      #
+    end
+  end
+
+  def chrooted
+    config.chrooted? ? 'chroot ' + Shellwords::escape(config.root) + ' ' : ''
+  end
+
+  # Returns the full zypper command including chroot, zypper command, options, etc.
+  def build_command(zypper_action, options = {})
+    check_mandatory_options(zypper_action, options)
+
+    chrooted + ' zypper ' + global_options(options) + ' ' +
+      zypper_command(zypper_action) + ' ' + zypper_command_options(zypper_action, options)
+  end
+
+  # Returns a zypper command (shell) defined by an action
+  def zypper_command zypper_action
+    case zypper_action
+      # version is a global option but not a command
+      when 'version'
+        ''
+      else
+        zypper_action
+    end
+  end
+
+  def escape_items(items = [])
+    items.collect{|package| Shellwords::escape(package)}.join(' ')
+  end
+
+  def escape(item = '')
+    Shellwords::escape(item)
+  end
+
+  # Returns string of command options depending on a given zypper command
+  # combined with provided options
+  def zypper_command_options(zypper_action, options = {})
+    ret_options = []
+
+    # Additional command-line options for a command
+    if options[:cmd_options]
+      ret_options = options[:cmd_options]
+    end
+
+    case zypper_action
+      when 'refresh'
+        ret_options = [
+          options[:force] ? '--force' : '',
+          options[:force_build] ? '--force-build' : '',
+        ]
+      when 'addrepo'
+        ret_options = [
+          config.refresh_repo? ? '--refresh':'',
+          options[:url],
+          options[:alias],
+        ]
+      when 'removerepo'
+        ret_options = [
+          options[:alias],
+        ]
+      when 'install'
+        ret_options = [
+          config.auto_agree_with_licenses? ? '--auto-agree-with-licenses' : '',
+          escape_items(options[:packages]),
+        ]
+      when 'remove'
+        ret_options = [
+          escape_items(options[:packages]),
+        ]
+      when 'version'
+        ret_options = [
+          '--version',
+        ]
+      when 'info'
+        ret_options = [
+          escape(options[:package]),
+        ]
+      when 'search'
+        ret_options = [
+          options[:status] == Zypper::Package::Status::INSTALLED ? '--installed-only' : '',
+          options[:status] == Zypper::Package::Status::AVAILABLE ? '--uninstalled-only' : '',
+
+          options[:name] ? '--match-exact ' + escape(options[:name]) : '',
+        ]
+    end
+
+    ret_options.join(' ')
+  end
+
+  # Returns string with global zypper options
+  def global_options(options = {})
+    [
+      (options[:quiet] ? '--quiet' : ''),
+      (config.changed_root? ? '--root=' + Shellwords::escape(config.root) : ''),
+      (options[:get] == XML_COMMANDS_GET ? '--xmlout' : ''),
+      '--non-interactive',
+      (config.auto_import_gpg? ? '--gpg-auto-import-keys' : ''),
+    ].join(' ')
+  end
+
+  def xml_run(command)
+    xml = run(command, {:get => XML_COMMANDS_GET})
+    out = XmlSimple.xml_in(xml)
+
+    if !out["message"].nil?
+      errors = out["message"].select{|hash| hash["type"] == "error"}
+      self.last_error = errors.collect{|hash| hash["content"]}.join("\n")
+    end
+
+    out
+  end
+
+  # Runs a command given as argument and returns the full output
+  # Exit status can be acquired using last_exit_status call
+  def run(command, params = {})
+    # FIXME: it's here just for debugging
+    puts "DEBUG: " + command
+
+    cmd_ret = POpen4::popen4(command) do |stdout, stderr, stdin, pid|
+      self.last_message       = stdout.read.strip
+      self.last_error_message = stderr.read.strip
+    end
+
+    last_exit_status = cmd_ret.exitstatus
+
+    if params[:get] == XML_COMMANDS_GET
+      last_message
+    else
+      last_exit_status == 0
+    end
+  end
+
+end

data/lib/zypper/version.rb

@@ -0,0 +1,4 @@
+module Zypper
+  # Zypper version (uses [semantic versioning](http://semver.org/)).
+  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").strip
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification 
+name: zypper
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Lukas Ocilka
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-26 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: popen4
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: |-
+  Library for accessing zypper functions such as searching and
+  installing packages, adding and removing repositories and services. Supports
+  calling zypper in changed root (both with local zypper and zypper in chroot).
+email: lukas.ocilka@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/zypper.rb
+- lib/zypper/config.rb
+- lib/zypper/repository.rb
+- lib/zypper/utils.rb
+- lib/zypper/package.rb
+- lib/zypper/patch.rb
+- lib/zypper/service.rb
+- lib/zypper/version.rb
+- LICENSE
+- CHANGELOG
+- README.markdown
+- VERSION
+homepage: https://github.com/kobliha/zypper
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Library for accessing zypper
+test_files: []
+
+has_rdoc: