lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/inflector/transliterate.rb

@@ -1,112 +0,0 @@
-require 'active_support/core_ext/string/multibyte'
-require 'active_support/i18n'
-
-module ActiveSupport
-  module Inflector
-
-    # Replaces non-ASCII characters with an ASCII approximation, or if none
-    # exists, a replacement character which defaults to "?".
-    #
-    #    transliterate('Ærøskøbing')
-    #    # => "AEroskobing"
-    #
-    # Default approximations are provided for Western/Latin characters,
-    # e.g, "ø", "ñ", "é", "ß", etc.
-    #
-    # This method is I18n aware, so you can set up custom approximations for a
-    # locale. This can be useful, for example, to transliterate German's "ü"
-    # and "ö" to "ue" and "oe", or to add support for transliterating Russian
-    # to ASCII.
-    #
-    # In order to make your custom transliterations available, you must set
-    # them as the <tt>i18n.transliterate.rule</tt> i18n key:
-    #
-    #   # Store the transliterations in locales/de.yml
-    #   i18n:
-    #     transliterate:
-    #       rule:
-    #         ü: "ue"
-    #         ö: "oe"
-    #
-    #   # Or set them using Ruby
-    #   I18n.backend.store_translations(:de, i18n: {
-    #     transliterate: {
-    #       rule: {
-    #         'ü' => 'ue',
-    #         'ö' => 'oe'
-    #       }
-    #     }
-    #   })
-    #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
-    # maps characters to ASCII approximations as shown above, or, for more
-    # complex requirements, a Proc:
-    #
-    #   I18n.backend.store_translations(:de, i18n: {
-    #     transliterate: {
-    #       rule: ->(string) { MyTransliterator.transliterate(string) }
-    #     }
-    #   })
-    #
-    # Now you can have different transliterations for each locale:
-    #
-    #   I18n.locale = :en
-    #   transliterate('Jürgen')
-    #   # => "Jurgen"
-    #
-    #   I18n.locale = :de
-    #   transliterate('Jürgen')
-    #   # => "Juergen"
-    def transliterate(string, replacement = "?".freeze)
-      I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
-        ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
-          :replacement => replacement)
-    end
-
-    # Replaces special characters in a string so that it may be used as part of
-    # a 'pretty' URL.
-    #
-    #   parameterize("Donald E. Knuth") # => "donald-e-knuth"
-    #   parameterize("^trés|Jolie-- ")  # => "tres-jolie"
-    #
-    # To use a custom separator, override the `separator` argument.
-    #
-    #  parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
-    #  parameterize("^trés|Jolie-- ", separator: '_')  # => "tres_jolie"
-    #
-    # To preserve the case of the characters in a string, use the `preserve_case` argument.
-    #
-    #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
-    #   parameterize("^trés|Jolie-- ", preserve_case: true) # => "tres-Jolie"
-    #
-    def parameterize(string, sep = :unused, separator: '-', preserve_case: false)
-      unless sep == :unused
-        ActiveSupport::Deprecation.warn("Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '#{sep}'` instead.")
-        separator = sep
-      end
-      # Replace accented chars with their ASCII equivalents.
-      parameterized_string = transliterate(string)
-
-      # Turn unwanted chars into the separator.
-      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
-
-      unless separator.nil? || separator.empty?
-        if separator == "-".freeze
-          re_duplicate_separator        = /-{2,}/
-          re_leading_trailing_separator = /^-|-$/i
-        else
-          re_sep = Regexp.escape(separator)
-          re_duplicate_separator        = /#{re_sep}{2,}/
-          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
-        end
-        # No more than one of the separator in a row.
-        parameterized_string.gsub!(re_duplicate_separator, separator)
-        # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, ''.freeze)
-      end
-      
-      parameterized_string.downcase! unless preserve_case
-      parameterized_string
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/json.rb

@@ -1,2 +0,0 @@
-require 'active_support/json/decoding'
-require 'active_support/json/encoding'

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/json/decoding.rb

