squared 0.0.1

data/README.ruby.md

@@ -0,0 +1,50 @@
+# squared 0.1
+
+* [source](https://github.com/anpham6/squared)
+* [manifest](https://github.com/anpham6/squared-repo)
+* [docs](https://squared.readthedocs.io)
+
+## Installation
+
+```sh
+gem install squared
+```
+
+## Prerequisites
+
+* Ruby 2.4+
+* Python 3.6+
+* [Repo](https://source.android.com/docs/setup/reference/repo)
+
+```sh
+mkdir -p ~/.bin
+PATH="${HOME}/.bin:${PATH}"
+curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo
+chmod a+rx ~/.bin/repo
+```
+
+## Example - Rakefile
+
+```ruby
+require "squared"
+
+Repo::Workspace
+  .new("squared")
+  .repo("https://github.com/anpham6/squared-repo", "nightly")
+  .add(:pathname, run: "rake compile", copy: "rake install", clean: "rake clean", ref: :ruby, group: "default") # Ruby
+  .add(:optparse, group: "default")
+  .add(:emc, "e-mc", copy: { from: "publish", into: "@e-mc", also: [:pir] }) # Node
+  .add(:pir, "pi-r", copy: { from: "publish", into: "@pi-r" })
+  .add(:squared)
+  .build(parallel: %i[pull fetch rebase copy clean])
+```
+
+## Usage
+
+```sh
+rake -T
+```
+
+## LICENSE
+
+BSD 3-Clause

data/lib/squared/common/class.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Squared
+  module Common
+    class JoinSet < ::Set
+      def initialize(data = [], delim: ' ')
+        super(data.compact)
+        @delim = delim
+      end
+
+      def done
+        ret = to_a.map!(&:to_s).reject(&:empty?).join(@delim)
+        clear
+        ret
+      end
+    end
+  end
+end

data/lib/squared/common/format.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Squared
+  module Common
+    module Format
+      def emphasize(val, title: nil, cols: nil, sub: nil)
+        n = 0
+        if title
+          title = title.to_s
+          n = title.size
+        end
+        if val.is_a?(::Array)
+          lines = val
+        else
+          lines = val.to_s.lines.map(&:chomp)
+          lines[0] = "#{val.class}: #{lines.first}" if (err = val.is_a?(::StandardError))
+        end
+        n = cols || [n, lines.max_by(&:size).size].max
+        if $stdout.tty?
+          require 'io/console'
+          (n = [n, $stdout.winsize[1] - 4].min) rescue nil
+        end
+        bord = '-' * (n + 4)
+        write = ->(line) { err ? warn(line) : puts(line) }
+        sub = as_a(sub)
+        pr = lambda do |line|
+          s = line.ljust(n)
+          sub.each { |h| s = sub_style(s, **h) }
+          "| #{s} |"
+        end
+        write.(bord)
+        if title
+          write.(pr.(title))
+          write.(bord)
+        end
+        lines.each { |line| write.(pr.(line)) }
+        write.(bord)
+      end
+
+      def sub_style(val, *args, pat: nil, styles: nil, index: 1)
+        return val unless ENV['NO_COLOR'].to_s.empty?
+
+        if pat && index != 0
+          return val unless (data = pat.match(val))
+
+          ret = index == -1 ? data.to_a[1..-1] : data[index]
+        else
+          ret = val
+          index = 0
+        end
+        wrap = ->(s, n) { "\x1B[#{n.join(';')}m#{s}\x1B[0m" }
+        code = []
+        args.concat(as_a(styles)).each_with_index do |type, i|
+          next unless type
+
+          if index == -1
+            s = ret[i]
+            next ret[i] = '' if s.nil?
+          else
+            s = ret
+          end
+          case (t = type.to_sym)
+          when :bold
+            s = "\x1B[1m#{s}\x1B[22m"
+          when :italic
+            s = "\x1B[3m#{s}\x1B[23m"
+          when :underline
+            s = "\x1B[4m#{s}\x1B[24m"
+          else
+            if (c = get(:colors)[t])
+              if index == -1
+                s = wrap.(s, [c])
+              else
+                code << c
+              end
+            end
+          end
+          if index == -1
+            ret[i] = s
+          else
+            ret = s
+          end
+        end
+        return ret.join if index == -1
+
+        ret = wrap.(ret, code) unless code.empty?
+        return ret unless data
+
+        out = +''
+        data.to_a.each_with_index do |group, i|
+          next if i == 0
+
+          if i == index
+            out << ret
+          elsif !group.nil?
+            out << group
+          end
+        end
+        out
+      end
+
+      def check_style(iter, empty: true)
+        ret = []
+        colors = get(:colors)
+        as_a(iter).each do |val|
+          case (val = val.to_sym)
+          when :bold, :italic, :underline
+            ret << val
+          else
+            ret << val if colors.key?(val)
+          end
+        end
+        !empty && ret.empty? ? nil : ret
+      end
+
+      def log_title(level, color: true)
+        level = if level.is_a?(::Numeric)
+                  case level
+                  when Logger::DEBUG
+                    :debug
+                  when Logger::INFO
+                    :info
+                  when Logger::WARN
+                    :warn
+                  when Logger::ERROR
+                    :error
+                  when Logger::FATAL
+                    :fatal
+                  else
+                    :unknown
+                  end
+                else
+                  level.to_s.downcase.to_sym
+                end
+        val = get(:logger)[level] || get(:logger)[level = :unknown]
+        level = +level.to_s.upcase
+        case level
+        when 'WARN', 'ERROR', 'FATAL'
+          level += '!'
+        end
+        color ? sub_style(level, *val) : level
+      end
+
+      def log_message(level, *args, subject: nil, hint: nil, color: true)
+        msg = [log_title(level, color: color)]
+        msg << (color ? sub_style(subject, :underline) : subject) if subject
+        message(msg.join(' '), *args, hint: hint)
+      end
+    end
+  end
+end

data/lib/squared/common/shell.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Squared
+  module Common
+    module Shell
+      def shell_escape(val)
+        return val if ::Rake::Win32.windows?
+
+        Shellwords.escape(val)
+      end
+
+      def shell_quote(val, force: true)
+        ret = val.to_s.strip
+        return ret if (!force && !ret.include?(' ')) || /(?:^|=)(["']).+\1$/m.match?(ret)
+
+        ::Rake::Win32.windows? ? "\"#{double_quote(ret)}\"" : "'#{single_quote(ret)}'"
+      end
+
+      def single_quote(val)
+        val.gsub("'", "'\\\\''")
+      end
+
+      def double_quote(val)
+        val.gsub(/(?<!\\)"/, '\\"')
+      end
+
+      def split_escape(val, char: ',')
+        val.split(/\s*(?<!\\)#{char}\s*/)
+      end
+
+      def trailing_slash(val)
+        val.to_s.chomp(::File::SEPARATOR) + ::File::SEPARATOR
+      end
+
+      def sanitize_args(*opts)
+        opts.map { |val| val.include?(' ') ? shell_quote(val) : shell_escape(val) }.join(' ')
+      end
+    end
+  end
+end

data/lib/squared/common/system.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Squared
+  module Common
+    module System
+      def shell(*cmd, **kwargs)
+        if /^2\.[0-5]\./.match?(RUBY_VERSION)
+          exception = kwargs.delete(:exception)
+          ret = system(*cmd, **kwargs)
+          raise $?.to_s if !ret && exception
+
+          ret
+        else
+          system(*cmd, **kwargs)
+        end
+      end
+
+      def copy_d(src, dest, glob: ['**/*'], create: false, verbose: true)
+        raise message(src, dest, hint: 'not found') if !create && !dest.exist?
+
+        subdir = []
+        files = 0
+        dest.mkpath if create
+        as_a(glob).each do |val|
+          Dir.glob(src.join(val)) do |path|
+            ent = Pathname.new(path)
+            next if ent.directory?
+
+            target = dest.join(ent.relative_path_from(src))
+            dir = target.dirname
+            if !subdir.include?(dir.to_s)
+              dir.mkpath
+              subdir << dir.to_s
+            end
+            copy_f ent, target
+            files += 1
+          end
+        end
+        puts message(dest.realpath, subdir.size.to_s, files.to_s) if verbose
+      end
+
+      def copy_f(src, dest, overwrite: true, verbose: false)
+        if !overwrite
+          path = Pathname.new(dest)
+          if path.directory?
+            src = as_a(src).reject { |val| path.join(File.basename(val)).exist? }
+          elsif path.exist?
+            return
+          end
+        end
+        FileUtils.cp(src, dest, verbose: verbose)
+      end
+    end
+  end
+end

data/lib/squared/common/task.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Squared
+  module Common
+    module Task
+      def collect_args(args, *keys)
+        ret = []
+        return ret unless args.is_a?(::Rake::TaskArguments)
+
+        keys.each { |key| ret << args[key] if args[key] }
+        ret += args.extras
+      end
+
+      def invoke(name, *args, exception: true)
+        ::Rake::Task[name].invoke(*args)
+      rescue StandardError => e
+        raise if exception
+
+        warn e
+      end
+
+      def invoked?(name)
+        ::Rake::Task.tasks.any? { |item| item.already_invoked && item.name == name.to_s }
+      end
+    end
+  end
+end

data/lib/squared/common.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'shellwords'
+require 'logger'
+require 'set'
+require 'rake'
+
+module Squared
+  module Common
+    VAR = {
+      project: {},
+      logger: {
+        unknown: %i[cyan],
+        fatal: %i[white bold red!],
+        error: %i[red bold],
+        warn: %i[yellow bold],
+        info: %i[blue],
+        debug: %i[green]
+      },
+      colors: {
+        black: '30',
+        red: '31',
+        green: '32',
+        yellow: '33',
+        blue: '34',
+        magenta: '35',
+        cyan: '36',
+        white: '37',
+        black!: '40',
+        red!: '41',
+        green!: '42',
+        yellow!: '43',
+        blue!: '44',
+        magenta!: '45',
+        cyan!: '46',
+        white!: '47'
+      }.freeze
+    }
+    private_constant :VAR
+
+    def get(key)
+      VAR[key.is_a?(::String) ? key.to_sym : key]
+    end
+
+    def set(key, val)
+      VAR[key.is_a?(::String) ? key.to_sym : key] = val
+    end
+
+    def message(*args, hint: nil)
+      args.reject(&:empty?).join(' => ') + (hint ? " (#{hint})" : '')
+    end
+
+    def as_a(obj)
+      return [] if obj.nil?
+
+      obj.is_a?(::Array) ? obj : [obj]
+    end
+  end
+end
+
+require_relative 'common/class'
+require_relative 'common/format'
+require_relative 'common/shell'
+require_relative 'common/system'
+require_relative 'common/task'

data/lib/squared/config.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Squared
+  module Config
+    class Viewer
+      include Common
+      include Format
+      include Task
+      include ::Rake::DSL
+
+      class << self
+        include Common::Format
+
+        attr_reader :styles
+
+        def style(name, *args)
+          args = check_style(args)
+          styles[name.to_sym]&.clear&.concat(args)
+        end
+      end
+
+      @styles = {
+        banner: %i[blue],
+        key: %i[bold],
+        value: %i[green],
+        string: %i[yellow],
+        hash: %i[green black!],
+        array: %i[blue black!],
+        number: %i[magenta],
+        undefined: %i[red italic]
+      }.freeze
+
+      attr_reader :main, :project, :name
+
+      def initialize(main = 'package', project: nil, name: nil)
+        if project
+          @project = get(:project)[project.to_sym]
+          @required = true
+        end
+        @name = (name || @project&.name)&.to_s
+        unless @name
+          msg, hint = project ? [project, 'not found'] : %w[name missing]
+          warn log_message(:warn, msg, subject: 'Config::Viewer', hint: hint, color: !pipe?)
+          @required = true
+        end
+        @main = main
+        @include = {}
+      end
+
+      def build
+        return unless enabled?
+
+        namespace @name do
+          namespace :view do
+            if @include['json'] && !::Rake::Task.task_defined?("#{@name}:view:json")
+              desc format_desc('json')
+              task :json, [:keys] do |_, args|
+                require 'json'
+                read_keys JSON, 'json', args.keys, args.extras
+              end
+            end
+
+            if @include['yaml'] && !::Rake::Task.task_defined?("#{@name}:view:yaml")
+              desc format_desc('yaml', 'yml')
+              task :yaml, [:keys] do |_, args|
+                require 'yaml'
+                read_keys YAML, 'yaml', args.keys, args.extras, 'yml', 'yaml'
+              end
+            end
+          end
+        end
+      end
+
+      def add(type, gem: nil, parse: nil, ext: [], opts: {}, command: nil, file: nil)
+        type = type.to_s
+        if parse && enabled?
+          require(gem || type)
+          obj = eval(parse)
+          ext = as_a(ext)
+          namespace @name do
+            desc format_desc(ext.first || type, command: command)
+            namespace(command || :view) do
+              task type, [:keys] do |_, args|
+                if file
+                  read_keys obj, type, file.to_s, collect_args(args, :keys), *ext
+                else
+                  read_keys obj, type, args.keys, args.extras, *ext
+                end
+              end
+            end
+          end
+        end
+      rescue LoadError, NameError
+        self
+      else
+        @include[type] = opts
+        self
+      end
+
+      def also(path, type = nil, name: nil, gem: nil, parse: nil, opts: {})
+        return self unless (file = base_path(path)).exist?
+
+        ext = chop_extname(file).downcase
+        name ||= file.basename.to_s.chomp(".#{ext}")
+        type = (type || ext).to_s
+        if !parse
+          case type
+          when 'json'
+            parse = 'JSON'
+          when 'yaml', 'yml'
+            type = 'yaml'
+            parse = 'YAML'
+          end
+        end
+        add(type, gem: gem, parse: parse, ext: ext, opts: opts, command: name, file: file)
+      end
+
+      def enabled?
+        !@required || !!@project&.enabled?
+      end
+
+      protected
+
+      def read_keys(reader, type, file, keys, *ext)
+        path = base_path(file)
+        fmt = chop_extname(file)
+        ext << type if ext.empty?
+        if path.exist? && path.basename.to_s.include?('.')
+          raise ArgumentError, message(file, fmt, hint: 'invalid') unless ext.include?(fmt)
+        else
+          if ext.include?(fmt)
+            alt = file
+            file = nil
+            ext[0] = fmt
+          else
+            keys.unshift(file)
+            alt = "#{@main}.{#{ext.join(',')}}"
+            alt = @project.base_path(alt) if @project
+            file = Dir[alt].first
+          end
+          if !file
+            raise ArgumentError, message(reader.name, "#{File.basename(alt, '.*')}.#{ext.first}", hint: 'not found')
+          end
+        end
+        doc = if reader.respond_to?(:load_file)
+                reader.load_file(file, **@include[type])
+              else
+                reader.parse(File.read(file), **@include[type])
+              end
+        lines = print_keys(type, doc, keys)
+        return unless lines
+
+        title = Pathname.new(file)
+                        .realpath
+                        .to_s
+                        .sub(/^#{Regexp.escape(Dir.pwd + ::File::SEPARATOR)}/, '')
+        sub = if pipe?
+                nil
+              else
+                [
+                  { pat: /^([^:]+|(?<! ):(?! ))+$/, styles: Viewer.styles[:banner] },
+                  { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: Viewer.styles[:undefined], index: 2 },
+                  { pat: /^(.+)( : (?!undefined))(.+)$/m, styles: Viewer.styles[:key] },
+                  { pat: /^(.+)( : )(-?[\d.]+)(\s*)$/m, styles: Viewer.styles[:number], index: 3 },
+                  { pat: /^(.+)( : ")(.+)("\s*)$/m, styles: Viewer.styles[:string], index: 3 },
+                  { pat: /^(.+)( : \{)(.+)(\}\s*)$/m, styles: Viewer.styles[:hash], index: 3 },
+                  { pat: /^(.+)( : \[)(.+)(\]\s*)$/m, styles: Viewer.styles[:array], index: 3 },
+                  { pat: /^(.+)( : (?!undefined))([^"\[{].*)$/m, styles: Viewer.styles[:value], index: 3 }
+                ]
+              end
+        emphasize(lines, title: title, sub: sub)
+      end
+
+      def print_keys(type, data, keys)
+        out = []
+        pad = 0
+        symbolize = @include[type][:symbolize_names]
+        keys.each do |key|
+          begin
+            items = key.split('.')
+            items = items.map(&:to_sym) if symbolize
+            val = data.dig(*items)
+            if val.nil?
+              val = data
+              items.each do |name|
+                raise name unless val.is_a?(::Hash) && val.key?(name)
+
+                val = val[name]
+              end
+            end
+          rescue StandardError
+            val = Regexp.escape($!.message)
+            key = key.sub(/(#{val})\.|\.(#{val})|(#{val})/) do
+              s = "<#{$3 || $2 || $1}>"
+              if $3
+                s
+              else
+                $2 ? ".#{s}" : "#{s}."
+              end
+            end
+            out << [key, 'undefined']
+          else
+            out << [key, val.inspect]
+          end
+          pad = key.size if key.size > pad
+        end
+        if pipe?
+          out = out.map do |item|
+            val = item.last
+            val.start_with?('"') && val.end_with?('"') ? val[1..-2] : val
+          end
+          puts out.join("\n")
+        else
+          out.map { |item| "#{item.first.ljust(pad)} : #{item.last}" }
+        end
+      end
+
+      def base_path(file)
+        @project ? @project.base_path(file) : Pathname.new(file).realdirpath
+      end
+
+      def format_desc(type, alt = nil, command: nil)
+        message(@name, command || 'view', "#{type}[#{command.nil? ? "file?=#{@main}.#{alt || type}," : ''}keys*]")
+      end
+
+      def chop_extname(file)
+        File.extname(file).sub('.', '')
+      end
+
+      def pipe?
+        return @project.workspace.pipe? if @project
+
+        val = ENV['PIPE_OUT']
+        !val.nil? && !val.empty? && val != '0'
+      end
+    end
+  end
+end
+
+Viewer = Squared::Config::Viewer