eco-helpers 0.8.3 → 0.8.4

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

@@ -1,85 +0,0 @@
-module Eco
-  module Common
-    class MetaThor
-      class Pipe
-        SYM = "!"
-        SYMS = [SYM]
-
-        class << self
-          #def rex_pipes
-          #  alternatives = Regex.escape(SYMS).join("|")
-          #  /(#{alternatives})/g
-          #end
-
-          def type(str)
-            case str
-            when SYM
-              :standard
-            else
-              :unkown
-            end
-          end
-
-          def pipe?(str)
-            SYMS.include?(str)
-          end
-
-          def piped?(args)
-            args.any? do |arg|
-              pipe?(arg)
-            end
-          end
-
-          def split(args, pipe_to_sym: false)
-            args = (args && [args].flatten) || []
-            if piped?(args)
-              args.reduce([[]]) do |groups,arg|
-                cg = []
-                cg = pipe?(arg) ? cg : groups.last
-                cg.push(arg) if arg
-
-                groups.push(cg) if pipe?(arg)
-                groups
-              end
-            else
-              [].push(args)
-            end
-          end
-        end
-
-        attr_reader :type, :command
-
-        def initialize(command:)
-          @command = command
-          args = @command.source_args
-          @type = self.class.type(args.shift)
-        end
-
-        def standard?
-          @type == :standard
-        end
-
-        def command_group
-          command.group
-        end
-
-        def index
-          command.index
-        end
-
-        def input_index
-          return nil unless index > 0
-          case type
-          when :standard
-            index - 1
-          end
-        end
-
-        def input
-          command_group[input_index].output if input_index
-        end
-
-      end
-    end
-  end
-end

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

@@ -1 +0,0 @@
-require_relative 'thor/command'

data/lib/eco/common/meta_thor/thor/command.rb

@@ -1,36 +0,0 @@
-class Thor
-  class Command
-
-    # By default, a command invokes a method in the thor class. You can change this
-    # implementation to create custom commands.
-    # Source: https://github.com/erikhuda/thor/blob/master/lib/thor/command.rb
-    # Trace:
-    # 1. Base_Class.start
-    # 2. Thor_Class.dispatch
-    #   - (new) Base.initialize -> with options
-    # 3. Base_Instance.invoke_command (invocation.rb)
-    # 4. Command_Instance.run
-    # @note: modified so it integrates input/output for custom Pipe
-    def run(instance, args = [])
-      arity = nil
-
-      if private_method?(instance)
-        result = instance.class.handle_no_command_error(name)
-      elsif public_method?(instance)
-        arity = instance.method(name).arity
-        result = instance.__send__(name, *args)
-      elsif local_method?(instance, :method_missing)
-        result = instance.__send__(:method_missing, name.to_sym, *args)
-      else
-        result = instance.class.handle_no_command_error(name)
-      end
-
-      result
-    rescue ArgumentError => e
-      handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
-    rescue NoMethodError => e
-      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e)
-    end
-
-  end
-end

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

@@ -1,54 +0,0 @@
-module Eco
-  module Common
-    class MetaThor
-      class Value
-        KEY = "MetaThorValue"
-        KEY_OPTION = "MetaThorJSON"
-
-        class << self
-          def to_value(doc)
-            case
-            when doc.is_a?(Hash)
-              case
-              when doc.key?(KEY_OPTION)
-                to_value(doc[KEY_OPTION])
-              when doc.key?(KEY)
-                doc[KEY]
-              else
-                doc
-              end
-            when doc.is_a?(String)
-              to_value(JSON.parse(doc))
-            when doc.is_a?(Value)
-              value.value
-            end
-          end
-
-          def key?(object)
-
-          end
-        end
-
-        attr_reader :value
-
-        def initialize(value)
-          @doc = {"#{KEY}" => value}
-        end
-
-        def value
-          @doc[KEY]
-        end
-
-        def as_input_option
-          "--#{INPUT_OPTION}=#{KEY_OPTION}:#{@doc.to_json}"
-        end
-
-        def as_option
-          {"#{INPUT_SYM}" => self}
-        end
-
-      end
-
-    end
-  end
-end

data/lib/eco/scripting.rb

@@ -1,32 +0,0 @@
-require_relative 'scripting/args_helpers'
-require_relative 'scripting/argument'
-require_relative 'scripting/arguments'
-
-module Eco
-  #TODO integrate Thor to build the CLI from bottom to top on load
-  class Scripting
-    include Scripting::ArgsHelpers
-
-    def args_contain?(*values)
-      match?(ARGV, patterns, [:any, :or, :insensitive, :pattern])
-    end
-
-    def modifiers(*values)
-      values.select { |arg| is_modifier?(arg) }
-    end
-
-    def args_filter_match(*values)
-      modifier = Eco::Language::MatchModifier.new.any.or.insensitive
-      patterns = modifier.to_regex(values)
-      params = modifiers(*ARGV)
-      patterns.each_with_index.reduce([]) { |done, (pat, i) |
-        done.push(values[i]) if Handy.match?(params, pat, modifier)
-        done
-      }
-    end
-
-  end
-end
-
-
-SCR = Eco::Scripting.new

