lewagon 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a59249bc762cfa6daf8e175b35a9ec859631d6a91c491a7e037c978dd4c46c1
+  data.tar.gz: 9d4a6f53e49e0fcae7f4bc022644bdaa1faa77cab7116fe9f13ec7c1b5aacb44
+SHA512:
+  metadata.gz: 3eea5ad6939d073a9921dc15a7252784bd91380c1e0a274b68803b5d40a4c9e20e94771f523b66b87803f60a0dadeec3d2a3f8ef24a1352dc2b66cef3aa7c658
+  data.tar.gz: 51f1cbb761a7b514bc84bbf40eef83565f9646b3db1c42b3b4277d959c94d62a9cca4c2322270953ae51c0ee980e621f656c64a13deff07dc0d15d8b3ee56228

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2019 Benjamin Curtis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/lewagon

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)

data/lib/helpers/base58.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LeWagon
+  module Base58
+    def self.encode(str)
+      alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+      base = alphabet.size
+
+      lv = 0
+      str.split('').reverse.each_with_index { |v, i| lv += v.unpack('C')[0] * 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,66 @@
+# frozen_string_literal: true
+
+module LeWagon
+  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'
+        end
+      end
+    end
+
+    def self.romanize_cyrillic(string)
+      if LeWagon::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 LeWagon::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 LeWagon
+  class UniqueGenerator
+    @marked_unique = Set.new # Holds names of generators with unique values
+
+    class << self
+      attr_reader :marked_unique
+    end
+
+    def initialize(generator, max_retries)
+      @generator = generator
+      @max_retries = max_retries
+      @previous_results = Hash.new { |hash, key| hash[key] = Set.new }
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    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)
+    # rubocop:enable Style/MethodMissingSuper
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.start_with?('lewagon_') || super
+    end
+
+    RetryLimitExceeded = Class.new(StandardError)
+
+    def clear
+      @previous_results.clear
+    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

data/lib/lewagon/it/batch380.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LeWagon
+  class Batch380 < Base
+    class << self
+      def massi
+        fetch('batch380.massi')
+      end
+    end
+  end
+end

data/lib/lewagon/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LeWagon #:nodoc:
+  VERSION = '0.0.1'
+end

