devinstall 1.0.1 → 1.1.0

data/bin/pkg-tool

@@ -1,36 +1,7 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 require 'bundler/setup'
-require 'devinstall/cli'
+require 'devinstall'
 
-unless ARGV[0]
-  puts 'You must specify an action'
-  exit! ''
-end
-
-package = [] # creata a new Array
-command = ARGV.shift
-
-while ARGV[0] and ARGV[0][0..1] != '--'
-  package << ARGV.shift
-end
-
-if %w"version --version -v".include? command
-  command = 'version'
-end
-
-if %w"help --help -h".include? command
-  command = 'help'
-end
-
-unless %w"build install upload test help version".include? command
-  puts "Unknown command #{command}"
-  exit! 1
-end
-
-## the next should be the package
-# so if ARGV[0] don't start with --
-# we name it package
-cli=Devinstall::Cli.new(*package) ## Cli can be called for multiple packages
-cli.send(command.to_sym)
+include Cli
 

data/devinstall.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'getopt'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'commander'
 end

data/doc/example.yml

@@ -12,7 +12,7 @@ base:
       arch: debian64
 defaults:
   package: devinstall
-  env: dev
+#  env: dev
   type: deb
 tests:
 # dev is the environment

data/lib/devinstall/cli.rb

@@ -1,95 +1,94 @@
-require 'devinstall'
+require 'devinstall/pkg'
 require 'getopt/long'
 require 'devinstall/settings'
+require 'commander/import'
 
-module Devinstall
-  class Cli
+module Cli
 
-    include Utils
+  program :name, 'DevInstall'
+  program :version, Devinstall::VERSION
+  program :description, 'Poor man builder/installer'
 
-    def get_config(*fnames)
-      config=nil
-      fnames.each do |f|
-        (config ||= (File.expand_path(f) if File.exist? f)) and break
-      end
-      config
+  global_option('--config FILE' 'Configuration file to be used') do |file|
+    unless Devinstall::Settings.instance.load! file
+      puts "Couldn't find #{file}"
+      exit!
     end
+  end
 
-    def initialize(*package)
-      begin
-        opt = Getopt::Long.getopts(
-            %w(--config -c),
-            %w(--type -t),
-            %w(--env -e),
-            %w(--verbose -v),
-            %w(--dry-run -d),
-        )
-      rescue
-        puts 'Invalid option at command line'
-        help
-      end
-      #verbose and dry-run
-      $verbose ||= opt['verbose']
-      $dry ||= opt['dry-run']
-      # get config file
-      config = Devinstall::Settings.instance # is a singleton so we don't use new here
-      cfgfile = get_config('./devinstall.yml', '~/.devinstall.yml', opt['config'])
-      exit! 'You must specify the config file' if cfgfile.empty?
-      config.load! cfgfile # load cfgfile
-      config.env = opt['env'] || config.env
-      config.type = opt['type'] || config.type
-      @packages = package || []
-      @packages = config.defaults(:package) if @packages.empty?
-      exit! 'You must ask for a package' if @packages.empty?
-      config.validate
-    rescue KeyNotDefinedError => e
-      exit! e.message
+  global_option('--verbose', 'Verbose output') { $verbose=true }
+  global_option('--dry-run', 'Dry-run; don\'t run commands, just pretend to') { $dry=true }
+  global_option('--type STRING', 'Package type (deb, rpm, tgz). Currently only deb')
+  global_option('--env STRING', 'Package environment to be built for')
+
+  def load_defaults
+    %w(./devinstall.yml ./.devinstall.yml ~/.devinstall).each do |f|
+      Devinstall::Settings.instance.load! f and return true
     end
+    puts "Couldn't find default config file and no --config option given at command line"
+    exit!
+  end
+
+  command :build do |c|
+    c.action do |args, options|
+      config=Devinstall::Settings.instance
+      load_defaults unless options.config
+      type = options.type ? options.type.to_sym : config.defaults(:type)
+      env = options.env ? options.env.to_sym : config.defaults(:env)
 
-    def build
-      @packages.each do |package|
-        pk=Devinstall::Pkg.new(package)
+      args.each do |p|
+        pk=Devinstall::Pkg.new(p, type, env)
         pk.build
       end
     end
