ric 0.14.2 → 0.15.0

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/async.rb

@@ -1,448 +0,0 @@
-require 'concurrent/configuration'
-require 'concurrent/ivar'
-require 'concurrent/synchronization/lockable_object'
-
-module Concurrent
-
-  # A mixin module that provides simple asynchronous behavior to a class,
-  # turning it into a simple actor. Loosely based on Erlang's
-  # [gen_server](http://www.erlang.org/doc/man/gen_server.html), but without
-  # supervision or linking.
-  #
-  # A more feature-rich {Concurrent::Actor} is also available when the
-  # capabilities of `Async` are too limited.
-  #
-  # ```cucumber
-  # Feature:
-  #   As a stateful, plain old Ruby class
-  #   I want safe, asynchronous behavior
-  #   So my long-running methods don't block the main thread
-  # ```
-  #
-  # The `Async` module is a way to mix simple yet powerful asynchronous
-  # capabilities into any plain old Ruby object or class, turning each object
-  # into a simple Actor. Method calls are processed on a background thread. The
-  # caller is free to perform other actions while processing occurs in the
-  # background.
-  #
-  # Method calls to the asynchronous object are made via two proxy methods:
-  # `async` (alias `cast`) and `await` (alias `call`). These proxy methods post
-  # the method call to the object's background thread and return a "future"
-  # which will eventually contain the result of the method call.
-  #
-  # This behavior is loosely patterned after Erlang's `gen_server` behavior.
-  # When an Erlang module implements the `gen_server` behavior it becomes
-  # inherently asynchronous. The `start` or `start_link` function spawns a
-  # process (similar to a thread but much more lightweight and efficient) and
-  # returns the ID of the process. Using the process ID, other processes can
-  # send messages to the `gen_server` via the `cast` and `call` methods. Unlike
-  # Erlang's `gen_server`, however, `Async` classes do not support linking or
-  # supervision trees.
-  #
-  # ## Basic Usage
-  #
-  # When this module is mixed into a class, objects of the class become inherently
-  # asynchronous. Each object gets its own background thread on which to post
-  # asynchronous method calls. Asynchronous method calls are executed in the
-  # background one at a time in the order they are received.
-  #
-  # To create an asynchronous class, simply mix in the `Concurrent::Async` module:
-  #
-  # ```
-  # class Hello
-  #   include Concurrent::Async
-  #
-  #   def hello(name)
-  #     "Hello, #{name}!"
-  #   end
-  # end
-  # ```
-  #
-  # Mixing this module into a class provides each object two proxy methods:
-  # `async` and `await`. These methods are thread safe with respect to the
-  # enclosing object. The former proxy allows methods to be called
-  # asynchronously by posting to the object's internal thread. The latter proxy
-  # allows a method to be called synchronously but does so safely with respect
-  # to any pending asynchronous method calls and ensures proper ordering. Both
-  # methods return a {Concurrent::IVar} which can be inspected for the result
-  # of the proxied method call. Calling a method with `async` will return a
-  # `:pending` `IVar` whereas `await` will return a `:complete` `IVar`.
-  #
-  # ```
-  # class Echo
-  #   include Concurrent::Async
-  #
-  #   def echo(msg)
-  #     print "#{msg}\n"
-  #   end
-  # end
-  #
-  # horn = Echo.new
-  # horn.echo('zero')      # synchronous, not thread-safe
-  #                        # returns the actual return value of the method
-  #
-  # horn.async.echo('one') # asynchronous, non-blocking, thread-safe
-  #                        # returns an IVar in the :pending state
-  #
-  # horn.await.echo('two') # synchronous, blocking, thread-safe
-  #                        # returns an IVar in the :complete state
-  # ```
-  #
-  # ## Let It Fail
-  #
-  # The `async` and `await` proxy methods have built-in error protection based
-  # on Erlang's famous "let it fail" philosophy. Instance methods should not be
-  # programmed defensively. When an exception is raised by a delegated method
-  # the proxy will rescue the exception, expose it to the caller as the `reason`
-  # attribute of the returned future, then process the next method call.
-  #
-  # ## Calling Methods Internally
-  #
-  # External method calls should *always* use the `async` and `await` proxy
-  # methods. When one method calls another method, the `async` proxy should
-  # rarely be used and the `await` proxy should *never* be used.
-  #
-  # When an object calls one of its own methods using the `await` proxy the
-  # second call will be enqueued *behind* the currently running method call.
-  # Any attempt to wait on the result will fail as the second call will never
-  # run until after the current call completes.
-  #
-  # Calling a method using the `await` proxy from within a method that was
-  # itself called using `async` or `await` will irreversibly deadlock the
-  # object. Do *not* do this, ever.
-  #
-  # ## Instance Variables and Attribute Accessors
-  #
-  # Instance variables do not need to be thread-safe so long as they are private.
-  # Asynchronous method calls are processed in the order they are received and
-  # are processed one at a time. Therefore private instance variables can only
-  # be accessed by one thread at a time. This is inherently thread-safe.
-  #
-  # When using private instance variables within asynchronous methods, the best
-  # practice is to read the instance variable into a local variable at the start
-  # of the method then update the instance variable at the *end* of the method.
-  # This way, should an exception be raised during method execution the internal
-  # state of the object will not have been changed.
-  #
-  # ### Reader Attributes
-  #
-  # The use of `attr_reader` is discouraged. Internal state exposed externally,
-  # when necessary, should be done through accessor methods. The instance
-  # variables exposed by these methods *must* be thread-safe, or they must be
-  # called using the `async` and `await` proxy methods. These two approaches are
-  # subtly different.
-  #
-  # When internal state is accessed via the `async` and `await` proxy methods,
-  # the returned value represents the object's state *at the time the call is
-  # processed*, which may *not* be the state of the object at the time the call
-  # is made.
-  #
-  # To get the state *at the current* time, irrespective of an enqueued method
-  # calls, a reader method must be called directly. This is inherently unsafe
-  # unless the instance variable is itself thread-safe, preferably using one
-  # of the thread-safe classes within this library. Because the thread-safe
-  # classes within this library are internally-locking or non-locking, they can
-  # be safely used from within asynchronous methods without causing deadlocks.
-  #
-  # Generally speaking, the best practice is to *not* expose internal state via
-  # reader methods. The best practice is to simply use the method's return value.
-  #
-  # ### Writer Attributes
-  #
-  # Writer attributes should never be used with asynchronous classes. Changing
-  # the state externally, even when done in the thread-safe way, is not logically
-  # consistent. Changes to state need to be timed with respect to all asynchronous
-  # method calls which my be in-process or enqueued. The only safe practice is to
-  # pass all necessary data to each method as arguments and let the method update
-  # the internal state as necessary.
-  #
-  # ## Class Constants, Variables, and Methods
-  #
-  # ### Class Constants
-  #
-  # Class constants do not need to be thread-safe. Since they are read-only and
-  # immutable they may be safely read both externally and from within
-  # asynchronous methods.
-  #
-  # ### Class Variables
-  #
-  # Class variables should be avoided. Class variables represent shared state.
-  # Shared state is anathema to concurrency. Should there be a need to share
-  # state using class variables they *must* be thread-safe, preferably
-  # using the thread-safe classes within this library. When updating class
-  # variables, never assign a new value/object to the variable itself. Assignment
-  # is not thread-safe in Ruby. Instead, use the thread-safe update functions
-  # of the variable itself to change the value.
-  #
-  # The best practice is to *never* use class variables with `Async` classes.
-  #
-  # ### Class Methods
-  #
-  # Class methods which are pure functions are safe. Class methods which modify
-  # class variables should be avoided, for all the reasons listed above.
-  #
-  # ## An Important Note About Thread Safe Guarantees
-  #
-  # > Thread safe guarantees can only be made when asynchronous method calls
-  # > are not mixed with direct method calls. Use only direct method calls
-  # > when the object is used exclusively on a single thread. Use only
-  # > `async` and `await` when the object is shared between threads. Once you
-  # > call a method using `async` or `await`, you should no longer call methods
-  # > directly on the object. Use `async` and `await` exclusively from then on.
-  #
-  # @example
-  #
-  #   class Echo
-  #     include Concurrent::Async
-  #
-  #     def echo(msg)
-  #       print "#{msg}\n"
-  #     end
-  #   end
-  #
-  #   horn = Echo.new
-  #   horn.echo('zero')      # synchronous, not thread-safe
-  #                          # returns the actual return value of the method
-  #
-  #   horn.async.echo('one') # asynchronous, non-blocking, thread-safe
-  #                          # returns an IVar in the :pending state
-  #
-  #   horn.await.echo('two') # synchronous, blocking, thread-safe
-  #                          # returns an IVar in the :complete state
-  #
-  # @see Concurrent::Actor
-  # @see https://en.wikipedia.org/wiki/Actor_model "Actor Model" at Wikipedia
-  # @see http://www.erlang.org/doc/man/gen_server.html Erlang gen_server
-  # @see http://c2.com/cgi/wiki?LetItCrash "Let It Crash" at http://c2.com/
-  module Async
-
-    # @!method self.new(*args, &block)
-    #
-    #   Instanciate a new object and ensure proper initialization of the
-    #   synchronization mechanisms.
-    #
-    #   @param [Array<Object>] args Zero or more arguments to be passed to the
-    #     object's initializer.
-    #   @param [Proc] block Optional block to pass to the object's initializer.
-    #   @return [Object] A properly initialized object of the asynchronous class.
-
-    # Check for the presence of a method on an object and determine if a given
-    # set of arguments matches the required arity.
-    #
-    # @param [Object] obj the object to check against
-    # @param [Symbol] method the method to check the object for
-    # @param [Array] args zero or more arguments for the arity check
-    #
-    # @raise [NameError] the object does not respond to `method` method
-    # @raise [ArgumentError] the given `args` do not match the arity of `method`
-    #
-    # @note This check is imperfect because of the way Ruby reports the arity of
-    #   methods with a variable number of arguments. It is possible to determine
-    #   if too few arguments are given but impossible to determine if too many
-    #   arguments are given. This check may also fail to recognize dynamic behavior
-    #   of the object, such as methods simulated with `method_missing`.
-    #
-    # @see http://www.ruby-doc.org/core-2.1.1/Method.html#method-i-arity Method#arity
-    # @see http://ruby-doc.org/core-2.1.0/Object.html#method-i-respond_to-3F Object#respond_to?
-    # @see http://www.ruby-doc.org/core-2.1.0/BasicObject.html#method-i-method_missing BasicObject#method_missing
-    #
-    # @!visibility private
-    def self.validate_argc(obj, method, *args)
-      argc = args.length
-      arity = obj.method(method).arity
-
-      if arity >= 0 && argc != arity
-        raise ArgumentError.new("wrong number of arguments (#{argc} for #{arity})")
-      elsif arity < 0 && (arity = (arity + 1).abs) > argc
-        raise ArgumentError.new("wrong number of arguments (#{argc} for #{arity}..*)")
-      end
-    end
-
-    # @!visibility private
-    def self.included(base)
-      base.singleton_class.send(:alias_method, :original_new, :new)
-      base.extend(ClassMethods)
-      super(base)
-    end
-
-    # @!visibility private
-    module ClassMethods
-      def new(*args, &block)
-        obj = original_new(*args, &block)
-        obj.send(:init_synchronization)
-        obj
-      end
-    end
-    private_constant :ClassMethods
-
-    # Delegates asynchronous, thread-safe method calls to the wrapped object.
-    #
-    # @!visibility private
-    class AsyncDelegator < Synchronization::LockableObject
-      safe_initialization!
-
-      # Create a new delegator object wrapping the given delegate.
-      #
-      # @param [Object] delegate the object to wrap and delegate method calls to
-      def initialize(delegate)
-        super()
-        @delegate = delegate
-        @queue = []
-        @executor = Concurrent.global_io_executor
-        @ruby_pid = $$
-      end
-
-      # Delegates method calls to the wrapped object.
-      #
-      # @param [Symbol] method the method being called
-      # @param [Array] args zero or more arguments to the method
-      #
-      # @return [IVar] the result of the method call
-      #
-      # @raise [NameError] the object does not respond to `method` method
-      # @raise [ArgumentError] the given `args` do not match the arity of `method`
-      def method_missing(method, *args, &block)
-        super unless @delegate.respond_to?(method)
-        Async::validate_argc(@delegate, method, *args)
-
-        ivar = Concurrent::IVar.new
-        synchronize do
-          reset_if_forked
-          @queue.push [ivar, method, args, block]
-          @executor.post { perform } if @queue.length == 1
-        end
-
-        ivar
-      end
-
-      # Check whether the method is responsive
-      #
-      # @param [Symbol] method the method being called
-      def respond_to_missing?(method, include_private = false)
-        @delegate.respond_to?(method) || super
-      end
-
-      # Perform all enqueued tasks.
-      #
-      # This method must be called from within the executor. It must not be
-      # called while already running. It will loop until the queue is empty.
-      def perform
-        loop do
-          ivar, method, args, block = synchronize { @queue.first }
-          break unless ivar # queue is empty
-
-          begin
-            ivar.set(@delegate.send(method, *args, &block))
-          rescue => error
-            ivar.fail(error)
-          end
-
-          synchronize do
-            @queue.shift
-            return if @queue.empty?
-          end
-        end
-      end
-
-      def reset_if_forked
-        if $$ != @ruby_pid
-          @queue.clear
-          @ruby_pid = $$
-        end
-      end
-    end
-    private_constant :AsyncDelegator
-
-    # Delegates synchronous, thread-safe method calls to the wrapped object.
-    #
-    # @!visibility private
-    class AwaitDelegator
-
-      # Create a new delegator object wrapping the given delegate.
-      #
-      # @param [AsyncDelegator] delegate the object to wrap and delegate method calls to
-      def initialize(delegate)
-        @delegate = delegate
-      end
-
-      # Delegates method calls to the wrapped object.
-      #
-      # @param [Symbol] method the method being called
-      # @param [Array] args zero or more arguments to the method
-      #
-      # @return [IVar] the result of the method call
-      #
-      # @raise [NameError] the object does not respond to `method` method
-      # @raise [ArgumentError] the given `args` do not match the arity of `method`
-      def method_missing(method, *args, &block)
-        ivar = @delegate.send(method, *args, &block)
-        ivar.wait
-        ivar
-      end
-
-      # Check whether the method is responsive
-      #
-      # @param [Symbol] method the method being called
-      def respond_to_missing?(method, include_private = false)
-        @delegate.respond_to?(method) || super
-      end
-    end
-    private_constant :AwaitDelegator
-
-    # Causes the chained method call to be performed asynchronously on the
-    # object's thread. The delegated method will return a future in the
-    # `:pending` state and the method call will have been scheduled on the
-    # object's thread. The final disposition of the method call can be obtained
-    # by inspecting the returned future.
-    #
-    # @!macro async_thread_safety_warning
-    #   @note The method call is guaranteed to be thread safe with respect to
-    #     all other method calls against the same object that are called with
-    #     either `async` or `await`. The mutable nature of Ruby references
-    #     (and object orientation in general) prevent any other thread safety
-    #     guarantees. Do NOT mix direct method calls with delegated method calls.
-    #     Use *only* delegated method calls when sharing the object between threads.
-    #
-    # @return [Concurrent::IVar] the pending result of the asynchronous operation
-    #
-    # @raise [NameError] the object does not respond to the requested method
-    # @raise [ArgumentError] the given `args` do not match the arity of
-    #   the requested method
-    def async
-      @__async_delegator__
-    end
-    alias_method :cast, :async
-
-    # Causes the chained method call to be performed synchronously on the
-    # current thread. The delegated will return a future in either the
-    # `:fulfilled` or `:rejected` state and the delegated method will have
-    # completed. The final disposition of the delegated method can be obtained
-    # by inspecting the returned future.
-    #
-    # @!macro async_thread_safety_warning
-    #
-    # @return [Concurrent::IVar] the completed result of the synchronous operation
-    #
-    # @raise [NameError] the object does not respond to the requested method
-    # @raise [ArgumentError] the given `args` do not match the arity of the
-    #   requested method
-    def await
-      @__await_delegator__
-    end
-    alias_method :call, :await
-
-    # Initialize the internal serializer and other stnchronization mechanisms.
-    #
-    # @note This method *must* be called immediately upon object construction.
-    #   This is the only way thread-safe initialization can be guaranteed.
-    #
-    # @!visibility private
-    def init_synchronization
-      return self if defined?(@__async_initialized__) && @__async_initialized__
-      @__async_initialized__ = true
-      @__async_delegator__ = AsyncDelegator.new(self)
-      @__await_delegator__ = AwaitDelegator.new(@__async_delegator__)
-      self
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/atom.rb

