squared 0.0.5 → 0.0.6

data/lib/squared/workspace/application.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    class Application
+      include Common
+      include Format
+      include ::Rake::DSL
+
+      TASK_BASE = {
+        build: [],
+        refresh: [],
+        depend: [],
+        outdated: [],
+        doc: [],
+        test: [],
+        copy: [],
+        clean: []
+      }
+      TASK_EXTEND = {}
+      WORKSPACE_KEYS = TASK_BASE.keys.freeze
+      private_constant :TASK_BASE, :TASK_EXTEND
+
+      class << self
+        def implement(*objs)
+          objs.each do |obj|
+            next unless obj < Project::Base
+
+            project_kind.unshift(obj)
+            obj.tasks&.each do |val|
+              TASK_BASE[val] ||= []
+              (TASK_EXTEND[val] ||= []).push(obj)
+            end
+          end
+        end
+
+        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 }
+            return ret if ret
+          end
+          project_kind.find { |proj| proj.is_a?(path) } if path
+        end
+
+        def to_s
+          super.to_s.match(/[^:]+$/)[0]
+        end
+
+        attr_reader :project_kind
+      end
+
+      @project_kind = []
+
+      attr_reader :main, :root, :home, :series, :theme, :warning
+      attr_accessor :exception, :pipe, :verbose
+
+      def initialize(main, *, common: true, exception: false, pipe: false, verbose: nil, **)
+        @main = main.to_s
+        @home = Pathname.pwd
+        @root = @home.parent
+        @series = Series.new(TASK_BASE, self)
+        @project = {}
+        @extensions = []
+        @script = {
+          group: {},
+          ref: {},
+          build: nil,
+          dev: nil,
+          prod: nil
+        }
+        @theme = common && @verbose ? __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
+      end
+
+      def build(**kwargs)
+        return unless enabled?
+
+        @project.each_value do |proj|
+          next unless proj.enabled?
+
+          series.populate(proj)
+          proj.populate(**kwargs)
+        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']
+
+          task default: init[1] unless task_defined?('default')
+
+          if series.has?(init[0]) && !task_defined?('init')
+            desc 'init'
+            task init: init
+          end
+        end
+        series.finalize!(kwargs.fetch(:parallel, []))
+
+        yield self if block_given?
+      end
+
+      def run(script, group: nil, ref: nil)
+        script_command :run, script, group, ref
+      end
+
+      def depend(script, group: nil, ref: nil)
+        script_command :depend, script, group, ref
+      end
+
+      def clean(script, group: nil, ref: nil)
+        script_command :clean, script, group, ref
+      end
+
+      def doc(script, group: nil, ref: nil)
+        script_command :doc, script, group, ref
+      end
+
+      def test(script, group: nil, ref: nil)
+        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]
+        self
+      end
+
+      def group(name, path, **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]
+        end
+        .each do |basename, dir, override|
+          opts = kwargs.dup
+          opts.merge!(override) if override
+          add(basename, dir, group: name, **opts)
+        end
+        self
+      end
+
+      def compose(name, &blk)
+        namespace(name, &blk)
+        self
+      end
+
+      def apply(&blk)
+        instance_eval(&blk)
+        self
+      end
+
+      def style(name, *args, target: nil, empty: false)
+        data = nil
+        if target
+          as_a(target).each_with_index do |val, i|
+            if i == 0
+              break unless (data = __get__(:theme)[val.to_sym])
+            else
+              data = data[val.to_sym] ||= {}
+            end
+          end
+          return unless data
+        end
+        apply_style(data || theme, name, *args, empty: empty)
+        self
+      end
+
+      def script(group: nil, ref: nil)
+        if group || ref
+          (group && @script[:group][group.to_sym]) || (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
+        return ret == equals.to_s unless equals.nil?
+
+        ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
+      end
+
+      def root_path(*args)
+        root.join(*args)
+      end
+
+      def home_path(*args)
+        home.join(*args)
+      end
+
+      def find_base(obj)
+        Application.project_kind.find { |proj| obj.instance_of?(proj) }
+      end
+
+      def to_s
+        root.to_s
+      end
+
+      def inspect
+        "#<#{self.class}: #{main} => #{self}>"
+      end
+
+      def enabled?
+        !@extensions.empty? || @project.any? { |_, proj| proj.enabled? }
+      end
+
+      def task_base?(key, val)
+        return val if task_defined?(key)
+
+        val if key == :refresh && series[:build].include?(val = "#{val.split(':').first}:build")
+      end
+
+      def task_include?(obj, key)
+        TASK_EXTEND.fetch(key, []).any? { |item| obj.is_a?(item) }
+      end
+
+      def task_defined?(key)
+        ::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?))
+      end
+
+      def prod?(script: nil, pat: nil, global: false)
+        return false if global && (@script[:dev] == true || !@script[:prod])
+
+        with?(:prod, script: script, pat: pat, global: global)
+      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
+        end
+      end
+
+      private
+
+      def script_command(task, val, group, ref)
+        if group
+          label = :group
+          items = as_a(group)
+        else
+          label = :ref
+          items = as_a(ref)
+        end
+        items.each { |name| (@script[label][name.to_sym] ||= {})[task] = val }
+        self
+      end
+
+      def with?(state, script: nil, pat: nil, global: false)
+        if global
+          pat = @script[state] if pat.nil?
+          script ||= @script[:build]
+        end
+        pat.is_a?(::Regexp) ? pat.match?(script) : pat == true
+      end
+    end
+  end
+end