+  end
+
+  command :install do |c|
+    c.action do |args, options|
+      config=Devinstall::Settings.instance
+      load_defaults unless options.config
+      type = options.type ? options.type.to_sym : config.defaults(:type)
+      env = options.env ? options.env.to_sym : config.defaults(:env)
 
-    def install
-      @packages.each do |package|
-        pk=Devinstall::Pkg.new(package)
+      args.each do |p|
+        pk=Devinstall::Pkg.new(p, type, env)
         pk.build
         pk.install
       end
     end
+  end
 
-    def upload
-      @packages.each do |package|
-        pk=Devinstall::Pkg.new(package)
-        pk.build
-        pk.run_tests
-        pk.upload
-      end
-    end
+  command :test do |c|
+    c.action do |args, options|
+      config=Devinstall::Settings.instance
+      load_defaults unless options.config
+      type = options.type ? options.type.to_sym : config.defaults(:type)
+      env = options.env ? options.env.to_sym : config.defaults(:env)
 
-    def test
-      @packages.each do |package|
-        pk=Devinstall::Pkg.new(package)
+      args.each do |p|
+        pk=Devinstall::Pkg.new(p, type, env)
         pk.run_tests
       end
     end
+  end
 
-    def help
-      puts 'Usage:'
-      puts 'pkg-tool command [package_name ... ] --config|-c <file>  --type|-t <package_type> --env|-e <environment>'
-      puts 'where command is one of the: build, install, upload, help, version'
-      exit! ''
-    end
+  command :upload do |c|
+    c.action do |args, options|
+      config=Devinstall::Settings.instance
+      load_defaults unless options.config
+      type = options.type ? options.type.to_sym : config.defaults(:type)
+      env = options.env ? options.env.to_sym : config.defaults(:env)
 
-    def version
-      puts "devinstall version #{Devinstall::VERSION}"
-      puts "pkg-tool version   #{Devinstall::VERSION}"
-      exit! ''
+      args.each do |p|
+        pk=Devinstall::Pkg.new(p, type, env)
+        pk.build
+        pk.run_tests
+        pk.upload
+      end
     end
-
   end
+
 end
 
+__END__
+

data/lib/devinstall/pkg.rb

