eco-helpers 0.6.0

data/lib/eco/api/usecases/use_group.rb

@@ -0,0 +1,104 @@
+module Eco
+  module API
+    module UseCases
+      class UseGroup
+
+        def initialize()
+          @usecases     = {}
+          @cache_init   = false
+          @cases_by_name = {}
+        end
+
+        def add(usecase)
+          raise "Expected UseCase object. Given: #{usecase}" if !usecase || !usecase.is_a?(UseCase)
+          name = usecase.name
+          type = usecase.type
+          puts "Warning: overriding '#{type.to_s}' case #{name}" if self.defined?(name, type: type)
+          @cache_init = false
+          @usecases[key(name, type)] = usecase
+          usecase
+        end
+
+        def define(name, type:, &block)
+          add(UseCase.new(name, type: type, root:self, &block))
+        end
+
+        def defined?(name, type: nil)
+          return @usecases.key?(key(name,type)) if type
+          name?(name)
+        end
+
+        def name?(name)
+          !!by_name[name]
+        end
+
+        def types(name)
+          return nil if !name?(name)
+          by_name[name].map { |usecase| usecase.type }
+        end
+
+        def case(name, type: nil)
+          return @usecases[key(name, type)] if type
+          return nil unless cases = by_name[name]
+
+          msg = "There are cases of different types (#{types(name).map(&:to_s).join(", ")}) named '#{name}'. You should specify a correct type"
+          raise msg if cases.length > 1
+          cases.first
+        end
+
+        def names
+          by_name.keys
+        end
+
+        # merges cases overriding self for exisint parsers
+        def merge(cases)
+          return self if !cases
+          raise "Expected a UseGroup object. Given #{cases}" if !cases.is_a?(UseGroup)
+          cases_hash = cases.hash
+
+          @usecases.merge!(cases_hash)
+
+          cases_hash.transform_values do |usecase|
+            usecase.root = self
+          end
+
+          @cache_init = false
+          self
+        end
+
+        protected
+
+        def hash
+          @usecases
+        end
+
+        private
+
+        def by_name
+          init_caches
+          @by_name
+        end
+
+        def init_caches
+          return true if @cache_init
+          @cache_init = true
+          @by_name = @usecases.values.group_by { |usecase| usecase.name }
+        end
+
+        def key(name, type)
+          name + type.to_s
+        end
+
+        def name(key)
+          key&.split(":").first
+        end
+
+        def type
+          key&.split(":").last&.to_sym
+        end
+
+      end
+
+    end
+  end
+end

data/lib/eco/cli.rb

@@ -0,0 +1,9 @@
+module Eco
+  module CLI
+  end
+end
+
+require_relative 'cli/root'
+require_relative 'cli/input'
+require_relative 'cli/input_multi'
+require_relative 'cli/session'

data/lib/eco/cli/input.rb

@@ -0,0 +1,109 @@
+module Eco
+  module CLI
+    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

data/lib/eco/cli/input_multi.rb

@@ -0,0 +1,137 @@
+module Eco
+  module CLI
+    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

data/lib/eco/cli/root.rb

@@ -0,0 +1,8 @@
+module Eco
+  module CLI
+    class Root < Eco::Common::BaseCLI
+      class_option :config_file, :aliases => "o", :type => :string,
+        :banner => "FILE", :desc => "specifes the session configuration file"
+    end
+  end
+end

data/lib/eco/cli/session.rb

@@ -0,0 +1,9 @@
+module Eco
+  module CLI
+    class Session < Eco::Common::BaseCLI
+
+    end
+  end
+end
+
+require_relative 'session/batch'

data/lib/eco/cli/session/batch.rb

@@ -0,0 +1,9 @@
+module Eco
+  module CLI
+    class Session
+      class Batch < Eco::Common::BaseCLI
+
+      end
+    end
+  end
+end

data/lib/eco/common.rb

@@ -0,0 +1,7 @@
+module Eco
+  module Common
+  end
+end
+
+require_relative 'common/base_cli'
+require_relative 'common/language'

data/lib/eco/common/base_cli.rb

@@ -0,0 +1,116 @@
+require 'thor'
+
+module Eco
+  module Common
+    class BaseCLI < Thor
+      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: {}, required: false, desc: "--input=json:STRING"
+
+      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)
+          options&.key?("input") || options&.key?(:input)
+        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, pipe = parse_pipe(args)
+          invoke command, args, {input: input_object(input)} if pipe
+          pipe
+        end
+
+        def parse_pipe(args)
+          args.shift if pipe = (args.first == PIPE)
+          subcommand = ""
+          if pipe
+            raise "Error: bad usage of pipe ('|'). Expected: '| 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, pipe]
+        end
+
+        def help?(value)
+          BaseCLI.help?(value)
+        end
+
+      end
+
+    end
+  end
+end