data/lib/lewagon.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+mydir = __dir__
+
+begin
+  require 'psych'
+end
+
+require 'i18n'
+require 'set' # Fixes a bug in i18n 0.6.11
+
+Dir.glob(File.join(File.dirname(__FILE__), 'helpers', '*.rb')).sort.each { |file| require file }
+
+I18n.load_path += Dir[File.join(mydir, 'locales', '**/*.yml')]
+I18n.reload! if I18n.backend.initialized?
+
+module LeWagon
+  class Config
+    @locale = nil
+    @random = nil
+
+    class << self
+      attr_writer :locale
+      attr_writer :random
+
+      def locale
+        @locale || I18n.locale
+      end
+
+      def own_locale
+        @locale
+      end
+
+      def random
+        @random || Random::DEFAULT
+      end
+    end
+  end
+
+  class Base
+    Numbers = Array(0..9)
+    ULetters = Array('A'..'Z')
+    LLetters = Array('a'..'z')
+    Letters = ULetters + LLetters
+
+    class << self
+      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(/\?/) { sample(ULetters) }
+      end
+
+      def bothify(string)
+        letterify(numerify(string))
+      end
+
+      # Given a regular expression, attempt to generate a string
+      # that would match it.  This is a rather simple implementation,
+      # so don't be shocked if it blows up on you in a spectacular fashion.
+      #
+      # It does not handle ., *, unbounded ranges such as {1,},
+      # extensions such as (?=), character classes, some abbreviations
+      # for character classes, and nested parentheses.
+      #
+      # I told you it was simple. :) It's also probably dog-slow,
+      # so you shouldn't use it.
+      #
+      # It will take a regex like this:
+      #
+      # /^[A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}$/
+      #
+      # and generate a string like this:
+      #
+      # "U3V  3TP"
+      #
+      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).split('')) } # 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("lewagon.#{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("lewagon.#{key}")
+        fetched = fetched.last if fetched.size <= 1
+        if !fetched.respond_to?(:sample) && fetched.match(%r{^\/}) && fetched.match(%r{\/$}) # A regex
+          regexify(fetched)
+        else
+          fetched
+        end
+      end
+
+      # Load formatted strings from the locale, "parsing" them
+      # into method calls that can be used to generate a
+      # formatted translation: e.g., "#{first_name} #{last_name}".
+      def parse(key)
+        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 ? LeWagon.const_get(kls.chop) : self
+
+          # 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 transation
+          # (e.g., lewagon.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
+        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)
+        opts[:locale] ||= LeWagon::Config.locale
+        opts[:raise] = true
+        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.
+        disable_enforce_available_locales do
+          I18n.translate(*args, **opts)
+        end
+      end
+
+      # Executes block with given locale set.
+      def with_locale(tmp_locale = nil)
+        current_locale = LeWagon::Config.own_locale
+        LeWagon::Config.locale = tmp_locale
+
+        disable_enforce_available_locales do
+          I18n.with_locale(tmp_locale) { yield }
+        end
+      ensure
+        LeWagon::Config.locale = current_locale
+      end
+
+      def flexible(key)
+        @flexible_key = key
+      end
+
+      # You can add whatever you want to the locale file, and it will get caught here.
+      # E.g., in your locale file, create a
+      #   name:
+      #     girls_name: ["Alice", "Cheryl", "Tatiana"]
+      # Then you can call LeWagon::Name.girls_name and it will act like #first_name
+      def method_missing(mth, *args, &block)
+        super unless @flexible_key
+
+        if (translation = translate("lewagon.#{@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)
+        list.respond_to?(:sample) ? list.sample(random: LeWagon::Config.random) : list
+      end
+
+      def shuffle(list)
+        list.shuffle(random: LeWagon::Config.random)
+      end
+
+      def rand(max = nil)
+        if max.nil?
+          LeWagon::Config.random.rand
+        elsif max.is_a?(Range) || max.to_i.positive?
+          LeWagon::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
+
+      private
+
+      def warn_for_deprecated_arguments
+        keywords = []
+        yield(keywords)
+
+        return if keywords.empty?
+
+        method_name = caller.first.match(/`(?<method_name>.*)'/)[:method_name]
+
+        keywords.each.with_index(1) do |keyword, index|
+          i = case index
+              when 1 then '1st'
+              when 2 then '2nd'
+              when 3 then '3rd'
+              else "#{index}th"
+              end
+
+          warn_with_uplevel(<<~MSG, uplevel: 5)
+            Passing `#{keyword}` with the #{i} argument of `#{method_name}` is deprecated. Use keyword argument like `#{method_name}(#{keyword}: ...)` instead.
+          MSG
+        end
+
+        warn(<<~MSG)
+
+          To automatically update from positional arguments to keyword arguments,
+          install rubocop-lewagon and run:
+
+          rubocop \\
+            --require rubocop-lewagon \\
+            --only LeWagon/DeprecatedArguments \\
+            --auto-correct
+
+        MSG
+      end
+
+      # Workaround for emulating `warn '...', uplevel: 1` in Ruby 2.4 or lower.
+      def warn_with_uplevel(message, uplevel: 1)
+        at = parse_caller(caller[uplevel]).join(':')
+        warn "#{at}: #{message}"
+      end
+
+      def parse_caller(at)
+        # rubocop:disable Style/GuardClause
+        if /^(.+?):(\d+)(?::in `.*')?/ =~ at
+          file = Regexp.last_match(1)
+          line = Regexp.last_match(2).to_i
+          [file, line]
+        end
+        # rubocop:enable Style/GuardClause
+      end
+    end
+  end
+end
+
+# require lewagon objects
+Dir.glob(File.join(File.dirname(__FILE__), 'lewagon', '/**/*.rb')).sort.each { |file| require file }

data/lib/locales/README.md

@@ -0,0 +1,40 @@
+# How Locales Work
+
+The default locale is English. You can see how it is implemented in the "translate" method in [LeWagon.rb](/lib/lewagon.rb).
+
+Here's how to set it:
+
+```ruby
+# Sets the locale to "Simplified Chinese":
+LeWagon::Config.locale = 'zh-CN'
+```
+
+It works so that once the LeWagon locale is set to a different location, the translate method will check that .yml file for an equivalent and use that data. If it doesn't exist, it defaults back to English. It uses the "i18n" gem to do this.
+
+Using Chinese as an example, when the locale is set to Chinese and you attempt to call for hipster ipsem (which doesn't exist at the time of this writing), you will get English back. It checks the "zh-CH.yml" file, does not find "hipster" and then checks the "en.yml" file and returns a word from that array.
+
+```ruby
+LeWagon::Config.locale = 'zh-CN'
+LeWagon::Hipster.word #=> "kogi"
+```
+
+In order to update a locale with more translation features, simply add a new field to the .yml file that corresponds to an existing piece of functionality in the "en.yml" file. In this example, that would mean providing Chinese hipster words.
+
+```yaml
+# /lib/locales/zh-CN.yml
+hipster:
+    - "屌丝"
+```
+
+```ruby
+# Now this should work:
+LeWagon::Hipster.word #=> "屌丝"
+```
+
+After you've done that, find or create a test file for the locale you've updated and test the functionality for that language.
+
+In our hypothetical example here, one would add something like this to the "test-zh-locale.rb" file in the "test_ch_methods" method:
+
+```ruby
+assert LeWagon::Hipster.word.is_a? String
+```