ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/serializers/json.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/json"
-
-module ActiveModel
-  module Serializers
-    # == Active \Model \JSON \Serializer
-    module JSON
-      extend ActiveSupport::Concern
-      include ActiveModel::Serialization
-
-      included do
-        extend ActiveModel::Naming
-
-        class_attribute :include_root_in_json, instance_writer: false, default: false
-      end
-
-      # Returns a hash representing the model. Some configuration can be
-      # passed through +options+.
-      #
-      # The option <tt>include_root_in_json</tt> controls the top-level behavior
-      # of +as_json+. If +true+, +as_json+ will emit a single root node named
-      # after the object's type. The default value for <tt>include_root_in_json</tt>
-      # option is +false+.
-      #
-      #   user = User.find(1)
-      #   user.as_json
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #     "created_at" => "2006/08/01", "awesome" => true}
-      #
-      #   ActiveRecord::Base.include_root_in_json = true
-      #
-      #   user.as_json
-      #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006/08/01", "awesome" => true } }
-      #
-      # This behavior can also be achieved by setting the <tt>:root</tt> option
-      # to +true+ as in:
-      #
-      #   user = User.find(1)
-      #   user.as_json(root: true)
-      #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006/08/01", "awesome" => true } }
-      #
-      # Without any +options+, the returned Hash will include all the model's
-      # attributes.
-      #
-      #   user = User.find(1)
-      #   user.as_json
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true}
-      #
-      # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit
-      # the attributes included, and work similar to the +attributes+ method.
-      #
-      #   user.as_json(only: [:id, :name])
-      #   # => { "id" => 1, "name" => "Konata Izumi" }
-      #
-      #   user.as_json(except: [:id, :created_at, :age])
-      #   # => { "name" => "Konata Izumi", "awesome" => true }
-      #
-      # To include the result of some method calls on the model use <tt>:methods</tt>:
-      #
-      #   user.as_json(methods: :permalink)
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
-      #   #      "permalink" => "1-konata-izumi" }
-      #
-      # To include associations use <tt>:include</tt>:
-      #
-      #   user.as_json(include: :posts)
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
-      #   #      "posts" => [ { "id" => 1, "author_id" => 1, "title" => "Welcome to the weblog" },
-      #   #                   { "id" => 2, "author_id" => 1, "title" => "So I was thinking" } ] }
-      #
-      # Second level and higher order associations work as well:
-      #
-      #   user.as_json(include: { posts: {
-      #                              include: { comments: {
-      #                                             only: :body } },
-      #                              only: :title } })
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
-      #   #      "posts" => [ { "comments" => [ { "body" => "1st post!" }, { "body" => "Second!" } ],
-      #   #                     "title" => "Welcome to the weblog" },
-      #   #                   { "comments" => [ { "body" => "Don't think too hard" } ],
-      #   #                     "title" => "So I was thinking" } ] }
-      def as_json(options = nil)
-        root = if options && options.key?(:root)
-          options[:root]
-        else
-          include_root_in_json
-        end
-
-        if root
-          root = model_name.element if root == true
-          { root => serializable_hash(options) }
-        else
-          serializable_hash(options)
-        end
-      end
-
-      # Sets the model +attributes+ from a JSON string. Returns +self+.
-      #
-      #   class Person
-      #     include ActiveModel::Serializers::JSON
-      #
-      #     attr_accessor :name, :age, :awesome
-      #
-      #     def attributes=(hash)
-      #       hash.each do |key, value|
-      #         send("#{key}=", value)
-      #       end
-      #     end
-      #
-      #     def attributes
-      #       instance_values
-      #     end
-      #   end
-      #
-      #   json = { name: 'bob', age: 22, awesome:true }.to_json
-      #   person = Person.new
-      #   person.from_json(json) # => #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
-      #   person.name            # => "bob"
-      #   person.age             # => 22
-      #   person.awesome         # => true
-      #
-      # The default value for +include_root+ is +false+. You can change it to
-      # +true+ if the given JSON string includes a single root node.
-      #
-      #   json = { person: { name: 'bob', age: 22, awesome:true } }.to_json
-      #   person = Person.new
-      #   person.from_json(json, true) # => #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
-      #   person.name                  # => "bob"
-      #   person.age                   # => 22
-      #   person.awesome               # => true
-      def from_json(json, include_root = include_root_in_json)
-        hash = ActiveSupport::JSON.decode(json)
-        hash = hash.values.first if include_root
-        self.attributes = hash
-        self
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/translation.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  # == Active \Model \Translation
-  #
-  # Provides integration between your object and the Rails internationalization
-  # (i18n) framework.
-  #
-  # A minimal implementation could be:
-  #
-  #   class TranslatedPerson
-  #     extend ActiveModel::Translation
-  #   end
-  #
-  #   TranslatedPerson.human_attribute_name('my_attribute')
-  #   # => "My attribute"
-  #
-  # This also provides the required class methods for hooking into the
-  # Rails internationalization API, including being able to define a
-  # class based +i18n_scope+ and +lookup_ancestors+ to find translations in
-  # parent classes.
-  module Translation
-    include ActiveModel::Naming
-
-    # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
-    def i18n_scope
-      :activemodel
-    end
-
-    # When localizing a string, it goes through the lookup returned by this
-    # method, which is used in ActiveModel::Name#human,
-    # ActiveModel::Errors#full_messages and
-    # ActiveModel::Translation#human_attribute_name.
-    def lookup_ancestors
-      ancestors.select { |x| x.respond_to?(:model_name) }
-    end
-
-    # Transforms attribute names into a more human format, such as "First name"
-    # instead of "first_name".
-    #
-    #   Person.human_attribute_name("first_name") # => "First name"
-    #
-    # Specify +options+ with additional translating options.
-    def human_attribute_name(attribute, options = {})
-      options   = { count: 1 }.merge!(options)
-      parts     = attribute.to_s.split(".")
-      attribute = parts.pop
-      namespace = parts.join("/") unless parts.empty?
-      attributes_scope = "#{i18n_scope}.attributes"
-
-      if namespace
-        defaults = lookup_ancestors.map do |klass|
-          :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.#{attribute}"
-        end
-        defaults << :"#{attributes_scope}.#{namespace}.#{attribute}"
-      else
-        defaults = lookup_ancestors.map do |klass|
-          :"#{attributes_scope}.#{klass.model_name.i18n_key}.#{attribute}"
-        end
-      end
-
-      defaults << :"attributes.#{attribute}"
-      defaults << options.delete(:default) if options[:default]
-      defaults << attribute.humanize
-
-      options[:default] = defaults
-      I18n.translate(defaults.shift, options)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/big_integer.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/type/integer"
-
-module ActiveModel
-  module Type
-    class BigInteger < Integer # :nodoc:
-      private
-
-        def max_value
-          ::Float::INFINITY
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/binary.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class Binary < Value # :nodoc:
-      def type
-        :binary
-      end
-
-      def binary?
-        true
-      end
-
-      def cast(value)
-        if value.is_a?(Data)
-          value.to_s
-        else
-          super
-        end
-      end
-
-      def serialize(value)
-        return if value.nil?
-        Data.new(super)
-      end
-
-      def changed_in_place?(raw_old_value, value)
-        old_value = deserialize(raw_old_value)
-        old_value != value
-      end
-
-      class Data # :nodoc:
-        def initialize(value)
-          @value = value.to_s
-        end
-
-        def to_s
-          @value
-        end
-        alias_method :to_str, :to_s
-
-        def hex
-          @value.unpack("H*")[0]
-        end
-
-        def ==(other)
-          other == to_s || super
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/boolean.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    # == Active \Model \Type \Boolean
-    #
-    # A class that behaves like a boolean type, including rules for coercion of user input.
-    #
-    # === Coercion
-    # Values set from user input will first be coerced into the appropriate ruby type.
-    # Coercion behavior is roughly mapped to Ruby's boolean semantics.
-    #
-    # - "false", "f" , "0", +0+ or any other value in +FALSE_VALUES+ will be coerced to +false+
-    # - Empty strings are coerced to +nil+
-    # - All other values will be coerced to +true+
-    class Boolean < Value
-      FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"].to_set
-
-      def type # :nodoc:
-        :boolean
-      end
-
-      def serialize(value) # :nodoc:
-        cast(value)
-      end
-
-      private
-
-        def cast_value(value)
-          if value == ""
-            nil
-          else
-            !FALSE_VALUES.include?(value)
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/date.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class Date < Value # :nodoc:
-      include Helpers::Timezone
-      include Helpers::AcceptsMultiparameterTime.new
-
-      def type
-        :date
-      end
-
-      def serialize(value)
-        cast(value)
-      end
-
-      def type_cast_for_schema(value)
-        value.to_s(:db).inspect
-      end
-
-      private
-
-        def cast_value(value)
-          if value.is_a?(::String)
-            return if value.empty?
-            fast_string_to_date(value) || fallback_string_to_date(value)
-          elsif value.respond_to?(:to_date)
-            value.to_date
-          else
-            value
-          end
-        end
-
-        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
-        def fast_string_to_date(string)
-          if string =~ ISO_DATE
-            new_date $1.to_i, $2.to_i, $3.to_i
-          end
-        end
-
-        def fallback_string_to_date(string)
-          new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
-        end
-
-        def new_date(year, mon, mday)
-          unless year.nil? || (year == 0 && mon == 0 && mday == 0)
-            ::Date.new(year, mon, mday) rescue nil
-          end
-        end
-
-        def value_from_multiparameter_assignment(*)
-          time = super
-          time && new_date(time.year, time.mon, time.mday)
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/date_time.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class DateTime < Value # :nodoc:
-      include Helpers::Timezone
-      include Helpers::TimeValue
-      include Helpers::AcceptsMultiparameterTime.new(
-        defaults: { 4 => 0, 5 => 0 }
-      )
-
-      def type
-        :datetime
-      end
-
-      def serialize(value)
-        super(cast(value))
-      end
-
-      private
-
-        def cast_value(value)
-          return apply_seconds_precision(value) unless value.is_a?(::String)
-          return if value.empty?
-
-          fast_string_to_time(value) || fallback_string_to_time(value)
-        end
-
-        # '0.123456' -> 123456
-        # '1.123456' -> 123456
-        def microseconds(time)
-          time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
-        end
-
-        def fallback_string_to_time(string)
-          time_hash = ::Date._parse(string)
-          time_hash[:sec_fraction] = microseconds(time_hash)
-
-          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
-        end
-
-        def value_from_multiparameter_assignment(values_hash)
-          missing_parameter = (1..3).detect { |key| !values_hash.key?(key) }
-          if missing_parameter
-            raise ArgumentError, missing_parameter
-          end
-          super
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/decimal.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal/util"
-
-module ActiveModel
-  module Type
-    class Decimal < Value # :nodoc:
-      include Helpers::Numeric
-      BIGDECIMAL_PRECISION = 18
-
-      def type
-        :decimal
-      end
-
-      def type_cast_for_schema(value)
-        value.to_s.inspect
-      end
-
-      private
-
-        def cast_value(value)
-          casted_value = \
-            case value
-            when ::Float
-              convert_float_to_big_decimal(value)
-            when ::Numeric
-              BigDecimal(value, precision || BIGDECIMAL_PRECISION)
-            when ::String
-              begin
-                value.to_d
-              rescue ArgumentError
-                BigDecimal(0)
-              end
-            else
-              if value.respond_to?(:to_d)
-                value.to_d
-              else
-                cast_value(value.to_s)
-              end
-            end
-
-          apply_scale(casted_value)
-        end
-
-        def convert_float_to_big_decimal(value)
-          if precision
-            BigDecimal(apply_scale(value), float_precision)
-          else
-            value.to_d
-          end
-        end
-
-        def float_precision
-          if precision.to_i > ::Float::DIG + 1
-            ::Float::DIG + 1
-          else
-            precision.to_i
-          end
-        end
-
-        def apply_scale(value)
-          if scale
-            value.round(scale)
-          else
-            value
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/float.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class Float < Value # :nodoc:
-      include Helpers::Numeric
-
-      def type
-        :float
-      end
-
-      def type_cast_for_schema(value)
-        return "::Float::NAN" if value.try(:nan?)
-        case value
-        when ::Float::INFINITY then "::Float::INFINITY"
-        when -::Float::INFINITY then "-::Float::INFINITY"
-        else super
-        end
-      end
-
-      alias serialize cast
-
-      private
-
-        def cast_value(value)
-          case value
-          when ::Float then value
-          when "Infinity" then ::Float::INFINITY
-          when "-Infinity" then -::Float::INFINITY
-          when "NaN" then ::Float::NAN
-          else value.to_f
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/helpers/accepts_multiparameter_time.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    module Helpers # :nodoc: all
-      class AcceptsMultiparameterTime < Module
-        def initialize(defaults: {})
-          define_method(:cast) do |value|
-            if value.is_a?(Hash)
-              value_from_multiparameter_assignment(value)
-            else
-              super(value)
-            end
-          end
-
-          define_method(:assert_valid_value) do |value|
-            if value.is_a?(Hash)
-              value_from_multiparameter_assignment(value)
-            else
-              super(value)
-            end
-          end
-
-          define_method(:value_constructed_by_mass_assignment?) do |value|
-            value.is_a?(Hash)
-          end
-
-          define_method(:value_from_multiparameter_assignment) do |values_hash|
-            defaults.each do |k, v|
-              values_hash[k] ||= v
-            end
-            return unless values_hash[1] && values_hash[2] && values_hash[3]
-            values = values_hash.sort.map(&:last)
-            ::Time.send(default_timezone, *values)
-          end
-          private :value_from_multiparameter_assignment
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/helpers/numeric.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    module Helpers # :nodoc: all
-      module Numeric
-        def cast(value)
-          value = \
-            case value
-            when true then 1
-            when false then 0
-            when ::String then value.presence
-            else value
-            end
-          super(value)
-        end
-
-        def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
-          super || number_to_non_number?(old_value, new_value_before_type_cast)
-        end
-
-        private
-
-          def number_to_non_number?(old_value, new_value_before_type_cast)
-            old_value != nil && non_numeric_string?(new_value_before_type_cast)
-          end
-
-          def non_numeric_string?(value)
-            # 'wibble'.to_i will give zero, we want to make sure
-            # that we aren't marking int zero to string zero as
-            # changed.
-            !/\A[-+]?\d+/.match?(value.to_s)
-          end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/type/helpers/time_value.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/zones"
-require "active_support/core_ext/time/zones"
-
-module ActiveModel
-  module Type
-    module Helpers # :nodoc: all
-      module TimeValue
-        def serialize(value)
-          value = apply_seconds_precision(value)
-
-          if value.acts_like?(:time)
-            zone_conversion_method = is_utc? ? :getutc : :getlocal
-
-            if value.respond_to?(zone_conversion_method)
-              value = value.send(zone_conversion_method)
-            end
-          end
-
-          value
-        end
-
-        def apply_seconds_precision(value)
-          return value unless precision && value.respond_to?(:usec)
-          number_of_insignificant_digits = 6 - precision
-          round_power = 10**number_of_insignificant_digits
-          value.change(usec: value.usec - value.usec % round_power)
-        end
-
-        def type_cast_for_schema(value)
-          value.to_s(:db).inspect
-        end
-
-        def user_input_in_time_zone(value)
-          value.in_time_zone
-        end
-
-        private
-
-          def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
-            # Treat 0000-00-00 00:00:00 as nil.
-            return if year.nil? || (year == 0 && mon == 0 && mday == 0)
-
-            if offset
-              time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
-              return unless time
-
-              time -= offset
-              is_utc? ? time : time.getlocal
-            else
-              ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
-            end
-          end
-
-          ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-
-          # Doesn't handle time zones.
-          def fast_string_to_time(string)
-            if string =~ ISO_DATETIME
-              microsec = ($7.to_r * 1_000_000).to_i
-              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
-            end
-          end
-      end
-    end
-  end
-end