eco-rake 0.1.1

data/lib/eco-rake/lib/task.rb

@@ -0,0 +1,10 @@
+require_relative 'task/runner_options'
+require_relative 'task/runner_rely'
+require_relative 'task/runner_launch'
+
+class EcoRake
+  module Lib
+    module Task
+    end
+  end
+end

data/lib/eco-rake/lib.rb

@@ -0,0 +1,15 @@
+require_relative 'lib/base_task'
+require_relative 'lib/notify'
+require_relative 'lib/files'
+require_relative 'lib/people'
+require_relative 'lib/export'
+require_relative 'lib/task'
+
+class EcoRake
+  module Lib
+    # points to the library of option sets
+    def options_library
+      EcoRake::Options::Library
+    end
+  end
+end

data/lib/eco-rake/option/default_lookup.rb

@@ -0,0 +1,39 @@
+class EcoRake
+  class Option
+    # To prevent dependencies, it should resolve via parent, where parent
+    # doesn't get new methods installed on the fly, but where the parent
+    # does have the final result (method or const)
+    module DefaultLookup
+      class << self
+        def included(base)
+          super(base)
+          base.extend EcoRake::Base::SymbolResolver
+        end
+      end
+
+      # Default may be a lookup
+      def default(&block)
+        return @default unless default_lookup?
+        result = self.class.safe_call(@default, parent, &block)
+        result = self.class.safe_call(result, &block) if [Proc, Method].any? {|k| result.is_a?(k)}
+        result
+      end
+
+      # @todo link to default resolver, but indirectly
+      # @return [Class, NilClass]
+      def type_coercion
+        return @type_coercion if @type_coercion
+        return nil            unless default?
+        value = default
+        return nil if value.nil?
+        value.class
+      end
+
+      protected
+
+      def default_lookup?
+        @default.is_a?(Proc) || @default.is_a?(Method)
+      end
+    end
+  end
+end

data/lib/eco-rake/option/mirror.rb

@@ -0,0 +1,34 @@
+class EcoRake
+  class Option
+    module Mirror
+      # It allows to redirect options
+      # @param value [String, Symbol] the value to use.
+      # @return [String] command option with value
+      def mirror(value = :not_used, raise: false)
+        opt = name_hyphened
+        return boolean_mirror(value) unless argument?
+
+        missing = (value == :not_used) && !default?
+        msg     = "required argument value #{argument} for option #{name} (#{short})"
+        raise ArgumentError, msg if missing && argument_required? && raise
+        return nil               if missing && argument_required?
+
+        value = value == :not_used ? default : value
+        "#{opt} \"#{value}\""
+      end
+
+      private
+
+      # Implements the mirror of Boolean options/switches.
+      def boolean_mirror(value = :not_used)
+        opt = name_hyphened
+        puts "boolean_mirror (#{value}): #{opt}" if name == :no_get
+
+        return nil unless [TrueClass, NilClass, FalseClass].any? {|klass| type_coercion == klass}
+        enabled_value = !boolean_name? || [TrueClass, NilClass].any? {|klass| type_coercion == klass}
+        return opt              if value == enabled_value
+        return name_false_hypen if boolean_name? && value == !enabled_value
+      end
+    end
+  end
+end

data/lib/eco-rake/option/parented.rb

@@ -0,0 +1,12 @@
+class EcoRake
+  class Option
+    module Parented
+      attr_accessor :parent
+
+      def initialize(*args, _parent: nil, **kargs, &block)
+        self.parent = _parent
+        super(*args, **kargs, &block)
+      end
+    end
+  end
+end

data/lib/eco-rake/option.rb

@@ -0,0 +1,19 @@
+class EcoRake
+  class Option < RakeCommander::Option
+    require_relative 'option/parented'
+    require_relative 'option/default_lookup'
+    require_relative 'option/mirror'
+
+    include EcoRake::Option::Parented
+    include EcoRake::Option::DefaultLookup
+    include EcoRake::Option::Mirror
+
+    def name_hyphened
+      self.class.name_hyphen(name)
+    end
+
+    def name_false_hyphened
+      self.class.name_hyphen("no-#{name}")
+    end
+  end
+end

