dply 0.2.19 → 0.3.0

data/lib/dply/env.rb

@@ -0,0 +1,9 @@
+module Dply
+  module Env
+    def self.build_env(extra_env, bundled_env:)
+      original_env = defined?(Bundler) ? Bundler.original_env : ENV
+      base_env = bundled_env ? ENV : original_env
+      base_env.to_h.merge(extra_env)
+    end
+  end
+end

data/lib/dply/git.rb

@@ -7,16 +7,23 @@ module Dply
     def self.pull(branch)
       cmd "git fetch"
       checkout(branch)
-      if tracking_branch = get_tracking_branch(branch)
+      if tracking_branch = tracking_branch(branch)
         cmd "git merge #{tracking_branch}"
       else
         cmd "git pull origin #{branch}"
       end
     end
-  
+
     def self.checkout(branch)
-      current_branch = `git rev-parse --abbrev-ref HEAD `.chomp.to_sym
-      cmd "git checkout #{branch}" if branch != current_branch
+      current_branch = `git rev-parse --abbrev-ref HEAD `.chomp
+      return if branch == current_branch
+
+      local_branch_exists = system "git", "show-ref", "-q", "--verify", "refs/heads/#{branch}"
+      if local_branch_exists
+        cmd "git checkout #{branch} --"
+      else
+        cmd "git checkout -b #{branch} -t origin/#{branch}"
+      end
     end
 
     def self.clone(repo, dir, mirror: nil)
@@ -33,17 +40,17 @@ module Dply
       cmd "git clean -dxf "
     end
 
-    def self.get_tracking_branch(branch)
+    def self.tracking_branch(branch)
       command = "git for-each-ref --format='%(upstream:short)' refs/heads/#{branch} --count=1"
-      tracking_branch = `#{command}`
+      tracking_branch = cmd command, return_output: true, display: false
       if tracking_branch =~ /[a-zA-Z0-9_]/
         return tracking_branch.chomp!
       else
         return nil
-      end  
+      end
     end
 
-    def self.get_remote_url
+    def self.remote_url
      remote_url = cmd "git config --get remote.origin.url", return_output: true, display: false
      logger.debug remote_url.chomp
      remote_url.chomp

data/lib/dply/helper.rb

@@ -1,44 +1,38 @@
-require 'dply/error'
-require 'dply/logger'
+require_relative 'error'
+require_relative 'logger'
+require_relative 'command'
+require_relative 'env'
 require 'fileutils'
 require 'tmpdir'
 
 module Dply
   module Helper
 
-    def cmd(command, display: true, error_msg: nil, return_output: false, env:{}, shell: false)
-      if command.is_a? Array
-        command_arr = command
-        command_str = command.join(" ")
-      else
-        command_arr = command.split
-        command_str = command
-      end
-      stringify_values!(env)
-      if display
-        logger.bullet command_str
-      else
-        logger.debug command_str
-      end
+    def cmd(command, env: {}, bundled_env: false, return_output: false, display: :bullet)
+      logger.command command, mode: display
+      new_env = Env.build_env(env, bundled_env: bundled_env)
+      cmd = Command.new command, env: new_env, shell: false
+      return_output ? cmd.capture : cmd.run
+    end
 
-      run_command = shell ? command_str : command_arr
-      output = if return_output
-        IO.popen(env, run_command) { |f| f.read }
-      else
-        system(env, *run_command, 2 => 1)
-      end
-      return_value = $?.exitstatus
-      error_msg ||= "non zero exit for \"#{command_str}\""
-      error error_msg if return_value != 0
-      return output
+    def sh(command, env: {}, bundled_env: false, return_output: false, display: :bullet)
+      logger.command command, mode: display
+      new_env = Env.build_env(env, bundled_env: bundled_env)
+      cmd = Command.new command, env: new_env, shell: true
+      return_output ? cmd.capture : cmd.run
     end
 
     def symlink(src, dst)
       if File.symlink? dst
