eco-helpers 0.6.4 → 0.6.5

data/lib/eco/common/base_cli_backup.rb

@@ -0,0 +1,119 @@
+require 'thor'
+
+module Eco
+  module Common
+    class BaseCLI < MethaThor
+      PIPE = "!"
+      CUSTOM_HELP_MAPPINGS = ["?", "help"]
+      ALL_HELP_MAPPINGS = Thor::HELP_MAPPINGS + CUSTOM_HELP_MAPPINGS
+
+      class_option :simulate, type: :boolean, aliases: :s, desc: "do not launch updates or rewrite files"
+      class_option :verbosity, type: :numeric, default: 0, desc: "defines the level of verbosity to show feedback"
+
+      class_option :input, type: :hash, default: {json: nil}, required: false, desc: "--input=json:STRING"
+      class_option :pipe, type: :boolean, default: false, required: false, desc: "--pipe subcommand"
+
+      def self.start(given_args = ARGV, config = {})
+        #given_args = splat_namespaces(given_args)
+        given_args = BaseCLI.parse_help(given_args)
+        super(given_args, config)
+      end
+
+      # incompatible with options / arguments of Hash type
+      # see: parse_hash here: https://github.com/erikhuda/thor/blob/master/lib/thor/parser/arguments.rb
+      def self.splat_namespaces(args)
+        args.reduce([]) do |done, arg|
+          done.concat(arg.split(":"))
+        end
+      end
+
+      def self.parse_help(args)
+        # Help enhancement. Adapted from: https://stackoverflow.com/a/49044225/4352306
+        last = args.last
+        if args.length > 1 && help?(last)
+          # switch last and second last position
+          last = "help" if custom_help?(last)
+          args.insert(args.length - 2, last).pop
+          puts "> #{args.join(" ")}"
+        end
+        args
+      end
+
+      def self.help?(value)
+        case value
+        when String
+          ALL_HELP_MAPPINGS.include?(value)
+        when Symbol
+          help?(value.to_s)
+        when Array
+          value.any? { |v| help?(v) }
+        when Hash
+          value.keys.any { |k| help?(v) }
+        end
+      end
+
+      def self.custom_help?(value)
+        CUSTOM_HELP_MAPPINGS.include?(value)
+      end
+
+      protected
+
+      no_commands do
+        def input?(options)
+          if options
+            options.key?("input") || options.key?(:input) ||
+            options.key?("json") ||  options.key?(:json)
+        end
+
+        def input_object(input)
+          Eco::CLI::Input.new(input)
+        end
+
+        def input(value)
+          case
+          when value.is_a?(Eco::CLI::Input)
+            value.value
+          when value.is_a?(Eco::CLI::MultiInput)
+            value.to_h
+          when value.is_a?(String)
+            input(JSON.parse(value))
+          when value&.key?("input")
+            input(value["input"])
+          when value&.key?(:input)
+            input(value[:input])
+          when value&.key?("json")
+            JSON.parse(value["json"])
+          when value&.key?(:json)
+            JSON.parse(value[:json])
+          end
+        end
+
+        def pipe(input, args)
+          command, args, piped = parse_pipe(args)
+          invoke command, args, {input: input_object(input)} if piped
+          piped
+        end
+
+        def parse_pipe(args)
+          args.shift if piped = (args.first == PIPE)
+          subcommand = ""
+          if piped
+            raise "Error: bad usage of pipe ('#{PIPE}'). Expected: '#{PIPE} command' " unless subcommand = args.slice!(0)
+            if help?(subcommand)
+              # Idea adapted from: https://stackoverflow.com/a/46167300/4352306
+              self.class.command_help(Thor::Base.shell.new, args.first)
+              exit
+            end
+          end
+          [subcommand, args, piped]
+        end
+
+        def help?(value)
+          BaseCLI.help?(value)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/eco/common/meta_thor.rb