@@ -1,222 +0,0 @@
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/collection/copy_on_notify_observer_set'
-require 'concurrent/concern/observable'
-require 'concurrent/synchronization'
-
-# @!macro thread_safe_variable_comparison
-#
-#   ## Thread-safe Variable Classes
-#
-#   Each of the thread-safe variable classes is designed to solve a different
-#   problem. In general:
-#
-#   * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
-#     uncoordinated, *asynchronous* change of individual values. Best used when
-#     the value will undergo frequent, complex updates. Suitable when the result
-#     of an update does not need to be known immediately.
-#   * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
-#     uncoordinated, *synchronous* change of individual values. Best used when
-#     the value will undergo frequent reads but only occasional, though complex,
-#     updates. Suitable when the result of an update must be known immediately.
-#   * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
-#     atomically. Updates are synchronous but fast. Best used when updates a
-#     simple set operations. Not suitable when updates are complex.
-#     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
-#     but optimized for the given data type.
-#   * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
-#     when two or more threads need to exchange data. The threads will pair then
-#     block on each other until the exchange is complete.
-#   * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
-#     must give a value to another, which must take the value. The threads will
-#     block on each other until the exchange is complete.
-#   * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
-#     holds a different value for each thread which has access. Often used as
-#     an instance variable in objects which must maintain different state
-#     for different threads.
-#   * *{Concurrent::TVar}:* Shared, mutable variables which provide
-#     *coordinated*, *synchronous*, change of *many* stated. Used when multiple
-#     value must change together, in an all-or-nothing transaction.
-
-
-module Concurrent
-
-  # Atoms provide a way to manage shared, synchronous, independent state.
-  #
-  # An atom is initialized with an initial value and an optional validation
-  # proc. At any time the value of the atom can be synchronously and safely
-  # changed. If a validator is given at construction then any new value
-  # will be checked against the validator and will be rejected if the
-  # validator returns false or raises an exception.
-  #
-  # There are two ways to change the value of an atom: {#compare_and_set} and
-  # {#swap}. The former will set the new value if and only if it validates and
-  # the current value matches the new value. The latter will atomically set the
-  # new value to the result of running the given block if and only if that
-  # value validates.
-  #
-  # ## Example
-  #
-  # ```
-  # def next_fibonacci(set = nil)
-  #   return [0, 1] if set.nil?
-  #   set + [set[-2..-1].reduce{|sum,x| sum + x }]
-  # end
-  #
-  # # create an atom with an initial value
-  # atom = Concurrent::Atom.new(next_fibonacci)
-  #
-  # # send a few update requests
-  # 5.times do
-  #   atom.swap{|set| next_fibonacci(set) }
-  # end
-  #
-  # # get the current value
-  # atom.value #=> [0, 1, 1, 2, 3, 5, 8]
-  # ```
-  #
-  # ## Observation
-  #
-  # Atoms support observers through the {Concurrent::Observable} mixin module.
-  # Notification of observers occurs every time the value of the Atom changes.
-  # When notified the observer will receive three arguments: `time`, `old_value`,
-  # and `new_value`. The `time` argument is the time at which the value change
-  # occurred. The `old_value` is the value of the Atom when the change began
-  # The `new_value` is the value to which the Atom was set when the change
-  # completed. Note that `old_value` and `new_value` may be the same. This is
-  # not an error. It simply means that the change operation returned the same
-  # value.
-  #
-  # Unlike in Clojure, `Atom` cannot participate in {Concurrent::TVar} transactions.
-  #
-  # @!macro thread_safe_variable_comparison
-  #
-  # @see http://clojure.org/atoms Clojure Atoms
-  # @see http://clojure.org/state Values and Change - Clojure's approach to Identity and State
-  class Atom < Synchronization::Object
-    include Concern::Observable
-
-    safe_initialization!
-    attr_atomic(:value)
-    private :value=, :swap_value, :compare_and_set_value, :update_value
-    public :value
-    alias_method :deref, :value
-
-    # @!method value
-    #   The current value of the atom.
-    #
-    #   @return [Object] The current value.
-
-    # Create a new atom with the given initial value.
-    #
-    # @param [Object] value The initial value
-    # @param [Hash] opts The options used to configure the atom
-    # @option opts [Proc] :validator (nil) Optional proc used to validate new
-    #   values. It must accept one and only one argument which will be the
-    #   intended new value. The validator will return true if the new value
-    #   is acceptable else return false (preferrably) or raise an exception.
-    #
-    # @!macro deref_options
-    #
-    # @raise [ArgumentError] if the validator is not a `Proc` (when given)
-    def initialize(value, opts = {})
-      super()
-      @Validator     = opts.fetch(:validator, -> v { true })
-      self.observers = Collection::CopyOnNotifyObserverSet.new
-      self.value     = value
-    end
-
-    # Atomically swaps the value of atom using the given block. The current
-    # value will be passed to the block, as will any arguments passed as
-    # arguments to the function. The new value will be validated against the
-    # (optional) validator proc given at construction. If validation fails the
-    # value will not be changed.
-    #
-    # Internally, {#swap} reads the current value, applies the block to it, and
-    # attempts to compare-and-set it in. Since another thread may have changed
-    # the value in the intervening time, it may have to retry, and does so in a
-    # spin loop. The net effect is that the value will always be the result of
-    # the application of the supplied block to a current value, atomically.
-    # However, because the block might be called multiple times, it must be free
-    # of side effects.
-    #
-    # @note The given block may be called multiple times, and thus should be free
-    #   of side effects.
-    #
-    # @param [Object] args Zero or more arguments passed to the block.
-    #
-    # @yield [value, args] Calculates a new value for the atom based on the
-    #   current value and any supplied arguments.
-    # @yieldparam value [Object] The current value of the atom.
-    # @yieldparam args [Object] All arguments passed to the function, in order.
-    # @yieldreturn [Object] The intended new value of the atom.
-    #
-    # @return [Object] The final value of the atom after all operations and
-    #   validations are complete.
-    #
-    # @raise [ArgumentError] When no block is given.
-    def swap(*args)
-      raise ArgumentError.new('no block given') unless block_given?
-
-      loop do
-        old_value = value
-        new_value = yield(old_value, *args)
-        begin
-          break old_value unless valid?(new_value)
-          break new_value if compare_and_set(old_value, new_value)
-        rescue
-          break old_value
-        end
-      end
-    end
-
-    # Atomically sets the value of atom to the new value if and only if the
-    # current value of the atom is identical to the old value and the new
-    # value successfully validates against the (optional) validator given
-    # at construction.
-    #
-    # @param [Object] old_value The expected current value.
-    # @param [Object] new_value The intended new value.
-    #
-    # @return [Boolean] True if the value is changed else false.
-    def compare_and_set(old_value, new_value)
-      if valid?(new_value) && compare_and_set_value(old_value, new_value)
-        observers.notify_observers(Time.now, old_value, new_value)
-        true
-      else
-        false
-      end
-    end
-
-    # Atomically sets the value of atom to the new value without regard for the
-    # current value so long as the new value successfully validates against the
-    # (optional) validator given at construction.
-    #
-    # @param [Object] new_value The intended new value.
-    #
-    # @return [Object] The final value of the atom after all operations and
-    #   validations are complete.
-    def reset(new_value)
-      old_value = value
-      if valid?(new_value)
-        self.value = new_value
-        observers.notify_observers(Time.now, old_value, new_value)
-        new_value
-      else
-        old_value
-      end
-    end
-
-    private
-
-    # Is the new value valid?
-    #
-    # @param [Object] new_value The intended new value.
-    # @return [Boolean] false if the validator function returns false or raises
-    #   an exception else true
-    def valid?(new_value)
-      @Validator.call(new_value)
-    rescue
-      false
-    end
-  end
-end