squared 0.5.12 → 0.6.0

data/lib/squared/common/shell.rb

@@ -49,19 +49,17 @@ module Squared
         val = val.to_s
         return val if (!force && !val.include?(' ')) || val.empty?
 
-        if option && val.match?(/(?:\A|\A[^=\s]+(?:=|\s+)|#{Rake::Win32.windows? ? '[\\\/]' : '\/'})(["']).+\1\z/m)
-          return val
-        end
-
-        if double || Rake::Win32.windows? || (ARG[:QUOTE] == '"' && !override)
+        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
           "'#{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 =~ /\A(["'])(.+)\1\z/
           double = $1 == '"'
@@ -70,19 +68,19 @@ module Squared
           override = true
         end
         b = if flag[0] == '-'
-              flag[1] == '-' ? '=' : ' '
+              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: option, force: force, double: double, override: override)
+                                 shell_quote(val, option: false, force: force, double: double, override: override)
                                else
                                  val
                                end}"
@@ -96,6 +94,41 @@ 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)
         key = name.upcase
         shell_quote((env && ENV["PATH_#{key}"]) || PATH[key] || PATH[key.to_sym] || name, option: false, force: false,

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

data/lib/squared/common/utils.rb

@@ -9,21 +9,44 @@ module Squared
     module Utils
       module_function
 
-      def split_escape(val, char: ',')
-        val.split(/\s*(?<!\\)#{char}\s*/)
+      def as_a(obj, *meth, flat: nil, compact: false, &blk)
+        return [] if obj.nil?
+
+        unless obj.is_a?(::Array)
+          obj = if obj.respond_to?(:to_ary)
+                  obj.to_ary
+                elsif obj.respond_to?(:to_a) && !obj.is_a?(::Hash) && (val = obj.to_a).is_a?(::Array)
+                  val
+                else
+                  [obj]
+                end
+        end
+        obj = flat.is_a?(::Numeric) ? obj.flatten(flat) : obj.flatten if flat
+        obj = obj.compact if compact
+        obj = obj.map(&meth.shift) until meth.empty?
+        return obj unless block_given?
+
+        obj.select(&blk)
+      end
+
+      def split_escape(val, char: ',', &blk)
+        ret = val.split(/\s*(?<!\\)#{char}\s*/)
+        return ret unless block_given?
+
+        ret.each(&blk)
       end
 
       def split_option(val)
         val = val.strip
         return [val, '', ''] unless (i = val.index('='))
 
-        last = val[(i + 1)..-1].strip
+        last = val[i.succ..-1].strip
         quote = ''
         if last =~ /\A(["'])(.+)\1\z/
           last = $2
           quote = $1
         end
-        [val[0..(i - 1)], last, quote]
+        [val[0..i.pred], last, quote]
       end
 
       def task_invoke(*cmd, args: [], exception: true, warning: true)
@@ -105,9 +128,9 @@ module Squared
         end
       end
 
-      def env(key, default = nil, suffix: nil, strict: false, equals: nil, ignore: nil)
+      def env(key, default = nil, suffix: nil, strict: false, equals: nil, ignore: nil, **)
         ret = env_value(key, suffix: suffix, strict: strict)
-        return ret == equals.to_s unless equals.nil?
+        return Array(equals).any? { |val| val.to_s == ret } unless equals.nil?
 
         ret.empty? || (ignore && Array(ignore).any? { |val| val.to_s == ret }) ? default : ret
       end

data/lib/squared/config.rb

@@ -86,7 +86,7 @@ module Squared
                       ['path not found', realpath]
                     else
                       @required = true
-                      project ? [project, 'not found'] : %w[name missing]
+                      project ? [project, 'missing'] : %w[name missing]
                     end
         warn log_message(Logger::WARN, msg, subject: self.class, hint: hint)
       end
@@ -106,7 +106,7 @@ module Squared
                   next unless (data = Viewer.parse(type, type.upcase, ext))
                 end
                 obj, ext = data
-                target = file || target? ? file || realpath : nil
+                target = file || (realpath if target?)
 
                 task_desc(command, *ext, target: target)
                 task type, [:keys] do |_, args|
@@ -205,14 +205,14 @@ module Squared
 
       def read_keys(reader, type, file, keys, ext: [type], opts: {})
         if file && (mime = mimetype(file)) && basepath(file).exist?
-          raise_error(file, mime, hint: 'invalid') unless ext.include?(mime)
+          raise_error file, mime, hint: 'invalid' unless ext.include?(mime)
         else
           if ext.include?(mime)
             alt = file
             file = nil
             ext[0] = mime
           elsif file
-            keys.prepend(file)
+            keys.unshift(file)
             alt = basepath "#{main}.{#{ext.join(',')}}"
             file = Dir[alt].first
           else
@@ -220,7 +220,7 @@ module Squared
             args = { hint: 'no keys' }
           end
           unless file
-            args ||= { hint: 'not found', kind: LoadError }
+            args ||= { kind: Errno::ENOENT }
             raise_error(reader.name, "#{File.basename(alt, '.*')}.#{ext.first}", **args)
           end
         end
@@ -237,22 +237,18 @@ module Squared
         title = Pathname.new(file)
                         .realpath
                         .to_s
-                        .sub(/\A#{Regexp.escape(File.join(Dir.pwd, ''))}/, '')
+                        .sub(/^#{Regexp.escape(File.join(Dir.pwd, ''))}/, '')
         emphasize(lines, title: title, sub: unless stdin?
                                               [
-                                                { pat: /\A((?:[^:]|(?<! ):(?! ))+)\z/, styles: theme[:banner] },
-                                                { pat: /\A(.*?)(<[^>]+>)(.+)\z/m, styles: theme[:undefined], index: 2 },
-                                                { pat: /\A((?~ : ))( : (?!undefined).+)\z/m, styles: theme[:key] },
-                                                { pat: /\A((?~: ): )(-?[\d.]+)(\s*)\z/m, styles: theme[:number],
-                                                  index: 2 },
-                                                { pat: /\A((?~: ): ")(.+)("\s*)\z/m, styles: theme[:string], index: 2 },
-                                                { pat: /\A((?~: ): \{)(.+)(\}\s*)\z/m, styles: theme[:hash], index: 2 },
-                                                { pat: /\A((?~: ): \[)(.+)(\]\s*)\z/m, styles: theme[:array],
-                                                  index: 2 },
-                                                { pat: /\A((?~: ): )(true|false)(\s*)\z/m, styles: theme[:boolean],
-                                                  index: 2 },
-                                                { pat: /\A((?~: ): (?!undefined))([^"\[{].*)\z/m, styles: theme[:value],
-                                                  index: 2 }
+                                                opt_style(theme[:banner], /\A((?:[^:]|(?<! ):(?! ))+)\z/),
+                                                opt_style(theme[:undefined], /\A(.*?)(<[^>]+>)(.+)\z/m, 2),
+                                                opt_style(theme[:key], /\A((?~ : ))( : (?!undefined).+)\z/m),
+                                                opt_style(theme[:number], /\A((?~: ): )(-?[\d.]+)(\s*)\z/m, 2),
+                                                opt_style(theme[:string], /\A((?~: ): ")(.+)("\s*)\z/m, 2),
+                                                opt_style(theme[:hash], /\A((?~: ): \{)(.+)(\}\s*)\z/m, 2),
+                                                opt_style(theme[:array], /\A((?~: ): \[)(.+)(\]\s*)\z/m, 2),
+                                                opt_style(theme[:boolean], /\A((?~: ): )(true|false)(\s*)\z/m, 2),
+                                                opt_style(theme[:value], /\A((?~: ): (?!undefined))([^"\[{].*)\z/m, 2)
                                               ]
                                             end, border: theme[:border])
       end
@@ -309,8 +305,8 @@ module Squared
       def task_desc(command, *ext, target: nil)
         return unless Rake::TaskManager.record_task_metadata
 
-        val = "#{ext.first}[#{target ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys+]"
-        args = *name.split(':').append(command, val)
+        val = "#{ext.first}[#{"file?=#{File.basename(main)}.#{ext.last}," if target}keys+]"
+        args = *name.split(':').push(command, val)
         if project
           project.workspace.task_desc(*args)
         else

data/lib/squared/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Squared
-  VERSION = '0.5.12'
+  VERSION = '0.6.0'
 end