@@ -0,0 +1,178 @@
+require 'devinstall/version'
+require 'devinstall/deep_symbolize'
+require 'devinstall/utils'
+require 'devinstall/settings'
+require 'pp'
+
+module Devinstall
+  class UndeffError < RuntimeError; end
+
+  class Pkg
+    include Utils
+
+    def get_version(pkg, type, env)
+      config=Settings.instance
+      folder=config.local(:folder, pkg:pkg, type:type, env:env)
+      case type
+        when :deb
+          begin
+            deb_changelog = File.expand_path "#{folder}/#{pkg}/debian/changelog"
+            unless File.exists? deb_changelog
+              exit! <<-eos
+                No 'debian/changelog' found in specified :local:folder (#{folder})
+                Please check your config file
+              eos
+            end
+            @_package_version[:deb] = File.open(deb_changelog, 'r') { |f| f.gets.chomp.sub(/^.*\((.*)\).*$/, '\1') }
+          rescue IOError => e
+            exit! <<-eos
+              IO Error while opening #{deb_changelog}
+              Aborting \n #{e}
+            eos
+          end
+        else
+          raise UndeffError, "TODO package type #{type}"
+      end
+    end
+
+    # @param [String] package
+    def initialize(package, type, env)
+      config=Settings.instance #class variable,first thing!
+      @type=type
+      @env=env
+      @package = package 
+      @_package_version = {} # versions for types:
+      @package_files = {}
+      arch = config.build(pkg:package, type:type, env:env)[:arch]
+      p_name = "#{@package}_#{get_version(package, type, env)}"
+      @package_files[:deb] = {deb: "#{p_name}_#{arch}.deb",
+                              tgz: "#{p_name}.tar.gz",
+                              dsc: "#{p_name}.dsc",
+                              chg: "#{p_name}_amd64.changes"}
+    end
+
+    def upload(pkg=@package, type=@type, env=@env)
+      config = Settings.instance
+      scp = config.base(:scp)
+      repo = config.repos(pkg:pkg, type:type, env:env)
+      local = config.local(pkg:pkg, type:type, env:env)
+
+      @package_files[type].each do |p, f|
+        puts "Uploading #{f}\t\t[#{p}] to #{repo[:host]}"
+        command("#{scp} #{local[:temp]}/#{f} #{repo[:user]}@#{repo[:host]}:#{repo[:folder]}")
+      end
+    rescue CommandError => e
+      puts e.verbose_message
+      exit! ''
+    rescue KeyNotDefinedError => e
+      puts e.message
+      exit! ''
+    end
+
+    def build(pkg=@package, type=@type, env=@env)
+      config = Settings.instance
+      puts "Building package #{pkg} type #{type}"
+      build = config.build(pkg:pkg, type:type, env:env)
+      local = config.local(pkg:pkg, type:type, env:env)
+      raise 'Invaild build configuration' unless build.valid?
+
+      ssh   = config.base(:ssh)
+      rsync = config.base(:rsync)
+      local_folder = File.expand_path local[:folder]
+      local_temp   = File.expand_path local[:temp]
+
+      build_command = build[:command].gsub('%f', build[:folder]).
+          gsub('%t', build[:target]).
+          gsub('%p', pkg.to_s).
+          gsub('%T', type.to_s)
+
+      upload_sources("#{local_folder}/", "#{build[:user]}@#{build[:host]}:#{build[:folder]}")
+      command("#{ssh} #{build[:user]}@#{build[:host]} \"#{build_command}\"")
+      @package_files[type].each do |p, t|
+        puts "Receiving target #{p.to_s} for #{t.to_s}"
+        command("#{rsync} -az #{build[:user]}@#{build[:host]}:#{build[:target]}/#{t} #{local_temp}")
+      end
+    rescue CommandError => e
+      puts e.verbose_message
+      exit! ''
+    rescue KeyNotDefinedError => e
+      puts e.message
+      exit! ''
+    end
+
+    def install(pkg=@package, type=@type, env=@env)
+      config=Settings.instance
+      puts "Installing #{pkg} in #{env} environment."
+      install=config.install(pkg:pkg, type:type, env:env)
+      temp  =config.local(pkg:pkg, type:type, env:env)[:temp]
+
+      sudo = config.base(:sudo)
+      scp  = config.base(:scp)
+
+      install[:host] = [install[:host]] unless Array === install[:host]
+      case type
+        when :deb
+          install[:host].each do |host|
+            command("#{scp} #{temp}/#{@package_files[type][:deb]} #{install[:user]}@#{host}:#{install[:folder]}")
+            command("#{sudo} #{install[:user]}@#{host} /usr/bin/dpkg -i #{install[:folder]}/#{@package_files[type][:deb]}")
+          end
+        else
+          exit! "unknown package type '#{type.to_s}'"
+      end
+    rescue CommandError => e
+      puts e.verbose_message
+      exit! ''
+    rescue KeyNotDefinedError => e
+      puts e.message
+      exit! ''
+    end
+
+    def run_tests(pkg=@package, type=@type, env=@env)
+      config=Settings.instance
+      # check if we have the test section in the configuration file
+      unless config.respond_to? :tests
+        puts 'No test section in the config file.'
+        puts 'Skipping tests'
+        return
+      end
+      # for tests we will use almost the same setup as for build
+      test  = config.tests(pkg:pkg, type:type, env:env)
+      local = config.local(pkg:pkg, type:type, env:env)
+      build = config.build(pkg:pkg, type:type, env:env)
+
+      ssh = config.base(:ssh)
+      # replace "variables" in commands
+      command = test[:command].
+          gsub('%f', test[:folder]).# %f is the folder where the sources are rsync-ed
+          gsub('%t', build[:target]).# %t is the folder where the build places the result
+          gsub('%p', pkg.to_s) # %p is the package name
+      # take the sources from the local folder
+      local_folder = File.expand_path local[:folder]
+      # upload them to the test machine
+      upload_sources("#{local_folder}/", "#{test[:user]}@#{test[:machine]}:#{test[:folder]}")
+      puts 'Running all tests'
+      puts 'This will take some time and you have no output'
+      command("#{ssh} #{test[:user]}@#{test[:machine]} \"#{command}\"")
+    rescue CommandError => e
+      puts e.verbose_message
+      exit! ''
+    rescue KeyNotDefinedError => e
+      puts e.message
+      exit! ''
+    end
+
+    def upload_sources (source, dest)
+      config=Settings.instance
+      rsync = config.base(:rsync)
+      command("#{rsync} -az #{source} #{dest}")
+    end
+  rescue CommandError => e
+    puts e.verbose_message
+    exit! ''
+  rescue KeyNotDefinedError => e
+    puts e.message
+    exit! ''
+  end
+
+end
+

data/lib/devinstall/settings.rb

@@ -7,142 +7,127 @@ class Hash
   include DeepSymbolizable
 end
 
-module Devinstall
 
-  class KeyNotDefinedError < RuntimeError;
-  end
 
-  class UnknownKeyError < RuntimeError;
-  end
+module Devinstall
+
+class KeyNotDefinedError < RuntimeError;end
+class UnknownKeyError < RuntimeError;end
 
   class Settings
     include Singleton
 
-    attr_accessor :env, :type
     FILES = []
     SETTINGS = {}
-
-    def pkg=(pkg)
-      if Array === pkg and pkg.length == 1
-        @pkg = pkg[0]
-      elsif pkg.class.method_defined? :to_sym
-        @pkg = pkg.to_sym
-      else
-        @pkg = pkg
+    MDEFS={
+        local: [:folder, :temp],
+        build: [:user, :host, :folder, :target, :arch, :command, :provider],
+        install: [:user, :host, :folder, :type, :arch, :provider],
+        tests: [:machine, :folder, :user, :command, :provider],
+        repos: [:user, :host, :folder, :type, :arch]
+    }
+
+    class Action
+      include Enumerable
+
+      def initialize(set, sect, pkg, type, env)
+        @set=set
+        @sect=sect
+        @pkg=pkg
+        @type=type
+        @env=env
       end
-    end
 
-    def pkg
-      @pkg
-    end
-
-    def validate
-      raise KeyNotDefinedError, 'Missing package' unless self.pkg
-      raise KeyNotDefinedError, 'Missing environment' unless self.env
-      raise KeyNotDefinedError, 'Missing package type' unless self.type
-      if Array === self.pkg
-        self.pkg.each do |p|
-          raise KeyNotDefinedError, "Package '#{p}' not defined" unless SETTINGS[:packages].has_key? p.to_sym
-          raise KeyNotDefinedError, "Package #{p} type '#{type}' not defined " unless SETTINGS[:packages][p.to_sym].has_key? self.type
+      def valid?
+        config = Settings.instance
+        return false unless Settings::MDEFS.has_key? @sect
+        Settings::MDEFS[@sect].inject (true) do |res, k|
+          res and config.respond_to? @sect and config.send(@sect, k, pkg: @pkg, type: @type, env: @env)
         end
-      else
-        raise KeyNotDefinedError, "Package '#{pkg}' not defined" unless SETTINGS[:packages].has_key? self.pkg.to_sym
-        raise KeyNotDefinedError, "Package #{pkg} type '#{type}' not defined " unless SETTINGS[:packages][self.pkg.to_sym].has_key? self.type
+      rescue KeyNotDefinedError => e
+        puts e.message
+        puts e.backtrace if $verbose
+        return false
       end
-    rescue KeyNotDefinedError => e
-      raise e
-    rescue UnknownKeyError => e
-      puts "Program error: #{e.message} at:"
-      puts e.backtrace
-      exit!
-    end
 
-    def load! (filename) # Multiple load -> merge settings
-      unless File.exist?(File.expand_path(filename))
-        puts "Unable to find config file \"#{File.expand_path(filename)}\""
-        exit!
+      def [](key)
+        Settings.instance.send(@sect, key, pkg: @pkg, type: @type, env: @env)
       end
-      unless FILES.include? filename
-        FILES << filename
-        newsets = YAML::load_file(filename).deep_symbolize
-        deep_merge!(SETTINGS, newsets)
-      end
-      ### initialize type, env from defaults unless already defined
-      self.env ||= defaults(:env).to_sym
-      self.type ||= defaults(:type).to_sym
-    end
 
-    def deep_merge!(target, data)
-      merger = proc do |_, v1, v2|
-        Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+      def each
+        config=Settings.instance
+        Settings::MDEFS[@sect].each do |key|
+          yield(key, config.send(@sect, key, pkg: @pkg, type: @type, env: @env)) if block_given?
+        end
+      end
+    end  ## Class Action
+
+    def load! (filename)
+      if File.exist?(File.expand_path(filename))
+        unless FILES.include? filename
+          FILES << filename
+          data = YAML::load_file(filename).deep_symbolize
+          merger = proc do |_, v1, v2|
+            Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+          end
+          SETTINGS.merge! data, &merger
+        end
       end
-      target.merge! data, &merger
-    end
-
-    def self.defaults(key=nil)
-      return SETTINGS.has_key? :defaults if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:package, :type, :env, :providers].include? key
-      SETTINGS[:defaults][key] or raise KeyNotDefinedError, "Undefined key :default:#{key.to_s}"
     end
 
     def defaults(key=nil)
