eco-helpers 1.5.1 → 1.5.6

data/lib/eco/cli/scripting.rb

@@ -7,8 +7,16 @@ module Eco
     class Scripting
       include Scripting::ArgsHelpers
 
+      def initialize(argv = ARGV)
+        @argv = argv
+      end
+
+      def argv
+        @argv.dup
+      end
+
       def args_contain?(*values)
-        match?(ARGV, patterns, [:any, :or, :insensitive, :pattern])
+        match?(argv, patterns, [:any, :or, :insensitive, :pattern])
       end
 
       def modifiers(*values)
@@ -20,4 +28,4 @@ module Eco
 end
 
 
-SCR = Eco::CLI::Scripting.new
+SCR = Eco::CLI::Scripting.new(ARGV)

data/lib/eco/cli/scripting/args_helpers.rb

@@ -3,12 +3,16 @@ module Eco
     class Scripting
       module ArgsHelpers
 
+        def argv
+          @argv || ARGV
+        end
+
         def is_modifier?(value)
           Argument.is_modifier?(value)
         end
 
         def arguments
-          @arguments ||= Arguments.new
+          @arguments ||= Arguments.new(argv)
         end
 
         def stop_on_unknown!(exclude: [], only_options: false)
@@ -23,38 +27,44 @@ module Eco
           end
         end
 
+        def get_arg_index(key)
+          return nil if !argv.include?(key)
+          argv.index(key)
+        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)
+          return nil unless index = get_arg_index(key)
           value = true
           if with_param
-            next_i = ARGV.index(key) + 1
-            value = ARGV[next_i]
+            value  = argv[index + 1]
             #puts "modifier argument: #{value}"
