eco-helpers 1.4.2 → 1.5.4

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.rb

@@ -15,9 +15,14 @@ module Eco
       end
 
       def read(file, **kargs)
-        coding = Eco::API::Common::Session::FileManager.encoding(file)
-        kargs = {headers: true,  skip_blanks: true,  encoding: coding}.merge(kargs)
-        out = super(file, **kargs).reject do |row|
+        kargs = {headers: true,  skip_blanks: true}.merge(kargs)
+
+        args = [file].tap do |arg|
+          coding = Eco::API::Common::Session::FileManager.encoding(file)
+          arg.push("rb:bom|utf-8") if coding == "bom"
+        end
+
+        out = super(*args, **kargs).reject do |row|
           values = row.to_hash.values
           values.all?(&:nil?) || values.map(&:to_s).all?(&:empty?)
         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/data/files/helpers.rb

@@ -62,8 +62,13 @@ module Eco
           File.write(dest_file, File.read(source_file))
         end
 
+        def file_empty?(path)
+          return true if !File.file?(path)
+          File.zero?(path)
+        end
+
         def has_bom?(path)
-          return false if !path
+          return false if !path || file_empty?(path)
           File.open(path, "rb") do |f|
             bytes = f.read(3)
             return bytes.unpack("C*") == [239, 187, 191]

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

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

@@ -1,29 +1,32 @@
 module Eco
   module Language
     module Models
-
+      # Basic class to define a parser/serializing framework
+      # @attr_reader attr [String, Symbol] the attribute this parser/serializer is linked to.
       class ParserSerializer
-
         attr_reader :attr
 
         # Parser/seralizer.
         # @param attr [String, Symbol] name of the parsed/serialized.
         # @param dependencies [Hash] provisioning of _**default dependencies**_ that will be required when calling back to the
-        # parsing or serializing functions.
+        #   parsing or serializing functions.
         def initialize(attr, dependencies: {})
-          @attr = attr
+          @attr         = attr
           @dependencies = dependencies
+          @parser       = {}
+          @serializer   = {}
         end
 
         # Defines the _parser_ of the attribute.
         # @note
         #   1. the _block_ should expect one or two parameters.
         #   2. the final dependencies is a merge of _default dependencies_ with `parse` call dependencies.
+        # @param category [Symbol] a way to classify multiple parsers by category.
         # @yield [source_data, dependencies] user defined parser that returns the parsed value.
         # @yieldparam source_data [Any] source data that will be parsed.
         # @yieldparam dependencies [Hash] hash with the provisioned dependencies.
-        def def_parser(&block)
-          @parser = block
+        def def_parser(category = :default, &block)
+          @parser[category.to_sym] = block
           self
         end
 
@@ -31,11 +34,12 @@ module Eco
         # @note
         #   1. the block should expect one or two parameters.
         #   2. the final dependencies is a merge of _default dependencies_ with `serialize` call dependencies.
+        # @param category [Symbol] a way to classify multiple serializers by category.
         # @yield [source_data, dependencies] user defined serialiser that returns the serialised value.
         # @yieldparam source_data [Any] source data that will be serialised.
         # @yieldparam dependencies [Hash] hash with the provisioned dependencies.
-        def def_serializer(&block)
-          @serializer = block
+        def def_serializer(category = :default, &block)
+          @serializer[category.to_sym] = block
           self
         end
 
@@ -45,9 +49,9 @@ module Eco
         # @raise [Exception] when there is **no** `parser` defined.
         # @param source [Any] source data to be parsed.
         # @param dependencies [Hash] _additional dependencies_ that should be merged to the _default dependencies_.
-        def parse(source, dependencies: {})
-          raise "There is no parser for this attribue '#{attr}'" if !@parser
-          @parser.call(source, @dependencies.merge(dependencies), attr)
+        def parse(source, category = :default, dependencies: {})
+          raise "There is no parser of type '#{category}' for this attribue '#{attr}'" unless parser_category?(category)
+          call_block(source, @dependencies.merge(dependencies), attr, &@parser[category.to_sym])
         end
 
         # Calls the `serializer` of this attribute by passing `object` and resolved dependencies.
@@ -56,13 +60,33 @@ module Eco
         # @raise [Exception] when there is **no** `serializer` defined.
         # @param object [Any] source data to be serialized.
         # @param dependencies [Hash] _additional dependencies_ that should be merged to the _default dependencies_.
-        def serialize(object, dependencies: {})
-          raise "There is no serializer for this attribue '#{attr}'" if !@serializer
-          @serializer.call(object, @dependencies.merge(dependencies), attr)
+        def serialize(object, category = :default, dependencies: {})
+          raise "There is no serializer of type '#{category}' for this attribue '#{attr}'" unless serializer_category?(category)
+          call_block(object, @dependencies.merge(dependencies), attr, &@serializer[category.to_sym])
         end
 
-      end
+        # Checks if there's a `parser` defined for `category`
+        # @return [Boolean] `true` if the parser is defined, and `false` otherwise
+        def parser_category?(category = :default)
+          @parser.key?(category.to_sym)
+        end
+
+        # Checks if there's a `serializer` defined for `category`
+        # @return [Boolean] `true` if the serializer is defined, and `false` otherwise
+        def serializer_category?(category = :default)
+          @serializer.key?(category.to_sym)
+        end
+
+        private
 
+        # The methods may expect less parameters from some type of parsers.
+        #   Here, we ensure they are called with the expected number of parameters.
+        def call_block(*args, &block)
+          params = block.parameters.zip(args).map(&:last)
+          yield(*params)
+        end
+
+      end
     end
   end
 end