eco-helpers 0.6.0

data/lib/eco/data/random/values.rb

@@ -0,0 +1,80 @@
+require 'json'
+
+module Eco
+  module Data
+    module Random
+      class Values
+
+        attr_accessor :multiple, :unique
+        attr_reader :options, :weights, :options_weight, :quantity
+        attr_reader :generator, :generator_config
+
+        def initialize(init = {})
+          @multiple = init.fetch('multiple', false)
+          @unique = init.fetch('unique', true)
+          self.quantity = init.fetch('quantity', nil)
+          @options_weight = init.fetch('options_weight', nil)
+          @options = init.fetch('options', @options_weight&.keys)
+          @weights = @options_weight&.values
+
+          @generator_config = init.fetch('generator_config', { "decimals" => 0 })
+          if @weights
+            @generator_config['weights'] = @weights unless @generator_config.key?('weights')
+            @generator_config['balance'] = 'forged' unless @generator_config.key?('balance')
+          else
+            case
+            when @options&.instance_of?(Array)
+              @generator_config['weights'] = @weights unless @generator_config.key?('weights')
+            end
+          end
+          @generator = Distribution.new(@generator_config)
+          @random = ::Random.new
+        end
+
+        def quantity=(num_or_range) # attr_writer
+          val = num_or_range
+          case
+          when val.is_a?(Numeric)
+            num = val.round
+            rng = (num..num)
+          when val.instance_of?(Range)
+            rng = val
+          else
+            rng = (0..1)
+          end
+          @quantity = rng
+        end
+
+        def generate
+          if @multiple
+            quantity = @random.rand(@quantity)
+            value = []
+            quantity.times {
+              val = @unique? generate_option(exclude: value): generate_option
+              value.push(val)
+            }
+            value = value.uniq if @unique
+          else
+            value = generate_option
+          end
+          return value
+        end
+
+        def generate_option(exclude: [])
+          case
+          when @options&.instance_of?(Array)
+            val = @options[@generator.generate]
+          else
+            puts "something bad with @options"
+          end
+          #exclude_aux = Marshal.load(Marshal::dump(exclude))
+          exclude_aux = JSON.parse(exclude.to_json)
+          exclude_aux.pop
+          val = generate_option(exclude: exclude_aux) if exclude.include?(val)
+          return val
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/language.rb

@@ -0,0 +1,12 @@
+module Eco
+  module Language
+  end
+end
+
+require_relative 'language/models'
+require_relative 'language/curry'
+require_relative 'language/hash_transform_modifier'
+require_relative 'language/hash_transform'
+require_relative 'language/values_at'
+require_relative 'language/match_modifier'
+require_relative 'language/match'

data/lib/eco/language/curry.rb

@@ -0,0 +1,28 @@
+module Eco
+  module Language
+
+    def required_parameters(method)
+      method.parameters.select { |type, _| type == :req || :keyreq}
+    end
+
+    def required_parameters?(method)
+      required_parameters(method).length > 0
+    end
+
+    def curry(method)
+      -> (*args, **kargs) {
+        required  = method.parameters.select { |type, _| type == :req }
+        krequired = method.parameters.select { |type, _| type == :keyreq }
+        all_args = (required.length <= args.length)
+        all_keys = krequired.all? { |_, name| kargs.has_key?(name) }
+        if all_args && all_keys
+          final_args = (args + kargs.map {|k,v| {k => v} })
+          method.call(*final_args)
+        else
+          -> (*args_, **kargs_) { curry(method)[*args, *args_, **kargs, **kargs_] }
+        end
+      }
+    end
+
+  end
+end

data/lib/eco/language/hash_transform.rb

@@ -0,0 +1,68 @@
+module Eco
+  module Language
+
+    def sym_str_transform(value, mode = HashTransformModifier.new)
+      v = value
+      if value && (value.is_a?(Symbol) || value.is_a?(String))
+        if mode.symbolize? && !value.is_a?(Symbol)
+          colon = mode.colon? && !value.include?(" ") && (
+            starts = value.start_with?(":") ||
+            ends   = value.end_with?(":")
+          )
+          if !mode.colon? || colon
+            value = value.slice(1, value.length) if colon && starts
+            value = value.slice(0, -1) if colon && ends
+            v = (value.to_sym rescue value) || value
+          end
+        elsif !value.is_a?(String) # stringify
+          v = (value.to_s rescue value) || value
+          v = ":" + v if mode.colon?
+        end
+      end
+      v
+    end
+
+    def hash_transform(hash, mode = HashTransformModifier.new)
+      hash = (mode.clone?) ? Marshal.load(Marshal.dump(hash)) : hash
+      hash.keys.each do |key|
+        value = (mode.keys?) ? hash.delete(key) : hash[key]
+        value = (value.is_a?(Hash) && mode.recurse?) ? hash_transform(value, mode) : value
+        value = sym_str_transform(value, mode) if mode.values?
+        key   = sym_str_transform(key,   mode) if mode.keys?
+        hash[key] = value
+      end
+      hash
+    end
+
+    def symbolize_keys(hash, mode = HashTransformModifier.new)
+      mode = mode.new.symbolize.keys
+      hash_transform(hash, mode)
+    end
+
+    def stringify_keys(hash, mode = HashTransformModifier.new)
+      mode = mode.new.stringify.keys
+      hash_transform(hash, mode)
+    end
+
+    def symbolize_values(hash, mode = HashTransformModifier.new)
+      mode = mode.new.symbolize.values
+      hash_transform(hash, mode)
+    end
+
+    def stringify_values(hash, mode = HashTransformModifier.new)
+      mode = mode.new.stringify.values
+      hash_transform(hash, mode)
+    end
+
+    def symbolize_hash(hash, mode = HashTransformModifier.new)
+      mode = mode.new.symbolize.keys.values
+      hash_transform(hash, mode)
+    end
+
+    def stringify_hash(hash, mode = HashTransformModifier.new)
+      mode = mode.new.stringify.keys.values
+      hash_transform(hash, mode)
+    end
+
+  end
+end