-      self.class.defaults key
+      return SETTINGS.has_key? :defaults if key.nil?
+      raise UnknownKeyError, "Unknowwn key: '#{key}'" unless [:package, :type, :env, :providers].include? key
+      return nil unless key_chain(:defaults, key)
+      SETTINGS[:defaults][key].to_sym or raise KeyNotDefinedError, "Undefined key :default:#{key.to_s}"
     end
 
-    def self.base(key=nil)
+    def base(key=nil)
       return SETTINGS.has_key? :base if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:rsync, :ssh, :sudo, :scp].include? key
+      raise UnknownKeyError, "Unknown key: '#{key}'" unless [:rsync, :ssh, :sudo, :scp].include? key
+      return nil unless key_chain(:base, key)
       SETTINGS[:base][key] or raise KeyNotDefinedError, "Undefined key :base:#{key.to_s}"
     end
 
-    def base(key=nil)
-      self.class.base key
-    end
-
-    def global_or_local(section, key)
-      ret = nil
-      if SETTINGS[:packages][self.pkg][self.type].has_key? section
-        ret ||= SETTINGS[:packages][self.pkg][self.type][section][self.env][key] if SETTINGS[:packages][self.pkg][self.type][section].has_key? self.env
-        ret ||= SETTINGS[:packages][self.pkg][self.type][section][key] # or nil
+    def method_missing (m, *args)
+      raise UnknownKeyError, "Undefined section '#{m}'" unless MDEFS.has_key? m
+      key=(args.shift or {})
+      if Hash === key
+        pkg = key[:pkg] or raise 'package must be defined'
+        type = (key[:type] or defaults(:type))
+        env = (key[:env] or defaults(:env))
+        return Action.new(SETTINGS, m, pkg, type, env)
       end