data/lib/squared/{repo → workspace}/project/base.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'date'
+require 'logger'
 
 module Squared
-  module Repo
+  module Workspace
     module Project
       class Base
         include Common
@@ -12,6 +13,8 @@ module Squared
         include Task
         include ::Rake::DSL
 
+        SEM_VER = /^(\d+)(\.)(\d+)(?:(\.)(\d+))?$/.freeze
+
         class << self
           include Common::Task
           include ::Rake::DSL
@@ -23,9 +26,12 @@ module Squared
           end
 
           def as_path(val)
-            return val if val.is_a?(::Pathname)
-
-            val.is_a?(::String) ? Pathname.new(val) : nil
+            case val
+            when ::Pathname
+              val
+            when ::String
+              Pathname.new(val)
+            end
           end
 
           def to_s
@@ -117,7 +123,7 @@ module Squared
         def populate(*)
           namespace name do
             workspace.series.each_key do |key|
-              next unless Workspace::TASK_KEYS.include?(key) ? has?(key) : workspace.task_defined?(self, key)
+              next unless Application::WORKSPACE_KEYS.include?(key) ? has?(key) : workspace.task_include?(self, key)
 
               desc message(name, key)
               task key do
@@ -127,7 +133,7 @@ module Squared
           end
         end
 
-        def build(*args)
+        def build(*args, sync: true)
           if args.empty?
             cmd, opts = @output
             opts &&= shell_escape(opts)
@@ -148,13 +154,13 @@ module Squared
             cmd = compose(opts)
             banner = env('REPO_BUILD') == 'verbose'
           end
-          run(cmd, exception: workspace.exception, banner: banner)
+          run(cmd, exception: workspace.exception, banner: banner, sync: sync)
         end
 
         def refresh(*)
-          build
+          build(sync: invoked_sync?('depend'))
           key = "#{name}:copy"
-          if ::Rake::Task.task_defined?(key)
+          if workspace.task_defined?(key)
             invoke key
           else
             copy
@@ -162,29 +168,30 @@ module Squared
         end
 
         def depend(*)
-          run(@depend, exception: workspace.exception) if @depend
+          run(@depend, exception: workspace.exception, sync: invoked_sync?('depend')) if @depend
         end
 
         def copy(*)
-          run_s @copy
+          run_s(@copy, sync: invoked_sync?('copy'))
         end
 
         def doc
-          build @doc if @doc
+          build(@doc, sync: invoked_sync?('doc')) if @doc
         end
 
         def test
-          build @test if @test
+          build(@test, sync: invoked_sync?('test')) if @test
         end
 
         def clean
           return unless @clean
 
           if @clean.is_a?(::String)
-            run_s @clean
+            run_s(@clean, sync: invoked_sync?('clean'))
           else
             @clean.each do |val|
-              if (val = val.to_s).match?(%r{[\\/]$})
+              val = val.to_s
+              if val =~ %r{[\\/]$}
                 dir = Pathname.new(val)
                 dir = base_path(dir) unless dir.absolute?
                 next unless dir.directory?