@@ -0,0 +1,111 @@
+require 'thor'
+
+module Eco
+  module Common
+    class MetaThor < Thor
+      INPUT_OPTION = "input"
+      INPUT_SYM    = :input
+      INPUT_KEY    = "json"
+      CUSTOM_HELP_MAPPINGS = ["?", "help"]
+      ALL_HELP_MAPPINGS = ::Thor::HELP_MAPPINGS + CUSTOM_HELP_MAPPINGS
+
+      class_option :input, type: :hash, default: {json: nil}, required: false, desc: "--input=json:STRING"
+      class_option :pipe, type: :boolean, default: false, required: false, desc: "--pipe subcommand"
+
+      class << self
+        def start(given_args = ARGV, config = {})
+          config[:shell] ||= Thor::Base.shell.new
+          CommandGroup.new(given_args).map do |unit|
+            args  = unit.args {|args| parse_custom_help(args)}
+            input = unit.input&.as_option
+            result = dispatch(nil, args.dup, input, config)
+            exit if help?(args)
+            unit.output = Value.new(result)
+          end
+        end
+
+        # @note: it allows to use `help` at the end (alias: `?`)
+        # If there is custom help at the end of the current command,
+        # normalize custom help to native `help` and switch last
+        # and second last arguments
+        def parse_custom_help(args)
+          return args unless custom_help?(args&.last)
+          # move from custom to native help
+          if args.length > 1
+            # switch args last and second last position
+            args.insert(args.length - 2, "help").pop
+          else
+            args[0] = "help"
+          end
+          args
+        end
+
+        def custom_help?(value)
+          CUSTOM_HELP_MAPPINGS.include?(value)
+        end
+
+        def help?(value)
+          case value
+          when String
+            ALL_HELP_MAPPINGS.include?(value)
+          when Symbol
+            help?(value.to_s)
+          when Array
+            value.any? { |v| help?(v) }
+          when Hash
+            value.keys.any? { |k| help?(v) }
+          else
+            "what? #{value}"
+          end
+        end
+
+      end
+
+      protected
+
+      no_commands do
+        def input?(options)
+          options &&
+          (options.key?(INPUT_OPTION) || options.key?(INPUT_KEY) ||
+          options.key?(Value::KEY_OPTION) )
+        end
+
+        def input(value)
+
+          case
+          when value.is_a?(Value)
+            value.value
+          when value.is_a?(String)
+            input(JSON.parse(value))
+          when value.is_a?(Hash)
+            case
+            when value.key?(Value::KEY_OPTION)
+              Value.to_value(value)
+            when value.key?(INPUT_OPTION)
+              input(value[INPUT_OPTION])
+            when value.key?(INPUT_SYM)
+              input(value[INPUT_SYM])
+            when value.key?(INPUT_KEY)
+              val = value[INPUT_KEY]
+              JSON.parse(val) unless val.is_a?(Hash)
+            else
+              value
+            end
+          else
+            value
+          end
+        end
+
+      end
+
+    end
+  end
+end
+
+require_relative 'meta_thor/pipe'
+require_relative 'meta_thor/command_unit'
+require_relative 'meta_thor/command_group'
+require_relative 'meta_thor/value'
+require_relative 'meta_thor/thor'
+#require_relative 'metha_thor/input'
+#require_relative 'metha_thor/input_multi'

data/lib/eco/common/meta_thor/command_group.rb

@@ -0,0 +1,36 @@
+module Eco
+  module Common
+    class MetaThor
+      class CommandGroup
+
+        attr_reader :units
+
+        def initialize(args)
+          args  = (args && [args].flatten) || []
+          #pp "CommandGroup split args: #{Pipe.split(args)}"
+          @units = Pipe.split(args).each_with_index.map do |arguments, i|
+            CommandUnit.new(args: arguments, group: self, index: i)
+          end
+          @units = units
+        end
+
+        def print
+          @units.map do |command|
+            pp command.args
+          end
+        end
+
+        def [](value)
+          @units[value]
+        end
+
+        def map
+          @units.map do |unit|
+            yield(unit)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/common/meta_thor/command_unit.rb

@@ -0,0 +1,48 @@
+module Eco
+  module Common
+    class MetaThor
+      class CommandUnit
+        class << self
+
+        end
+
+        attr_reader :group, :index
+        attr_reader :pipe
+        attr_reader :args, :source_args
+        attr_accessor :output
+
+        def initialize(args:, group:, index:)
+          @source_args = args.dup || []
+          @args = @source_args
+          @args = @args.slice(1..-1) if Pipe.piped?(@source_args)
+          @pipe = Pipe.new(command: self) if Pipe.piped?(@source_args)
+
+          @group = group
+          @index = index
+        end
+
+        def piped?
+          !!@pipe
+        end
+
+        def input
+          pipe&.input
+        end
+
+        def args
+          arguments = @args.dup
+          arguments = yield(arguments) if block_given?
+          arguments
+        end
+
+        def piped_args
+          args.tap do |arguments|
+            arguments = yield(arguments) if block_given?
+            arguments.push(pipe.input.as_input_option) if piped?
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/common/meta_thor/input_backup.rb