data/lib/eco/scripting/README.md

@@ -1,11 +0,0 @@
-# API Helpers Command Line Interface
-
-The idea is to use **[Thor](http://whatisthor.com/)**
-
-`TODO`:
-
-* check if the unique point access can be feed by the current loading architecture, and make it fit with *Thor*
-  * analyze if **subcommands** can do the trick there and how
-  * check of **modifiers / flags** support (is it all *via subcommands*)
-* implement the architecture to easily expose specific logics of the helpers
-* check if the cli pipe can be used to **thor** between commands

data/lib/eco/scripting/args_helpers.rb

@@ -1,53 +0,0 @@
-module Eco
-  class Scripting
-    module ArgsHelpers
-
-      def is_modifier?(value)
-       value&.start_with?("-")
-      end
-
-      def arguments
-        @arguments ||= Arguments.new
-      end
-
-      def stop_on_unknown!(exclude: [])
-        if arguments.any_unkown?(exclude: exclude)
-          raise "There are unknown options in your command line arguments: #{arguments.unknown(exclude: exclude)}"
-        end
-      end
-
-      def get_arg(key, with_param: false, valid: true)
-        # track what a known option looks like
-        arguments.add(key, with_param: with_param)
-        return nil if !ARGV.include?(key)
-        value = true
-        if with_param
-          next_i = ARGV.index(key) + 1
-          value = ARGV[next_i]
-          #puts "modifier argument: #{value}"
-          value = nil if valid && is_modifier?(value)
-        end
-        return value
-      end
-
-      def get_file(key, required: false, should_exist: true)
-        filename = get_arg(key, with_param: true)
-        if !filename
-            if required
-              puts "you need to specify a file '#{key} file'"
-              exit
-            end
-        elsif  !(File.exists?(filename) || File.exists?(File.expand_path(filename)))
-          if should_exist && required
-            puts "file doesn't exist #{filename}"
-            exit
-          end
-        end
-
-        filename = File.expand_path(filename) if filename && should_exist
-        filename
-      end
-
-    end
-  end
-end

data/lib/eco/scripting/argument.rb

@@ -1,29 +0,0 @@
-module Eco
-  class Scripting
-    class Argument
-
-      attr_reader :key
-
-      def initialize(key, with_param: false)
-        @key        = key
-        @with_param = !!with_param
-      end
-
-      def args_slice(*args)
-        #pp "known arg '#{key}' => included? #{args.include?(key)}"
-        return args unless args.include?(key)
-        i = args.index(key)
-        j = with_param?? i+1 : i
-        args - args.slice(i..j)
-      end
-
-      def with_param!
-        @with_param = true
-      end
-
-      def with_param?
-        @with_param
-      end
-    end
-  end
-end

data/lib/eco/scripting/arguments.rb

@@ -1,68 +0,0 @@
-module Eco
-  class Scripting
-    class Arguments
-      include Enumerable
-
-      attr_reader :args
-
-      def initialize(args = ARGV)
-        @args  = args
-        @known = {}
-      end
-
-      def each(params: {}, &block)
-        return to_enum(:each) unless block
-        @known.values.each(&block)
-      end
-
-      def add(key, with_param: false)
-        self << Argument.new(key, with_param: with_param)
-      end
-
-      def <<(arg)
-        raise "Expected Argument. Given #{arg.class}" unless arg.is_a?(Argument)
-        if karg = @known[arg.key]
-          #puts "Found already existent option #{arg.key} (with_param: arg.with_param?)"
-          karg.with_param! if arg.with_param?
-        else
-          #puts "Adding unexistent option #{arg.key}"
-          @known[arg.key] = arg
-        end
-        self
-      end
-
-      def known?(value)
-        @known.key?(to_key(value))
-      end
-
-      def keys
-        @known.keys
-      end
-
-      def unknown(exclude: [])
-        reduce(args.dup - exclude) do |not_known, arg|
-          arg.args_slice(*not_known)
-        end
-      end
-
-      def any_unkown?(exclude: [])
-        unknown(exclude: exclude).length > 0
-      end
-
-      private
-
-      def to_key(value)
-        case value
-        when String
-          value
-        when Argument
-          value.key
-        else
-          "Missuse: only able to transform to key a String or an Argument. Given #{value.class}"
-        end
-      end
-
-
-    end
-  end
-end