faker 1.1.2 → 3.2.0

data/lib/faker/tv_shows/the_office.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    class TheOffice < Base
+      flexible :the_office
+
+      class << self
+        ##
+        # Produces a character from The Office.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TheOffice.character #=> "Michael Scott"
+        #
+        # @faker.version next
+        def character
+          fetch('the_office.characters')
+        end
+
+        ##
+        # Produces a quote from The Office.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TheOffice.quote #=> "Identity theft is not a joke, Jim! Millions of families suffer every year."
+        #
+        # @faker.version next
+        def quote
+          fetch('the_office.quotes')
+        end
+      end
+    end
+  end
+end

data/lib/faker/tv_shows/the_thick_of_it.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    class TheThickOfIt < Base
+      flexible :the_thick_of_it
+
+      class << self
+        ##
+        # Produces a character from The Thick of It.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TheThickOfIt.character #=> "Nicola Murray"
+        #
+        # @faker.version 1.8.5
+        def character
+          fetch('the_thick_of_it.characters')
+        end
+
+        ##
+        # Produces a department from The Thick of It.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TheThickOfIt.department #=> "Shadow Cabinet"
+        #
+        # @faker.version 1.8.5
+        def department
+          fetch('the_thick_of_it.departments')
+        end
+
+        ##
+        # Produces a position from The Thick of It.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TheThickOfIt.position
+        #     #=> "Director of Communications"
+        #
+        # @faker.version 1.8.5
+        def position
+          fetch('the_thick_of_it.positions')
+        end
+      end
+    end
+  end
+end

data/lib/faker/tv_shows/twin_peaks.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    class TwinPeaks < Base
+      flexible :twin_peaks
+
+      class << self
+        ##
+        # Produces a character from Twin Peaks.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TwinPeaks.character #=> "Dale Cooper"
+        #
+        # @faker.version 1.7.0
+        def character
+          fetch('twin_peaks.characters')
+        end
+
+        ##
+        # Produces a location from Twin Peaks.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TwinPeaks.location #=> "Black Lodge"
+        #
+        # @faker.version 1.7.0
+        def location
+          fetch('twin_peaks.locations')
+        end
+
+        ##
+        # Produces a quote from Twin Peaks.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::TwinPeaks.quote
+        #     #=> "The owls are not what they seem."
+        #
+        # @faker.version 1.7.0
+        def quote
+          fetch('twin_peaks.quotes')
+        end
+      end
+    end
+  end
+end

data/lib/faker/tv_shows/venture_bros.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Faker
+  class TvShows
+    class VentureBros < Base
+      flexible :venture_bros
+
+      class << self
+        ##
+        # Produces a character from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.character #=> "Scaramantula"
+        #
+        # @faker.version 1.8.3
+        def character
+          fetch('venture_bros.character')
+        end
+
+        ##
+        # Produces an organization from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.organization
+        #     #=> "Guild of Calamitous Intent"
+        #
+        # @faker.version 1.8.3
+        def organization
+          fetch('venture_bros.organization')
+        end
+
+        ##
+        # Produces a vehicle from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.vehicle #=> "Monarchmobile"
+        #
+        # @faker.version 1.8.3
+        def vehicle
+          fetch('venture_bros.vehicle')
+        end
+
+        ##
+        # Produces a quote from The Venture Bros.
+        #
+        # @return [String]
+        #
+        # @example
+        #   Faker::TvShows::VentureBros.quote
+        #     #=> "Revenge, like gazpacho soup, is best served cold, precise, and merciless."
+        #
+        # @faker.version 1.8.3
+        def quote
+          fetch('venture_bros.quote')
+        end
+      end
+    end
+  end
+end

data/lib/faker/version.rb

@@ -1,3 +1,5 @@
-module Faker #:nodoc:
-  VERSION = "1.1.2"
+# frozen_string_literal: true
+
+module Faker # :nodoc:
+  VERSION = '3.2.0'
 end

data/lib/faker.rb

@@ -1,23 +1,36 @@
-mydir = File.expand_path(File.dirname(__FILE__))
+# frozen_string_literal: true
 
-begin
-  require 'psych'
-rescue LoadError
-end
+mydir = __dir__
 
+require 'psych'
 require 'i18n'
-I18n.load_path += Dir[File.join(mydir, 'locales', '*.yml')]
-I18n.reload!
 
+Dir.glob(File.join(mydir, 'helpers', '*.rb')).sort.each { |file| require file }
 