@@ -1,74 +0,0 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/module/delegation'
-require 'json'
-
-module ActiveSupport
-  # Look for and parse json strings that look like ISO 8601 times.
-  mattr_accessor :parse_json_times
-
-  module JSON
-    # matches YAML-formatted dates
-    DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/
-    DATETIME_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)$/
-
-    class << self
-      # Parses a JSON string (JavaScript Object Notation) into a hash.
-      # See http://www.json.org for more info.
-      #
-      #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
-      #   => {"team" => "rails", "players" => "36"}
-      def decode(json)
-        data = ::JSON.parse(json, quirks_mode: true)
-
-        if ActiveSupport.parse_json_times
-          convert_dates_from(data)
-        else
-          data
-        end
-      end
-
-      # Returns the class of the error that will be raised when there is an
-      # error in decoding JSON. Using this method means you won't directly
-      # depend on the ActiveSupport's JSON implementation, in case it changes
-      # in the future.
-      #
-      #   begin
-      #     obj = ActiveSupport::JSON.decode(some_string)
-      #   rescue ActiveSupport::JSON.parse_error
-      #     Rails.logger.warn("Attempted to decode invalid JSON: #{some_string}")
-      #   end
-      def parse_error
-        ::JSON::ParserError
-      end
-
-      private
-
-      def convert_dates_from(data)
-        case data
-        when nil
-          nil
-        when DATE_REGEX
-          begin
-            Date.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when DATETIME_REGEX
-          begin
-            Time.zone.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when Array
-          data.map! { |d| convert_dates_from(d) }
-        when Hash
-          data.each do |key, value|
-            data[key] = convert_dates_from(value)
-          end
-        else
-          data
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/json/encoding.rb

@@ -1,127 +0,0 @@
-require 'active_support/core_ext/object/json'
-require 'active_support/core_ext/module/delegation'
-
-module ActiveSupport
-  class << self
-    delegate :use_standard_json_time_format, :use_standard_json_time_format=,
-      :time_precision, :time_precision=,
-      :escape_html_entities_in_json, :escape_html_entities_in_json=,
-      :json_encoder, :json_encoder=,
-      :to => :'ActiveSupport::JSON::Encoding'
-  end
-
-  module JSON
-    # Dumps objects in JSON (JavaScript Object Notation).
-    # See http://www.json.org for more info.
-    #
-    #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
-    #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-    def self.encode(value, options = nil)
-      Encoding.json_encoder.new(options).encode(value)
-    end
-
-    module Encoding #:nodoc:
-      class JSONGemEncoder #:nodoc:
-        attr_reader :options
-
-        def initialize(options = nil)
-          @options = options || {}
-        end
-
-        # Encode the given object into a JSON string
-        def encode(value)
-          stringify jsonify value.as_json(options.dup)
-        end
-
-        private
-          # Rails does more escaping than the JSON gem natively does (we
-          # escape \u2028 and \u2029 and optionally >, <, & to work around
-          # certain browser problems).
-          ESCAPED_CHARS = {
-            "\u2028" => '\u2028',
-            "\u2029" => '\u2029',
-            '>'      => '\u003e',
-            '<'      => '\u003c',
-            '&'      => '\u0026',
-            }
-
-          ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
-          ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = /[\u2028\u2029]/u
-
-          # This class wraps all the strings we see and does the extra escaping
-          class EscapedString < String #:nodoc:
-            def to_json(*)
-              if Encoding.escape_html_entities_in_json
-                super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
-              else
-                super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
-              end
-            end
-
-            def to_s
-              self
-            end
-          end
-
-          # Mark these as private so we don't leak encoding-specific constructs
-          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES,
-            :ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, :EscapedString
-
-          # Convert an object into a "JSON-ready" representation composed of
-          # primitives like Hash, Array, String, Numeric, and true/false/nil.
-          # Recursively calls #as_json to the object to recursively build a
-          # fully JSON-ready object.
-          #
-          # This allows developers to implement #as_json without having to
-          # worry about what base types of objects they are allowed to return
-          # or having to remember to call #as_json recursively.
-          #
-          # Note: the +options+ hash passed to +object.to_json+ is only passed
-          # to +object.as_json+, not any of this method's recursive +#as_json+
-          # calls.
-          def jsonify(value)
-            case value
-            when String
-              EscapedString.new(value)
-            when Numeric, NilClass, TrueClass, FalseClass
-              value.as_json
-            when Hash
-              Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
-            when Array
-              value.map { |v| jsonify(v) }
-            else
-              jsonify value.as_json
-            end
-          end
-
-          # Encode a "jsonified" Ruby data structure using the JSON gem
-          def stringify(jsonified)
-            ::JSON.generate(jsonified, quirks_mode: true, max_nesting: false)
-          end
-      end
-
-      class << self
-        # If true, use ISO 8601 format for dates and times. Otherwise, fall back
-        # to the Active Support legacy format.
-        attr_accessor :use_standard_json_time_format
-
-        # If true, encode >, <, & as escaped unicode sequences (e.g. > as \u003e)
-        # as a safety measure.
-        attr_accessor :escape_html_entities_in_json
-
-        # Sets the precision of encoded time values.
-        # Defaults to 3 (equivalent to millisecond precision)
-        attr_accessor :time_precision
-
-        # Sets the encoder used by Rails to encode Ruby objects into JSON strings
-        # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
-        attr_accessor :json_encoder
-      end
-
-      self.use_standard_json_time_format = true
-      self.escape_html_entities_in_json  = true
-      self.json_encoder = JSONGemEncoder
-      self.time_precision = 3
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/key_generator.rb