@@ -0,0 +1,111 @@
+module Eco
+  module Common
+    class MethaThor
+      class Input
+        MODES = [:both, :json, :value]
+
+        attr_reader :mode
+
+        def initialize(value, mode = :both)
+          @mode = mode
+          @mode = :both unless MODES.include?(mode)
+
+          @doc = {}
+          @doc['value'] = {} if self.value?
+          @doc['json']  = {} if self.json?
+
+          self.value = value
+        end
+
+        def to_h
+          @doc
+        end
+
+        def json?
+          @mode == :json || @mode = :both
+        end
+
+        def value?
+          @mode == :value || @mode = :both
+        end
+
+        def json
+          @doc['json'] if self.json?
+        end
+
+        def parse
+          JSON.parse(self.json) if self.json?
+        end
+
+        def json=(value)
+          @doc['value'] = value if self.value?
+          @doc['json']  = to_json(value) if self.json?
+        end
+
+        def value
+          return @doc['value'] if self.value?
+          self.parse
+        end
+
+        def value=(value)
+          @doc['value'] = value if self.value?
+          @doc['json']  = to_json(value) if self.json?
+        end
+
+        def present?(key)
+          self[key]&.present?
+        end
+
+        def empty?
+          return @doc['value'].keys.length == 0 if self.value?
+          @doc['json'].keys.length == 0
+        end
+
+        # merging implies that @mode is equalized to the lesser
+        # => :both.merge(:json) == :json ; :value.merge(:both) == :value mode
+        # => :json.merge(:value) will raise an exception
+        def merge(value)
+          merge_hash(hash(value))
+          self
+        end
+
+        private
+
+        def to_json(value)
+          if value.respond_to?(:as_json)
+            input.as_json
+          elsif value.respond_to?(:to_json)
+            value.to_json
+          end
+        end
+
+        def doc_mode(doc)
+          case doc
+          when String
+            doc = JSON.parse(doc)
+            return nil unless doc.is_a?(Hash)
+            doc_mode(doc)
+          when CliInput
+            doc.mode
+          when Hash
+            mod_json  = doc.key?('json')
+            mod_value = doc.key?('value')
+            mod_json ? (mod_value ? :both : :json) : (mod_value ? :value : nil)
+          end
+        end
+
+        def hash(value)
+          case value
+          when String
+            JSON.parse(value)
+          when CliInput
+            value.to_h
+          when Hash
+            value
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/common/meta_thor/input_multi_backup.rb

@@ -0,0 +1,139 @@
+module Eco
+  module Common
+    class MethaThor
+      class MultiInput
+        MODES = [:both, :json, :value]
+
+        attr_reader :mode
+
+        def initialize(doc = {}, mode = :both)
+          @mode = doc_mode(doc) || mode
+          @mode = :both unless MODES.include?(@mode)
+
+          @doc = {}
+          @doc['value'] = {} if self.value?
+          @doc['json']  = {} if self.json?
+
+          self.merge(doc) unless doc.empty?
+        end
+
+        def to_h
+          @doc
+        end
+
+        def json?
+          @mode == :json || @mode = :both
+        end
+
+        def value?
+          @mode == :value || @mode = :both
+        end
+
+        def json(key)
+          @doc.dig('json', key)
+        end
+
+        def [](key)
+          return @doc.dig('value', key) if self.value?
+          JSON.parse(@doc.dig('json', key))
+        end
+
+        def []=(key, value)
+          @doc['value'][key] = value if self.value?
+          @doc['json'][key]  = to_json(value) if self.json?
+        end
+
+        def delete(key)
+          if self.key?(key)
+            value  = @doc['value'].delete(key) if self.value?
+            value2 = JSON.parse(@doc['json'].delete(key)) if self.json?
+            return value if self.value?
+            value2
+          end
+        end
+
+        def key?(key)
+          return @doc['value'].key?(key) if self.value?
+          @doc['json'].key?(key)
+        end
+
+        def present?(key)
+          self[key]&.present?
+        end
+
+        def empty?
+          return @doc['value'].keys.length == 0 if self.value?
+          @doc['json'].keys.length == 0
+        end
+
+        # merging implies that @mode is equalized to the lesser
+        # => :both.merge(:json) == :json ; :value.merge(:both) == :value mode
+        # => :json.merge(:value) will raise an exception
+        def merge(value)
+          merge_hash(hash(value))
+          self
+        end
+
+        private
+
+        def to_json(value)
+          if value.respond_to?(:as_json)
+            input.as_json
+          elsif value.respond_to?(:to_json)
+            value.to_json
+          end
+        end
+
+        def doc_mode(doc)
+          case doc
+          when String
+            doc = JSON.parse(doc)
+            return nil unless doc.is_a?(Hash)
+            doc_mode(doc)
+          when CliInput
+            doc.mode
+          when Hash
+            mod_json  = doc.key?('json')
+            mod_value = doc.key?('value')
+            mod_json ? (mod_value ? :both : :json) : (mod_value ? :value : nil)
+          end
+        end
+
+        def hash(value)
+          case value
+          when String
+            JSON.parse(value)
+          when CliInput
+            value.to_h
+          when Hash
+            value
+          end
+        end
+
+        def merge_hash(value)
+          err_input = "Error: merge requires a correct Hashable value or a #{self.class.name} instance."
+          err_incompatible = "Error: can't merge value mode with json mode."
+          raise err_input unless value.is_a?(Hash)
+          return unless !value.empty?
+
+          raise err_input if ! (mode = doc_mode(value))
+          raise err_incompatible if ! (new_mode = resolve_mode(mode))
+          @mode = new_mode
+
+          @doc.delete('json')  unless self.json?
+          @doc.delete('value') unless self.value?
+
+          @doc['json'].merge(value['json']) if self.json?
+          @doc['value'].merge(value['value']) if self.value?
+        end
+
+        def resolve_mode(mode)
+          return mode if @mode == :both
+          return @mode if mode == :both
+          return mode if @mode == mode
+        end
+
+      end
+    end
+  end
+end