eco-helpers 0.8.3 → 0.8.4

data/lib/eco/common/meta_thor.rb

@@ -1,111 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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