@@ -1,71 +0,0 @@
-require 'concurrent/map'
-require 'openssl'
-
-module ActiveSupport
-  # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2.
-  # It can be used to derive a number of keys for various purposes from a given secret.
-  # This lets Rails applications have a single secure secret, but avoid reusing that
-  # key in multiple incompatible contexts.
-  class KeyGenerator
-    def initialize(secret, options = {})
-      @secret = secret
-      # The default iterations are higher than required for our key derivation uses
-      # on the off chance someone uses this for password storage
-      @iterations = options[:iterations] || 2**16
-    end
-
-    # Returns a derived key suitable for use.  The default key_size is chosen
-    # to be compatible with the default settings of ActiveSupport::MessageVerifier.
-    # i.e. OpenSSL::Digest::SHA1#block_length
-    def generate_key(salt, key_size=64)
-      OpenSSL::PKCS5.pbkdf2_hmac_sha1(@secret, salt, @iterations, key_size)
-    end
-  end
-
-  # CachingKeyGenerator is a wrapper around KeyGenerator which allows users to avoid
-  # re-executing the key generation process when it's called using the same salt and
-  # key_size.
-  class CachingKeyGenerator
-    def initialize(key_generator)
-      @key_generator = key_generator
-      @cache_keys = Concurrent::Map.new
-    end
-
-    # Returns a derived key suitable for use.
-    def generate_key(*args)
-      @cache_keys[args.join] ||= @key_generator.generate_key(*args)
-    end
-  end
-
-  class LegacyKeyGenerator # :nodoc:
-    SECRET_MIN_LENGTH = 30 # Characters
-
-    def initialize(secret)
-      ensure_secret_secure(secret)
-      @secret = secret
-    end
-
-    def generate_key(salt)
-      @secret
-    end
-
-    private
-
-    # To prevent users from using something insecure like "Password" we make sure that the
-    # secret they've provided is at least 30 characters in length.
-    def ensure_secret_secure(secret)
-      if secret.blank?
-        raise ArgumentError, "A secret is required to generate an integrity hash " \
-          "for cookie session data. Set a secret_key_base of at least " \
-          "#{SECRET_MIN_LENGTH} characters in config/secrets.yml."
-      end
-
-      if secret.length < SECRET_MIN_LENGTH
-        raise ArgumentError, "Secret should be something secure, " \
-          "like \"#{SecureRandom.hex(16)}\". The value you " \
-          "provided, \"#{secret}\", is shorter than the minimum length " \
-          "of #{SECRET_MIN_LENGTH} characters."
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/lazy_load_hooks.rb

@@ -1,56 +0,0 @@
-module ActiveSupport
-  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
-  # making the app boot faster. Because of this feature now there is no need to
-  # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
-  # configuration. Instead a hook is registered that applies configuration once
-  # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is
-  # used as example but this feature can be applied elsewhere too.
-  #
-  # Here is an example where +on_load+ method is called to register a hook.
-  #
-  #   initializer 'active_record.initialize_timezone' do
-  #     ActiveSupport.on_load(:active_record) do
-  #       self.time_zone_aware_attributes = true
-  #       self.default_timezone = :utc
-  #     end
-  #   end
-  #
-  # When the entirety of +activerecord/lib/active_record/base.rb+ has been
-  # evaluated then +run_load_hooks+ is invoked. The very last line of
-  # +activerecord/lib/active_record/base.rb+ is:
-  #
-  #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  module LazyLoadHooks
-    def self.extended(base) # :nodoc:
-      base.class_eval do
-        @load_hooks = Hash.new { |h,k| h[k] = [] }
-        @loaded     = Hash.new { |h,k| h[k] = [] }
-      end
-    end
-
-    def on_load(name, options = {}, &block)
-      @loaded[name].each do |base|
-        execute_hook(base, options, block)
-      end
-
-      @load_hooks[name] << [block, options]
-    end
-
-    def execute_hook(base, options, block)
-      if options[:yield]
-        block.call(base)
-      else
-        base.instance_eval(&block)
-      end
-    end
-
-    def run_load_hooks(name, base = Object)
-      @loaded[name] << base
-      @load_hooks[name].each do |hook, options|
-        execute_hook(base, options, hook)
-      end
-    end
-  end
-
-  extend LazyLoadHooks
-end