squared 0.0.6 → 0.0.7

data/lib/squared/workspace/application.rb

@@ -36,7 +36,7 @@ module Squared
 
         def find(path: nil, ref: nil)
           if ref.is_a?(::Symbol) || ref.is_a?(::String)
-            ret = project_kind.find { |proj| proj.to_sym == ref.to_sym }
+            ret = project_kind.find { |proj| proj.ref == ref.to_sym }
             return ret if ret
           end
           project_kind.find { |proj| proj.is_a?(path) } if path
@@ -51,14 +51,14 @@ module Squared
 
       @project_kind = []
 
-      attr_reader :main, :root, :home, :series, :theme, :warning
-      attr_accessor :exception, :pipe, :verbose
+      attr_reader :main, :root, :home, :series, :theme
+      attr_accessor :exception, :warning, :pipe, :verbose
 
-      def initialize(main, *, common: true, exception: false, pipe: false, verbose: nil, **)
+      def initialize(main, *, exception: false, pipe: false, verbose: nil, **kwargs)
         @main = main.to_s
         @home = Pathname.pwd
         @root = @home.parent
-        @series = Series.new(TASK_BASE, self)
+        @series = Series.new(TASK_BASE)
         @project = {}
         @extensions = []
         @script = {
@@ -68,11 +68,12 @@ module Squared
           dev: nil,
           prod: nil
         }
-        @theme = common && @verbose ? __get__(:theme)[:workspace] : {}
+        @theme = kwargs.key?(:common) && !kwargs[:common] ? {} : __get__(:theme)[:workspace]
         @exception = exception.is_a?(String) ? !env(exception, ignore: '0').nil? : exception
         @pipe = pipe.is_a?(String) ? !env(pipe, ignore: '0').nil? : pipe
         @verbose = verbose.nil? ? !@pipe : verbose
-        @warning = true
+        @warning = @verbose
+        __set__(:no_color, true) if @pipe
       end
 
       def build(**kwargs)
@@ -81,82 +82,84 @@ module Squared
         @project.each_value do |proj|
           next unless proj.enabled?
 
-          series.populate(proj)
           proj.populate(**kwargs)
+          series.populate(proj)
         end
 
         Application.project_kind.each { |obj| obj.populate(self, **kwargs) }
         @extensions.each { |ext| __send__(ext, **kwargs) }
 
-        series[:refresh].clear if series[:refresh].all? { |val| val.end_with?(':build') }
-
-        task default: kwargs[:default] if series.has?(kwargs[:default]) && !task_defined?('default')
-
-        if series.has?('build')
-          init = ['depend', dev? && series.has?('refresh') ? 'refresh' : 'build']
+        __build__(**kwargs)
+        series.build(**kwargs)
 
-          task default: init[1] unless task_defined?('default')
+        yield self if block_given?
+      end
 
-          if series.has?(init[0]) && !task_defined?('init')
-            desc 'init'
-            task init: init
-          end
+      def with(group: nil, ref: nil)
+        @group = nil
+        @ref = nil
+        if group
+          @group = group
+        elsif ref
+          @ref = ref
         end
-        series.finalize!(kwargs.fetch(:parallel, []))
-
-        yield self if block_given?
+        self
       end
 
-      def run(script, group: nil, ref: nil)
+      def run(script, group: @group, ref: @ref)
         script_command :run, script, group, ref
       end
 
-      def depend(script, group: nil, ref: nil)
+      def depend(script, group: @group, ref: @ref)
         script_command :depend, script, group, ref
       end
 
-      def clean(script, group: nil, ref: nil)
+      def clean(script, group: @group, ref: @ref)
         script_command :clean, script, group, ref
       end
 
-      def doc(script, group: nil, ref: nil)
+      def doc(script, group: @group, ref: @ref)
         script_command :doc, script, group, ref
       end
 
-      def test(script, group: nil, ref: nil)
+      def test(script, group: @group, ref: @ref)
         script_command :test, script, group, ref
       end
 
-      def add(name, path = nil, ref: nil, **kwargs)
-        path = root_path((path || name).to_s)
-        project = if !ref.is_a?(::Class)
-                    Application.find(path: path, ref: ref)
-                  elsif ref < Project::Base
-                    ref
-                  end
-        instance = (project || Project::Base).new(name, path, self, **kwargs)
-        @project[n = name.to_sym] = instance
-        __get__(:project)[n] = instance unless kwargs[:private]
+      def add(name, path = nil, **kwargs)
+        ref = if kwargs.key?(:ref)
+                kwargs.delete(:ref)
+              elsif !@ref.is_a?(::Array)
+                @ref
+              end
+        kwargs[:group] = @group if !kwargs.key?(:group) && !@group.is_a?(::Array)
+        path = root_path(path || name.to_s)
+        proj = ((if !ref.is_a?(::Class)
+                   Application.find(path: path, ref: ref)
+                 elsif ref < Project::Base
+                   ref
+                 end) || Project::Base).new(name, path, self, **kwargs)
+        @project[name = name.to_sym] = proj
+        __get__(:project)[name] = proj unless kwargs[:private]
         self
       end
 
