eco-helpers 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90298e8d317e2d72234cdb650b018b40d71dae3c0b95143ac4510f9f3242a42c
-  data.tar.gz: 8833b41ee773996db86e26392ae8be989db9ecdb2f6a5b9602ec9143277840a0
+  metadata.gz: e0c1cca427dcc2ced629146debcbe71a05f062002919b68b32e88ebddd86c25c
+  data.tar.gz: e74e5b3c8007af145e1255903a4a1a26dc785b84004434291524275a5ac38734
 SHA512:
-  metadata.gz: 36b915adf179fb4adaec1a27335770378449a0fcdecc3e39d8e5af6c0208fdd8688ac43ec670207b41faaa7bd518822c10b73c44ef11802d28548c80ded34678
-  data.tar.gz: 34ed17712f7071649ea20391dcd820f2cb0e67fcba0b2742685f25fe9270d59be1eb43cd533c260877565621b3c9202babfcdfa34176a30ea6a84f1b527d6ce0
+  metadata.gz: 55e089b0827e28aafb5ac51e5b7ff37a09a81ab71160087080ecff70a10a44397dec6d0e2d847f8a5767b52c44a6ae548affd06c28a6e4ccb3d2edf37472f81a
+  data.tar.gz: 4801acfeedc39e1287808f812845c915316e0bac92d16594fe412899483104cba6604f30e1cf717dae6438c2f4e69a4e1adb1ea7af863d3a2a27273a36b1ec3a

data/eco-helpers.gemspec

@@ -33,7 +33,5 @@ Gem::Specification.new do |s|
   s.add_dependency 'aws-sdk-ses',   '~> 1.14', '>= 1.14.0'
   s.add_dependency 'dotenv',        '~> 2.6',  '>= 2.6.0'
   s.add_dependency 'net-sftp',      '~> 2.1',  '>= 2.1.2'
-  s.add_dependency 'faker',         '~> 2',    '>= 2.1'
-  s.add_dependency 'distribution',  '~> 0.7',  '>= 0.7.3'
 
 end

data/lib/eco-helpers.rb

@@ -10,6 +10,5 @@ require_relative 'eco/language'
 require_relative 'eco/common'
 require_relative 'eco/data'
 require_relative 'eco/api'
-require_relative 'eco/tester'
 require_relative 'eco/cli'
 require_relative 'eco/assets'

data/lib/eco/api.rb

@@ -11,4 +11,3 @@ require_relative 'api/policies'
 require_relative 'api/error'
 require_relative 'api/organization'
 require_relative 'api/session'
-require_relative 'api/eco_faker'

data/lib/eco/api/common/people/person_entry_attribute_mapper.rb

@@ -31,10 +31,10 @@ module Eco
             raise "Constructor needs a PersonParser. Given: #{parser}" if !person_parser.is_a?(Eco::API::Common::People::PersonParser)
             raise "Expecting Mapper object. Given: #{attr_map}" if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
 
-            @source   = data
+            @source         = data
             @person_parser  = person_parser
-            @attr_map = attr_map
-            @logger   = logger
+            @attr_map       = attr_map
+            @logger         = logger
 
             if parsing?
               @external_entry   = data
@@ -142,34 +142,54 @@ module Eco
 
           # when parsing:
           def init_attr_trackers
-            # internal <-> external attributes
-            int_aliased     = @person_parser.all_attrs.select  { |attr| to_external(attr) }
-            ext_alias       = int_aliased.map { |attr| to_external(attr) }
-
-            # virtual attrs (non native internal attr that require aliasing):
-            ext_vi_aliased  = attributes(@external_entry).select do |attr|
-              !ext_alias.include?(attr) && @attr_map&.external?(attr)
+            # (def) all internal attributes we can expect
+            def_all_attrs     = @person_parser.all_attrs
+            # (def) internal attrs with no aliasing nor parser definition (expected to be direct)
+            def_unlinked      = @person_parser.undefined_attrs.select { |attr| !to_external(attr) }
+            # (def) those with parser or alias:
+            def_linked        = def_all_attrs - def_unlinked
+
+            # (data) data attributes (actual attributes of the entry)
+            data_attrs        = attributes(@external_entry)
+            # (data) attributes of the data that come directly as internal attribute names
+            data_direct_attrs = data_attrs & def_all_attrs
+
+            # (def) configured  as alised (internal <-> external attributes)
+            def_int_aliased   = def_all_attrs.select  { |attr| to_external(attr) }
+            def_ext_alias     = def_int_aliased.map   { |attr| to_external(attr) }
+
+            # (data) virtual attrs (external alias of non native internal attr in data):
+            data_vi_ext_alias = data_attrs.select do |attr|
+              !def_ext_alias.include?(attr) && @attr_map&.external?(attr)
             end