+        # to_s to handle pathnames
+        return true if File.readlink(dst) == src.to_s
         Dir.mktmpdir("sym-", "./") do |d|
           dst_tmp = "#{d}/#{File.basename dst}"
           FileUtils.ln_s src, dst_tmp
-          cmd "mv #{dst_tmp} #{File.dirname dst}", display: false
+
+          # using 'mv' here as FileUtils.mv doesn't replace a symlink which points
+          # to a directory
+          cmd ["mv", dst_tmp, File.dirname(dst)], display: false
         end
       elsif File.exist? dst
         error "cannot create symlink #{dst} => #{src}"
@@ -47,12 +41,6 @@ module Dply
       end
     end
 
-    def stringify_values!(hash)
-      hash.each do |k,v|
-        hash[k] = v.to_s
-      end
-    end
-
     def logger
       Logger.logger
     end

data/lib/dply/linker.rb

@@ -4,53 +4,53 @@ module Dply
 
     include Helper
 
-    attr_reader :src_dir, :dest_dir, :map
-
     def initialize(src_dir, dest_dir, map: {})
       verify_absolute src_dir, dest_dir
       @src_dir = src_dir
       @dest_dir = dest_dir
       @map = map
+      validate_map!
     end
-    
+
     def create_symlinks
-      mapped_files.each do |f|
-        target = link_target(f)
-        source = link_source(f)
-        relative_source = link_relative_source(source, target)
-        logger.debug "linking #{target} -> #{source}"
-        error "source #{source} doesn't exist" if not File.exist? source
-        symlink(relative_source, target)
+      link_pairs.each do |src, dest|
+        relative_source = src_relative_to_dest(src, dest)
+        logger.debug "linking #{dest} -> #{src}" if logger.debug?
+        error "source #{src} doesn't exist" if not src.exist?
+        symlink(relative_source, dest)
       end
     end
 
-    def link_target(relative_target)
-      Pathname.new "#{dest_dir}/#{relative_target}"
-    end
+    private
 
-    def link_source(relative_target)
-      relative_source = map[relative_target]
-      Pathname.new "#{src_dir}/#{relative_source}"
+    def link_pairs
+      Enumerator.new do |y|
+        @map.each do |dest, src|
+          src_path = Pathname.new "#{@src_dir}/#{src}"
+          dest_path = Pathname.new "#{@dest_dir}/#{dest}"
+          y.yield [src_path, dest_path]
+        end
+      end
     end
 
-    def link_relative_source(source, target)
-      source.relative_path_from target.parent
-    end
-    
-    def mapped_files
-      map.keys.collect do |k|
-        path = Pathname.new k 
-        raise "config map path cannot be absoulte" if path.absolute?
-        k
-      end
+    def src_relative_to_dest(src, dest)
+      src.relative_path_from dest.parent
     end
 
     def verify_absolute(*paths)
       paths.each do |path|
         absolute = Pathname.new(path).absolute?
-        raise "#{path} not absolute" if not absolute
+        raise Error, "#{path} not absolute" if not absolute
       end
     end
 
+    def validate_map!
+      @map.each do |dest, src|
+        dest_path = Pathname.new dest
+        src_path = Pathname.new src
+        raise Error, "dest path #{dest_path} not relative" if not dest_path.relative?
+        raise Error, "src path #{src_path} not relative" if not src_path.relative?
+      end
+    end
   end
 end

data/lib/dply/lock.rb

@@ -4,7 +4,7 @@ module Dply
 
     include Helper
 
-    def initialize(dir = nil)
+    def initialize(dir)
       @dir = dir
     end
 
@@ -15,14 +15,7 @@ module Dply
     end
 
     def lock_file
-      @lock_file ||= File.open("#{dir}/.dply.lock", "a+")
+      @lock_file ||= File.open("#{@dir}/.dply.lock", "a+")
     end
-
-    private
-
-    def dir
-      @dir ||= Dir.pwd
-    end
-
   end
 end