-      def group(name, path, **kwargs)
+      def group(name, path, override: {}, **kwargs)
         root_path(path).children.map do |ent|
           next unless (dir = Pathname.new(ent)).directory?
 
           index = 0
           basename = dir.basename.to_s.to_sym
-          override = kwargs.delete(basename)
           while @project[basename]
             index += 1
             basename = :"#{basename}-#{index}"
           end
-          [basename, dir, override]
+          [basename, dir, override[basename]]
         end
-        .each do |basename, dir, override|
-          opts = kwargs.dup
-          opts.merge!(override) if override
-          add(basename, dir, group: name, **opts)
+        .each do |basename, dir, opts|
+          args = kwargs.dup
+          args.merge!(opts) if opts
+          add(basename, dir, group: name, **args)
         end
         self
       end
@@ -188,15 +191,17 @@ module Squared
       end
 
       def script(group: nil, ref: nil)
-        if group || ref
-          (group && @script[:group][group.to_sym]) || (ref && @script[:ref][ref.to_sym])
+        if group
+          @script[:group][group.to_sym]
+        elsif ref
+          @script[:ref][ref.to_sym]
         else
           @script[:build]
         end
       end
 
-      def env(key, equals: nil, ignore: nil, default: nil)
-        ret = ENV.fetch("#{key}_#{main.gsub(/[^\w]/, '_').upcase}", ENV[key]).to_s
+      def env(key, default = nil, equals: nil, ignore: nil)
+        ret = ENV.fetch("#{key}_#{main.gsub(/[^\w]+/, '_').upcase}", ENV[key]).to_s
         return ret == equals.to_s unless equals.nil?
 
         ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
@@ -240,47 +245,36 @@ module Squared
         ::Rake::Task.task_defined?(key)
       end
 
-      def dev?(script: nil, pat: nil, global: nil)
-        with?(:dev, script: script, pat: pat, global: global || (pat.nil? && global.nil?))
+      def dev?(global: nil, **kwargs)
+        script?(:dev, global: global.nil? ? kwargs[:pat].nil? : global, **kwargs)
       end
 
-      def prod?(script: nil, pat: nil, global: false)
+      def prod?(global: false, **kwargs)
         return false if global && (@script[:dev] == true || !@script[:prod])
 
-        with?(:prod, script: script, pat: pat, global: global)
+        script?(:prod, global: global, **kwargs)
       end
 