-
-            # internal name of external attrs that are not native internal attrs
-            int_vi_aliased  = ext_vi_aliased.map do |attr|
+            # (data) virtual internal attrs (the internal names of those virtual attrs)
+            data_vi_int_aliased = data_vi_ext_alias.map do |attr|
               # to_internal(attr) can't be used here, becauase virtual fields would get filtered out,
               # as they are not recognized by @parser.all_attrs.include?(attr)
               @attr_map.to_internal(attr)
             end.compact
 
-            @aliased_attrs  = int_aliased + int_vi_aliased
+            # (data) attrs that could come aliased in the current data
+            # => modify aliased based on those that came directly as internal attrs in the entry
+            data_def_int_aliased = def_int_aliased - data_direct_attrs
+            data_def_ext_alias   = data_def_int_aliased.map { |attr| to_external(attr) }
+            # (data) actual attrs of the data that come aliased
+            data_ext_alias       = data_def_ext_alias & data_attrs
 
-            int_unlinked    = @person_parser.undefined_attrs.select { |attr| !to_external(attr) }
-            # those with parser or alias:
-            int_linked      = @person_parser.all_attrs - int_unlinked
+            # (data) all internal attributes that could come aliased, with given the entry
+            @aliased_attrs       = data_def_int_aliased + data_vi_int_aliased
+            # (data) all those ext attrs present that will require aliasing
+            #data_ext_alias_all   = data_def_ext_alias   + data_vi_ext_alias
+            data_ext_alias_all   = data_ext_alias       + data_vi_ext_alias
 
-            ext_aliased     = ext_alias + ext_vi_aliased
             # those that are direct external to internal:
-            ext_direct      = attributes(@external_entry) - ext_aliased
+            data_ext_direct      = data_attrs - data_ext_alias_all
+
+            # (data) attributes that do not require aliasing
             # to avoid collisions between internal names:
-            @direct_attrs   = ext_direct - int_linked
-            @internal_attrs = @aliased_attrs | @direct_attrs
+            #@direct_attrs        = data_ext_direct - def_linked
+            @direct_attrs        = data_ext_direct
+            @internal_attrs      = @aliased_attrs | @direct_attrs
           end
 
           def attributes(value)

data/lib/eco/api/session/batch/feedback.rb

@@ -100,8 +100,11 @@ module Eco
                   end
                   msg << "#{sample.slice(0, sample_length).pretty_inspect}"
                 end
-                msg << "#{"+"*3}  #{type.to_s.upcase} length: #{requests.length}  #{"+"*3}  STATS  (job '#{name}')  #{"+"*3}"
+                stats_str = "#{"+"*3}  #{type.to_s.upcase} length: #{requests.length}  #{"+"*3}  STATS  (job '#{name}')  #{"+"*3}"
+                msg << "#{"-"*stats_str.length}" if only_stats
+                msg << stats_str
                 msg << "#{request_stats(requests).message}"
+                msg << "#{"-"*stats_str.length}" if only_stats
                 msg << "*" * header.length unless only_stats
               end
             end.join("\n")

data/lib/eco/api/session/batch/job.rb

@@ -29,7 +29,7 @@ module Eco
           attr_reader :usecase
           attr_reader :status, :feedback
 
-          # @param e [Eco::API::Common::Session::Environment] requires a session environmen, as any child of `Eco::API::Common::Session::BaseSession`
+          # @param e [Eco::API::Common::Session::Environment] requires a session environment, as any child of `Eco::API::Common::Session::BaseSession`
           # @param name [String] the name of this `batch job`
           # @param type [Symbol] a valid batch operation
           # @param usecase [Eco::API::UseCases::UseCase, nil] when provided: `usecase` that generated this `batch job`

data/lib/eco/api/session/batch/status.rb

@@ -27,7 +27,7 @@ module Eco
             end
           end
 