data/lib/dply/logger.rb

@@ -1,5 +1,5 @@
 require 'logger'
-require 'dply/custom_logger'
+require_relative 'custom_logger'
 module Dply
   module Logger
 

data/lib/dply/pkgs.rb

@@ -1,5 +1,5 @@
 require 'yaml'
-require 'dply/helper'
+require_relative 'helper'
 require_relative 'yum'
 
 module Dply
@@ -9,19 +9,19 @@ module Dply
 
     attr_reader :runtime, :build, :all
 
-    def initialize(pkgs_yml = nil)
-      @pkgs_yml = pkgs_yml || "pkgs.yml"
+    def initialize(pkgs_yml)
+      @pkgs_yml = pkgs_yml
       read_config
     end
 
-    def install(build_mode: false, sudo: false)
+    def install(build_mode: false)
       pkgs = build_mode ? @all : @runtime
-      Yum.new(pkgs, sudo: sudo).install
+      Yum.install pkgs
     end
 
     def installed?(build_mode: false)
       pkgs = build_mode ? @all : @runtime
-      Yum.new(pkgs).installed?
+      Yum.installed? pkgs
     end
 
     private
@@ -44,18 +44,16 @@ module Dply
         return {}
       end
       YAML.safe_load(File.read(@pkgs_yml)) || {}
-    rescue => e
-      error "error loading pkgs list" 
+    rescue
+      error "error loading pkgs list"
     end
 
     def validate!(pkg)
       msg = "invalid pkg name #{pkg}"
       error msg if pkg =~ /\.rpm\z/i
-      error msg if pkg =~/\A[A-Za-z_0-9\.\-]\z/
+      error msg if not pkg =~ /\A[A-Za-z_0-9\.\-]+\z/
       return true
     end
 
   end
 end
-
-

data/lib/dply/release.rb

@@ -1,4 +1,4 @@
-require 'dply/archive'
+require_relative 'remote_archive'
 require 'dply/helper'
 require 'tmpdir'
 
@@ -74,7 +74,7 @@ module Dply
     private
 
     def archive
-      @archive ||= Archive.new(url, verify_checksum: @verify_checksum)
+      @archive ||= RemoteArchive.new(url, verify_checksum: @verify_checksum)
     end
 
     def timestamp

data/lib/dply/{archive.rb → remote_archive.rb}

@@ -4,7 +4,7 @@ require 'uri'
 require 'tmpdir'
 
 module Dply
-  class Archive
+  class RemoteArchive
 
     include Helper
 

data/lib/dply/repo.rb

@@ -12,7 +12,7 @@ module Dply
 
     def create
       if Dir.exist? "#{dir}/.git"
-        raise "unable to create repo" if not verify_remote_url
+        raise Error, "unable to create repo (another repo already exists)" if not verify_remote_url
       else
         Git.clone upstream, dir, mirror: @mirror
       end
@@ -22,10 +22,10 @@ module Dply
 
     def verify_remote_url
       remote_url = Dir.chdir(dir) do
-        Git.get_remote_url
+        Git.remote_url
       end
       remote_url == upstream
     end
- 
+
   end
 end

data/lib/dply/rpm.rb

@@ -1,32 +1,24 @@
-require 'dply/helper'
+require_relative 'helper'
 
 module Dply
-  class Rpm
-    include Helper
+  module Rpm
+    extend Helper
 
     # libs should include ()(64bit) in their name if 64bit libs
-
-    def libs_packages_map(libs)
+    def self.libs_pkgs_map(libs)
       h = {}
-      libs.each do |lib|
-        list = whatprovides(lib)
-        h[lib] = list if not list.empty?
-      end
+      libs.each { |lib| h[lib] = pkg_list(lib) }
       return h
     end
 
-    private
-
-    def filtered?(pkg)
-      @filtered ||= ["glibc", "libgcc", "libstdc++", "openssl", "ruby-alt", "jemalloc"]
-      @filtered.include? pkg.strip
-    end
+    class << self
+      private
 
