squared 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71eae17e75e9ebe9a4fbe250f49da6397b169f06ac85c7f77170b9fc575bd63e
-  data.tar.gz: f68b5c36da52802d0b952c54a406d6d6bde3085308c465c2f058c8c944dce894
+  metadata.gz: 2d9e8c772c9f4d0ce5c54dbeb1b9583d2e477f155036faf34cfc547659c34ec4
+  data.tar.gz: 87de412a78c0071eabd4b26713cbf84978a92fca6ea1a6dfe18653ddf22c90ee
 SHA512:
-  metadata.gz: 515aa7c65dd969fb9dd165a38716695a6c08ccbf0597ef3d7936bcd70750c2c54f661fc44e9dc303d34b8d99947d27939039654ca5ffd43afcf33f917deb2866
-  data.tar.gz: cfe3827d03d56619de9d3c60a4df2b249ff1f802bc9a6be407b96c5db95fb14faf6b3719e657c83dc046287d62272f1cf2e676fdad67da345abc93675e511474
+  metadata.gz: '08475f426b15c41dab20fbead5d7c1ead70f5d80384e0a0772cbe7b101512a4402a1bb1231b2550f7da16aac2796f8411f6a6e3e570ae728d59b03f88fea5960'
+  data.tar.gz: 5c0334640b20dda82641925cd94b41d76be4cd4e603355fef593a5cd69731ac926febab67f3ffa494267291ec9d89efba2f8a9ac4dde978ab2814a0f8a481a67

data/README.ruby.md

@@ -34,7 +34,14 @@ Projects from any accessible folder can be added either relative to `REPO_ROOT`
 
 ```ruby
 require "squared"
-require "squared/workspace/repo" # Repo (optional)
+
+require "squared/workspace"
+require "squared/workspace/repo"           # Optional
+require "squared/workspace/project/node"   #
+require "squared/workspace/project/python" #
+require "squared/workspace/project/ruby"   #
+# OR
+require "squared/app"                      # All workspace related modules
 
 # NODE_ENV  = production
 # REPO_ROOT = /workspaces
@@ -52,7 +59,7 @@ require "squared/workspace/repo" # Repo (optional)
 
 Workspace::Application
   .new(Dir.pwd, main: "squared") # Dir.pwd? (main? is implicitly basename)
-  .banner("group", "project", styles: %i[yellow black], border: "bold") # name | project | path | ref | group?
+  .banner("group", "project", styles: ["yellow", "black"], border: "bold") # name | project | path | ref | group? | parent? | version?
   .repo("https://github.com/anpham6/squared-repo", "nightly", script: ["build:dev", "build:prod"], ref: :node) # Repo (optional)
   .run("rake install", ref: :ruby)
   .depend(false, group: "default")
@@ -63,13 +70,17 @@ Workspace::Application
     "CFLAGS" => "-fPIC -O1"
   })
   .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("e-mc", "emc", copy: { from: "publish", into: "@e-mc", also: [:pir, "squared-express/"] }, ref: :node) # Node
-  .add("pi-r", "pir", copy: { from: "publish", into: "@pi-r" }, clean: ["publish/**/*.js", "tmp/"]) # Trailing slash required for directories
+  .add("logger", copy: { from: "lib", glob: "**/*.rb", into: "~/.rvm/gems/ruby-3.3.5/gems/logger-1.6.1" }, clean: ["tmp/"]) # autodetect: true
+  .add("e-mc", "emc", copy: { from: "publish", scope: "@e-mc", also: [:pir, "squared-express/"] }, ref: :node) # Node
+  .add("pi-r", "pir", copy: { from: "publish", scope: "@pi-r" }, clean: ["publish/**/*.js", "tmp/"]) # Trailing slash required for directories
   .add("squared", script: ["build:stage1", "build:stage2"], group: "app") do # Copy target (main)
-    add("publish/sqd-cli", "cli", exclude: [:git])
-    add("publish/sqd-serve")
+    add("publish/sqd-cli", "cli", exclude: [:git]) # rake cli:build
+    add("publish/sqd-serve")                       # rake sqd-serve:build
     add("publish/sqd-admin", group: "sqd", exclude: [:base])
+    # OR
+    with(exclude: [:base]) { add("publish/*", "packages") } # rake packages:sqd-serve:build
+    # OR
+    add(["publish/sqd-cli", "publish/sqd-serve", "publish/sqd-admin"], true, exclude: [:base]) # rake squared:sqd-serve:build
   end
   .add("squared/sqd", exclude: [:git]) do
     variable_set :script, "build:sqd"     # Override detection
@@ -77,7 +88,7 @@ Workspace::Application
     variable_set :clean, ["build/sqd/"]
   end
   .style("banner", 255.255) # 256 colors (fg | fg.bg | -0.bg)
-  .build(default: "status", parallel: ["pull", "fetch", "rebase", "copy", "clean"]) do |workspace|
+  .build(default: "status", parallel: ["pull", "fetch", "rebase", "copy", "clean", "outdated:ruby"]) do |workspace|
     workspace
       .enable_aixterm
       .style({
@@ -97,28 +108,80 @@ Workspace::Application
   .new(ENV["SQUARED_HOME"], prefix: "rb", common: false) # Local styles
   .group("ruby", "default", run: "rake build", copy: "rake install", clean: "rake clean", ref: :ruby, override: {
     pathname: {
-      run: "rake compile"                               # rake rb:pathname:build
+      run: "rake compile"                                # rake rb:pathname:build
     }
   })
-  .with(:python) do                                     # ref=Symbol  | group=String
-    banner("path", command: false, styles: "yellow")    # 
-    doc("make html")                                    # rake rb:doc:python
-    run(false)                                          # rake rb:build:python (disabled)
-    exclude(%i[base git])                               # Project::Git.ref (superclass)
-    add("android-docs", "android")                      # rake rb:android:doc
-    add("chrome-docs", "chrome")                        # rake rb:chrome:doc
-  end                                                   #
+  .with(:python) do                                      # ref=Symbol | group=String
+    banner([:name, ": ", :version], "path")              # chrome-docs: 0.1.0 | /workspaces/chrome-docs
+    doc("make html")                                     # rake rb:doc:python
+    run(false)                                           # rake rb:build:python (disabled)
+    exclude(%i[base git])                                # Project::Git.ref (superclass)
+    add("android-docs", "android")                       # rake rb:android:doc
+    add("chrome-docs", "chrome")                         # rake rb:chrome:doc
+  end                                                    #
   .style("inline", "bold")
   .build
 ```
 