-          # @param e [Eco::API::Common::Session::Environment] requires a session environmen, as any child of `Eco::API::Common::Session::BaseSession`
+          # @param e [Eco::API::Common::Session::Environment] requires a session environment, as any child of `Eco::API::Common::Session::BaseSession`
           # @param queue  [Array<Hash>, Array<Ecoportal::API::V1::Person>, Array<Ecoportal::API::Internal::Person>] the `source_queue`
           # @param method [Symbol] the type of `batch operation`
           # @param mode [Symbol] the mode of `batch operation` (search)
@@ -83,7 +83,7 @@ module Eco
           #   1. `Integer`: index/position of the entry in the final `queue`
           #   2. `Hash`: entry queries can be raw `Hash` objects
           #   3. `Person` object: the most common case is to use the person wrapper classes of the `Ecoportal::API` namespace.
-          # @return response key [Ecoportal::API::Common::BatchResponse]
+          # @return [Ecoportal::API::Common::BatchResponse]
           def [](key)
             @responses[to_index(key)]
           end
@@ -97,10 +97,10 @@ module Eco
           end
 
           # The _person_ we got from the Server wrapped to the `Person` object for the input entry object `key`
-          # @note it only makes sense when the batch method used was `get`
+          # @note it only makes sense when the used batch method was `get`
           # @param key [Integer, Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           # @see Eco::API::Session::Batch::Status#[] for `key` options
-          # return [Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
+          # @return [Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           def person(key)
             return self[key].result if success?(key)
             nil
@@ -112,7 +112,7 @@ module Eco
           #   - **found using a search criteria** (`mode` == `:search`), as opposite to find the person directly by `external_id`
           # @param key [Integer, Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           # @see Eco::API::Session::Batch::Status#[] for `key` options
-          # return [Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
+          # @return [Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           def person_match(key)
             @person_match[to_index(key)]
           end
@@ -130,14 +130,14 @@ module Eco
           end
 
           # Has the _entry_ `key` been queried to the server?
-          # @param key [Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
+          # @param key [Integer, Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           # @return [Boolean] `true` if input entry `key` has an associated `Ecoportal::API::Common::BatchResponse`
           def received?(key)
             !!self[key]
           end
 
           # Has the _entry_ `key` 's query to the server been successful
-          # @param key [Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
+          # @param key [Integer, Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           # @return [Boolean] `true` if input entry `key` has not had a server Error during the query
           def success?(key)
             self[key]&.success?
@@ -169,6 +169,7 @@ module Eco
           end
 
           # Helper to transform any `key` to an `Integer` index
+          # @param key [Integer, Hash, Ecoportal::API::V1::Person, Ecoportal::API::Internal::Person]
           # @return [Integer] the index that `key` has in the final `queue`
           def to_index(key)
             key.is_a?(Integer) ? valid_index(index: key) : valid_index(entry: key)

data/lib/eco/api/session/config/workflow.rb

@@ -234,7 +234,7 @@ module Eco
             rescue SystemExit
               exit
             rescue Interrupt => i
-              raise i
+              raise
             rescue Exception => e
               self.rescue.call(e, io) if self.rescue
               raise

data/lib/eco/data.rb

@@ -5,5 +5,4 @@ end
 
 require_relative 'data/crypto'
 require_relative 'data/files'
-require_relative 'data/random'
 require_relative 'data/mapper'

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "1.1.5"
+  VERSION = "1.1.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6
 platform: ruby
 authors:
 - Oscar Segura
@@ -198,46 +198,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
-- !ruby/object:Gem::Dependency
-  name: faker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.1'
-- !ruby/object:Gem::Dependency
-  name: distribution
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.7.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.7.3
 description: 
 email:
 - oscar@ecoportal.co.nz
@@ -291,7 +251,6 @@ files:
 - lib/eco/api/common/version_patches/exception.rb
 - lib/eco/api/common/version_patches/hash.rb
 - lib/eco/api/common/version_patches/hash/deep_merge.rb
-- lib/eco/api/eco_faker.rb
 - lib/eco/api/error.rb
 - lib/eco/api/error/handler.rb
 - lib/eco/api/error/handlers.rb
@@ -390,10 +349,6 @@ files:
 - lib/eco/data/files/file_pattern.rb
 - lib/eco/data/files/helpers.rb
 - lib/eco/data/mapper.rb