-      ret ||= SETTINGS[section][self.env][key] if SETTINGS[section].has_key? self.env
-      ret ||= SETTINGS[section][key] # or nil
-      ret
-    end
-
-    def local(key=nil)
-      return SETTINGS.has_key? :local if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:folder, :temp].include? key
-      global_or_local(:local, key) or raise KeyNotDefinedError, "Undefined key :local:#{key} or :#{self.pkg}:local:#{key}"
+      rest=(args.shift or {})
+      (pkg = rest[:pkg]) or raise 'package must be defined'
+      type = (rest[:type] or defaults(:type))
+      env = (rest[:env] or defaults(:env))
+      pkg=pkg.to_sym
+      raise UnknownKeyError, "Unknown key #{key}" unless MDEFS[m].include? key
+      global_or_local(m, key, pkg, type, env) or raise KeyNotDefinedError, "Undefined key '#{m}:#{key}' or alternate for ['#{pkg}' '#{type}' '#{env}']"
     end
 
-    def build(key=nil)
-      return (SETTINGS.has_key? :build or SETTINGS[:packages][self.pkg][self.type].has_key? :build) if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:user, :host, :folder, :target, :arch, :command, :provider].include? key
-      global_or_local(:build, key) or raise KeyNotDefinedError, "Undefined key :build:#{key} or :#{self.pkg}:#{self.type}:build:#{key}"
+    def respond_to_missing?(method, _)
+      MDEFS.has_key? method and SETTINGS.has_key? method
     end
 
