squared 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 867bfab9c2ffade3d9158228c67fca5f0f4675ecd24a3d7201d0b85f42945d8f
-  data.tar.gz: 0ee6b84388949cd03c7a0667e7bd0d8aab8b3b30c597da6ae8b486fa3063d89e
+  metadata.gz: ef428776d582a23bb5560efdc5c6f6d77fa5fb1adaecca5f11500b978126283a
+  data.tar.gz: cd8dfbae3f5162b55fd081ac65e31f0e2fca1167d4932e52ccd723f128a1a312
 SHA512:
-  metadata.gz: ce95fe135ead9dec6e92106955e921442f3a9fe73a8a11863a8d3022187065056236b52449b8e40e30cd34bd3a95c949a296817af30932b9edc64032cb255919
-  data.tar.gz: 63d8d2d3e22572d614b3a3d214427a1864cb528c5231e107db984949214955efa804376548b769f90ee7390223dd2b7715fd85ad78d2f15b85e77fe4b48b710e
+  metadata.gz: e8bf3197a021dadc3bf8d15d4f80d5064a4254359a23b9e7576babe716189e0d17564acae48e018fc64b7caddde250f53eb479cae3e4997d7a3792fe66e07d5a
+  data.tar.gz: 312231359e1bd8f7052c91250234750ba9c41f5be1b806e852c60517d4c04e8d4ef55450d1b65fb35a946b2c6138d83bccc8280587b6c5b9832d717fa377c84a

data/README.md

@@ -81,13 +81,13 @@
 #### Install
 
 ```sh
-mkdir -p ~/.bin
-PATH="${HOME}/.bin:${PATH}"
+mkdir -p ~/bin/repo
+PATH="${HOME}/bin:${PATH}"
 
-curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo
-chmod a+rx ~/.bin/repo
+curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
+chmod a+rx ~/bin/repo
 # OR
-scripts/repo-install.sh ~/.bin
+scripts/repo-install.sh ~/bin
 ```
 
 #### Usage

data/README.ruby.md