-      protected
-
-      def confirm(msg, agree: 'Y', cancel: 'N', default: nil, 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
+      private
+
+      def __build__(**kwargs)
+        if !task_defined?('default') && (default = kwargs[:default]) && !series.has?(default)
+          task default: default
         end
-      end
+        return unless series.has?('build')
 
-      private
+        if (refresh = series[:refresh]).all? { |val| val.end_with?(':build') }
+          refresh.clear
+        end
+        init = ['depend', dev? && series.has?('refresh') ? 'refresh' : 'build']
+
+        task default: init[1] unless task_defined?('default')
+
+        return if task_defined?('init') || !series.has?(init[0])
+
+        desc 'init'
+        task init: init
+      end
 
       def script_command(task, val, group, ref)
         if group
@@ -294,8 +288,10 @@ module Squared
         self
       end
 
-      def with?(state, script: nil, pat: nil, global: false)
-        if global
+      def script?(state, script: nil, pat: nil, ref: nil, group: nil, global: false)
+        gr = @script[:ref][:_]
+        gg = @script[:group][:_]
+        if global && ((!ref && !group) || (!gr && !gg) || (ref && ref == gr) || (group && group == gg))
           pat = @script[state] if pat.nil?
           script ||= @script[:build]
         end

data/lib/squared/workspace/project/base.rb

@@ -13,12 +13,9 @@ module Squared
         include Task
         include ::Rake::DSL
 
-        SEM_VER = /^(\d+)(\.)(\d+)(?:(\.)(\d+))?$/.freeze
+        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?/.freeze
 
         class << self
-          include Common::Task
-          include ::Rake::DSL
-
           def populate(*); end
 
           def tasks
@@ -34,24 +31,24 @@ module Squared
             end
           end
 
-          def to_s
-            super.to_s.match(/[^:]+$/)[0]
+          def ref
+            @ref ||= to_s.downcase.to_sym
           end
 
-          def to_sym
-            to_s.downcase.to_sym
+          def to_s
+            super.to_s.match(/[^:]+$/)[0]
           end
         end
 
         @@print_order = 0
         @@tasks = {}
 
-        attr_reader :name, :project, :workspace, :group, :path, :log, :theme
+        attr_reader :name, :project, :workspace, :group, :path, :theme
         attr_accessor :warning
 
-        def initialize(name, path, workspace, *, group: nil, log: nil, common: true, **kwargs)
+        def initialize(name, path, workspace, *, group: nil, **kwargs)
           @name = name.to_s
-          @path = workspace.root_path(path.to_s)
+          @path = path
           @project = @path.basename.to_s
           @workspace = workspace
           @group = group&.to_s
@@ -61,40 +58,50 @@ module Squared
           @output = [kwargs[:run], nil]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
+          @exclude = as_a(kwargs[:exclude])
           @warning = workspace.warning
           @theme = if !workspace.verbose
                      {}
-                   elsif common
+                   elsif kwargs.fetch(:common, true)
                      workspace.theme
                    else
                      __get__(:theme)[:project][to_sym] ||= {}
                    end
-          log = { file: log } unless log.is_a?(::Hash)
-          if (logfile = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
-            logfile = case auto
-                      when 'y', 'year'
-                        "#{@name}-#{Date.today.year}.log"
-                      when 'm', 'month'
-                        "#{@name}-#{Date.today.strftime('%Y-%m')}.log"
-                      when 'd', 'day', '1'
-                        "#{@name}-#{Date.today}.log"
-                      end
+          initialize_logger(**kwargs)
+        end
+
+        def initialize_logger(log: nil, **)
+          log = log.is_a?(::Hash) ? log.dup : { file: log }
+          if (file = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
+            file = case auto
+                   when 'y', 'year'
+                     "#{@name}-#{Date.today.year}.log"
+                   when 'm', 'month'
+                     "#{@name}-#{Date.today.strftime('%Y-%m')}.log"
+                   when 'd', 'day', '1'
+                     "#{@name}-#{Date.today}.log"
+                   end
           end
-          if logfile ||= log[:file]
-            logfile = Date.today.strftime(logfile)
-            logfile = (dir = env('LOG_DIR')) ? Pathname.new(dir).join(logfile) : Pathname.new(logfile)
+          if file ||= log[:file]
+            file = Date.today.strftime(file)
+            file = (dir = env('LOG_DIR')) ? Pathname.new(dir).join(file) : Pathname.new(file)
             begin
-              logfile.realdirpath
+              file = file.realdirpath
             rescue StandardError => e
-              logfile = nil
+              raise if @workspace.exception
+
+              file = nil
               warn e if @warning
             end
           end
-          @log = Logger.new(logfile, progname: @name, level: env('LOG_LEVEL') || log[:level] || Logger::INFO)
+          log[:progname] = @name
+          log[:level] = env('LOG_LEVEL', log[:level] || Logger::INFO, ignore: nil)
+          log.delete(:file)
+          @log = [file, log]
         end
 
         def initialize_build(ref, **kwargs)
-          initialize_script(ref)
+          initialize_script(ref, **kwargs)
           if (val = env('BUILD', strict: true))
             @output[0] = val
           elsif @script && @output[0] != false
@@ -106,11 +113,11 @@ module Squared
           elsif env('BUILD', suffix: 'DEV')
             @dev = true
           elsif @dev.nil?
-            @dev = workspace.dev?
+            @dev = !group.nil? && workspace.dev?(group: group, global: true)
           end
         end
 
-        def initialize_script(ref)
+        def initialize_script(ref, **)
           return unless (script = workspace.script(group: group, ref: ref))
 
           @depend = script[:depend] if @depend.nil?
@@ -121,6 +128,8 @@ module Squared
         end
 
         def populate(*)
+          return if @exclude.include?(Base.ref)
+
           namespace name do
             workspace.series.each_key do |key|
               next unless Application::WORKSPACE_KEYS.include?(key) ? has?(key) : workspace.task_include?(self, key)
@@ -154,7 +163,7 @@ module Squared
             cmd = compose(opts)
             banner = env('REPO_BUILD') == 'verbose'
           end
-          run(cmd, exception: workspace.exception, banner: banner, sync: sync)
+          run(cmd, banner: banner, sync: sync)
         end
 
         def refresh(*)
@@ -168,11 +177,11 @@ module Squared
         end
 
         def depend(*)
-          run(@depend, exception: workspace.exception, sync: invoked_sync?('depend')) if @depend
+          run(@depend, sync: invoked_sync?('depend')) if @depend
         end
 
         def copy(*)
-          run_s(@copy, sync: invoked_sync?('copy'))
+          run_s(@copy, sync: invoked_sync?('copy')) if @copy
         end
 
         def doc
@@ -212,6 +221,12 @@ module Squared
           end
         end
 
+        def log
+          return @log unless @log.is_a?(::Array)
+
+          @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
+        end
+
         def base_path(*args)
           path.join(*args)
         end
@@ -245,7 +260,7 @@ module Squared
         end
 
         def depend?
-          !!@depend
+          @depend != false && (!@depend.nil? || has?('outdated'))
         end
 
         def doc?
@@ -264,16 +279,25 @@ module Squared
           !!@clean
         end
 
+        def dev?
+          !!@dev
+        end
+
         protected
 
-        def run(cmd = @session, exception: false, banner: true, sync: true, req: nil)
+        def run(cmd = @session, exception: workspace.exception, banner: true, sync: true, req: nil, **)
           return if req && !base_path(req).exist?
 
           cmd = close_session(cmd)
           log.info cmd
-          print_item format_banner(cmd, banner: banner) if sync
           begin
-            shell(cmd, chdir: path, exception: exception)
+            if cmd =~ /^\S+:(\S+:?)+$/ && workspace.task_defined?(cmd)
+              print_item if sync
+              invoke(cmd, exception: exception)
+            else
+              print_item format_banner(cmd, banner: banner) if sync
+              shell(cmd, chdir: path, exception: exception)
+            end
           rescue StandardError => e
             log.error e
             raise
@@ -281,11 +305,11 @@ module Squared
         end
 
         def run_s(cmd, **kwargs)
-          run(cmd, exception: workspace.exception, banner: verbose?, **kwargs) if cmd.is_a?(::String)
+          run(cmd, banner: verbose?, **kwargs) if cmd.is_a?(::String)
         end
 
-        def env(key, equals: nil, ignore: ['0'].freeze, default: nil, suffix: nil, strict: false)
-          a = "#{key}_#{name.upcase}"
+        def env(key, default = nil, equals: nil, ignore: ['0'].freeze, suffix: nil, strict: false)
+          a = "#{key}_#{name.gsub(/[^\w]+/, '_').upcase}"
           b = ''
           if suffix
             a = [a, suffix].flatten.join('_')
@@ -328,7 +352,7 @@ module Squared
               styles = [:bold] + styles
             end
           end
-          n = max_width(lines)
+          n = Project.max_width(lines)
           ch = ' ' * pad
           index = -1
           out = lines.map do |val|
@@ -344,15 +368,17 @@ module Squared
           out.join("\n")
         end
 
-        def print_footer(*lines, sub: nil, border: theme[:border])
-          n = max_width(lines)
+        def print_footer(*lines, sub: nil, border: theme[:border], reverse: false)
+          n = Project.max_width(lines)
           sub = as_a(sub)
           lines.map! do |val|
             s = val.ljust(n)
             sub.each { |h| s = sub_style(s, **h) }
             s
           end
-          [sub_style('-' * n, styles: border), *lines].join("\n")
+          ret = [sub_style('-' * n, styles: border), *lines]
+          ret.reverse! if reverse
+          ret.join("\n")
         end
 
         def format_desc(action, flag, opts = nil, req: 'opts*')
@@ -374,8 +400,8 @@ module Squared
           end
         end
 
-        def empty_status(msg, title, obj)
-          "#{msg}#{!obj || obj == 0 || obj.to_s.empty? ? '' : message(hint: message(title, obj.to_s))}"
+        def empty_status(msg, title, obj, always: false)
+          "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
         end
 
         def append_nocolor
@@ -394,10 +420,33 @@ module Squared
             @session = nil
             raise_error(action, "#{flag}[]", hint: 'empty')
           end
-          return unless action.to_s.empty?
+        end
 
-          @session = nil
-          raise_error('parameter', flag, hint: 'missing')
+        def store_pwd(done = nil)
+          if @pwd
+            Dir.chdir(@pwd)
+            @pwd = nil
+          elsif !done && Dir.pwd != path.to_s
+            @pwd = Dir.pwd
+            Dir.chdir(path)
+            @pwd
+          end
+        end
+
+        def semver(val)
+          unless val[3]
+            val[3] = '.'
+            val[4] = '0'
+          end
+          unless val[1]
+            val[1] = '.'
+            val[2] = '0'
+          end
+          val
+        end
+
+        def semmajor(cur, want)
+          cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]
         end
 
         def verbose?
@@ -423,17 +472,11 @@ module Squared
             return ret unless ret.nil?
           end
           if (base = workspace.find_base(self))
-            ret = check.("#{action}:#{base.to_sym}")
+            ret = check.("#{action}:#{base.ref}")
             return ret unless ret.nil?
           end
           invoked?("#{name}:#{action}") && (!invoked?(action) || !workspace.task_defined?("#{action}:sync"))
         end
-
-        private
-
-        def max_width(lines)
-          [lines.max_by(&:size).size, Project.line_width].max
-        end
       end
     end
   end