squared 0.5.22 → 0.6.0

data/lib/squared/common/format.rb

@@ -39,6 +39,10 @@ module Squared
       TEXT_STYLE = [:bold, :dim, :italic, :underline, :blinking, nil, :inverse, :hidden, :strikethrough].freeze
       private_constant :AIX_TERM, :BOX_GRAPH, :BOX_BORDER, :TEXT_STYLE
 
+      String.define_method(:stripstyle) { gsub(/\x1B\[(?:\d+;?)+m/, '') }
+      String.define_method(:stripext) { File.basename(self, '.*') }
+      String.define_method(:subhint) { |s| s.nil? || (s.is_a?(::String) && s.empty?) ? self : "#{self} (#{s})" }
+
       def enable_aixterm
         unless (colors = __get__(:colors)).frozen?
           colors.update(AIX_TERM)
@@ -67,7 +71,6 @@ module Squared
         end
         wrap = ->(s, n) { "\x1B[#{n.join(';')}m#{s}\x1B[0m" }
         code = []
-        args.clear if args.size == 1 && args.first.nil?
         args.concat(Array(styles)).flatten.each_with_index do |type, i|
           next unless type
 
@@ -86,7 +89,7 @@ module Squared
             end
           else
             t = type.to_sym
-            if (c = __get__(:colors)[t])
+            if (c = __get__(:colors)[t] || __get__(:colors)[t.to_s.sub('bright_', '').to_sym])
               if index == -1
                 s = wrap.call(s, [c])
               else
@@ -95,7 +98,7 @@ module Squared
             else
               next unless (n = TEXT_STYLE.index(t))
 
-              s = "\x1B[#{n + 1}m#{s}\x1B[#{n == 0 ? 22 : n + 21}m"
+              s = "\x1B[#{n.succ}m#{s}\x1B[#{n == 0 ? 22 : n + 21}m"
             end
           end
           if index == -1
@@ -127,8 +130,8 @@ module Squared
         colors = __get__(:colors)
         Array(args).flatten.compact.each do |val|
           if !val.is_a?(::Numeric)
-            val = val.to_sym
-            ret << val if colors.key?(val) || TEXT_STYLE.include?(val)
+            k = val.to_sym
+            ret << k if colors.key?(k) || colors.key?(k.to_s.sub('bright_', '').to_sym) || TEXT_STYLE.include?(k)
           elsif val.between?(0, 256)
             ret << val
           elsif val < 0 && (b = val.to_s.split('.')[1])
@@ -152,6 +155,10 @@ module Squared
         end
       end
 
+      def opt_style(styles, pat = nil, index = 1)
+        { styles: styles, pat: pat, index: index }
+      end
+
       def log_sym(level)
         if level.is_a?(::Numeric)
           case level
@@ -181,22 +188,23 @@ module Squared
         args = args.map(&:to_s)
         if level.is_a?(::Numeric)
           if append && respond_to?(:log)
-            ref = log rescue nil
-            ref.add(level, message(subject, *args, hint: hint, space: ', ')) if ref.is_a?(::Logger)
+            (log rescue nil).tap do |ref|
+              ref.add(level, message(subject, *args, hint: hint, space: ', ')) if ref.is_a?(::Logger)
+            end
           end
-          return false unless pass || level >= ARG[:LEVEL]
+          return false if !pass && level < ARG[:LEVEL]
         end
-        if hint.nil? ? args.size > 1 : !hint
+        if (args.size > 1 && !hint) || hint == false
           title = log_title(level, color: false)
-          if color
-            sub = [{ pat: /\A(#{Regexp.escape(title)})(.*)\z/m, styles: __get__(:theme)[:logger][log_sym(level)] }]
-          end
-          emphasize(args, title: title + (subject ? " #{subject}" : ''), sub: sub, pipe: -1)
+          emphasize(args,
+                    title: title + (subject ? " #{subject}" : ''),
+                    pipe: -1,
+                    sub: if color
+                           opt_style(__get__(:theme)[:logger][log_sym(level)], /\A(#{Regexp.escape(title)})(.*)\z/m)
+                         end)
         else
           msg = [log_title(level, color: color)]
-          if subject
-            msg << (color ? sub_style(subject.to_s, (@theme.is_a?(::Hash) && @theme[:subject]) || :bold) : subject)
-          end
+          msg << (color ? sub_style(subject.to_s, styles: (@theme && @theme[:subject]) || :bold) : subject) if subject
           msg << args.shift if msg.size == 1
           message(msg.join(' '), *args, hint: hint)
         end
@@ -209,7 +217,7 @@ module Squared
           begin
             File.open(pipe, 'a') do |f|
               br = File::SEPARATOR == '\\' ? "\r\n" : "\n"
-              args.flatten.each { |val| f.write(strip_style(val.chomp) + br) }
+              args.flatten.each { |val| f.write(val.chomp.stripstyle + br) }
             end
             return
           rescue StandardError
@@ -219,17 +227,16 @@ module Squared
         (pipe == 2 ? $stderr : $stdout).puts(*args)
       end
 
-      alias puts_oe log_console
-
       module_function
 
       def message(*args, hint: nil, empty: false, space: ARG[:SPACE])
         (empty ? args.reject { |val| val.nil? || (val.respond_to?(:empty?) && val.empty?) } : args)
-          .join(space) + (hint ? " (#{hint})" : '')
+          .join(space)
+          .subhint(hint)
       end
 
       def emphasize(val, title: nil, footer: nil, right: false, cols: nil, sub: nil, pipe: nil,
-                    border: @theme.is_a?(::Hash) && @theme[:border])
+                    border: @theme && @theme[:border])
         n = 0
         max = ->(a) { n = [n, a.max_by(&:size).size].max }
         set = ->(s) { Array(s).map(&:to_s).tap { |a| max.call(a) } }
@@ -241,9 +248,7 @@ module Squared
           lines = val.to_s.lines(chomp: true)
           lines[0] = "#{val.class}: #{lines.first}" if (err = val.is_a?(::StandardError))
         end
-        return if lines.empty?
-
-        n = cols || max.call(lines)
+        n = (cols.is_a?(::Array) ? cols.map(&:size).max : cols) || max.call(lines)
         if $stdout.tty?
           require 'io/console'
           (n = [n, $stdout.winsize[1] - 4].min) rescue nil
@@ -261,14 +266,14 @@ module Squared
           sub.each { |h| s = sub_style(s, **h) }
           s = "#{b0} #{s} #{b0}"
           if border
-            s = sub_style(s, pat: /\A(#{Regexp.escape(b0)})(.+)\z/om, styles: border)
-            s = sub_style(s, pat: /\A(.+)(#{Regexp.escape(b0)})\z/om, styles: border, index: 2)
+            s = sub_style(s, **opt_style(border, /\A(#{Regexp.escape(b0)})(.+)\z/m))
+            s = sub_style(s, **opt_style(border, /\A(.+)(#{Regexp.escape(b0)})\z/m, 2))
           end
           s
         end
         out << draw.call(b2, b3)
         if title
-          out.concat(title.map { |t| pr.call(t) })
+          out.concat(title.map! { |t| pr.call(t) })
           out << draw.call(b6, b7)
         end
         lines.each { |line| out << pr.call(line) }
@@ -296,22 +301,19 @@ module Squared
           else
             pipe = $stdout unless pipe.respond_to?(:puts)
           end
-          pipe.puts(out)
+          pipe.puts out
         else
           err ? warn(out) : puts(out)
         end
       end
 
-      def strip_style(val)
-        val.gsub(/\x1B\[(\d+;?)+m/, '')
-      end
-
-      def stripext(val)
-        File.basename(val, '.*')
-      end
-
-      def raise_error(*args, hint: nil, kind: ArgumentError)
-        raise kind, message(*args, hint: hint, empty: true), caller_locations(1).map(&:to_s)
+      def raise_error(*args, hint: nil, kind: RuntimeError, start: 0)
+        kind = args.shift if args.first.is_a?(::Class) && args.first < ::Exception
+        raise kind, message(*args, hint: hint, empty: true), if ARG[:BACKTRACE]
+                                                               caller(start.succ)
+                                                             else
+                                                               caller_locations(start.succ, 1).first&.base_label
+                                                             end
       end
     end
   end

data/lib/squared/common/prompt.rb

@@ -1,12 +1,25 @@
 # frozen_string_literal: true
 
+unless defined?(Readline)
+  if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.7'
+    require 'readline'
+  else
+    begin
+      require 'reline'
+      Object.send(:remove_const, :Readline) if Object.const_defined?(:Readline)
+      Readline = Reline
+    rescue LoadError
+      require 'readline'
+    end
+  end
+end
+
 module Squared
   module Common
     module Prompt
       module_function
 
-      def confirm(msg, default = nil, agree: 'Y', cancel: 'N', attempts: 5, timeout: 30)
-        require 'readline'
+      def confirm(msg, default = nil, agree: 'Y', cancel: 'N', attempts: 3, timeout: 60)
         require 'timeout'
         if agree == 'Y' && cancel == 'N' && !msg.match?(%r{\[(?:Yn|nY|Y/n|y/N)\]})
           case default
@@ -38,9 +51,8 @@ module Squared
         end
       end
 
-      def choice(msg, list = nil, min: 1, max: 1, multiple: false, force: true, grep: nil, auto: true,
-                 attempts: 5, timeout: 0)
-        require 'readline'
+      def choice(msg, list = nil, min: 1, max: 1, multiple: false, index: false, grep: nil, border: nil, auto: true,
+                 force: true, attempts: 3, timeout: 0)
         require 'timeout'
         if list
           grep &&= Array(grep).map { |val| Regexp.new(val) }
@@ -52,40 +64,51 @@ module Squared
             puts '%2d. %s' % [items.size, val]
           end
           max = items.size
-          raise_error 'empty selection list' if max == 0
+          raise ArgumentError, 'empty selection list' if max == 0
+
           min = grep ? 1 : [min, max].min
           if auto
-            msg = "#{msg}: [#{min}-#{max}#{if multiple
-                                             "|,#{multiple.is_a?(::Numeric) ? "{#{multiple}}" : ''}"
-                                           end}] "
+            auto.times { puts } if auto.is_a?(::Numeric)
+            if border == true
+              puts print_footer
+            elsif border
+              puts print_footer(border: border)
+            end
+            msg = "#{msg + (force ? ':' : '?')} [#{min}-#{max}#{if (n = multiple)
+                                                                  "|,#{n.is_a?(::Numeric) ? "{#{n}}" : '*'}"
+                                                                end}] "
           end
         end
-        valid = ->(s) { s.match?(/^\d+$/) && s.to_i.between?(min, max) }
+        between = ->(s) { s.match?(/^\d+$/) && s.to_i.between?(min, max) }
         Timeout.timeout(timeout) do
           while (ch = Readline.readline(msg))
             unless (ch = ch.strip).empty?
               if multiple
-                a = ch.split(',')
-                b = a.map do |s|
-                  s.strip!
-                  if s =~ /^(\d+)-(\d+)$/
-                    next unless valid.call($1) && valid.call($2)
+                k = if ch == '*'
+                      (min..max).to_a
+                    else
+                      ch.split(/\s*,\s*/).map! do |s|
+                        if s =~ /^(\d+)-(\d+)$/
+                          next unless between.call($1) && between.call($2)
 
-                    c = $1.to_i
-                    d = $2.to_i
-                    next (c..d).to_a if c < d
-                  elsif valid.call(s)
-                    s.to_i
+                          i = $1.to_i
+                          j = $2.to_i
+                          next (i..j).to_a if i < j
+                        elsif between.call(s)
+                          s.to_i
+                        end
+                      end
+                    end
+                unless k.include?(nil)
+                  k.flatten!
+                  k.uniq!
+                  k.sort!
+                  unless multiple.is_a?(::Numeric) && multiple != k.size
+                    return index || !items ? k : k.map! { |i| items[i.pred] }
                   end
                 end
-                unless b.include?(nil)
-                  b.flatten!
-                  b.uniq!
-                  b.sort!
-                  return items ? b.map! { |i| items[i - 1] } : b unless multiple.is_a?(::Numeric) && multiple != b.size
-                end
-              elsif valid.call(ch)
-                return items ? items[ch.to_i - 1] : ch.to_i
+              elsif between.call(ch)
+                return index || !items ? ch.to_i : items[ch.to_i.pred]
               end
             end
             attempts -= 1
@@ -98,12 +121,11 @@ module Squared
           puts
           exit 0
         else
-          multiple ? [] : nil
+          [] if multiple
         end
       end
 
       def readline(msg, history = false, force: nil, multiline: nil, &blk)
-        require 'readline'
         multiline = if multiline && Readline.respond_to?(:readmultiline)
                       multiline.is_a?(::Enumerable) || block_given? ? multiline : [multiline.to_s]
                     end
@@ -113,20 +135,16 @@ module Squared
           elsif block_given?
             Readline.readmultiline(msg, history, &blk)
           else
-            Readline.readmultiline(msg, history) do |line|
-              next if line.strip.empty?
-
-              multiline.any? { |val| line.split.last.end_with?(val.to_s) }
-            end
+            Readline.readmultiline(msg, history) { |line| multiline.any? { |val| line.split.last.end_with?(val.to_s) } }
           end
         end
         case force
         when ::TrueClass, ::FalseClass
-          msg = "#{msg} %s " % if multiline
-                                 multiline.is_a?(::Enumerable) ? "{#{multiline.to_a.join('|')}}" : multiline
-                               else
-                                 "(#{force ? 'required' : 'optional'}):"
-                               end
+          msg = "#{msg}%s%s " % if multiline
+                                  [' ', multiline.is_a?(::Enumerable) ? "{#{multiline.to_a.join('|')}}" : multiline]
+                                else
+                                  [force ? ':' : '?', '']
+                                end
           ret = (prompt.call || '').strip
           multiline.each { |val| break if ret.delete_suffix!(val.to_s) } if multiline.is_a?(::Enumerable)
           exit 1 if force && ret.empty?

data/lib/squared/common/shell.rb

@@ -6,14 +6,11 @@ require 'shellwords'
 module Squared
   module Common
     module Shell
-      QUOTE_VALUE = /\A(["'])(.*)\1\z/m.freeze
-      private_constant :QUOTE_VALUE
-
       module_function
 
       def shell_escape(val, quote: false, force: false, double: false, option: false, override: false)
-        if (r = /\A(--?)([^=\s]+)((=|\s+)(["'])?(?(5)(.*)\5|(.*)))?\z/m.match(val = val.to_s))
-          if (data = r[2].match(QUOTE_VALUE))
+        if (r = /\A(--?)([^= ]+)((=|\s+)(["'])?(?(5)(.*)\5|(.*)))?\z/m.match(val = val.to_s))
+          if (data = r[2].match(/\A(["'])(.+)\1\z/))
             double = data[1] == '"'
             override = true
           elsif !r[3] || r[6]
@@ -28,9 +25,9 @@ module Squared
 
                   r[7]
                 end
-          r[1] + (data ? data[2] : r[2]) + r[4] + shell_quote(opt, force: force, double: double, override: override)
-        elsif option && val =~ /\A(-{0,2}[^=\s-][^=\s]*)=(.+)\z/m
-          return val if $2.match?(QUOTE_VALUE)
+          r[1] + (data ? data[2] : r[2]) + r[4] + shell_quote(opt, double: double, force: force, override: override)
+        elsif option && val =~ /\A([^=]+)=(.+)\z/m
+          return val if $2.match?(/\A(["']).+\1\z/m)
 
           "#{$1}=%s" % if $2.include?(' ')
                          shell_quote($2, option: false)
@@ -40,7 +37,7 @@ module Squared
                          Shellwords.escape($2)
                        end
         elsif Rake::Win32.windows?
-          quote ? shell_quote(val, force: force, double: double) : val
+          quote ? shell_quote(val, double: double, force: force) : val
         elsif val.empty?
           ''
         else
@@ -48,60 +45,46 @@ module Squared
         end
       end
 
-      def shell_quote(val, option: true, force: true, double: false, preserve: true, override: false)
+      def shell_quote(val, option: true, force: true, double: false, override: false)
         val = val.to_s
         return val if (!force && !val.include?(' ')) || val.empty?
 
-        if option
-          pat = /\A(?:-[^=\s-](?:=|\s+)?|(--)?[^=\s-][^=\s]*(?(1)(?:=|\s+)|=))(["']).+\2\z/m
-          return val if val.match?(pat)
-        end
-        q = ->(s) { s.gsub("'\\\\''", "'") }
-        if val =~ QUOTE_VALUE
-          return val if $1 == '"' && Rake::Win32.windows? && val.match?(/(?:[#{File::SEPARATOR} ]|\\")/o)
-
-          base = $2 unless preserve
-        end
-        if double || Rake::Win32.windows? || (ARG[:QUOTE] == '"' && !override)
-          "\"#{q.call(base || val).gsub(/(?<!\\)"/, '\\"')}\""
+        if option && val.match?(/(?:\A|\A[^=\s]+(?:=|\s+)|#{Rake::Win32.windows? ? '[\\\/]' : '\/'})(["']).+\1\z/mo)
+          val
+        elsif double || Rake::Win32.windows? || (ARG[:QUOTE] == '"' && !override)
+          "\"#{val.gsub(/(?<!\\)"/, '\\"')}\""
         else
-          base ? val : "'#{q.call(val).gsub("'", "'\\\\''")}'"
+          "'#{val.gsub("'", "'\\\\''")}'"
         end
       end
 
-      def shell_option(flag, val = nil, escape: true, quote: true, option: true, force: true, double: false,
-                       merge: false, override: false)
+      def shell_option(flag, val = nil, sep: '=', escape: true, quote: true, force: true, double: false, merge: false,
+                       override: false)
         flag = flag.to_s
-        if flag =~ QUOTE_VALUE
+        if flag =~ /\A(["'])(.+)\1\z/
           double = $1 == '"'
           flag = $2
           escape = false
           override = true
         end
-        sep = unless flag.empty?
-                if flag[0] == '-'
-                  if flag[1] == '-'
-                    '='
-                  else
-                    merge ? '' : ' '
-                  end
-                elsif flag.size == 1
-                  pre = '-'
-                  merge ? '' : ' '
-                else
-                  pre = '--'
-                  '='
-                end
-              end
-        "#{pre}#{flag}#{unless val.nil?
-                          "#{sep}#{if escape
-                                     shell_escape(val, quote: quote, double: double, override: override)
-                                   elsif quote
-                                     shell_quote(val, option: option, force: force, double: double, override: override)
-                                   else
-                                     val
-                                   end}"
-                        end}"
+        b = if flag[0] == '-'
+              flag[1] == '-' ? sep : ' '
+            elsif flag.size == 1
+              a = '-'
+              merge ? '' : ' '
+            else
+              a = '--'
+              sep
+            end
+        "#{a}#{flag}#{unless val.nil?
+                        "#{b}#{if escape
+                                 shell_escape(val, quote: quote, double: double, override: override)
+                               elsif quote
+                                 shell_quote(val, option: false, force: force, double: double, override: override)
+                               else
+                                 val
+                               end}"
+                      end}"
       end
 
       def shell_split(val, join: nil, **kwargs)
@@ -111,12 +94,45 @@ module Squared
         ret.join(join.is_a?(::String) ? join : ' ')
       end
 
+      def shell_parse(val, escape: false, force: true, **kwargs)
+        a = []
+        b = []
+        c = []
+        d = []
+        e = [a, b]
+        j = -1
+        val.shellsplit.each_with_index do |opt, i|
+          if opt == '--'
+            e = [c, d]
+          elsif opt =~ /\A--?[^=]+(=|\z)/
+            j = $1 == '=' ? -1 : i
+            e[0] << [opt]
+          elsif j >= 0
+            e[0][j] << opt
+          else
+            e[1] << shell_quote(opt, option: false, force: force)
+          end
+        end
+        ret = [[a, b], [], [c, d]].flat_map do |e, f|
+          next '--' unless e
+
+          e.flat_map do |item|
+            if item.size == 1
+              fill_option(item.first)
+            else
+              flag = item.shift
+              item.map! { |s| shell_option(flag, s, escape: escape, force: force, **kwargs) }
+            end
+          end.concat(f)
+        end
+        ret.pop if ret.last == '--'
+        ret
+      end
+
       def shell_bin(name, env: true)
-        require_relative 'base'
-        key = name.to_s.upcase
-        key = File.basename(key, '.*') if Rake::Win32.windows?
-        shell_quote((env && ENV["PATH_#{key}"]) || PATH[key] || PATH[key.to_sym] || name,
-                    option: false, force: false, double: true)
+        key = name.upcase
+        shell_quote((env && ENV["PATH_#{key}"]) || PATH[key] || PATH[key.to_sym] || name, option: false, force: false,
+                                                                                          double: true)
       end
 
       def line_width(lines)
@@ -125,7 +141,6 @@ module Squared
       end
 
       def fill_option(val, **kwargs)
-        return val unless val.is_a?(::String)
         return "-#{val}" if val.match?(/\A(?:[a-z]\d*|\d)\z/i)
 
         shell_escape(val.start_with?('-') ? val : "--#{val}", **kwargs)

data/lib/squared/common/system.rb

@@ -6,6 +6,25 @@ require 'rake'
 module Squared
   module Common
     module System
+      class << self
+        private
+
+        def parse_link(val)
+          case val
+          when ::TrueClass, 's'
+            1
+          when 'r'
+            2
+          when 'h'
+            3
+          else
+            raise ArgumentError, "unrecognized 'link' flag: #{val}" if val
+
+            0
+          end
+        end
+      end
+
       module_function
 
       def shell(*args, name: :system, **kwargs)
@@ -29,11 +48,11 @@ module Squared
         raise $?.to_s
       end
 
-      def copy_dir(src, dest, glob = ['**/*'], create: false, link: nil, force: false, pass: nil, hidden: false,
-                   verbose: true)
+      def copy_dir(src, dest, glob = ['**/*'], create: false, link: nil, preserve: nil, force: false, verbose: true,
+                   pass: nil, hidden: false)
         base = Pathname.new(src)
         target = Pathname.new(dest)
-        raise "#{target.cleanpath} (not found)" if !create && !target.parent.exist?
+        raise Errno::ENOENT, dest.cleanpath.to_s unless create || target.parent.exist?
 
         subdir = {}
         target.mkpath if create
@@ -57,53 +76,67 @@ module Squared
         end
         count = 0
         soft = 0
+        type = System.send :parse_link, link
         subdir.each do |dir, files|
-          if link
-            files.dup.tap do |items|
-              files.clear
-              items.each do |file|
-                if file.exist?
-                  if !file.symlink?
-                    files << file
-                  elsif !force
-                    next
-                  end
-                end
-                if link == 'hard'
-                  FileUtils.ln(file, dir, force: force, verbose: false)
-                else
-                  FileUtils.ln_s(file, dir, force: force, verbose: false)
+          unless type == 0
+            items = files.dup
+            files.clear
+            items.each do |file|
+              if file.exist?
+                if !file.symlink?
+                  files << file
+                elsif !force
+                  next
                 end
-                soft += 1
               end
+              case type
+              when 1
+                FileUtils.ln_s(file, dir, force: force, verbose: false)
+              when 2
+                FileUtils.ln_s(file.relative_path_from(dir), dir, force: force, verbose: false)
+              else
+                FileUtils.ln(file, dir, force: force, verbose: false)
+              end
+              soft += 1
             end
           end
           next if files.empty?
 
-          out = FileUtils.cp(files, dir, verbose: false)
+          out = FileUtils.cp(files, dir, preserve: preserve, verbose: false)
           count += out.size
         end
         puts [target.realpath, subdir.size, soft > 0 ? "#{count}+#{soft}" : count].join(' => ') if verbose
       end
 
-      def copy_guard(src, dest, link: nil, force: false, verbose: true)
-        unless force
-          target = Pathname.new(dest)
-          if target.directory?
-            src = Array(src).reject { |val| target.join(File.basename(val)).exist? }
-            return if src.empty?
-          elsif target.exist?
-            return
+      def copy_guard(*src, dest, base: '.', create: false, link: nil, preserve: nil, force: false, verbose: true)
+        src = src.compact.flatten
+        dest = Pathname.new(dest).realdirpath
+        base = Pathname.new(base).realpath
+        dir = if dest.directory?
+                true
+              elsif src.size > 1
+                raise Errno::ENOENT, dest.cleanpath.to_s unless create && !dest.exist?
+
+                dest.mkpath
+                true
+              end
+        targets = src.map! { |file| [base + file, dir ? dest + File.basename(file) : dest] }
+        return if !force && (targets = targets.reject { |to| to[1].exist? }).empty?
+
+        type = System.send :parse_link, link
+        targets.each do |file, to|
+          case type
+          when 0
+            FileUtils.cp(file, to, preserve: preserve, verbose: verbose)
+          when 1
+            FileUtils.ln_s(file, to, force: force, verbose: verbose)
+          when 2
+            FileUtils.ln_s(file.relative_path_from(dir ? to.dirname : to), to, force: force, verbose: verbose)
+          else
+            FileUtils.ln(file, to, force: force, verbose: verbose)
           end
         end
-        case link
-        when 'hard', 1
-          FileUtils.ln(src, dest, force: force, verbose: verbose)
-        when ::TrueClass, 'soft', 0
-          FileUtils.ln_s(src, dest, force: force, verbose: verbose)
-        else
-          FileUtils.cp(src, dest, verbose: verbose)
-        end
+        nil
       end
     end
   end