data/lib/eco/language/hash_transform_modifier.rb

@@ -0,0 +1,114 @@
+module Eco
+  module Language
+    class HashTransformModifier < Eco::Language::Models::Modifier
+
+      FLAT_MODE         = [:flat, :non_recursivre]
+      RECURSIVE_MODE    = [:recurse, :deep, :recursive, :r]
+
+      COPY_MODE         = [:copy, :clone, :c]
+      BANG_MODE         = [:!, :bang]
+
+      COLON_MODE        = [:colon, :colon_to_key, :only_colon]
+      ALL_TO_SYM        = [:all_to_sym, :all]
+
+      STRINGIFY_MODE    = [:stringify, :string, :to_s]
+      SYMBOLIZE_MODE    = [:symbolize, :sym, :to_sym]
+
+      KEYS_MODE         = [:keys]
+      NO_KEYS_MODE      = [:no_keys]
+
+      NO_VALUES_MODE    = [:no_values]
+      VALUES_MODE       = [:values]
+
+      def reset_recursive
+        self < self.mode - (RECURSIVE_MODE | FLAT_MODE)
+      end
+
+      def reset_bang
+        self < self.mode - (BANG_MODE | COPY_MODE)
+      end
+
+      def reset_colon_mode
+        self < self.mode - (COLON_MODE | ALL_TO_SYM)
+      end
+
+      def recurse
+        self.push(:recurse)
+      end
+
+      def non_recurse
+        self.push(:flat)
+      end
+
+      def copy
+        self.push(:copy)
+      end
+
+      def bang
+        self.push(:bang)
+      end
+
+      def colon
+        self.push(:colon)
+      end
+
+      def all
+        self.push(:all)
+      end
+
+      def symbolize
+        self.push(:symbolize)
+      end
+
+      def stringify
+        self.push(:stringify)
+      end
+
+      def keys
+        self.push(:keys)
+      end
+
+      def values
+        self.push(:values)
+      end
+
+      def recurse?
+        mode.any? { |m| RECURSIVE_MODE.include?(m) }
+      end
+
+      def clone?
+        mode.all? { |m| !BANG_MODE.include?(m) }
+      end
+
+      def colon?
+        mode.any? { |m| COLON_MODE.include?(m) }
+      end
+
+      def symbolize?
+        mode.any? { |m| SYMBOLIZE_MODE.include?(m) }
+      end
+
+      def keys?
+        mode.any? { |m| KEYS_MODE.include?(m) }
+      end
+
+      def values?
+        mode.any? { |m| VALUES_MODE.include?(m) }
+      end
+
+      protected
+
+      def resolve_mode
+        modifiers = self.to_a
+        modifiers = resolve(modifiers, RECURSIVE_MODE | FLAT_MODE)
+        modifiers = resolve(modifiers, BANG_MODE | COPY_MODE)
+        modifiers = resolve(modifiers, COLON_MODE | ALL_TO_SYM)
+        modifiers = resolve(modifiers, STRINGIFY_MODE | SYMBOLIZE_MODE)
+        modifiers = resolve(modifiers, KEYS_MODE | NO_KEYS_MODE)
+        modifiers = resolve(modifiers, VALUES_MODE | NO_VALUES_MODE)
+        modifiers
+      end
+
+    end
+  end
+end

data/lib/eco/language/match.rb

@@ -0,0 +1,30 @@
+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) }
+
+      case
+      when mode.reverse?
+        return match?(at   , value, mode.new.reset_reverse)
+      when mode.pattern?
+        at = mode.to_regex(at)
+        return match?(value,    at, mode.new.reset_pattern)
+      when value.is_a?(Array)
+        return value.any?(&out_match) if mode.any?
+        return value.all?(&out_match) # defaults to EVERY
+      when at.is_a?(Array)
+        return at.all?(&in_match) if mode.and?
+        return at.any?(&in_match) # defaullts to OR
+      when at.is_a?(Regexp)
+        return at.match?(value)
+      when value.is_a?(Regexp)
+        return value.match?(at)
+      else # final compare
+        m = (value == at) ||
+          (mode.insensitive? && at&.downcase == value&.downcase)
+        (mode.not?) ? !m : m
+      end
+    end
+  end
+end