-- lib/eco/data/random.rb
-- lib/eco/data/random/distribution.rb
-- lib/eco/data/random/fake.rb
-- lib/eco/data/random/values.rb
 - lib/eco/language.rb
 - lib/eco/language/curry.rb
 - lib/eco/language/hash_transform.rb
@@ -406,7 +361,6 @@ files:
 - lib/eco/language/models/parser_serializer.rb
 - lib/eco/language/models/wrap.rb
 - lib/eco/language/values_at.rb
-- lib/eco/tester.rb
 - lib/eco/version.rb
 homepage: https://www.ecoportal.com
 licenses:

data/lib/eco/api/eco_faker.rb

@@ -1,59 +0,0 @@
-module Eco
-  module API
-    # faker object
-    @@faker = nil
-    class EcoFaker
-      @@api = nil
-      @org = nil
-      # attr_accessor
-      attr_reader :org
-      def initialize(init = {})
-        set_settings(init)
-      end
-      # allows to change certain configuration settings on an existing Faker instance object
-      def set_settings (init = {})
-        @today = (aux = init['today'])? aux : Time.now
-        api = init.fetch('api', nil)
-        @@api = api.instance_of?(Ecoportal::API::Internal) && api
-        # this will initialize org basics (i.e. people_schemas, policy_groups, login_providers)
-        @org = Organization.new(init)
-      end
-      def newPerson ()
-
-      end
-      def modifyPerson(person)
-
-      end
-      private
-    end
-
-    def self.new(init = {})
-      @@faker = EcoFaker.new(init)
-    end
-
-    class FakePerson < Ecoportal::API::Internal::Person
-      @@faker
-      def initialize(faker, *args)
-        raise "You must initialize the faker first" unless faker && faker.instance_of(Faker)
-        @@faker = faker
-        super(*args)
-        @@faker.set_details
-      end
-    end
-
-    class FakeField
-      @@types = ["boolean", "number", "text", "select", "date", "phone_number"]
-      @@multiple = false
-      attr_accessor :type, :multiple
-      #attr_reader
-      def initialize (init = {})
-        init_values_generator(init)
-      end
-      private
-      def init_values_faker (init = {})
-        include
-        @fake_values = API::Data::Random::ValuesGenerator.new(init)
-      end
-    end
-  end
-end

data/lib/eco/data/random.rb

@@ -1,10 +0,0 @@
-module Eco
-  module Data
-    module Random
-    end
-  end
-end
-
-require_relative 'random/distribution'
-require_relative 'random/values'
-require_relative 'random/fake'

data/lib/eco/data/random/distribution.rb