data/lib/eco-rake/options/default_lookup.rb

@@ -0,0 +1,29 @@
+class EcoRake
+  module Options
+    module DefaultLookup
+      class << self
+        def included(base)
+          super(base)
+          base.extend EcoRake::Base::MethodHelpers
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        # @note it extends `RakeCommander::Options`
+        #   1. default can be re-configured via callback or constant
+        # [ @see RakeCommander::Options::option ]
+        def option(*args, default_lookup: :not_used, **kargs, &block)
+          kargs.merge!(default: symbol_resolver(default_lookup, as: %i[method const])) unless default_lookup == :not_used
+          super(*args, **kargs, &block)
+        end
+
+        # [ @see RakeCommander::Options::option_reopen ]
+        def option_reopen(*args, default_lookup: :not_used, **kargs, &block)
+          kargs.merge!(default: symbol_resolver(default_lookup, as: %i[method const])) unless default_lookup == :not_used
+          super(*args, **kargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/options/forwarding/proxy.rb

@@ -0,0 +1,125 @@
+class EcoRake
+  module Options
+    module Forwarding
+      # Collection of forwarding rules.
+      # @note rules keep associated with the option `name` (not their `short`)
+      #   * The above means that changing the name of an exisint option will brake the link with
+      #     a forwarding rule (as they do not auto-update on option name change)
+      class Proxy
+        include Enumerable
+
+        attr_reader :parent
+
+        # @param parent [RakeCommander::Options::Class]
+        def initialize(parent)
+          pklass = parent.is_a?(Class)? parent : parent.class
+          msg    = "Expecting parent to be RakeCommander::Options::Class. Given: #{pklass}"
+          raise ArgumentError, msg unless parent.is_a?(Class) && parent <= RakeCommander::Options
+          @parent = parent
+          @rules  = {}
+        end
+
+        def each(&block)
+          return to_enum(:each) unless block_given?
+          @rules.values.each(&block)
+        end
+
+        # @return [EcoRake::Options::Forwarding::Proxy] with a copy of the rules.
+        def dup(parent, override: true, require_option: false)
+          self.class.new(parent).tap do |rely|
+            each {|rule| rely.add_rule(rule.deep_dup, override: override, require_option: require_option)}
+          end
+        end
+        alias_method :deep_dup, :dup
+
+        # @return [EcoRake::Options::Forwarding::Rule]
+        def [](value)
+          @rules[key(value)]
+        end
+
+        # Adds a new rule or overrides an existing one.
+        # @see #add_rule
+        def add(sym, rule, override: true, require_option: true)
+          add_rule(
+            EcoRake::Options::Forwarding::Rule.new(key(sym) || sym, rule, parent: self),
+            override:       override,
+            require_option: require_option
+          )
+        end
+
+        # @param ref [Symbol, EcoRake::Options::Forwarding::Rule, EcoRake::Option]
+        # @return [EcoRake::Options::Forwarding::Rule] the rule that has been deleted.
+        def delete(ref)
+          @rules.delete(key(ref))
+        end
+
+        # It applies the rule associated with `sym` to `from` parsed option results.
+        # @param sym [Symbol] the `short` or `name` of an existing option.
+        # @param from [Hash] the parsed option results.
+        # @return [Value] the value that the rule returns.
+        def forward(sym, from:)
+          self[sym]&.apply(from)
+        end
+
+        protected
+
+        # @note
+        #   1. It fixes the `rule.sym` to the option `name`, if option exists.
+        #   2. By default, it does not require the target option to exist.
+        #   3. If `override`, it will warn on overriding, but if `false` it will just silently fail
+        # @raise ArgumentError if there isn't an option in `parent` with and `require_option` is `true`
+        # @raise ArgumentError if there `sym` has already a rule and `override` is `false`
+        # @param sym [Symbol] the `short` or `name` of an existing option.
+        # @param rule [String, Proc] the rule associated wtih `sym`.
+        # @param override [Boolean] whether overriding existing rule is allowed.
+        # @param require_option [Boolean] whether an option with `sym` as short or name must exist.
+        # @param warning [Boolean] whether an override should warn.
+        # @return [Boolean, EcoRake::Options::Forwarding::Rule] the added rule if succeeded, and `false` otherwise.
+        def add_rule(rule, override: true, require_option: false, warning: false)
+          msg = "Expecting EcoRake::Options::Forwarding::Rule. Given: #{rule.class}"
+          raise ArgumentError, msg unless rule.is_a?(EcoRake::Options::Forwarding::Rule)
+
+          msg = "Could not find any defined option associated with '#{rule.sym}'"
+          raise ArgumentError, msg unless (opt = option(rule.sym)) || !require_option
+
+          rule.sym = opt&.name
+          if existing_rule = self[rule.sym]
+            return false unless override
+            puts "Warning: Overriding forwarding '#{existing_rule.desc}'" if warning
+          end
+
+          rule.parent      = self
+          @rules[rule.sym] = rule
+        end
+
+        # Retrieves the rule key
+        #   1. The option name of an existing option
+        #   2. The sym of an existing rule
+        # @return [Symbol]
+        def key(value)
+          case value
+          when RakeCommander::Option
+            value.name
+          when Symbol
+            if opt = option(value)
+              key(opt)
+            elsif @rules.key?(value)
+              value
+            end
+          when String
+            key(value.to_sym)
+          when EcoRake::Options::Forwarding::Rule
+            key(value.sym)
+          end
+        end
+
+        private
+
+        # Retrieves the option associated to a symbol
+        def option(sym)
+          parent.option_get(sym.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/options/forwarding/rule.rb

@@ -0,0 +1,82 @@
+class EcoRake
+  module Options
+    module Forwarding
+      class Rule
+        extend EcoRake::Base::MethodHelpers
+
+        RULE_TYPES   = [String, Symbol, Proc].freeze
+        SYMBOL_TYPES = [:mirror].freeze
+
+        attr_accessor :parent, :sym
+        attr_reader :rule
+
+        # @param rule [String, Proc]
+        #   - `Proc` -> [value, ]
+        def initialize(sym, rule, parent: nil)
+          msg = "Rule should be either of: #{RULE_TYPES.join(', ')}. Given: #{rule.class}"
+          raise ArgumentError, msg unless RULE_TYPES.any? {|type| rule.is_a?(type)}
+          msg = "Accepted Symbol rules are: :#{SYMBOL_TYPES.join(', :')}. Given :#{rule}"
+          raise ArgumentError, msg if rule.is_a?(Symbol) && SYMBOL_TYPES.none? {|type| rule == type}
+          @parent = parent
+          @sym    = sym
+          @rule   = rule
+        end
+
+        def active?(option_results)
+          opt = option
+          [opt&.name, opt&.short, sym].compact.any? {|k| option_results.key?(k)}
+        end
+
+        def results_value(option_results)
+          opt = option
+          value = nil
+          value = option_results[opt.name]  if opt && value.nil?
+          value = option_results[opt.short] if opt && value.nil?
+          value = option_results[sym]       if value.nil?
+          value
+        end
+
+        # @note
+        #   1. Retrives value from parsed options results by using the option name, short or sym.
+        #   2. It then applies the rule on it.
+        # @param option_results [Hash] the parsed option results.
+        # @return [NilClass, Value] the value that the rule returns, `nil` if rule inactive/not-applicable.
+        def apply(option_results)
+          return nil unless active?(option_results)
+          opt = option
+          return nil unless opt || rule != :mirror
+
+          value = results_value(option_results)
+          return rule                       if value && rule.is_a?(String)
+          return nil                        if rule.is_a?(String)
+          return opt.mirror(value)          if rule == :mirror
+
+          self.class.safe_call(rule, value, option_results, opt)
+        end
+
+        # Does a copy of this rule.
+        # @return [EcoRake::Options::Forwarding::Rule]
+        def dup(parent: nil)
+          new_rule = rule.respond_to?(:deep_dup)? rule.deep_dup : rule.dup
+          self.class.new(sym, new_rule, parent: parent)
+        end
+        alias_method :deep_dup, :dup
+
+        def desc
+          ref = (opt_ref = option_ref) ? opt_ref : "on #{sym} (no associated option)"
+          "rule #{ref}"
+        end
+
+        # Reference of the associated option.
+        def option_ref
+          (opt = option) ? "on option '#{opt.name}' (#{opt.short})" : nil
+        end
+
+        # @return [EcoRake::Option] the option associated with `sym` name.
+        def option
+          parent&.send(:option, sym)
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/options/forwarding.rb

@@ -0,0 +1,45 @@
+require_relative 'forwarding/rule'
+require_relative 'forwarding/proxy'
+
+class EcoRake
+  module Options
+    # Offers a way to relaunch command options from options results.
+    module Forwarding
+      class << self
+        def included(base)
+          super(base)
+          base.extend ClassMethods
+          base.attr_inheritable(:options_proxy) {|value, subclass| value&.deep_dup(subclass)}
+        end
+      end
+
+      module ClassMethods
+        # Service class to forward options.
+        def options_proxy
+          @options_proxy ||= EcoRake::Options::Forwarding::Proxy.new(self)
+        end
+
+        # Declare the forwarding rules for options.
+        # @param rules [Hash] where keys are option names or shorts and values the rules.
+        def option_forwarding(**rules)
+          rules.each do |sym, rule|
+            options_proxy.add(sym, rule, override: true)
+          end
+        end
+      end
+
+      # @param sym [Symbol] a short or name of an option that may be present in `from`
+      # @param from [Hash] the parsed option results.
+      # @return [Value] the value defined by the `rule` linked to `opt`
+      def forward_option(sym, from: options)
+        self.class.options_proxy.forward(sym, from: from)
+      end
+
+      # @see `#forward_option` (the same but for multiple options)
+      # @return [Array<Value>] the values defined by the `rules` linked to `opts`
+      def forward_options(*syms, from: options)
+        syms.map {|sym| forward_option(sym, from: from)}
+      end
+    end
+  end
+end

data/lib/eco-rake/options/library.rb

@@ -0,0 +1,81 @@
+class EcoRake
+  module Options
+    # Gathers all the option presets (`EcoRake::Options::Set`) defined.
+    # It works at class level and does lazy loading.
+    class Library
+      extend RakeCommander::Base::ClassHelpers
+      extend RakeCommander::Base::ClassAutoLoader
+
+      class_resolver :item_class, EcoRake::Options::Set
+
+      autoloads_children_of :item_class
+      autoload_namespace_ignore "EcoRake::Options"
+
+      class << self
+        include Enumerable
+
+        # Iterator
+        def each(&block)
+          return to_enum(:each) unless block_given?
+          sets.values.each(&block)
+        end
+
+        # Retrieve an options set
+        # @return [EcoRake::Options::Set] the class with that `name`
+        def [](value)
+          sets[to_name(value)]
+        end
+
+        # @return [Boolean]
+        def set?(name)
+          raise "Expected String or Symbol. Given: #{name.class}" unless name.respond_to?(:to_sym)
+          sets.key?(name.to_sym)
+        end
+
+        # @return [Array<Symbol>] names list of all available option sets.
+        def names
+          setes.keys
+        end
+
+        # Add a new options set.
+        # @note
+        #   1. If it receives an `item_class` (`Class`) it just adds it in
+        #   2. If it receives an object instance, it adds its class
+        # @return [EcoRake::Options::Set] the class
+        def add(options_set)
+          klass = options_set.is_a?(Class)? options_set : options_set.class
+          raise "Expecting #{item_class} child or instance. Given: #{klass}" unless klass <= item_class
+          puts "Warning: redefining options set '#{set.name}'"               if self[options_set.name]
+          sets[options_set.name] = klass
+        end
+
+        private
+
+        def autoload_children
+          super(self) do |instance|
+            add(instance)
+          end
+        end
+
+        # It loads pending children of `item_class` every time it's invoked.
+        # @note if sets is used as unique access point, this should ensure all children are known/loaded.
+        # @return [Hash] where `key` is option_set name and value is the `item_class` (i.e. EcoRake::Options::Set)
+        def sets
+          autoload_children
+          @sets ||= {}
+        end
+
+        # To-name converter
+        # @return [Symbol, NilClass]
+        def to_name(value)
+          case value
+          when String, Symbol
+            value.to_sym
+          when item_class
+            value.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/options/parental.rb

@@ -0,0 +1,37 @@
+class EcoRake
+  module Options
+    module Parental
+      class << self
+        def included(base)
+          super(base)
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        private
+
+        def add_to_options(opt, *args)
+          super.tap do |out|
+            next unless opt.respond_to?(:parent=)
+            opt.parent = self if opt == out
+          end
+        end
+
+        def delete_from_options(opt)
+          super.tap do |out|
+            next unless opt.respond_to?(:parent=)
+            out.parent = nil if opt == out
+          end
+        end
+
+        def replace_in_options(ref, opt, **kargs)
+          super.tap do |out|
+            next unless opt.respond_to?(:parent=)
+            ref.parent = nil if opt == out
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/options/set.rb

@@ -0,0 +1,21 @@
+class EcoRake
+  module Options
+    class Set < RakeCommander::Options::Set
+      include EcoRake::Options
+
+      #banner ''
+      attr_reader :parent
+
+      def initialize(*args, _parent: nil)
+        @parent = _parent
+        super(*args)
+      end
+
+      def name
+        self.class.name.tap do |nm|
+          raise ArgumentError, "Class #{self.class}, should have a name defined" unless nm
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/options.rb

@@ -0,0 +1,25 @@
+require_relative 'options/forwarding'
+require_relative 'options/parental'
+require_relative 'options/default_lookup'
+
+class EcoRake
+  module Options
+    class << self
+      def included(base)
+        super(base)
+        base.extend ClassMethods
+        base.class_resolver :option_class, EcoRake::Option
+        base.send :include, EcoRake::Options::Parental
+        base.send :include, EcoRake::Options::Forwarding
+        base.send :include, EcoRake::Options::DefaultLookup
+      end
+    end
+
+
+    module ClassMethods
+    end
+  end
+end
+
+require_relative 'options/set'
+require_relative 'options/library'

data/lib/eco-rake/rake_task.rb

@@ -0,0 +1,10 @@
+class EcoRake
+  module RakeTask
+    class << self
+      def included(base)
+        super(base)
+        base.send :include, EcoRake::Default
+      end
+    end
+  end
+end

data/lib/eco-rake/shell/command.rb

@@ -0,0 +1,59 @@
+class EcoRake
+  module Shell
+    module Command
+      include Rake::DSL
+
+      # It double quotes a string (escapes the double quotes)
+      # @param str [String]
+      # @return [String]
+      def double_quote(str)
+        "\"#{str}\"" if str
+      end
+
+      # Helper to build command line
+      # @note it excludes `nil` values.
+      # @return [String, Array<String>]
+      def array_cmd(base, *opts)
+        base = [base] unless base.is_a?(Array)
+        base.tap do |out|
+          opts.each {|opt| out << opt unless opt.nil?}
+          yield(out) if block_given?
+        end
+      end
+
+      # @see #array_cmd it the same but it returns a `String`
+      # @return [String]
+      def string_cmd(base, *options, join: ' ')
+        array_cmd(base, *options).join(join)
+      end
+
+      # @param continue [Boolean] whether it should continue when one failed.
+      # @param arr [Array<String>] array of commands to be run
+      def sh_chain(cmds, continue: false, &block)
+        cmds.each do |cmd|
+          next sh(cmd, &block) unless continue
+          ch_continue(cmd, &block)
+        end
+      end
+
+      # It **continues** even if there was an error or `exit(1)` during the execution
+      # @param comm [String] the command line
+      def sh_continue(comm, &block)
+        sh(comm, &sh_default_block(comm, &block))
+      end
+
+      # Returns the default block for `sh` native method.
+      # @note it wraps `block` if given
+      # @return [Proc]
+      def sh_default_block(comm)
+        proc do |ok, res|
+          yield(ok, res) if block_given?
+          unless ok
+            msg = "Command failed (status = #{res.exitstatus})"
+            puts "#{msg}\n  • #{comm}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/shell/eco_helpers.rb

@@ -0,0 +1,10 @@
+class EcoRake
+  module Shell
+    module EcoHelpers
+      # What main file should be used (based on running env)
+      def ruby_runner
+        "ruby main.rb"
+      end
+    end
+  end
+end