-    def install(key=nil)
-      return SETTINGS.has_key? :install if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:user, :host, :folder, :type, :arch, :provider].include? key
-      global_or_local(:install, key) or raise KeyNotDefinedError, "Undefined key :install:#{self.env.to_s}:#{key} or :#{self.pkg}:install:#{self.env.to_s}:#{key}"
-    end
+    private
 
-    def tests(key=nil) # tests don't have 'env'
-      return SETTINGS.has_key?(:tests) if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:machine, :folder, :user, :command, :provider].include? key
-      global_or_local(:tests, key) or raise KeyNotDefinedError, "Undefined key :tests:#{self.env.to_s}:#{key} or :#{self.pkg}:tests:#{self.env.to_s}:#{key}"
-    end
-
-    def repos(key=nil)
-      return SETTINGS.has_key?(:repos) if key.nil?
-      raise UnknownKeyError, "Don't know what are you asking about: '#{key}'" unless [:user, :host, :folder, :type, :arch].include? key
-      global_or_local(:repos, key) or raise KeyNotDefinedError, "Undefined key :repos:environments:#{self.env.to_s}:#{key} or :#{self.pkg}:repos:#{self.env.to_s}:#{key}"
+    def key_chain(*keys)
+      res=SETTINGS
+      keys.each do |key|
+        next if key.nil?
+        return nil unless res.has_key? key
+        res=res[key]
+      end
+      res
     end
 
-    def packages(key=nil)
-      return SETTINGS.has_key?(:packages) if key.nil?
-      SETTINGS[:packages][key] ## no checks here!
+    def global_or_local(section, key, pkg, type, env)
+      key_chain(:packages, pkg, type, section, env, key) ||
+          key_chain(:packages, pkg, type, section, key) ||
+          key_chain(section, env, key) ||
+          key_chain(section, key)
     end
 
   end

data/lib/devinstall/utils.rb

@@ -28,8 +28,8 @@ module Utils
     ret
   end
 
-  def exit!(msg=nil)
-    puts msg || 'Aborting!'
+  def exit!(msg='Aborting')
+    puts msg
     Kernel.exit 1
   end
 

data/lib/devinstall/version.rb

@@ -1,3 +1,3 @@
 module Devinstall
-  VERSION = '1.0.1' # Working!
+  VERSION = '1.1.0' # Working!
 end

data/lib/devinstall.rb

@@ -2,168 +2,6 @@ require 'devinstall/version'
 require 'devinstall/deep_symbolize'
 require 'devinstall/utils'
 require 'devinstall/settings'