@@ -1,133 +0,0 @@
-require 'distribution' # source: https://github.com/sciruby/distribution
-
-# todo: remove distribution dependency by developing a normal distribution generator
-# - Reference: https://stackoverflow.com/a/6178290/4352306
-
-module Eco
-  module Data
-    module Random
-      class Distribution
-
-        MAX_DECIMALS = 10
-        BALANCE = ["uniform", "normal", "half-normal", "forged"]
-
-        attr_accessor :decimals
-        attr_reader :calls
-        attr_reader :range, :min, :max, :balance, :mean, :sigma
-        attr_reader :weights, :weights_distribution
-        def initialize(init = {})
-          @calls = 0
-          @weight_positions = 0
-
-          @decimals = init.fetch('decimals', MAX_DECIMALS)
-          self.range = init.fetch('range', 0..1)
-          self.weights = init.fetch('weights', nil)
-          self.balance = init.fetch('balance', nil)
-
-          @normal = ::Distribution::Normal.rng(@mean, @sigma)
-          @random = ::Random.new
-        end
-
-        def balance=(value)
-          @balance = value
-          @balance = BALANCE[0] if !BALANCE.include?(@balance)
-          case @balance
-          when 'forged'
-            if @weights&.instance_of?(Array)
-              top = @weights.length - 1
-              self.range = (0..top)
-            end
-          end
-        end
-
-        def range=(value)
-          @range = value
-          @min = @range.first; @max = @range.last
-          @mean = @max / 2
-          @sigma = (@max - @mean) / 3.5
-        end
-
-        def weights=(value)
-          @weights = nil; @weights_distribution = nil; @weight_positions = 0
-          @weights = value if value && value.instance_of?(Array)
-          if @weights
-            total = @weights.inject(0, :+)
-            @weight_positions = total * 20
-            @weights_distribution = Array.new(@weight_positions)
-
-            i = 0; j = 0
-            while i < @weights.length
-              positions = (@weights[i] * @weight_positions / total).round
-              positions.times do
-                @weights_distribution[j] = i
-                j += 1
-              end
-              i += 1
-            end
-            if (missing = @weight_positions - j) >= 0
-              (missing + 1).times {
-                @weights_distribution[j] = 0
-                j += 1
-              }
-            end
-          end
-        end
-
-        def generate
-          @calls += 1
-          case @balance
-          when 'uniform'
-            num = generate_uniform
-          when 'normal'
-            num = generate_normal
-          when 'half-normal'
-            num = generate_half_normal
-          when 'forged'
-            num = generate_forged
-          else
-            num = generate_uniform
-          end
-
-          num = generate if num && !@range.member?(num.round)
-          return num && num.round(@decimals)
-        end
-
-        private
-
-        def generate_uniform
-          @random.rand(@range)
-        end
-
-        def generate_normal
-          @normal.call
-        end
-
-        def generate_half_normal
-          num = generate_normal
-          num = normal_mirror(num, @mean) if num.round < @mean
-          num = generate_half_normal if num.round == @mean
-          num -= @mean
-          num = num - 1 if num.round > 0 # move distribution to left (mirroring doubles density except at mean)
-          return num
-        end
-
-        def generate_forged
-          #raise "You need to assign weights to be able to use the forge balance!" if !@weights_distribution&.instance_of?(Array)
-          if @weights_distribution&.instance_of?(Array)
-            top = @weight_positions - 1
-            pos = @random.rand(0..top)
-            return weights_distribution[pos]
-          end
-          return generate_normal # should raise error at the beginning of the function
-        end
-
-        def normal_mirror (num, mean)
-          return mean + (mean - num) if num.round < mean
-          return mean - (num - mean) if num.round > mean
-          return num
-        end
-
-      end
-    end
-  end
-end

data/lib/eco/data/random/fake.rb