-            value = nil if valid && is_modifier?(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(1)
-              end
-          elsif  !(File.exists?(filename) || File.exists?(File.expand_path(filename)))
-            if should_exist && required
-              puts "file doesn't exist #{filename}"
-              exit
-            end
+          if !filename && required
+            puts "You need to specify a file '#{key} file'"
+            exit(1)
+          elsif !file_exists?(filename) && should_exist && required
+            puts "This file doesn't exist '#{filename}'"
+            exit(1)
           end
 
           filename = File.expand_path(filename) if filename && should_exist
           filename
         end
 
+        private
+
+        def file_exists?(filename)
+          File.exists?(filename) || File.exists?(File.expand_path(filename))
+        end
+
       end
     end
   end

data/lib/eco/cli/scripting/argument.rb

@@ -31,6 +31,7 @@ module Eco
         def with_param?
           @with_param
         end
+        
       end
     end
   end

data/lib/eco/cli/scripting/arguments.rb

@@ -11,7 +11,7 @@ module Eco
           @known = {}
         end
 
-        def each(params: {}, &block)
+        def each(&block)
           return to_enum(:each) unless block
           @known.values.each(&block)
         end

data/lib/eco/csv/table.rb

@@ -3,7 +3,7 @@ module Eco
   class CSV
     class Table < ::CSV::Table
 
-      # @param ary_arrays [Array<Row>, Array<Array>, Eco::CSV::Table, ::CSV::Table]
+      # @param input [Array<Row>, Array<Array>, Eco::CSV::Table, ::CSV::Table]
       #   - when `Array<Array>` => all `rows` as arrays where first array is the **header**
       def initialize(input)
         super(to_rows_array(input))

data/lib/eco/data/crypto/encryption.rb

@@ -7,6 +7,7 @@ require_relative '../../cli/scripting'
 
 # see some ramblings here: http://distributed-frostbite.blogspot.com/2010/06/file-encryption-in-ruby-with-openssl.html
 
+
 def run! # this will run only if called from command line (not when require'd nor load'd)
   include Eco::CLI::Scripting
   include Eco::Data::Crypto
@@ -145,6 +146,8 @@ module Eco
           str_c += cipher.final
           return str_c
           #EncryptedData.new({content: str_c, key: key, iv: iv})
+
+          
         end
         def aes256_decrypt(data, key: , iv: , block_octets: BLOCK_OCTETS)
           block_bits = block_bits * 8

data/lib/eco/language/match.rb

@@ -1,30 +1,40 @@
 module Eco
   module Language
-    def match?(value, at, mode = MatchModifier.new)
-      out_match = ->(v) { match?(v,    at, mode) }
-      in_match  = ->(a) { match?(value, a, mode) }
+
+    def match?(value, at, mode = MatchModifier.new, depth: 0)
+      out_match  = ->(v) { match?(v,    at, mode, depth: depth + 1)         }
+      in_match   = ->(a) { match?(value, a, mode, depth: depth + 1)         }
+      indent_msg = ->(m) { puts ("  " * depth) + m if mode.debug?   }
 
       case
       when mode.reverse?
-        return match?(at   , value, mode.new.reset_reverse)
+        indent_msg.call("reverse value #{value} <--> at: #{at}")
+        match?(at   , value, mode.new.reset_reverse, depth: depth + 1)
       when mode.pattern?
+        indent_msg.call("at to pattern: #{at}")
         at = mode.to_regex(at)
-        return match?(value,    at, mode.new.reset_pattern)
+        match?(value,    at, mode.new.reset_pattern, depth: depth + 1)
       when value.is_a?(Array)
+        indent_msg.call("array #{value} value.#{mode.any?? "any?" : "all?"} match(v_item, at) at: #{at}")
         return value.any?(&out_match) if mode.any?
-        return value.all?(&out_match) # defaults to EVERY
+        value.all?(&out_match) # defaults to EVERY
       when at.is_a?(Array)
+        indent_msg.call("array #{at} at.#{mode.and?? "all?" : "any?"} match(value, at_item). value: #{value}")
         return at.all?(&in_match) if mode.and?
-        return at.any?(&in_match) # defaullts to OR
+        at.any?(&in_match) # defaullts to OR
       when at.is_a?(Regexp)
-        return at.match?(value)
+        indent_msg.call("(#{at.inspect}) at.match?(value); value: #{value}")
+        at.match?(value)
       when value.is_a?(Regexp)
-        return value.match?(at)
+        indent_msg.call("(#{value.inspect}) value.match?(at); at: #{at}")
+        value.match?(at)
       else # final compare
+        indent_msg.call("-- final -- mode: #{mode.to_a}; value: #{value}; at: #{at}")
         m = (value == at) ||
           (mode.insensitive? && at&.downcase == value&.downcase)
         (mode.not?) ? !m : m
       end
     end
+    
   end
 end

data/lib/eco/language/match_modifier.rb

@@ -60,6 +60,10 @@ module Eco
         self < self.mode - (NOT_MODE | YES_MODE)
       end
 
+      def debug
+        self.push(:debug)
+      end
+
       def pattern
         self.push(:pattern)
       end
@@ -116,24 +120,28 @@ module Eco
         self.push(:not)
       end
 
+      def debug?
+        mode.any? {|m| m == :debug}
+      end
+      
       def pattern?
-        mode.any? { |m| PATTERN_MODE.include?(m) }
+        mode.any? {|m| PATTERN_MODE.include?(m)}
       end
 
       def value?
-        mode.any? { |m| VALUE_MODE.include?(m) }
+        mode.any? {|m| VALUE_MODE.include?(m)}
       end
 
       def reverse?
-        mode.any? { |m| REVERSE_MODE.include?(m) }
+        mode.any? {|m| REVERSE_MODE.include?(m)}
       end
 
       def non_reverse?
-        mode.any? { |m| NON_REVERSE_MODE.include?(m) }
+        mode.any? {|m| NON_REVERSE_MODE.include?(m)}
       end
 
       def any?
-        mode.any? { |m| ANY_MODE.include?(m) }
+        mode.any? {|m| ANY_MODE.include?(m)}
       end
 
       def some?

data/lib/eco/language/models/collection.rb

@@ -4,19 +4,19 @@ module Eco
       class Collection
         include Enumerable
 
-        ATTR_PRESENCE_METHODS =   ["present", "empty", "present_all?", "present_some?"]
-        ATTR_COLLECTION_METHODS = ["exclude", "remove", "attr", "attr?", "attrs", "unique_attrs", "contains"] + ATTR_PRESENCE_METHODS
+        BASIC_METHODS    = ["present", "empty", "present_all?", "present_some?"]
+        EXTENDED_METHODS = BASIC_METHODS + ["exclude", "remove", "attr", "attr?", "attrs", "unique_attrs", "contains"]
 
         class << self
 
-          def attr_collection (*attrs)
+          def attr_presence(*attrs)
             block = ->(method) { attrs_create_method(attrs, method) }
-            ATTR_COLLECTION_METHODS.each(&block)
+            BASIC_METHODS.each(&block)
           end
 
-          def attr_presence (*attrs)
+          def attr_collection(*attrs)
             block = ->(method) { attrs_create_method(attrs, method) }
-            ATTR_PRESENCE_METHODS.each(&block)
+            EXTENDED_METHODS.each(&block)
           end
 
           def attrs_create_method(attrs, method)
@@ -35,8 +35,6 @@ module Eco
 
         end
 
-        #attr_reader :items
-
         def initialize(data = [], klass:, factory: nil, handy: Eco::Assets::Language.new)
           raise "Raise klass required, given: #{klass}" if !klass
           @klass   = klass
@@ -45,6 +43,15 @@ module Eco
           @items   = to_klass(data)
         end
 
+        # @!group pure collection methods
+        def to_c
+          Collection.new(self, klass: @klass, factory: @factory)
+        end
+
+        def new
+          newFrom to_a
+        end
+
         def newFrom(data)
           self.class.new(data, klass: @klass, factory: @factory)
         end
@@ -54,14 +61,6 @@ module Eco
           newFrom to_a + data
         end
 
-        def to_c
-          Collection.new(self, klass: @klass, factory: @factory)
-        end
-
-        def new
-          self.class.new(to_a, klass: @klass, factory: @factory)
-        end
-
         def length
           count
         end
@@ -70,7 +69,7 @@ module Eco
           count == 0
         end
 
-        def each(params: {}, &block)
+        def each(&block)
           return to_enum(:each) unless block
           @items.each(&block)
         end
@@ -93,47 +92,57 @@ module Eco
         def delete!(value)
           self < @items - into_a(value)
         end
+        # @!endgroup
 
-        # attr dependant methods
-        def exclude(attr, value, modifier = Language::MatchModifier.new)
+        # @!group `attr` dependant methods
+        def exclude(attr, value, modifier = default_modifier)
           newFrom @items - self.attr(attr, value, modifier)
         end
 
-        def remove(attr, value, modifier = Language::MatchModifier.new)
+        def remove(attr, value, modifier = default_modifier)
           self < exclude(attr, value, modifier)
         end
 
-        def attr(attr, value = true, modifier = Language::MatchModifier.new)
-          if !!value == value # boolean?
-            present(attr, value)
-          else
-            return newFrom select { |object|
-              attr_val = fetch_attr(object, attr)
-              match?(attr_val, value, modifier)
-            }
+        def attr(attr, value = true, modifier = default_modifier)
+          return present(attr, value) if boolean?(value)
+          select do |object|
+            match?(attr_value(object, attr), value, modifier)
+          end.yield_self do |matching|
+            newFrom matching
           end
         end
 
-        def attr?(attr, value = true, modifier = Language::MatchModifier.new)
-          modifier = modifier.new.reverse
-          if !!value == value # boolean?
-            present(attr, value).length == length
-          else
-            obj_vals = attrs(attr)
-            return match?(obj_vals, value, modifier)
-          end
+        def attr?(attr, value = true, modifier = default_modifier)
+          return present(attr, value).length == length if boolean?(value)
+          match?(attrs(attr), value, modifier.new.reverse)
+        end
+
+        def contains(attr, value, modifier = default_modifier)
+          self.attr(attr, value, modifier.new.pattern)
         end
 
         def attrs(attr)
-          map { |object| fetch_attr(object, attr) }
+          map { |object| attr_value(object, attr) }
         end
 
         def unique_attrs(attr)
           to_h(attr).keys
         end
 
+        def group_by(attr = nil, &block)
+          return to_h(attr) if attr
+          to_a.group_by(&block) if block
+        end
+
+        def to_h(attr)
+          return {} if !attr
+          to_a.group_by { |object| object.method(attr).call }
+        end
+        # @!endgroup
+
+        # @!group `attr` presence methods
         def present(attr, flag = true)
-          block = ->(o) { !!fetch_attr(o, attr) == !!flag }
+          block = ->(o) { attr_value_present?(o, attr) == !!flag }
           newFrom select(&block)
         end
 
@@ -148,21 +157,7 @@ module Eco
         def present_some?(attr, flag = true)
           present(attr, flag).length > 0
         end
-
-        def contains(attr, value, modifier = Language::MatchModifier.new)
-          modifier = modifier.new.pattern
-          self.attr(attr, value, modifier)
-        end
-
-        def group_by(attr = nil, &block)
-          return to_h(attr) if attr
-          to_a.group_by(&block) if block
-        end
-
-        def to_h(attr)
-          return {} if !attr
-          to_a.group_by { |object| object.method(attr).call }
-        end
+        # @!endgroup
 
         protected
 
@@ -171,12 +166,34 @@ module Eco
         end
 
         def into_a(value)
-          value = [].push(value) unless value.is_a?(Enumerable)
+          value = [].push(value) if value.is_a?(Hash) || !value.is_a?(Enumerable)
           value.to_a
         end
 
         private
 
+        def attr_value(obj, attr)
+          return nil unless obj && attr
+          case
+          when obj.is_a?(Hash)
+            obj[attr]
+          when obj.respond_to?(attr.to_sym)
+            obj.send(attr)
+          end
+        end
+
+        def attr_value_present?(obj, attr)
+          return false unless value = attr_value(obj, attr)
+          case
+          when value.is_a?(Enumerable)
+            value.count > 1
+          when value.is_a?(String)
+            !value.strip.empty?
+          else
+            !!value
+          end
+        end
+
         def match?(*args)
           @handy.match?(*args)
         end
@@ -187,8 +204,12 @@ module Eco
           end
         end
 
-        def fetch_attr(object,attr)
-          object.method(attr).call
+        def default_modifier
+          Language::MatchModifier.new
+        end
+
+        def boolean?(value)
+          value == !!value
         end
 
       end