-    def whatprovides(lib)
-      command = ["rpm", "--queryformat", "%{NAME} ", "-q", "--whatprovides", lib]
-      output = cmd command, return_output: true, display: false
-      list = output.strip.split.select {|pkg| not filtered? pkg }
+      def pkg_list(lib)
+        command = ["rpm", "--queryformat", "%{NAME} ", "-q", "--whatprovides", lib]
+        output = cmd command, return_output: true, display: false
+        output.strip.split
+      end
     end
-
   end
 end

data/lib/dply/scripts/depcheck.rb

@@ -0,0 +1,4 @@
+require_relative '../deplist'
+
+deplist = Dply::Deplist.new(ARGV.shift)
+deplist.verify!

data/lib/dply/shared_dirs.rb

@@ -9,7 +9,7 @@ module Dply
 
     def create
       FileUtils.mkdir_p dirs
-    end 
+    end
 
     def create_in(dir)
       Dir.chdir(dir) { create }

data/lib/dply/strategy/archive.rb

@@ -1,5 +1,5 @@
 require 'dply/helper'
-require 'dply/tasks'
+require 'dply/util'
 require 'dply/setup'
 require 'dply/config_downloader'
 require 'dply/yum'
@@ -7,11 +7,10 @@ require 'dply/release'
 require 'dply/release_helper'
 require 'forwardable'
 
-
 module Dply
   module Strategy
     class Archive
-      
+
       extend Forwardable
       include Helper
 
@@ -19,20 +18,20 @@ module Dply
       def_delegators :config, :target, :branch, :revision, :name,
                      :config_map, :dir_map, :config_skip_download,
                      :config_download_url, :build_url
-                
+
       def initialize(config, options)
         @config = config
         @options = options || {}
       end
 
       def deploy
-        error "revision not specified( use -r)" if not revision 
+        error "revision not specified( use -r)" if not revision
         setup.archive
         if release.already_deployed? && release.current?
           logger.info "revision #{revision} is currently deployed"
           current_version = previous_version = get_release
           prune_releases
-          tasks.report_changes(current_version, previous_version)
+          util.report_changes(current_version, previous_version)
           return
         end
         download_configs if config_download_url
@@ -40,25 +39,19 @@ module Dply
         previous_version = get_release
         release.make_current
         Dir.chdir current_dir do
-          tasks.deploy deploy_target
+          util.run "deploy:#{deploy_target}"
         end
         release.record_deployment
         current_version = get_release
         prune_releases
-        tasks.report_changes(previous_version, current_version)
+        util.report_changes(previous_version, current_version)
       end
-      
+
       def reload
         download_configs if config_download_url
         Dir.chdir current_dir do
           link_all
-          tasks.reload
-        end
-      end
-
-      def task(name)
-        Dir.chdir current_dir do
-          tasks.rake name
+          util.run :reload
         end
       end
 
@@ -80,7 +73,7 @@ module Dply
       def download_configs
         files = config_map.values.uniq
         downloader = ConfigDownloader.new(files, config_download_url)
-        downloader.skip_download = config_skip_download if config_skip_download 
+        downloader.skip_download = config_skip_download if config_skip_download
         downloader.download_all
       end
 
@@ -98,21 +91,21 @@ module Dply
         release.install
         Dir.chdir release.path do
           link_all
-          tasks.install_pkgs(use_yum: options[:use_yum])
+          util.install_pkgs
         end
       end
 
       def link_all
-        tasks.link "#{config.dir}/shared", dir_map
-        tasks.link "#{config.dir}/config", config_map
+        util.link "#{config.dir}/shared", dir_map
+        util.link "#{config.dir}/config", config_map
       end
 
       def setup
         @setup ||= Setup.new(@config)
       end
 
-      def tasks
-        @tasks ||= Tasks.new
+      def util
+        @util ||= Util.new
       end
 
       def prune_releases