-**NOTE**: The use of "**ref**" (class name) is only necessary when running `repo:init` for the first time into an empty directory.
+**NOTE**: The use of "**ref**" (class name) is only necessary when initializing an empty directory (e.g. *rake repo:init*).
+
+### Graph
+
+```ruby
+Workspace::Application
+  .new(main: "squared")
+  .with(:python) do
+    add("android-docs", "android")
+    add("chrome-docs", "chrome", graph: "android")
+  end
+  .with(:node) do
+    graph(["build", "copy"]) # Optional
+    add("e-mc", "emc")
+    add("pi-r", "pir", graph: "emc")
+    add("squared-express", "express", graph: "pir")
+    add("squared", graph: ["chrome", "express"])
+  end
+  .with(:ruby) do
+    add("pathname")
+    add("fileutils", graph: "pathname")
+    add("optparse")
+    add("rake", graph: ["fileutils", "optparse"])
+  end
+  .build
+```
+
+```sh
+rake pir:graph      # emc + pir
+rake express:graph  # emc + pir + express
+rake chrome:graph   # android + chrome
+rake graph:python   # same
+rake squared:graph  # android + chrome + emc + pir + express + squared
+rake graph:node     # same
+rake rake:graph     # pathname + fileutils + optparse + rake
+rake graph:ruby     # same
+rake graph          # graph:node + graph:ruby
+```
+
+### Batch
+
+```ruby
+Workspace::Series.batch(:ruby, :node, {
+  stage: %i[graph test],
+  reset: %i[stash pull]
+})
+```
+
+### Rename
+
+```ruby
+Workspace::Series.rename("depend", "install")
+```
 
 ## Usage
 
 ```sh
-rake -T           # List tasks
-rake              # rake status (usually "build")
+rake -T             # List tasks
+rake                # rake status (usually "build")
 
 # GIT_OPTIONS=rebase
 rake pull           # All except "default" + "app"
@@ -145,6 +208,7 @@ rake build:app                   # squared + cli + sqd-serve
 rake squared:build:workspace     # cli + sqd-serve
 rake pull:sqd                    # sqd-admin
 rake squared:pull:workspace      # sqd-serve + sqd-admin
+rake squared:outdated:workspace  # cli + sqd-serve + sqd-admin
 ```
 
 ## Methods