-require 'pp'
-
-module Devinstall
-
-  class Pkg
-
-    include Utils
-
-    def get_version
-      case @config.type
-        when :deb
-          begin
-            deb_changelog = File.expand_path "#{@config.local(:folder)}/#{@package}/debian/changelog" # This is the folder that should be checked
-            unless File.exists? deb_changelog
-              exit! <<-eos
-                No 'debian/changelog' found in specified :local:folder (#{@config.local(:folder)})
-                Please check your config file
-              eos
-            end
-            @_package_version[:deb] = File.open(deb_changelog, 'r') { |f| f.gets.chomp.sub(/^.*\((.*)\).*$/, '\1') }
-          rescue IOError => e
-            exit! <<-eos
-              IO Error while opening #{deb_changelog}
-              Aborting \n #{e}
-            eos
-          end
-      end
-    end
-
-    # @param [String] package
-    def initialize(package)
-      @config=Settings.instance #class variable,first thing!
-      @config.pkg=package # very important!
-      @package = package # currently implemented only for .deb packages (for .rpm later :D)
-      @_package_version = {} # versions for types:
-      @package_files = {}
-      arch = @config.build(:arch)
-      p_name = "#{@package}_#{get_version}"
-      @package_files[:deb] = {deb: "#{p_name}_#{arch}.deb",
-                              tgz: "#{p_name}.tar.gz",
-                              dsc: "#{p_name}.dsc",
-                              chg: "#{p_name}_amd64.changes"}
-    end
-
-    def upload
-      scp = @config.base(:scp)
-      repo = {}
-      [:user, :host, :folder, :type].each do |k|
-        repo[k] = @config.repos(k) # looks stupid
-      end
-      @package_files[type].each do |p, f|
-        puts "Uploading #{f}\t\t[#{p}] to $#{repo[:host]}"
-        command("#{scp} #{@config.local(:temp)}/#{f} #{repo[:user]}@#{repo[:host]}:#{repo[:folder]}")
-      end
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotdefinederror => e
-      puts e.message
-      exit! ''
-    end
-
-    def build
-      type = @config.type
-      puts "Building package #{@package} type #{type}"
-      build = {}
-      [:user, :host, :folder, :target].each do |k|
-        build[k] = @config.build(k)
-      end
-
-      ssh = @config.base(:ssh)
-      build_command = @config.build(:command)
-      rsync = @config.base(:rsync)
-      local_folder = File.expand_path @config.local(:folder)
-      local_temp = File.expand_path @config.local(:temp)
-
-      build_command = build_command.gsub('%f', build[:folder]).
-          gsub('%t', @config.build(:target)).
-          gsub('%p', @package.to_s).
-          gsub('%T', type.to_s)
-
-      upload_sources("#{local_folder}/", "#{build[:user]}@#{build[:host]}:#{build[:folder]}")
-      command("#{ssh} #{build[:user]}@#{build[:host]} \"#{build_command}\"")
-      @package_files[type].each do |p, t|
-        puts "Receiving target #{p.to_s} for #{t.to_s}"
-        command("#{rsync} -az #{build[:user]}@#{build[:host]}:#{build[:target]}/#{t} #{local_temp}")
-      end
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotdefinederror => e
-      puts e.message
-      exit! ''
-    end
-
-    def install
-      env = @config.env
-      puts "Installing #{@package} in #{env} environment."
-      local_temp = @config.local(:temp)
-      sudo = @config.base(:sudo)
-      scp = @config.base(:scp)
-      type = @config.type
-      install = {}
-      [:user, :host, :folder].each do |k|
-        install[k] = @config.install(k)
-      end
-      install[:host] = [install[:host]] unless Array === install[:host]
-      case type
-        when :deb
-          install[:host].each do |host|
-            command("#{scp} #{local_temp}/#{@package_files[type][:deb]} #{install[:user]}@#{host}:#{install[:folder]}")
-            command("#{sudo} #{install[:user]}@#{host} /usr/bin/dpkg -i #{install[:folder]}/#{@package_files[type][:deb]}")
-          end
-        else
-          exit! "unknown package type '#{type.to_s}'"
-      end
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotdefinederror => e
-      puts e.message
-      exit! ''
-    end
-
-    def run_tests
-      # check if we have the test section in the configuration file
-      unless @config.tests
-        puts 'No test section in the config file.'
-        puts 'Skipping tests'
-        return
-      end
-      # for tests we will use almost the same setup as for build
-      test = {}
-      [:user, :machine, :command, :folder].each do |k|
-        test[k] = @config.tests(k)
-      end
-      ssh = @config.base(:ssh)
-      # replace "variables" in commands
-      test[:command] = test[:command].
-          gsub('%f', test[:folder]).# %f is the folder where the sources are rsync-ed
-          gsub('%t', @config.build(:target)).# %t is the folder where the build places the result
-          gsub('%p', @package.to_s) # %p is the package name
-      # take the sources from the local folder
-      local_folder = File.expand_path @config.local(:folder)
-      # upload them to the test machine
-      upload_sources("#{local_folder}/", "#{test[:user]}@#{test[:machine]}:#{test[:folder]}")
-      puts 'Running all tests'
-      puts 'This will take some time and you have no output'
-      command("#{ssh} #{test[:user]}@#{test[:machine]} \"#{test[:command]}\"")
-    end
-
-    def upload_sources (source, dest)
-      rsync = @config.base(:rsync)
-      command("#{rsync} -az #{source} #{dest}")
-    end
-  rescue CommandError => e
-    puts e.verbose_message
-    exit! ''
-  rescue KeyNotdefinederror => e
-    puts e.message
-    exit! ''
-  end
-
-end
+require 'devinstall/pkg'
+require 'devinstall/cli'
 

data/spec/settings_spec.rb

@@ -4,12 +4,24 @@ require 'devinstall/settings'
 
 describe 'Settings' do
   config=Devinstall::Settings.instance
-  config.load! "./doc/example.yml"
+  config.load! './doc/example.yml' ## use defaults for type and env
+
+  package=:devinstall
+  type=:deb
+  env=nil
+
+  it 'should load an existig file' do
+    expect(config.load!('doc/example.yml')).to be_true
+  end
+
+  it 'should not load an unexisting file' do
+    expect(config.load!('doc/unexisting.yml')).to be_false
+  end
 
   it 'should load at init' do
     expect(config).to be_an_instance_of(Devinstall::Settings)
-    [:defaults, :base, :local, :build, :install, :tests, :packages, :repos].each do |p|
-      expect(config.send(p)).to be_true
+    [:defaults, :base, :local, :build, :install, :tests, :repos].each do |p|
+      expect(config.respond_to? p).to be_true
     end # all sections loaded!
   end
 
@@ -17,8 +29,22 @@ describe 'Settings' do
     expect(config.defaults).to be_true
   end
 
-  it 'should have a static default' do
-    expect(Devinstall::Settings.defaults(:package)).to be(config.defaults(:package))
+  it 'should produce validators when hashes are given' do
+    expect(config.build(type:'deb', env:'dev', pkg:package)).to be_an_instance_of(Devinstall::Settings::Action)
+  end
+
+  it 'should produce validators when partial hashes are given' do
+    expect(config.build(pkg:package)).to be_an_instance_of(Devinstall::Settings::Action)
+  end
+
+  it 'should validate correct data' do
+    expect(rr=config.build(pkg:package, type:type, env:env)).to be_an_instance_of(Devinstall::Settings::Action)
+    expect(rr.valid?).to be_true
+  end
+
+  it 'should not validate incorrect data' do
+    expect(rr=config.build(pkg:package, type: :rpm, env:env)).to be_an_instance_of(Devinstall::Settings::Action)
+    expect(rr.valid?).to be_false
   end
 
   it 'should raise errors for unknown keys' do
@@ -26,6 +52,24 @@ describe 'Settings' do
   end
 
   it 'should raise errors for undefined keys' do
-    expect{config.tests(:provider)}.to raise_error(Devinstall::KeyNotDefinedError)
+    expect{config.tests(:provider, pkg:package)}.to raise_error(Devinstall::KeyNotDefinedError)
   end
+
+  it 'should produce a value if aok' do
+    expect(config.build(:user, pkg:package)).to eq('dboca')
+  end
+
+  it 'validator should have a [] method' do
+    rr=config.build(pkg:package, type:type, env:env)
+    expect(rr[:user]).to eq('dboca')
+  end
+
+  it 'should enumerate all defined values' do
+    ar=[]
+    config.build(pkg:package, type:type, env:env).each do |k,v|
+       ar << k
+    end
+    expect(ar).to eql([:user, :host, :folder, :target, :arch, :command, :provider])
+  end
+
 end

metadata

@@ -1,69 +1,94 @@
 --- !ruby/object:Gem::Specification
 name: devinstall
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Dragos Boca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-02 00:00:00.000000000 Z
+date: 2013-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: getopt
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: remote builder and installer
@@ -86,6 +111,7 @@ files:
 - lib/devinstall.rb
 - lib/devinstall/cli.rb
 - lib/devinstall/deep_symbolize.rb
+- lib/devinstall/pkg.rb
 - lib/devinstall/settings.rb
 - lib/devinstall/utils.rb
 - lib/devinstall/version.rb
@@ -93,26 +119,27 @@ files:
 homepage: http://github.com/dboca/devinstall
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Copy the source files to a build host, build the packages and install builded
   packages
 test_files:

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 020bb3bf72c1b2c8c0028b4f3325535ac560bd89
-  data.tar.gz: dee754076fd8134e9f29ddd04e985495c62ed0ce
-SHA512:
-  metadata.gz: bc609fc9b54577ebc424b47b106af5892c8af416d27634936302162546e084eb4ac273c3518a88a71f60c579d0c70f3763f158bafdf73aa31fc3442e0dd373ed
-  data.tar.gz: df8ca74a6cddefa371bb4c7cc78a619ee0608396b022cd834a43fd55b78de47bc017688c1fb35dab9e269872de683642e9039363a4b1626439492caca7c1d789