-module Faker
-  class Config
-    @locale = nil
+I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
 
+module Faker
+  module Config
     class << self
-      attr_writer :locale
+      def locale=(new_locale)
+        Thread.current[:faker_config_locale] = new_locale
+      end
+
       def locale
-        @locale || I18n.locale.downcase
+        # Because I18n.locale defaults to :en, if we don't have :en in our available_locales, errors will happen
+        Thread.current[:faker_config_locale] || (I18n.available_locales.include?(I18n.locale) ? I18n.locale : I18n.available_locales.first)
+      end
+
+      def own_locale
+        Thread.current[:faker_config_locale]
+      end
+
+      def random=(new_random)
+        Thread.current[:faker_config_random] = new_random
+      end
+
+      def random
+        Thread.current[:faker_config_random] || Random
       end
     end
   end
@@ -25,16 +38,23 @@ module Faker
   class Base
     Numbers = Array(0..9)
     ULetters = Array('A'..'Z')
-    Letters = ULetters + Array('a'..'z')
+    LLetters = Array('a'..'z')
+    Letters = ULetters + LLetters
 
     class << self
-      ## make sure numerify results doesn’t start with a zero
-      def numerify(number_string)
-        number_string.sub(/#/) { (rand(9)+1).to_s }.gsub(/#/) { rand(10).to_s }
+      attr_reader :flexible_key
+
+      NOT_GIVEN = Object.new
+
+      ## by default numerify results do not start with a zero
+      def numerify(number_string, leading_zero: false)
+        return number_string.gsub(/#/) { rand(10).to_s } if leading_zero
+
+        number_string.sub(/#/) { rand(1..9).to_s }.gsub(/#/) { rand(10).to_s }
       end
 
       def letterify(letter_string)
-        letter_string.gsub(/\?/) { ULetters.sample }
+        letter_string.gsub(/\?/) { sample(ULetters) }
       end
 
       def bothify(string)
@@ -60,27 +80,38 @@ module Faker
       #
       # "U3V  3TP"
       #
-      def regexify(re)
-        re = re.source if re.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
-        re.
-          gsub(/^\/?\^?/, '').gsub(/\$?\/?$/, '').                                                                      # Ditch the anchors
-          gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}').                                                             # All {2} become {2,2} and ? become {0,1}
-          gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                # [12]{1,2} becomes [12] or [12][12]
-          gsub(/(\([^\)]+\))\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
-          gsub(/(\\?.)\{(\d+),(\d+)\}/) {|match| $1 * Array(Range.new($2.to_i, $3.to_i)).sample }.                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
-          gsub(/\((.*?)\)/) {|match| match.gsub(/[\(\)]/, '').split('|').sample }.                                      # (this|that) becomes 'this' or 'that'
-          gsub(/\[([^\]]+)\]/) {|match| match.gsub(/(\w\-\w)/) {|range| Array(Range.new(*range.split('-'))).sample } }. # All A-Z inside of [] become C (or X, or whatever)
-          gsub(/\[([^\]]+)\]/) {|match| $1.split('').sample }.                                                          # All [ABC] become B (or A or C)
-          gsub('\d') {|match| Numbers.sample }.
-          gsub('\w') {|match| Letters.sample }
+      def regexify(reg)
+        reg = reg.source if reg.respond_to?(:source) # Handle either a Regexp or a String that looks like a Regexp
+        reg
+          .gsub(%r{^/?\^?}, '').gsub(%r{\$?/?$}, '') # Ditch the anchors
+          .gsub(/\{(\d+)\}/, '{\1,\1}').gsub(/\?/, '{0,1}') # All {2} become {2,2} and ? become {0,1}
+          .gsub(/(\[[^\]]+\])\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                # [12]{1,2} becomes [12] or [12][12]
+          .gsub(/(\([^)]+\))\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                 # (12|34){1,2} becomes (12|34) or (12|34)(12|34)
+          .gsub(/(\\?.)\{(\d+),(\d+)\}/) { |_match| Regexp.last_match(1) * sample(Array(Range.new(Regexp.last_match(2).to_i, Regexp.last_match(3).to_i))) }                      # A{1,2} becomes A or AA or \d{3} becomes \d\d\d
+          .gsub(/\((.*?)\)/) { |match| sample(match.gsub(/[()]/, '').split('|')) } # (this|that) becomes 'this' or 'that'
+          .gsub(/\[([^\]]+)\]/) { |match| match.gsub(/(\w-\w)/) { |range| sample(Array(Range.new(*range.split('-')))) } } # All A-Z inside of [] become C (or X, or whatever)
+          .gsub(/\[([^\]]+)\]/) { |_match| sample(Regexp.last_match(1).chars) } # All [ABC] become B (or A or C)
+          .gsub('\d') { |_match| sample(Numbers) }
+          .gsub('\w') { |_match| sample(Letters) }
       end
 
       # Helper for the common approach of grabbing a translation
       # with an array of values and selecting one of them.
       def fetch(key)
