monero_wallet_gen 0.1.0

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/deprecation/proxy_wrappers.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/regexp"
+
+module ActiveSupport
+  class Deprecation
+    class DeprecationProxy #:nodoc:
+      def self.new(*args, &block)
+        object = args.first
+
+        return object unless object
+        super
+      end
+
+      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
+
+      # Don't give a deprecation warning on inspect since test/unit and error
+      # logs rely on it for diagnostics.
+      def inspect
+        target.inspect
+      end
+
+      private
+        def method_missing(called, *args, &block)
+          warn caller_locations, called, args
+          target.__send__(called, *args, &block)
+        end
+    end
+
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It
+    # takes an object, a deprecation message and optionally a deprecator. The
+    # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
+    #
+    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
+    #   # => #<Object:0x007fb9b34c34b0>
+    #
+    #   deprecated_object.to_s
+    #   DEPRECATION WARNING: This object is now deprecated.
+    #   (Backtrace)
+    #   # => "#<Object:0x007fb9b34c34b0>"
+    class DeprecatedObjectProxy < DeprecationProxy
+      def initialize(object, message, deprecator = ActiveSupport::Deprecation.instance)
+        @object = object
+        @message = message
+        @deprecator = deprecator
+      end
+
+      private
+        def target
+          @object
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn(@message, callstack)
+        end
+    end
+
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a
+    # deprecated one. It takes an instance of a class, a method on that class
+    # and an instance variable. It optionally takes a deprecator as the last
+    # argument. The deprecator defaults to +ActiveSupport::Deprecator+ if none
+    # is specified.
+    #
+    #   class Example
+    #     def initialize
+    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
+    #       @_request = :special_request
+    #     end
+    #
+    #     def request
+    #       @_request
+    #     end
+    #
+    #     def old_request
+    #       @request
+    #     end
+    #   end
+    #
+    #   example = Example.new
+    #   # => #<Example:0x007fb9b31090b8 @_request=:special_request, @request=:special_request>
+    #
+    #   example.old_request.to_s
+    #   # => DEPRECATION WARNING: @request is deprecated! Call request.to_s instead of
+    #      @request.to_s
+    #      (Backtrace information…)
+    #      "special_request"
+    #
+    #   example.request.to_s
+    #   # => "special_request"
+    class DeprecatedInstanceVariableProxy < DeprecationProxy
+      def initialize(instance, method, var = "@#{method}", deprecator = ActiveSupport::Deprecation.instance)
+        @instance = instance
+        @method = method
+        @var = var
+        @deprecator = deprecator
+      end
+
+      private
+        def target
+          @instance.__send__(@method)
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
+        end
+    end
+
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. It
+    # takes the names of an old (deprecated) constant and of a new constant
+    # (both in string form) and optionally a deprecator. The deprecator defaults
+    # to +ActiveSupport::Deprecator+ if none is specified. The deprecated constant
+    # now returns the value of the new one.
+    #
+    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
+    #
+    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
+    #
+    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+    #
+    #   PLANETS.map { |planet| planet.capitalize }
+    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
+    #        (Backtrace information…)
+    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+    class DeprecatedConstantProxy < DeprecationProxy
+      def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+        require "active_support/inflector/methods"
+
+        @old_const = old_const
+        @new_const = new_const
+        @deprecator = deprecator
+        @message = message
+      end
+
+      # Returns the class of the new constant.
+      #
+      #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+      #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+      #   PLANETS.class # => Array
+      def class
+        target.class
+      end
+
+      private
+        def target
+          ActiveSupport::Inflector.constantize(@new_const.to_s)
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn(@message, callstack)
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/deprecation/reporting.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module ActiveSupport
+  class Deprecation
+    module Reporting
+      # Whether to print a message (silent mode)
+      attr_accessor :silenced
+      # Name of gem where method is deprecated
+      attr_accessor :gem_name
+
+      # Outputs a deprecation warning to the output configured by
+      # <tt>ActiveSupport::Deprecation.behavior</tt>.
+      #
+      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
+      def warn(message = nil, callstack = nil)
+        return if silenced
+
+        callstack ||= caller_locations(2)
+        deprecation_message(callstack, message).tap do |m|
+          behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+        end
+      end
+
+      # Silence deprecation warnings within the block.
+      #
+      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
+      #
+      #   ActiveSupport::Deprecation.silence do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => nil
+      def silence
+        old_silenced, @silenced = @silenced, true
+        yield
+      ensure
+        @silenced = old_silenced
+      end
+
+      def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
+        caller_backtrace ||= caller_locations(2)
+        deprecated_method_warning(deprecated_method_name, message).tap do |msg|
+          warn(msg, caller_backtrace)
+        end
+      end
+
+      private
+        # Outputs a deprecation warning message
+        #
+        #   deprecated_method_warning(:method_name)
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon}"
+        #   deprecated_method_warning(:method_name, :another_method)
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (use another_method instead)"
+        #   deprecated_method_warning(:method_name, "Optional message")
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (Optional message)"
+        def deprecated_method_warning(method_name, message = nil)
+          warning = "#{method_name} is deprecated and will be removed from #{gem_name} #{deprecation_horizon}"
+          case message
+          when Symbol then "#{warning} (use #{message} instead)"
+          when String then "#{warning} (#{message})"
+          else warning
+          end
+        end
+
+        def deprecation_message(callstack, message = nil)
+          message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
+          "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
+        end
+
+        def deprecation_caller_message(callstack)
+          file, line, method = extract_callstack(callstack)
+          if file
+            if line && method
+              "(called from #{method} at #{file}:#{line})"
+            else
+              "(called from #{file}:#{line})"
+            end
+          end
+        end
+
+        def extract_callstack(callstack)
+          return _extract_callstack(callstack) if callstack.first.is_a? String
+
+          offending_line = callstack.find { |frame|
+            frame.absolute_path && !ignored_callstack(frame.absolute_path)
+          } || callstack.first
+
+          [offending_line.path, offending_line.lineno, offending_line.label]
+        end
+
+        def _extract_callstack(callstack)
+          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
+          offending_line = callstack.find { |line| !ignored_callstack(line) } || callstack.first
+
+          if offending_line
+            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
+              md.captures
+            else
+              offending_line
+            end
+          end
+        end
+
+        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__)
+
+        def ignored_callstack(path)
+          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/descendants_tracker.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # This module provides an internal implementation to track descendants
+  # which is faster than iterating through ObjectSpace.
+  module DescendantsTracker
+    @@direct_descendants = {}
+
+    class << self
+      def direct_descendants(klass)
+        @@direct_descendants[klass] || []
+      end
+
+      def descendants(klass)
+        arr = []
+        accumulate_descendants(klass, arr)
+        arr
+      end
+
+      def clear
+        if defined? ActiveSupport::Dependencies
+          @@direct_descendants.each do |klass, descendants|
+            if ActiveSupport::Dependencies.autoloaded?(klass)
+              @@direct_descendants.delete(klass)
+            else
+              descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
+            end
+          end
+        else
+          @@direct_descendants.clear
+        end
+      end
+
+      # This is the only method that is not thread safe, but is only ever called
+      # during the eager loading phase.
+      def store_inherited(klass, descendant)
+        (@@direct_descendants[klass] ||= []) << descendant
+      end
+
+      private
+      def accumulate_descendants(klass, acc)
+        if direct_descendants = @@direct_descendants[klass]
+          acc.concat(direct_descendants)
+          direct_descendants.each { |direct_descendant| accumulate_descendants(direct_descendant, acc) }
+        end
+      end
+    end
+
+    def inherited(base)
+      DescendantsTracker.store_inherited(self, base)
+      super
+    end
+
+    def direct_descendants
+      DescendantsTracker.direct_descendants(self)
+    end
+
+    def descendants
+      DescendantsTracker.descendants(self)
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/digest.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Digest #:nodoc:
+    class <<self
+      def hash_digest_class
+        @hash_digest_class ||= ::Digest::MD5
+      end
+
+      def hash_digest_class=(klass)
+        raise ArgumentError, "#{klass} is expected to implement hexdigest class method" unless klass.respond_to?(:hexdigest)
+        @hash_digest_class = klass
+      end
+
+      def hexdigest(arg)
+        hash_digest_class.hexdigest(arg)[0...32]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/duration.rb