@@ -153,6 +217,7 @@ Task:
 
 * run
 * depend
+* graph
 * test
 * doc
 * clean
@@ -179,14 +244,21 @@ Non-task:
 ### Build
 
 ```ruby
+# :env                                         :run           :opts
 # LD_LIBRARY_PATH="path/to/lib" CFLAGS="-Wall" gcc a.c -o a.o -c
 BUILD_${NAME}      # gcc a.c -o a.o
-BUILD_${NAME}_OPTS # -c
-BUILD_${NAME}_ENV  # {"LD_LIBRARY_PATH":"path/to/lib","CFLAGS":"-Wall"} (json)
-
-# Scripts
-BUILD_${NAME}_DEV  # pattern,0,1
-BUILD_${NAME}_PROD # pattern,0,1
+BUILD_OPTS_${NAME} # -c
+BUILD_ENV_${NAME}  # {"LD_LIBRARY_PATH":"path/to/lib","CFLAGS":"-Wall"} (hash/json)
+
+# :env                                       :opts                               :script
+# NODE_ENV="production" NO_COLOR="1" npm run --loglevel=error --workspaces=false build:dev
+BUILD_${NAME}      # build:dev
+BUILD_OPTS_${NAME} # --loglevel=error --workspaces=false
+BUILD_ENV_${NAME}  # {"NODE_ENV":"production","NO_COLOR":"1"} (hash/json)
+BUILD_DEV_${NAME}  # pattern,0,1 (:dev)
+BUILD_PROD_${NAME} # pattern,0,1 (:prod)
+
+BUILD_${NAME}=0    # skip project
 ```
 
 These options also support the project specific suffix `${NAME}`. (e.g. LOG_FILE_SQUARED)

data/lib/squared/app.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'workspace'
+require_relative 'workspace/repo'
+require_relative 'workspace/project/node'
+require_relative 'workspace/project/python'
+require_relative 'workspace/project/ruby'
+require_relative 'config'
+
+Common = Squared::Common

data/lib/squared/common/base.rb

@@ -2,10 +2,16 @@
 
 module Squared
   module Common