+        fetched = sample(translate("faker.#{key}"))
+        if fetched&.match(%r{^/}) && fetched&.match(%r{/$}) # A regex
+          regexify(fetched)
+        else
+          fetched
+        end
+      end
+
+      # Helper for the common approach of grabbing a translation
+      # with an array of values and returning all of them.
+      def fetch_all(key)
         fetched = translate("faker.#{key}")
-        fetched = fetched.sample if fetched.respond_to?(:sample)
-        if fetched.match(/^\//) and fetched.match(/\/$/) # A regex
+        fetched = fetched.last if fetched.size <= 1
+        if !fetched.respond_to?(:sample) && fetched.match(%r{^/}) && fetched.match(%r{/$}) # A regex
           regexify(fetched)
         else
           fetched
@@ -91,32 +122,60 @@ module Faker
       # into method calls that can be used to generate a
       # formatted translation: e.g., "#{first_name} #{last_name}".
       def parse(key)
-        fetch(key).scan(/#\{([A-Za-z]+\.)?([^\}]+)\}([^#]+)?/).map {|kls, meth, etc|
+        fetched = fetch(key)
+        parts = fetched.scan(/(\(?)#\{([A-Za-z]+\.)?([^}]+)\}([^#]+)?/).map do |prefix, kls, meth, etc|
           # If the token had a class Prefix (e.g., Name.first_name)
           # grab the constant, otherwise use self
           cls = kls ? Faker.const_get(kls.chop) : self
 
-          # If the class has the method, call it, otherwise
-          # fetch the transation (i.e., faker.name.first_name)
-          text = cls.respond_to?(meth) ? cls.send(meth) : fetch("#{(kls || self).to_s.split('::').last.downcase}.#{meth.downcase}")
+          # If an optional leading parentheses is not present, prefix.should == "", otherwise prefix.should == "("
+          # In either case the information will be retained for reconstruction of the string.
+          text = prefix
+
+          # If the class has the method, call it, otherwise fetch the translation
+          # (e.g., faker.phone_number.area_code)
+          text += if cls.respond_to?(meth)
+                    cls.send(meth)
+                  else
+                    # Do just enough snake casing to convert PhoneNumber to phone_number
+                    key_path = cls.to_s.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+                    fetch("#{key_path}.#{meth.downcase}")
+                  end
 
           # And tack on spaces, commas, etc. left over in the string
-          text += etc.to_s
-        }.join
+          text + etc.to_s
+        end
+        # If the fetched key couldn't be parsed, then fallback to numerify
+        parts.any? ? parts.join : numerify(fetched)
       end
 
       # Call I18n.translate with our configured locale if no
       # locale is specified
-      def translate(*args)
-        opts = args.last.is_a?(Hash) ? args.pop : {}
+      def translate(*args, **opts)
         opts[:locale] ||= Faker::Config.locale
         opts[:raise] = true
-        I18n.translate(*(args.push(opts)))
-      rescue I18n::MissingTranslationData => e
+        I18n.translate(*args, **opts)
+      rescue I18n::MissingTranslationData
+        opts[:locale] = :en
+
         # Super-simple fallback -- fallback to en if the
         # translation was missing.  If the translation isn't
         # in en either, then it will raise again.
-        I18n.translate(*(args.push(opts.merge(:locale => :en))))
+        disable_enforce_available_locales do
+          I18n.translate(*args, **opts)
+        end
+      end
+
+      # Executes block with given locale set.
+      def with_locale(tmp_locale = nil, &block)
+        current_locale = Faker::Config.own_locale
+        Faker::Config.locale = tmp_locale
+
+        disable_enforce_available_locales do
+          I18n.with_locale(tmp_locale, &block)
+        end
+      ensure
+        Faker::Config.locale = current_locale
       end
 
       def flexible(key)
@@ -128,28 +187,80 @@ module Faker
       #   name:
       #     girls_name: ["Alice", "Cheryl", "Tatiana"]
       # Then you can call Faker::Name.girls_name and it will act like #first_name
-      def method_missing(m, *args, &block)
-        super unless @flexible_key
+      def method_missing(mth, *args, &block)
+        super unless flexible_key
 
-        # Use the alternate form of translate to get a nil rather than a "missing translation" string
-        if translation = translate(:faker)[@flexible_key][m]
-          translation.respond_to?(:sample) ? translation.sample : translation
+        if (translation = translate("faker.#{flexible_key}.#{mth}"))
+          sample(translation)
         else
           super
         end
       end
 
+      def respond_to_missing?(method_name, include_private = false)
+        super
+      end
+
+      # Generates a random value between the interval
+      def rand_in_range(from, to)
+        from, to = to, from if to < from
+        rand(from..to)
+      end
+
+      # If an array or range is passed, a random value will be selected.
+      # All other values are simply returned.
+      def resolve(value)
+        case value
+        when Array then sample(value)
+        when Range then rand value
+        else value
+        end
+      end
+
+      # Return unique values from the generator every time.
+      #
+      # @param max_retries [Integer] The max number of retries that should be done before giving up.
+      # @return [self]
+      def unique(max_retries = 10_000)
+        @unique ||= UniqueGenerator.new(self, max_retries)
+      end
+
+      def sample(list, num = nil)
+        if list.respond_to?(:sample)
+          if num
+            list.sample(num, random: Faker::Config.random)
+          else
+            list.sample(random: Faker::Config.random)
+          end
+        else
+          list
+        end
+      end
+
+      def shuffle(list)
+        list.shuffle(random: Faker::Config.random)
+      end
+
+      def rand(max = nil)
+        if max.nil?
+          Faker::Config.random.rand
+        elsif max.is_a?(Range) || max.to_i.positive?
+          Faker::Config.random.rand(max)
+        else
+          0
+        end
+      end
+
+      def disable_enforce_available_locales
+        old_enforce_available_locales = I18n.enforce_available_locales
+        I18n.enforce_available_locales = false
+        yield
+      ensure
+        I18n.enforce_available_locales = old_enforce_available_locales
+      end
     end
   end
 end
 
-require 'faker/address'
-require 'faker/company'
-require 'faker/internet'
-require 'faker/lorem'
-require 'faker/name'
-require 'faker/phone_number'
-require 'faker/version'
-
-require 'extensions/array'
-require 'extensions/symbol'
+# require faker objects
+Dir.glob(File.join(mydir, 'faker', '/**/*.rb')).sort.each { |file| require file }

data/lib/helpers/base58.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Faker
+  module Base58
+    def self.encode(str)
+      alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+      base = alphabet.size
+
+      lv = 0
+      str.chars.reverse.each_with_index { |v, i| lv += v.unpack1('C') * 256**i }
+
+      ret = +''
+      while lv.positive?
+        lv, mod = lv.divmod(base)
+        ret << alphabet[mod]
+      end
+
+      npad = str.match(/^#{0.chr}*/)[0].to_s.size
+      '1' * npad + ret.reverse
+    end
+  end
+end

data/lib/helpers/char.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Faker
+  module Char
+    def self.prepare(string)
+      result = romanize_cyrillic string
+      result = fix_umlauts result
+      result.gsub(/[^\w-]/, '').downcase
+    end
+
+    def self.fix_umlauts(string)
+      string.gsub(/[äöüß]/i) do |match|
+        case match.downcase
+        when 'ä' then 'ae'
+        when 'ö' then 'oe'
+        when 'ü' then 'ue'
+        when 'ß' then 'ss'
+        else match.downcase
+        end
+      end
+    end
+
+    def self.romanize_cyrillic(string)
+      if Faker::Config.locale == 'uk'
+        # Based on conventions abopted by BGN/PCGN for Ukrainian
+        uk_chars = {
+          'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'h', 'ґ' => 'g', 'д' => 'd', 'е' => 'e',
+          'є' => 'ye', 'ж' => 'zh', 'з' => 'z', 'и' => 'y', 'і' => 'i', 'ї' => 'yi', 'й' => 'y',
+          'к' => 'k',  'л' => 'l', 'м' => 'm', 'н' => 'n', 'о' => 'o', 'п' => 'p', 'р' => 'r',
+          'с' => 's', 'т' => 't', 'у' => 'u', 'ф' => 'f', 'х' => 'kh', 'ц' => 'ts', 'ч' => 'ch',
+          'ш' => 'sh', 'щ' => 'shch', 'ю' => 'yu', 'я' => 'ya', 'А' => 'a', 'Б' => 'b', 'В' => 'v',
+          'Г' => 'h', 'Ґ' => 'g', 'Д' => 'd', 'Е' => 'e', 'Є' => 'ye', 'Ж' => 'zh', 'З' => 'z',
+          'И' => 'y', 'І' => 'i', 'Ї' => 'yi', 'Й' => 'y', 'К' => 'k', 'Л' => 'l', 'М' => 'm',
+          'Н' => 'n', 'О' => 'o', 'П' => 'p', 'Р' => 'r', 'С' => 's', 'Т' => 't', 'У' => 'u',
+          'Ф' => 'f', 'Х' => 'kh', 'Ц' => 'ts', 'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ю' => 'yu',
+          'Я' => 'ya', 'ь' => '' # Ignore symbol, because its standard presentation is not allowed in URLs
+        }
+        return string.gsub(/[а-яА-ЯіїєґІЇЄҐ]/, uk_chars)
+      end
+
+      if Faker::Config.locale == 'ru'
+        # Based on conventions abopted by BGN/PCGN for Russian
+        ru_chars = {
+          'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'h', 'д' => 'd', 'е' => 'e',
+          'ё' => 'ye', 'ж' => 'zh', 'з' => 'z', 'и' => 'i', 'й' => 'y', 'к' => 'k',
+          'л' => 'l',  'м' => 'm',  'н' => 'n',  'о' => 'o', 'п' => 'p', 'р' => 'r',
+          'с' => 's',  'т' => 't',  'у' => 'u',  'ф' => 'f', 'х' => 'kh', 'ц' => 'ts',
+          'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shch', 'ы' => 'у', 'э' => 'e', 'ю' => 'yu',
+          'я' => 'ya', 'А' => 'a',  'Б' => 'b', 'В' => 'v', 'Г' => 'h', 'Д' => 'd',
+          'Е' => 'e', 'Ё' => 'ye', 'Ж' => 'zh', 'З' => 'z', 'И' => 'i', 'Й' => 'y',
+          'К' => 'k', 'Л' => 'l', 'М' => 'm', 'Н' => 'n', 'О' => 'o', 'П' => 'p', 'Р' => 'r',
+          'С' => 's',  'Т' => 't',  'У' => 'u', 'Ф' => 'f', 'Х' => 'kh', 'Ц' => 'ts',
+          'Ч' => 'ch', 'Ш' => 'sh', 'Щ' => 'shch', 'Ы' => 'у', 'Э' => 'e', 'Ю' => 'yu',
+          'Я' => 'ya', 'ь' => '', 'ъ' => '' # Ignore symbols, because its standard presentation is not allowed in URLs
+        }
+        return string.gsub(/[а-яА-Я]/, ru_chars)
+      end
+      string
+    end
+  end
+end

data/lib/helpers/unique_generator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Faker
+  class UniqueGenerator
+    def initialize(generator, max_retries)
+      @generator = generator
+      @max_retries = max_retries
+    end
+
+    def method_missing(name, *arguments)
+      self.class.marked_unique.add(self)
+
+      @max_retries.times do
+        result = @generator.public_send(name, *arguments)
+
+        next if previous_results[[name, arguments]].include?(result)
+
+        previous_results[[name, arguments]] << result
+        return result
+      end
+
+      raise RetryLimitExceeded, "Retry limit exceeded for #{name}"
+    end
+    # Have method_missing use ruby 2.x keywords if the method exists.
+    # This is necessary because the syntax for passing arguments (`...`)
+    # is invalid on versions before Ruby 2.7, so it can't be used.
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.start_with?('faker_') || super
+    end
+
+    RetryLimitExceeded = Class.new(StandardError)
+
+    def previous_results
+      Thread.current[:faker_unique_generator_previous_results] ||= {}
+      Thread.current[:faker_unique_generator_previous_results][@generator] ||= Hash.new { |hash, key| hash[key] = Set.new }
+    end
+
+    def clear
+      previous_results.clear
+    end
+
+    def self.marked_unique
+      Thread.current[:faker_unique_generator_marked_unique] ||= Set.new
+    end
+
+    def self.clear
+      marked_unique.each(&:clear)
+      marked_unique.clear
+    end
+
+    def exclude(name, arguments, values)
+      values ||= []
+      values.each do |value|
+        previous_results[[name, arguments]] << value
+      end
+    end
+  end
+end