@@ -1,320 +0,0 @@
-require 'faker'
-
-module Eco
-  module Data
-    module Random
-      class Fake
-
-        MAX_UNIQUE_ERRORS = 13
-        DEFAULT_LOCALE = 'en'
-        DEFAULT_EMAIL_PATTERN = 'oscar+name@ecoportal.co.nz'
-        LOCALES_MAPS = {'en' => 'en', 'nz' => 'en-NZ', 'ca' => 'en-CA', 'uk' => 'en-GB', 'usa' => 'en-USA'}
-        TOPICS_MAPS = {
-          'general' => ['General', 'Vehicle', 'University', 'Address'],
-          'fantasy' => ['LordOfTheRings', 'Hobbit', 'HarryPotter', 'BackToTheFuture', 'FunnyName', 'GameOfThrones', 'PricesBride', 'StarWars', 'StarkTrek'],
-          'medieval-fantasy' => ['LordOfTheRings', 'Hobbit', 'GameOfThrones', 'PricesBride'],
-          'futuristic-fantasy' => ['BackToTheFuture', 'StarWars', 'StarTrek'],
-          'tolkien' => ['LordOfTheRings', 'Hobbit'],
-          'funny' => ['FunnyName', 'Simpsons', 'Superhero'],
-          'famous' => ['Book', 'GreekPhilosophers' ,'Scientists', 'SiliconValley', 'Space', 'WorldCup'],
-          'philosophers' => 'GreekPhilosophers'
-        }
-        @name = nil; @name_topics = nil
-        @location = nil; @location_topics = nil
-
-        attr_reader :local, :topic, :general_topic_on_fail
-        attr_reader :today, :email_pattern, :unique_errors, :unique_resets, :force_unique
-
-        def initialize(init = {})
-          @unique_resets = 0; @unique_errors = 0
-          init_topics
-          self.topic = init.fetch('topic', TOPICS_MAPS.keys.sample)
-          self.general_topic_on_fail = init.fetch('general_topic_on_fail', false)
-          self.force_unique = init.fetch('force_unique', false)
-
-          self.local = init.fetch('local', nil)
-          self.today = init.fetch('today', Date.today)
-          self.email_pattern = init.fetch('email_pattern', DEFAULT_EMAIL_PATTERN)
-
-          @boolean = Faker::Boolean.method('boolean')
-          @date_between = Faker::Date.method('between')
-
-          @gender = Faker::Gender.method('binary_type')
-
-          @name = get_topic_wrapper(@name_topics)
-          @company = get_topic_wrapper(@company_topics)
-          @location = get_topic_wrapper(@location_topics)
-
-          @community = wrap_method { Faker::Address.community }
-          @address = wrap_method { Faker::Address.unique.full_address }
-          @country = wrap_method { Faker::Address.country }
-          @city = wrap_method { Faker::Address.city }
-          @postcode = wrap_method { Faker::Address.postcode }
-          @timezone = Faker::Address.method('time_zone')
-
-          @phone = wrap_method { Faker::PhoneNumber.unique.phone_number }
-          @mobile = wrap_method { Faker::PhoneNumber.unique.cell_phone }
-          @mobile_code = wrap_method { Faker::Code.unique.imei }
-        end
-
-        def topic=(value)
-          @topic = TOPICS_MAPS.values.first # 'General'
-          @topic = TOPICS_MAPS[value.downcase] if value && TOPICS_MAPS.keys.include?(value.downcase)
-          init_topic_wrappers
-        end
-
-        def general_topic_on_fail=(value)
-          @general_topic_on_fail = value
-        end
-
-        def today=(value)
-          @today = nil
-          @today = value if value.instance_of?(Date)
-          @today = Date.today if !@today
-        end
-
-        def email_pattern=(value)
-          @email_pattern = value
-          @email_pattern = DEFAULT_EMAIL_PATTERN if !@mail_pattern&.include?('@ecoportal.co.nz')
-        end
-
-        def local=(value)
-          @local = DEFAULT_LOCALE
-          alias_locales = LOCALES_MAPS.keys; locales = LOCALES_MAPS.values
-          permitted = value && (alias_locales.include?(value.downcase) || locales.include?(value))
-          @local = LOCALES_MAPS[value.downcase] if permitted
-          ::Faker::Config.locale = @local
-        end
-
-        def force_unique=(value)
-          @force_unique = !!value
-        end
-
-        def reset_unique
-          @unique_errors = 0
-          @unique_resets += 1
-          ::Faker::UniqueGenerator.clear
-        end
-
-        def boolean
-          @boolean.call
-        end
-
-        def past_date(years = 3)
-          @date_between.call(previous_date(years), @today)
-        end
-
-        def future_date(years = 3)
-          @date_between.call(@today, later_date(years))
-        end
-
-        def birthday(min_age = 18, max_age = 65)
-          @date_between.call(previous_date(min_age), previous_date(max_age))
-        end
-
-        def name
-          new_value = get_unique(@name, @name_topics)
-          @name = get_topic_wrapper(@name_topics)
-          return new_value
-        end
-
-        def company
-          new_value = get_unique(@company, @company_topics)
-          @company = get_topic_wrapper(@company_topics)
-          return new_value
-        end
-
-        def community
-          @community.call
-        end
-
-        def location
-          new_value = get_unique(@location, @location_topics)
-          @location = get_topic_wrapper(@location_topics)
-          return new_value
-        end
-
-        def address
-          @address.call
-        end
-
-        def contry
-          @country.call
-        end
-
-        def city
-          @city.call
-        end
-
-        def postcode
-          @postcode.call
-        end
-
-        def timezone
-          @timezone.call
-        end
-
-        def gender
-          @geneder.call
-        end
-
-        def email(str_name = nil)
-          str_name = self.name if !str_name&.strip
-          @email_pattern.gsub('name', email_encode(str_name))
-        end
-
-        def phone
-          @phone.call
-        end
-
-        def mobile
-          @mobile.call
-        end
-
-        def mobile_code
-          @mobile_code.call
-        end
-
-        private
-
-        def unique_error_count
-          @unique_errors += 1
-          unique_overflow = @unique_errors > MAX_UNIQUE_ERRORS
-          err_msg = "Error uniqueness broken"
-          raise Faker::UniqueGenerator::RetryLimitExceeded.new(err_msg), err_msg if self.force_unique && unique_overflow
-          self.reset_unique if unique_overflow
-        end
-
-        def previous_date(years = 3)
-          @today - (years * 365)
-        end
-
-        def later_date(years = 3)
-          @today + (years * 365)
-        end
-
-        def init_topics
-          @name_topics = {
-            'General' => wrap_method { Faker::Name.unique.name },
-            'LordOfTheRings' => wrap_method { Faker::LordOfTheRings.unique.character },
-            'Hobbit' => wrap_method { Faker::Hobbit.unique.character },
-            'BackToTheFuture' => wrap_method { Faker::BackToTheFuture.unique.character },
-            'HarryPotter' =>  wrap_method { Faker::HarryPotter.unique.character },
-            'GameOfThrones' => wrap_method { Faker::GameOfThrones.unique.character },
-            'PrincesBride' => wrap_method { Faker::PrincesBride.unique.character },
-            'StarWars' => wrap_method { Faker::StarWars.unique.character },
-            'StarTrek' => wrap_method { Faker::StarTrek.unique.character },
-            'Simpsons' => wrap_method { Faker::Simpsons.unique.character },
-            'Superhero' => wrap_method { Faker::Superhero.unique.name },
-            'FunnyName' => wrap_method { Faker::FunnyName.unique.name },
-            'Book' => wrap_method { Faker::Book.unique.author },
-            'GreekPhilosophers' => wrap_method { Faker::GreekPhilosophers.unique.name },
-            'Scientists' => wrap_method { Faker::Science.unique.scientist },
-            'SiliconValley' => wrap_method { Faker::SiliconValley.unique.character },
-            'WorldCup' => wrap_method { Faker::WorldCup.unique.roster }
-          }
-
-          @location_topics = {
-            'General' => wrap_method { Faker::Nation.capital_city },
-            'LordOfTheRings' => wrap_method { Faker::LordOfTheRings.location },
-            'Hobbit' => wrap_method { Faker::Hobbit.location },
-            'HarryPotter' => wrap_method { Faker::HarryPotter.location },
-            'GameOfThrones' => wrap_method { Faker::GameOfThrones.city },
-            'Simpsons' => wrap_method { Faker::Simpsons.location },
-            'StarTrek' => wrap_method { Faker::StarTrek.location },
-            'WorldCup' => wrap_method { Faker::WorldCup.city },
-            'University' => wrap_method { Faker::University.name },
-            'Address' => wrap_method { Faker::Address.city }
-          }
-
-          @company_topics = {
-            'General' => wrap_method { Faker::Company.name },
-            'Vehicle' => wrap_method {  Faker::Vehicle.manufacture },
-            'SiliconValley' => wrap_method { Faker::SiliconValley.company },
-            'Space' => wrap_method { Faker::Space.company }
-          }
-
-          @deparment_topics = {
-            'General' => wrap_method { Faker::Commerce.department }
-          }
-        end
-
-        def init_topic_wrappers
-          @name = get_topic_wrapper(@name_topics)
-          @location = get_topic_wrapper(@location_topics)
-        end
-
-        def get_topic_wrapper(type_topics)
-          all_topics = @topic.instance_of?(Array)? @topic : [@topic]
-          topics = filter_by_key(type_topics, all_topics)
-          failed_topic = !@topic || !topics || topics.values.length < 1
-
-          if !failed_topic
-            topic = topics.values.sample
-            #puts "\"Custom!!!!\""
-          else
-            if @general_topic_on_fail
-              topic = type_topics.fetch('General', nil)
-              #puts "\"Genearal!!!!\""
-            else
-              topic = type_topics.values.sample
-              #puts "\"Force Random!!!!\""
-            end
-          end
-          return topic
-        end
-
-        def get_unique(wrapper, related_topics)
-          begin
-            new_value = wrapper.call
-          rescue Faker::UniqueGenerator::RetryLimitExceeded
-            unique_error_count
-            wrapper = get_topic_wrapper(related_topics)
-            new_value = get_unique(wrapper, related_topics)
-          end
-          return new_value
-        end
-
-        def filter_by_key (hash, keys)
-          hash.select { |k,v| keys.include?(k) }
-        end
-
-        # should allow different topics
-        def email_encode(str)
-          return nil if !str.is_a?(String)
-          return str.gsub(/\s+/,"_")&.gsub(/\W/,"")&.slice(0,25).downcase
-        end
-
-        def wrap_method(&block)
-          block
-        end
-
-        def self.test(test_times = 500, fantasy: true, force_unique: false)
-          pp "##########  Testing Faker wrapper ###########"
-          topic = if fantasy then 'fantasy' else nil end
-          faker = self.new({
-            'today' => Date.new(2018,1,1),
-            'locale' => 'nz',
-            'topic' => topic,
-            'general_topic_on_fail' => true,
-            'force_unique' => force_unique
-          })
-          begin
-            items = 0
-            test_times.times {
-              pp "#{name=faker.name} - #{faker.birthday(20, 40).to_s} : #{faker.mobile} : #{faker.email(name)}" + \
-                  " : #{faker.location} : #{faker.company} : #{faker.community}"
-              items += 1
-            }
-          rescue ::Faker::UniqueGenerator::RetryLimitExceeded => e
-            puts "###  Error: #{e.message}  ###"
-          end
-          puts "total generated: #{items}"
-          puts "locale: #{faker.local}; topic: #{topic}"
-          puts "unique errors: #{faker.unique_errors} & #{faker.unique_resets} resets"
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-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/tester.rb