@@ -0,0 +1,432 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/acts_like"
+require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
+
+module ActiveSupport
+  # Provides accurate date and time measurements using Date#advance and
+  # Time#advance, respectively. It mainly supports the methods on Numeric.
+  #
+  #   1.month.ago       # equivalent to Time.now.advance(months: -1)
+  class Duration
+    class Scalar < Numeric #:nodoc:
+      attr_reader :value
+      delegate :to_i, :to_f, :to_s, to: :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def coerce(other)
+        [Scalar.new(other), self]
+      end
+
+      def -@
+        Scalar.new(-value)
+      end
+
+      def <=>(other)
+        if Scalar === other || Duration === other
+          value <=> other.value
+        elsif Numeric === other
+          value <=> other
+        else
+          nil
+        end
+      end
+
+      def +(other)
+        if Duration === other
+          seconds   = value + other.parts[:seconds]
+          new_parts = other.parts.merge(seconds: seconds)
+          new_value = value + other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:+, other)
+        end
+      end
+
+      def -(other)
+        if Duration === other
+          seconds   = value - other.parts[:seconds]
+          new_parts = other.parts.map { |part, other_value| [part, -other_value] }.to_h
+          new_parts = new_parts.merge(seconds: seconds)
+          new_value = value - other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:-, other)
+        end
+      end
+
+      def *(other)
+        if Duration === other
+          new_parts = other.parts.map { |part, other_value| [part, value * other_value] }.to_h
+          new_value = value * other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:*, other)
+        end
+      end
+
+      def /(other)
+        if Duration === other
+          value / other.value
+        else
+          calculate(:/, other)
+        end
+      end
+
+      def %(other)
+        if Duration === other
+          Duration.build(value % other.value)
+        else
+          calculate(:%, other)
+        end
+      end
+
+      private
+        def calculate(op, other)
+          if Scalar === other
+            Scalar.new(value.public_send(op, other.value))
+          elsif Numeric === other
+            Scalar.new(value.public_send(op, other))
+          else
+            raise_type_error(other)
+          end
+        end
+
+        def raise_type_error(other)
+          raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
+        end
+    end
+
+    SECONDS_PER_MINUTE = 60
+    SECONDS_PER_HOUR   = 3600
+    SECONDS_PER_DAY    = 86400
+    SECONDS_PER_WEEK   = 604800
+    SECONDS_PER_MONTH  = 2629746  # 1/12 of a gregorian year
+    SECONDS_PER_YEAR   = 31556952 # length of a gregorian year (365.2425 days)
+
+    PARTS_IN_SECONDS = {
+      seconds: 1,
+      minutes: SECONDS_PER_MINUTE,
+      hours:   SECONDS_PER_HOUR,
+      days:    SECONDS_PER_DAY,
+      weeks:   SECONDS_PER_WEEK,
+      months:  SECONDS_PER_MONTH,
+      years:   SECONDS_PER_YEAR
+    }.freeze
+
+    PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
+
+    attr_accessor :value, :parts
+
+    autoload :ISO8601Parser,     "active_support/duration/iso8601_parser"
+    autoload :ISO8601Serializer, "active_support/duration/iso8601_serializer"
+
+    class << self
+      # Creates a new Duration from string formatted according to ISO 8601 Duration.
+      #
+      # See {ISO 8601}[https://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+      # This method allows negative parts to be present in pattern.
+      # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
+      def parse(iso8601duration)
+        parts = ISO8601Parser.new(iso8601duration).parse!
+        new(calculate_total_seconds(parts), parts)
+      end
+
+      def ===(other) #:nodoc:
+        other.is_a?(Duration)
+      rescue ::NoMethodError
+        false
+      end
+
+      def seconds(value) #:nodoc:
+        new(value, [[:seconds, value]])
+      end
+
+      def minutes(value) #:nodoc:
+        new(value * SECONDS_PER_MINUTE, [[:minutes, value]])
+      end
+
+      def hours(value) #:nodoc:
+        new(value * SECONDS_PER_HOUR, [[:hours, value]])
+      end
+
+      def days(value) #:nodoc:
+        new(value * SECONDS_PER_DAY, [[:days, value]])
+      end
+
+      def weeks(value) #:nodoc:
+        new(value * SECONDS_PER_WEEK, [[:weeks, value]])
+      end
+
+      def months(value) #:nodoc:
+        new(value * SECONDS_PER_MONTH, [[:months, value]])
+      end
+
+      def years(value) #:nodoc:
+        new(value * SECONDS_PER_YEAR, [[:years, value]])
+      end
+
+      # Creates a new Duration from a seconds value that is converted
+      # to the individual parts:
+      #
+      #   ActiveSupport::Duration.build(31556952).parts # => {:years=>1}
+      #   ActiveSupport::Duration.build(2716146).parts  # => {:months=>1, :days=>1}
+      #
+      def build(value)
+        parts = {}
+        remainder = value.to_f
+
+        PARTS.each do |part|
+          unless part == :seconds
+            part_in_seconds = PARTS_IN_SECONDS[part]
+            parts[part] = remainder.div(part_in_seconds)
+            remainder = (remainder % part_in_seconds).round(9)
+          end
+        end
+
+        parts[:seconds] = remainder
+
+        new(value, parts)
+      end
+
+      private
+
+        def calculate_total_seconds(parts)
+          parts.inject(0) do |total, (part, value)|
+            total + value * PARTS_IN_SECONDS[part]
+          end
+        end
+    end
+
+    def initialize(value, parts) #:nodoc:
+      @value, @parts = value, parts.to_h
+      @parts.default = 0
+      @parts.reject! { |k, v| v.zero? }
+    end
+
+    def coerce(other) #:nodoc:
+      if Scalar === other
+        [other, self]
+      else
+        [Scalar.new(other), self]
+      end
+    end
+
+    # Compares one Duration with another or a Numeric to this Duration.
+    # Numeric values are treated as seconds.
+    def <=>(other)
+      if Duration === other
+        value <=> other.value
+      elsif Numeric === other
+        value <=> other
+      end
+    end
+
+    # Adds another Duration or a Numeric to this Duration. Numeric values
+    # are treated as seconds.
+    def +(other)
+      if Duration === other
+        parts = @parts.dup
+        other.parts.each do |(key, value)|
+          parts[key] += value
+        end
+        Duration.new(value + other.value, parts)
+      else
+        seconds = @parts[:seconds] + other
+        Duration.new(value + other, @parts.merge(seconds: seconds))
+      end
+    end
+
+    # Subtracts another Duration or a Numeric from this Duration. Numeric
+    # values are treated as seconds.
+    def -(other)
+      self + (-other)
+    end
+
+    # Multiplies this Duration by a Numeric and returns a new Duration.
+    def *(other)
+      if Scalar === other || Duration === other
+        Duration.new(value * other.value, parts.map { |type, number| [type, number * other.value] })
+      elsif Numeric === other
+        Duration.new(value * other, parts.map { |type, number| [type, number * other] })
+      else
+        raise_type_error(other)
+      end
+    end
+
+    # Divides this Duration by a Numeric and returns a new Duration.
+    def /(other)
+      if Scalar === other
+        Duration.new(value / other.value, parts.map { |type, number| [type, number / other.value] })
+      elsif Duration === other
+        value / other.value
+      elsif Numeric === other
+        Duration.new(value / other, parts.map { |type, number| [type, number / other] })
+      else
+        raise_type_error(other)
+      end
+    end
+
+    # Returns the modulo of this Duration by another Duration or Numeric.
+    # Numeric values are treated as seconds.
+    def %(other)
+      if Duration === other || Scalar === other
+        Duration.build(value % other.value)
+      elsif Numeric === other
+        Duration.build(value % other)
+      else
+        raise_type_error(other)
+      end
+    end
+
+    def -@ #:nodoc:
+      Duration.new(-value, parts.map { |type, number| [type, -number] })
+    end
+
+    def is_a?(klass) #:nodoc:
+      Duration == klass || value.is_a?(klass)
+    end
+    alias :kind_of? :is_a?
+
+    def instance_of?(klass) # :nodoc:
+      Duration == klass || value.instance_of?(klass)
+    end
+
+    # Returns +true+ if +other+ is also a Duration instance with the
+    # same +value+, or if <tt>other == value</tt>.
+    def ==(other)
+      if Duration === other
+        other.value == value
+      else
+        other == value
+      end
+    end
+
+    # Returns the amount of seconds a duration covers as a string.
+    # For more information check to_i method.
+    #
+    #   1.day.to_s # => "86400"
+    def to_s
+      @value.to_s
+    end
+
+    # Returns the number of seconds that this Duration represents.
+    #
+    #   1.minute.to_i   # => 60
+    #   1.hour.to_i     # => 3600
+    #   1.day.to_i      # => 86400
+    #
+    # Note that this conversion makes some assumptions about the
+    # duration of some periods, e.g. months are always 1/12 of year
+    # and years are 365.2425 days:
+    #
+    #   # equivalent to (1.year / 12).to_i
+    #   1.month.to_i    # => 2629746
+    #
+    #   # equivalent to 365.2425.days.to_i
+    #   1.year.to_i     # => 31556952
+    #
+    # In such cases, Ruby's core
+    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # date and time arithmetic.
+    def to_i
+      @value.to_i
+    end
+
+    # Returns +true+ if +other+ is also a Duration instance, which has the
+    # same parts as this one.
+    def eql?(other)
+      Duration === other && other.value.eql?(value)
+    end
+
+    def hash
+      @value.hash
+    end
+
+    # Calculates a new Time or Date that is as far in the future
+    # as this Duration represents.
+    def since(time = ::Time.current)
+      sum(1, time)
+    end
+    alias :from_now :since
+    alias :after :since
+
+    # Calculates a new Time or Date that is as far in the past
+    # as this Duration represents.
+    def ago(time = ::Time.current)
+      sum(-1, time)
+    end
+    alias :until :ago
+    alias :before :ago
+
+    def inspect #:nodoc:
+      return "0 seconds" if parts.empty?
+
+      parts.
+        reduce(::Hash.new(0)) { |h, (l, r)| h[l] += r; h }.
+        sort_by { |unit,  _ | PARTS.index(unit) }.
+        map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
+        to_sentence(locale: ::I18n.default_locale)
+    end
+
+    def as_json(options = nil) #:nodoc:
+      to_i
+    end
+
+    def init_with(coder) #:nodoc:
+      initialize(coder["value"], coder["parts"])
+    end
+
+    def encode_with(coder) #:nodoc:
+      coder.map = { "value" => @value, "parts" => @parts }
+    end
+
+    # Build ISO 8601 Duration string for this duration.
+    # The +precision+ parameter can be used to limit seconds' precision of duration.
+    def iso8601(precision: nil)
+      ISO8601Serializer.new(self, precision: precision).serialize
+    end
+
+    private
+
+      def sum(sign, time = ::Time.current)
+        parts.inject(time) do |t, (type, number)|
+          if t.acts_like?(:time) || t.acts_like?(:date)
+            if type == :seconds
+              t.since(sign * number)
+            elsif type == :minutes
+              t.since(sign * number * 60)
+            elsif type == :hours
+              t.since(sign * number * 3600)
+            else
+              t.advance(type => sign * number)
+            end
+          else
+            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
+          end
+        end
+      end
+
+      def respond_to_missing?(method, _)
+        value.respond_to?(method)
+      end
+
+      def method_missing(method, *args, &block)
+        value.public_send(method, *args, &block)
+      end
+
+      def raise_type_error(other)
+        raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
+      end
+  end
+end