data/lib/eco/language/match_modifier.rb

@@ -0,0 +1,190 @@
+module Eco
+  module Language
+    class MatchModifier < Eco::Language::Models::Modifier
+
+      VALUE_MODE   = [   :value,       :is,         ]
+      PATTERN_MODE = [ :pattern, :contains, :regexp ]
+
+      REVERSE_MODE     = [ :reverse, :at_to_value, :<< ]
+      NON_REVERSE_MODE = [  :normal, :value_to_at, :non_reverse, :>> ]
+
+      ALL_MODE = [ :all, :every ]
+      ANY_MODE = [ :any,  :some ]
+
+      AND_MODE = [ :AND, :and, :&, :intersection, :intersect ]
+      OR_MODE  = [  :OR,  :or, :|, :union ]
+
+      CASE_MODE   = [ :c,   :case_sensitive, :case, :sensitive ]
+      INCASE_MODE = [ :i, :case_insensitive, :insensitive ]
+
+      YES_MODE = [ :==, :YES, :yes,  :true, :include,   :eq ]
+      NOT_MODE = [  :!, :NOT, :not, :false, :exclude, :diff ]
+
+      def to_regex(value)
+        case
+        when value.is_a?(Array)
+          return value.map { |v| self.to_regex(v) }
+        when value.is_a?(Regexp)
+          return value
+        when value.is_a?(String)
+          esub = Regexp.escape(value)
+          if self.insensitive?
+            return /#{esub}/i
+          else
+            return /#{esub}/
+          end
+        end
+      end
+
+      def reset_pattern
+        self < self.mode - (PATTERN_MODE | VALUE_MODE)
+      end
+
+      def reset_reverse
+        self < self.mode - (REVERSE_MODE | NON_REVERSE_MODE)
+      end
+
+      def reset_every
+        self < self.mode - (ALL_MODE | ANY_MODE)
+      end
+
+      def reset_and
+        self < self.mode - (AND_MODE | OR_MODE)
+      end
+
+      def reset_case
+        self < self.mode - (INCASE_MODE | CASE_MODE)
+      end
+
+      def reset_not
+        self < self.mode - (NOT_MODE | YES_MODE)
+      end
+
+      def pattern
+        self.push(:pattern)
+      end
+
+      def value
+        self.push(:value)
+      end
+
+      def reverse
+        self.push(:reverse)
+      end
+
+      def normal
+        self.push(:normal)
+      end
+
+      def every
+        self.push(:every)
+      end
+
+      def all
+        every
+      end
+
+      def some
+        self.push(:some)
+      end
+
+      def any
+        some
+      end
+
+      def and
+        self.push(:and)
+      end
+
+      def or
+        self.push(:or)
+      end
+
+      def case
+        self.push(:sensitive)
+      end
+
+      def insensitive
+        self.push(:insensitive)
+      end
+
+      def eq
+        self.push(:eq)
+      end
+
+      def not
+        self.push(:not)
+      end
+
+      def pattern?
+        mode.any? { |m| PATTERN_MODE.include?(m) }
+      end
+
+      def value?
+        mode.any? { |m| VALUE_MODE.include?(m) }
+      end
+
+      def reverse?
+        mode.any? { |m| REVERSE_MODE.include?(m) }
+      end
+
+      def non_reverse?
+        mode.any? { |m| NON_REVERSE_MODE.include?(m) }
+      end
+
+      def any?
+        mode.any? { |m| ANY_MODE.include?(m) }
+      end
+
+      def some?
+        self.any?
+      end
+
+      def all?
+        mode.any? { |m| ALL_MODE.include?(m) }
+      end
+
+      def every?
+        self.all?
+      end
+
+      def and?
+        mode.any? { |m| AND_MODE.include?(m) }
+      end
+
+      def or?
+        mode.any? { |m| OR_MODE.include?(m) }
+      end
+
+      def insensitive?
+        mode.any? { |m| INCASE_MODE.include?(m) }
+      end
+
+      def case_sensitive?
+        mode.any? { |m| CASE_MODE.include?(m) }
+      end
+
+      def not?
+        mode.any? { |m| NOT_MODE.include?(m) }
+      end
+
+      def yes?
+        mode.any? { |m| YES_MODE.include?(m) }
+      end
+
+      protected
+
+      def resolve_mode
+        modifiers = self.to_a
+        modifiers = resolve(modifiers, PATTERN_MODE | VALUE_MODE)
+        modifiers = resolve(modifiers, REVERSE_MODE | NON_REVERSE_MODE)
+        modifiers = resolve(modifiers, ALL_MODE | ANY_MODE)
+        modifiers = resolve(modifiers, AND_MODE | OR_MODE)
+        modifiers = resolve(modifiers, INCASE_MODE | CASE_MODE)
+        modifiers = resolve(modifiers, NOT_MODE | YES_MODE)
+        modifiers
+      end
+
+    end
+  end
+end