-    KEY = {
+    ARG = {
       PIPE: 1,
+      OUT: nil,
+      VERBOSE: nil,
       FAIL: false,
-      COMMON: true
+      COMMON: true,
+      BANNER: true,
+      SPACE: ' => ',
+      GRAPH: ['│', '─', '├', '└', '┬'],
+      COLOR: ENV.fetch('NO_COLOR', '').empty?
     }
     VAR = {
       project: {},
@@ -70,6 +76,7 @@ module Squared
     end
 
     def __freeze__
+      ARG.freeze
       VAR.each_value(&:freeze)
       VAR[:theme].each_value(&:freeze)
       VAR.freeze
@@ -77,30 +84,19 @@ module Squared
 
     module_function
 
-    def env(key, default = nil, equals: nil, ignore: nil, **)
-      ret = ENV.fetch(key, '')
-      return ret == equals.to_s unless equals.nil?
-
-      ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
-    end
-
-    def message(*args, hint: nil)
-      args.reject(&:empty?).join(' => ') + (hint ? " (#{hint})" : '')
-    end
-
     def as_a(obj, meth = nil, flat: nil, compact: false)
       return [] if obj.nil?
 
       unless obj.is_a?(::Array)
-        obj = if !obj.is_a?(::Hash) && obj.respond_to?(:to_a) && (val = obj.to_a).is_a?(::Array)
+        obj = if obj.respond_to?(:to_a) && !obj.is_a?(::Hash) && (val = obj.to_a).is_a?(::Array)
                 val
               else
                 [obj]
               end
       end
       obj = obj.flatten(flat.is_a?(::Numeric) ? flat : nil) if flat
-      obj = obj.map(&meth) if meth
-      compact ? obj.compact : obj
+      obj = obj.compact if compact
+      meth ? obj.map(&meth) : obj
     end
   end
 end

data/lib/squared/common/class.rb

@@ -1,12 +1,37 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'forwardable'
 
 module Squared
   module Common
+    class SymSet
+      extend Forwardable
+
+      def self.to_s
+        super.match(/[^:]+$/)[0]
+      end
+
+      def_delegators :@data, :+, :each, :each_with_index, :entries, :to_a, :include?
+
+      def initialize(data = [])
+        @data = ::Set.new(data)
+      end
+
+      def add(val)
+        @data.add(val.to_sym)
+      end
+
+      def to_s
+        @data.to_s.sub('Set', SymSet.to_s)
+      end
+
+      alias inspect to_s
+    end
+
     class JoinSet < ::Set
       def self.to_s
-        super.to_s.match(/[^:]+$/)[0]
+        super.match(/[^:]+$/)[0]
       end
 
       def initialize(data = [], delim: ' ')

data/lib/squared/common/format.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'pathname'
 require 'logger'
 
 require_relative 'base'
@@ -40,7 +41,7 @@ module Squared
       private
 
       def sub_style(val, *args, styles: nil, pat: nil, index: 1)
-        return val unless ENV.fetch('NO_COLOR', '').empty? && !__get__(:no_color)
+        return val unless ARG[:COLOR]
 
         if pat && index != 0
           return val unless (data = pat.match(val))
@@ -106,7 +107,7 @@ module Squared
         out
       end
 
-      def check_style(*args, empty: true)
+      def check_style(args, empty: true)
         ret = []
         colors = __get__(:colors)
         as_a(args, flat: true, compact: true).each do |val|
@@ -123,7 +124,7 @@ module Squared
         ret if empty || !ret.empty?
       end
 
-      def apply_style(data, key, *args, empty: true)
+      def apply_style(data, key, args, empty: true)
         return if data.is_a?(::Symbol) && (data = __get__(:theme)[data]).nil?
 
         set = ->(k, v) { data[k] = check_style(v, empty: empty) }
@@ -137,15 +138,15 @@ module Squared
       def log_sym(level)
         if level.is_a?(::Numeric)
           case level
-          when Logger::DEBUG
+          when ::Logger::DEBUG
             :debug
-          when Logger::INFO
+          when ::Logger::INFO
             :info
-          when Logger::WARN
+          when ::Logger::WARN
             :warn
-          when Logger::ERROR
+          when ::Logger::ERROR
             :error
-          when Logger::FATAL
+          when ::Logger::FATAL
             :fatal
           else
             :unknown
@@ -155,7 +156,7 @@ module Squared
         end
       end
 
-      def log_title(level, color: true)
+      def log_title(level, color: ARG[:COLOR])
         theme = __get__(:theme)[:logger]
         styles = theme[level = log_sym(level)] || theme[level = :unknown]
         case (ret = +level.to_s.upcase)
@@ -165,7 +166,7 @@ module Squared
         color ? sub_style(ret, *styles) : ret
       end
 
-      def log_message(level, *args, subject: nil, hint: nil, color: true)
+      def log_message(level, *args, subject: nil, hint: nil, color: ARG[:COLOR])
         args = args.map(&:to_s)
         if args.size > 1
           title = log_title(level, color: false)
@@ -183,49 +184,103 @@ module Squared
         end
       end
 
-      def raise_error(*args, hint: nil, kind: ArgumentError)
-        raise kind, message(*args, hint: hint)
+      def puts_oe(*args, pipe: 1)
+        if pipe.is_a?(::Pathname)
+          begin
+            ::File.open(pipe, 'a') do |f|
+              br = ::File::SEPARATOR == '\\' ? "\r\n" : "\n"
+              args.flatten.each { |val| f.write("#{strip_style(val.chomp)}#{br}") }
+            end
+            return
+          rescue StandardError
+            pipe = 2
+          end
+        end
+        (pipe == 2 ? $stderr : $stdout).puts(*args)
       end
 
       module_function
 
-      def emphasize(val, title: nil, cols: nil, sub: nil, pipe: nil)
+      def message(*args, hint: nil, empty: false)
+        (empty ? args.reject { |val| val.nil? || val.empty? } : args).join(ARG[:SPACE]) + (hint ? " (#{hint})" : '')
+      end
+
+      def emphasize(val, title: nil, footer: nil, right: false, cols: nil, sub: nil, border: nil, pipe: nil)
         n = 0
-        if title
-          title = title.to_s
-          n = title.size
+        max = ->(v) { n = [n, v.max_by(&:size).size].max }
+        set = lambda do |v|
+          ret = as_a(v, :to_s)
+          max.(ret)
+          ret
         end
+        title &&= set.(title)
+        footer &&= set.(footer)
         if val.is_a?(::Array)
-          lines = val
+          lines = val.map(&:to_s)
         else
           lines = val.to_s.lines.map(&:chomp)
-          lines[0] = "#{val.class}: #{lines.first}" if (err = val.is_a?(::StandardError))
+          lines[0] = "#{val.class}: #{lines.first}" if (err = val.is_a?(StandardError))
         end
-        n = cols || [n, lines.max_by(&:size).size].max
+        n = cols || max.(lines)
         if $stdout.tty?
           require 'io/console'
           (n = [n, $stdout.winsize[1] - 4].min) rescue nil
         end
         out = []
         bord = '-' * (n + 4)
-        sub = [sub] if sub && !sub.is_a?(::Array)
+        bord = sub_style(bord, styles: border) if border
+        sub = as_a(sub)
         pr = lambda do |line|
           s = line.ljust(n)
-          sub&.each { |h| s = sub_style(s, **h) }
-          "| #{s} |"
+          sub.each { |h| s = sub_style(s, **h) }
+          s = "| #{s} |"
+          if border
+            s = sub_style(s, pat: /^(\|)(.+)$/m, styles: border)
+            s = sub_style(s, pat: /^(.+)(\|)$/m, styles: border, index: 2)
+          end
+          s
         end
         out << bord
-        out << pr.(title) << bord if title
+        if title
+          out += title.map { |t| pr.(t) }
+          out << bord
+        end
         lines.each { |line| out << pr.(line) }
         out << bord
+        if footer
+          unless sub.empty? && !right
+            footer.map! do |s|
+              s = s.rjust(n + 4) if right
+              sub.each { |h| s = sub_style(s, **h) }
+              s
+            end
+          end
+          out += footer
+        end
         if block_given?
           yield out
-        elsif pipe.respond_to?(:puts)
+        elsif pipe
+          case pipe
+          when 0
+            pipe = $stdin
+          when 2
+            pipe = $stderr
+          else
+            pipe = $stdout unless pipe.respond_to?(:puts)
+          end
           pipe.puts out
         else
           err ? warn(out) : puts(out)
         end
       end
+
+      def strip_style(val)
+        val.gsub(/\x1B\[(\d+;?)+m/, '')
+      end
+
+      def raise_error(*args, hint: nil, kind: ArgumentError)
+        raise kind, message(*args, hint: hint, empty: true)
+      end
     end
   end
 end

data/lib/squared/common/prompt.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Squared
+  module Common
+    module Prompt
+      module_function
+
+      def confirm(msg, default = nil, agree: 'Y', cancel: 'N', attempts: 5, timeout: 15)
+        require 'readline'
+        require 'timeout'
+        agree = /^#{agree}$/i if agree.is_a?(::String)
+        cancel = /^#{cancel}$/i if cancel.is_a?(::String)
+        Timeout.timeout(timeout) do
+          begin
+            while (ch = Readline.readline(msg, true))
+              ch = ch.chomp
+              case (ch.empty? ? default : ch)
+              when agree
+                return true
+              when cancel
+                return false
+              end
+              attempts -= 1
+              exit 1 unless attempts >= 0
+            end
+          rescue Interrupt
+            puts
+            exit 0
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/squared/common/shell.rb

@@ -9,9 +9,10 @@ module Squared
       module_function
 
       def shell_escape(val, quote: false)
-        return Shellwords.escape(val) unless ::Rake::Win32.windows?
+        val = val.to_s
+        return ::Shellwords.escape(val) unless ::Rake::Win32.windows?
 
-        quote ? shell_quote(opt, force: false) : opt
+        quote ? shell_quote(val, force: false) : val
       end
 
       def shell_quote(val, force: true)
@@ -22,7 +23,7 @@ module Squared
       end
 
       def shell_split(val, quote: false, join: false)
-        ret = Shellwords.split(val).map do |opt|
+        ret = ::Shellwords.split(val).map do |opt|
           if (data = /^(--?[^= ]+)(=|\s+)?(["'])?(.+?)\3?$/m.match(opt))
             next opt unless data[2] && !data[3]
 

data/lib/squared/common/system.rb

@@ -8,67 +8,37 @@ module Squared
     module System
       module_function
 
-      def shell(*cmd, **kwargs)
+      def shell(*args, **kwargs)
         if RUBY_VERSION =~ /^2\.[0-5]\./
           exception = kwargs.delete(:exception)
-          ret = system(*cmd, **kwargs)
-          raise $?.to_s if !ret && exception
+          ret = system(*args, **kwargs)
+          return ret if ret || !exception
 
-          ret
+          raise $?.to_s
         else
-          system(*cmd, **kwargs)
-        end
-      end
-
-      def confirm(msg, default = nil, agree: 'Y', cancel: 'N', attempts: 5, timeout: 15)
-        require 'readline'
-        require 'timeout'
-        agree = /^#{agree}$/i if agree.is_a?(::String)
-        cancel = /^#{cancel}$/i if cancel.is_a?(::String)
-        Timeout.timeout(timeout) do
-          begin
-            while (ch = Readline.readline(msg, true))
-              ch = ch.chomp
-              ch = default if ch.empty?
-              case ch
-              when agree
-                return true
-              when cancel
-                return false
-              end
-              attempts -= 1
-              exit 1 unless attempts >= 0
-            end
-          rescue Interrupt
-            puts
-            exit 0
-          else
-            false
-          end
+          system(*args, **kwargs)
         end
       end
 
       def copy_d(src, dest, glob: ['**/*'], create: false, verbose: true)
-        src = Pathname.new(src)
-        dest = Pathname.new(dest)
+        src = ::Pathname.new(src)
+        dest = ::Pathname.new(dest)
         raise "#{dest} (not found)" if !create && !dest.exist?
 
         subdir = []
         files = 0
         dest.mkpath if create
-        glob = [glob] unless glob.is_a?(::Array)
-        glob.each do |val|
-          Dir.glob(src.join(val)) do |path|
-            ent = Pathname.new(path)
-            next if ent.directory?
+        (glob.is_a?(::Array) ? glob : [glob]).each do |val|
+          ::Dir.glob(src.join(val)) do |path|
+            next if (path = ::Pathname.new(path)).directory?
 
-            target = dest.join(ent.relative_path_from(src))
+            target = dest.join(path.relative_path_from(src))
             dir = target.dirname
             unless subdir.include?(dir.to_s)
               dir.mkpath
               subdir << dir.to_s
             end
-            copy_f ent, target
+            copy_f path, target
             files += 1
           end
         end
@@ -77,15 +47,13 @@ module Squared
 
       def copy_f(src, dest, overwrite: true, verbose: false)
         unless overwrite
-          path = Pathname.new(dest)
-          if path.directory?
-            src = [src] unless src.is_a?(::Array)
-            src = src.reject { |val| path.join(File.basename(val)).exist? }
+          if (path = ::Pathname.new(dest)).directory?
+            src = (src.is_a?(::Array) ? src : [src]).reject { |val| path.join(::File.basename(val)).exist? }
           elsif path.exist?
             return
           end
         end
-        FileUtils.cp(src, dest, verbose: verbose)
+        ::FileUtils.cp(src, dest, verbose: verbose)
       end
     end
   end