@@ -4,17 +4,14 @@
 * [manifest](https://github.com/anpham6/squared-repo)
 * [docs](https://squared.readthedocs.io)
 
-## Installation
-
-```sh
-gem install squared
-```
-
 ## Prerequisites
 
 * Ruby 2.4+
-* Python 3.6+
+
+### Optional
+
 * [Repo](https://source.android.com/docs/setup/reference/repo)
+* Python 3.6+
 
 ```sh
 mkdir -p ~/.bin
@@ -23,26 +20,64 @@ curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo
 chmod a+rx ~/.bin/repo
 ```
 
+## Installation
+
+```sh
+gem install squared
+```
+
 ## 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])
+  .new("squared") # REPO_HOME
+  .repo("https://github.com/anpham6/squared-repo", "nightly", run: 'build') # Optional
+  .run("rake install", ref: :ruby)
+  .clean("rake clean", group: "default") # depend test doc
+  .clean(["build/"], group: "app")
+  .add("pathname", run: "rake compile", copy: "rake install", test: "rake test", group: "default", ref: :ruby) # Ruby (with C extensions)
+  .add("optparse", doc: "rake rdoc", group: "default") # Uses bundler/gem_tasks (without C extensions)
+  .add("logger", copy: { from: "lib", glob: "**/*.rb", gemdir: "~/.rvm/gems/ruby-3.3.5/gems/logger-1.6.1" }, clean: ["tmp/"]) # autodetect: true
+  .add("android", "android-docs", run: false, doc: "make html", ref: :python) # task namespace "android" | directory "android-docs"
+  .add("emc", "e-mc", copy: { from: "publish", into: "@e-mc", also: [:pir, "squared-express/"] }, ref: :node) # Node
+  .add("pir", "pi-r", copy: { from: "publish", into: "@pi-r" }, clean: ["publish/**/*.js", "tmp/"]) # Trailing slash required for directories
+  .add("squared", log: { file: "tmp/%Y-%m-%d.log", level: "debug" }, group: "app") # Copy target (main)
+  .style(:banner, 255.255) # 256 colors (fg | fg.bg | -0.bg)
+  .build(default: "status", parallel: ["pull", "fetch", "rebase", "copy", "clean"]) do |workspace|
+    workspace
+      .enable_aixterm
+      .style(:banner, "bright_cyan", "bold", "bright_black!")
+      .finalize! # Optional
+  end
 ```
 
+**NOTE**: The use of "**ref**" (class name) is only necessary when running `repo:init` for the first time into an empty directory.
+
 ## Usage
 
 ```sh
-rake -T
+rake -T           # List tasks
+rake              # rake status (usually "build")
+
+# GIT_OPTIONS=rebase
+rake pull           # All except "default" + "app"
+rake pull:ruby      # pathname + optparse + logger
+rake pull:default   # pathname + optparse
+rake pull:app       # squared
+rake pull:node      # emc + pir + squared
+
+rake build          # All except "android"
+rake doc            # optparse + android
+
+rake build:ruby     # rake compile + rake install + rake install
+
+rake clean          # All except "default" + "app"
+rake clean:ruby     # rake clean + rake clean + ["tmp/"]
+rake clean:default  # rake clean + rake clean + skip
+rake clean:app      # none + skip + ["build/"]
+rake clean:node     # none + ["publish/**/*.js", "tmp/"] + ["build/"]
 ```
 
 ## LICENSE

data/lib/squared/common/class.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Squared
   module Common
     class JoinSet < ::Set
+      def self.to_s
+        /[^:]+$/.match(super.to_s)[0]
+      end
+
       def initialize(data = [], delim: ' ')
         super(data.compact)
         @delim = delim

data/lib/squared/common/format.rb

@@ -3,7 +3,37 @@
 module Squared
   module Common
     module Format
-      def emphasize(val, title: nil, cols: nil, sub: nil)
+      include Common
+
+      AIX_TERM = {
+        bright_black: '90',
+        bright_red: '91',
+        bright_green: '92',
+        bright_yellow: '93',
+        bright_blue: '94',
+        bright_magenta: '95',
+        bright_cyan: '96',
+        bright_white: '97',
+        bright_black!: '100',
+        bright_red!: '101',
+        bright_green!: '102',
+        bright_yellow!: '103',
+        bright_blue!: '104',
+        bright_magenta!: '105',
+        bright_cyan!: '106',
+        bright_white!: '107'
+      }.freeze
+      TEXT_STYLE = [:bold, :dim, :italic, :underline, :blinking, nil, :inverse, :hidden, :strikethrough].freeze
+      private_constant :AIX_TERM, :TEXT_STYLE
+
+      def enable_aixterm
+        unless (colors = __get__(:colors)).frozen?
+          colors.merge!(AIX_TERM)
+        end
+        block_given? ? yield(self) : self
+      end
+
+      def emphasize(val, title: nil, cols: nil, sub: nil, pipe: nil)
         n = 0
         if title
           title = title.to_s
@@ -20,21 +50,27 @@ module Squared
           require 'io/console'
           (n = [n, $stdout.winsize[1] - 4].min) rescue nil
         end
+        out = []
         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)
+        out << bord
+        out.push(pr.(title), bord) if title
+        lines.each { |line| out << pr.(line) }
+        out << bord
+        if block_given?
+          yield out
+        elsif pipe.respond_to?(:puts)
+          pipe.puts out
+        elsif err
+          defined?(__warn__) == 'method' ? __warn__(out) : warn(out)
+        else
+          puts out
         end
-        lines.each { |line| write.(pr.(line)) }
-        write.(bord)
       end
 
       def sub_style(val, *args, pat: nil, styles: nil, index: 1)
@@ -59,20 +95,25 @@ module Squared
           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"
+          if type.is_a?(Numeric)
+            f, b = type.to_s.split('.')
+            s = wrap.(s, ['38', '5', f]) if f[0] != '-' && f.to_i <= 255
+            if b
+              b = b[0..2]
+              s = wrap.(s, ['48', '5', b]) unless b.to_i > 255
+            end
           else
-            if (c = get(:colors)[t])
+            t = type.to_sym
+            if (c = __get__(:colors)[t])
               if index == -1
                 s = wrap.(s, [c])
               else
                 code << c
               end
+            else
+              next unless (n = TEXT_STYLE.index { |style| style == t })
+
+              s = "\x1B[#{n + 1}m#{s}\x1B[#{n == 0 ? 22 : n + 21}m"
             end
           end
           if index == -1
@@ -99,20 +140,34 @@ module Squared
         out
       end
 
-      def check_style(iter, empty: true)
+      def check_style(*args, empty: true)
         ret = []
-        colors = get(:colors)
-        as_a(iter).each do |val|
-          case (val = val.to_sym)
-          when :bold, :italic, :underline
+        colors = __get__(:colors)
+        as_a(args, flat: true).each do |val|
+          if !val.is_a?(Numeric)
+            val = val.to_sym
+            ret << val if colors.key?(val) || TEXT_STYLE.include?(val)
+          elsif val >= 0 && val <= 256
             ret << val
-          else
-            ret << val if colors.key?(val)
+          elsif val < 0 && (b = val.to_s.split('.')[1])
+            b = b[0..2]
+            ret << "-0.#{b}".to_f unless b.to_i > 255
           end
         end
         !empty && ret.empty? ? nil : ret
       end
 
+      def apply_style(data, key, *args, empty: true)
+        return unless !data.is_a?(Symbol) || (data = __get__(:theme)[data])
+
+        set = ->(k, v) { data[k.to_sym] = check_style(v, empty: empty) }
+        if key.is_a?(Hash)
+          key.each { |k, v| set.(k, v || args.flatten) }
+        else
+          set.(key, args.flatten)
+        end
+      end
+
       def log_title(level, color: true)
         level = if level.is_a?(::Numeric)
                   case level
@@ -132,7 +187,8 @@ module Squared
                 else
                   level.to_s.downcase.to_sym
                 end
-        val = get(:logger)[level] || get(:logger)[level = :unknown]
+        theme = __get__(:theme)[:logger]
+        val = theme[level] || theme[level = :unknown]
         level = +level.to_s.upcase
         case level
         when 'WARN', 'ERROR', 'FATAL'

data/lib/squared/common/shell.rb

@@ -6,16 +6,24 @@ module Squared
       def shell_escape(val)
         return val if ::Rake::Win32.windows?
 
+        require 'shellwords'
         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)
+        return ret if (!force && !ret.include?(' ')) || ret.match?(/(?:^|=)(["']).+\1$/m)
 
         ::Rake::Win32.windows? ? "\"#{double_quote(ret)}\"" : "'#{single_quote(ret)}'"
       end
 
+      def fill_option(val)
+        return "-#{val}" if val.size == 1 || val.match?(/^[a-z]\d+$/i)
+
+        val = "--#{val}" unless val.start_with?('-')
+        shell_escape(val).sub('\\=', '=')
+      end
+
       def single_quote(val)
         val.gsub("'", "'\\\\''")
       end

data/lib/squared/common/system.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 module Squared
   module Common
     module System
@@ -16,7 +18,7 @@ module Squared
       end
 
       def copy_d(src, dest, glob: ['**/*'], create: false, verbose: true)
-        raise message(src, dest, hint: 'not found') if !create && !dest.exist?
+        raise "#{dest} (not found)" if !create && !dest.exist?
 
         subdir = []
         files = 0
@@ -36,7 +38,7 @@ module Squared
             files += 1
           end
         end
-        puts message(dest.realpath, subdir.size.to_s, files.to_s) if verbose
+        puts [dest.realpath, subdir.size.to_s, files.to_s].join(' => ') if verbose
       end
 
       def copy_f(src, dest, overwrite: true, verbose: false)

data/lib/squared/common/task.rb

@@ -16,7 +16,7 @@ module Squared
       rescue StandardError => e
         raise if exception
 
-        warn e
+        defined?(__warn__) == 'method' ? __warn__(e) : warn(e)
       end
 
       def invoked?(name)

data/lib/squared/common.rb

@@ -1,23 +1,13 @@
 # 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',
@@ -35,26 +25,58 @@ module Squared
         magenta!: '45',
         cyan!: '46',
         white!: '47'
-      }.freeze
-    }
+      },
+      theme: {
+        workspace: {},
+        project: {},
+        viewer: {
+          banner: %i[blue bold],
+          key: %i[bold],
+          value: %i[green],
+          string: %i[yellow],
+          hash: %i[green black!],
+          array: %i[blue black!],
+          number: %i[magenta],
+          undefined: %i[red italic]
+        },
+        logger: {
+          unknown: %i[cyan],
+          fatal: %i[white bold red!],
+          error: %i[red bold],
+          warn: %i[yellow bold],
+          info: %i[blue],
+          debug: %i[green]
+        }
+      }
+    }.compare_by_identity
     private_constant :VAR
 
-    def get(key)
+    def __get__(key)
       VAR[key.is_a?(::String) ? key.to_sym : key]
     end
 
-    def set(key, val)
+    def __set__(key, val)
+      return if VAR.frozen?
+
       VAR[key.is_a?(::String) ? key.to_sym : key] = val
     end
 
+    def finalize!
+      VAR.each_value(&:freeze)
+      VAR[:theme].each_value(&:freeze)
+      VAR.freeze
+    end
+
     def message(*args, hint: nil)
       args.reject(&:empty?).join(' => ') + (hint ? " (#{hint})" : '')
     end
 
-    def as_a(obj)
+    def as_a(obj, flat: nil)
       return [] if obj.nil?
+      return [obj] unless obj.is_a?(::Array)
+      return obj unless flat
 
-      obj.is_a?(::Array) ? obj : [obj]
+      obj.flatten(flat == true ? nil : flat)
     end
   end
 end