@@ -1,97 +0,0 @@
-require 'pp'
-
-module Eco
-  TEST_TIMES = 5000
-  RANDOM = Eco::Data::Random
-  class Tester
-    include Data
-
-    def test_normal(test_times = TEST_TIMES)
-      pp "##########  Testing Normal Distribution ###########"
-      generator_config = {
-        "range" => (1..100),
-        "decimals" => 0,
-        "balance" => 'normal'
-      }
-      generator = RANDOM::Distribution.new(generator_config)
-      frequency = frequency_sample(generator, test_times)
-      draw_frequency(frequency)
-    end
-
-    def test_half_normal(test_times = TEST_TIMES)
-      pp "##########  Testing Half-Normal Distribution ###########"
-      generator_config = {
-        "range" => (1..100),
-        "decimals" => 0,
-        "balance" => 'half-normal'
-      }
-      generator = RANDOM::Distribution.new(generator_config)
-      frequency = frequency_sample(generator, test_times)
-      draw_frequency(frequency)
-    end
-
-    def test_forged(test_times = TEST_TIMES)
-      pp "##########  Testing Forged Distribution ###########"
-      generator_config = {
-        "range" => (1..100),
-        "decimals" => 0,
-        "balance" => 'forged'
-      }
-      options_weight = {"One" => 10, "Two" => 5, "Three" => 2, "Four" => 1, "Five" => 1}
-      options_config = {
-        #'generator_config' => generator_config,
-        'options_weight' => options_weight,
-        'multiple' => false,
-        'quantity' => 2
-      }
-
-      generator = RANDOM::Values.new(options_config)
-      frequency = frequency_sample(generator, test_times)
-      draw_frequency(frequency)
-    end
-
-    private
-
-    def frequency_sample (generator, test_times = TEST_TIMES)
-      frequency = Hash.new {|hash, key| hash[key]=0}
-      test_times.times.map {
-        val = generator.generate
-        "here a nil!!" if !val
-        val = val.round if val.is_a? Numeric
-        frequency[val] += 1 if val
-      }
-      return frequency
-    end
-
-    def draw_frequency(frequency, generator = nil, histogram: true)
-      #pp frequency
-      vals = frequency.values
-      test_times = vals.inject(0, :+)
-      opts = vals.length
-
-      raise "no tests to show" if !test_times || test_times < 1
-      dimension = Math::log10(test_times)
-      draw_unit = (10**(dimension - 1) / (opts * 3)).round
-
-      total = 0; sum = 0
-      frequency.keys.sort.each do |k|
-        f = frequency[k]
-        percent = (f * 100 / test_times ).round
-        puts "#{k} (#{percent}/100): #{'*' * (f / draw_unit).round}" if :historgram
-        #puts "#{k} (#{percent}/100): #{'*' * f}" if :historgram
-        puts "#{k} (#{percent}/100): #{f}" if !:historgram
-        total += frequency[k]
-        v = k
-        v = 1 if !k.is_a? Numeric
-        sum += (frequency[k] * v)
-      end
-
-      summary = "total: #{total}; mean: #{sum / total}"
-      summary += "; draw unit #{draw_unit}" if :historgram
-      puts summary
-      pp "generator weights (config): #{generator.weights}" if generator
-      pp "generator unique  (config): #{generator.unique}" if generator
-    end
-
-  end
-end