@@ -234,7 +241,7 @@ module Squared
         end
 
         def refresh?
-          build? && (copy? || ::Rake::Task.task_defined?("#{name}:copy"))
+          build? && (copy? || workspace.task_defined?("#{name}:copy"))
         end
 
         def depend?
@@ -259,12 +266,12 @@ module Squared
 
         protected
 
-        def run(cmd = @session, exception: false, banner: true, req: nil)
+        def run(cmd = @session, exception: false, 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)
+          print_item format_banner(cmd, banner: banner) if sync
           begin
             shell(cmd, chdir: path, exception: exception)
           rescue StandardError => e
@@ -273,22 +280,22 @@ module Squared
           end
         end
 
-        def run_s(cmd)
-          run(cmd, exception: workspace.exception, banner: verbose?) if cmd.is_a?(::String)
+        def run_s(cmd, **kwargs)
+          run(cmd, exception: workspace.exception, banner: verbose?, **kwargs) if cmd.is_a?(::String)
         end
 
-        def env(key, suffix: nil, equals: nil, strict: false)
-          alt = "#{key}_#{name.upcase}"
-          ret = if suffix
-                  ENV.fetch(([alt] + as_a(suffix)).join('_'), '')
-                else
-                  ENV.fetch(alt, strict ? '' : ENV[key]).to_s
-                end
-          if !equals.nil?
-            ret == equals.to_s
-          elsif !ret.empty? && ret != '0'
-            ret
+        def env(key, equals: nil, ignore: ['0'].freeze, default: nil, suffix: nil, strict: false)
+          a = "#{key}_#{name.upcase}"
+          b = ''
+          if suffix
+            a = [a, suffix].flatten.join('_')
+          elsif !strict
+            b = ENV.fetch(key, '')
           end
+          ret = ENV.fetch(a, b)
+          return ret == equals.to_s unless equals.nil?
+
+          ret.empty? || as_a(ignore).any? { |val| ret == val.to_s } ? default : ret
         end
 
         def session(*cmd, options: nil)
@@ -300,8 +307,8 @@ module Squared
 
         def close_session(cmd)
           return cmd unless cmd.respond_to?(:done)
-          raise ArgumentError, message('none were provided', hint: name) if cmd.empty?
 
+          raise_error('none were provided', hint: name) if cmd.empty?
           @session = nil if cmd == @session
           cmd.done
         end
@@ -362,7 +369,7 @@ module Squared
 
           if verbose?
             print_banner(cmd.sub(/^\S+/, &:upcase), path.to_s)
-          elsif multiple && workspace.multiple?
+          elsif multiple && workspace.series.multiple?
             "## #{path} ##"
           end
         end
@@ -380,17 +387,17 @@ module Squared
             return unless (val = args[key]).nil? || (pat && !val.match?(pat))
 
             @session = nil
-            raise ArgumentError, message(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
+            raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
           elsif args.is_a?(::Array)
             return unless args.empty?
 
             @session = nil
-            raise ArgumentError, message(action, "#{flag}[]", hint: 'empty')
+            raise_error(action, "#{flag}[]", hint: 'empty')
           end
           return unless action.to_s.empty?
 
           @session = nil
-          raise ArgumentError, message('parameter', flag, hint: 'missing')
+          raise_error('parameter', flag, hint: 'missing')
         end
 
         def verbose?
@@ -402,13 +409,12 @@ module Squared
         end
 
         def invoked_sync?(action)
-          return true if workspace.sync?("#{action}:sync")
+          return true if workspace.series.sync?("#{action}:sync")
 
-          missing = ->(val) { ::Rake::Task.tasks.none? { |item| item.name == val } }
           check = lambda do |val|
             if invoked?(val)
-              missing.("#{val}:sync")
-            elsif workspace.sync?("#{val}:sync")
+              !workspace.task_defined?("#{val}:sync")
+            elsif workspace.series.sync?("#{val}:sync")
               true
             end
           end
@@ -420,7 +426,7 @@ module Squared
             ret = check.("#{action}:#{base.to_sym}")
             return ret unless ret.nil?
           end
-          invoked?("#{name}:#{action}") && (!invoked?(action) || missing.("#{action}:sync"))
+          invoked?("#{name}:#{action}") && (!invoked?(action) || !workspace.task_defined?("#{action}:sync"))
         end
 
         private