validated_object 2.0.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c1aef88260ebc19d28fa8bd90a400ec6d05c45a60fea1632ebb1b81bbe2b456
-  data.tar.gz: 239216afd24adc90bb9ae4641253443a91d303e312f49b7bc6f348c541563f5f
+  metadata.gz: 66bdc1ee048b6518b260908a2a48e8c4676c4350f99641a0da1c041fdc82a530
+  data.tar.gz: 27e9c03469ee86a4875fc9b99d8796055f12e48f7c627bbf410c7b43468c6022
 SHA512:
-  metadata.gz: 032c79475b1a99e990f4b04da2cda94cd5cca556cb38e385a783300ef675bfcd2ed51cc055d653b86f77b70270de87518cd7296b1c754a108f11c70d4e989c86
-  data.tar.gz: affdd5eb1d8dd2525c6b0fd7730fb907317ce0ad3bf8f105b42d67c66aba69e3389c65f7eae85dbfc67ed273e242761a34c67210153f4d9cbaaa694a3e6cac57
+  metadata.gz: 667688231472cb2d893ac1235be71c97111831f8f8510164c5152e4d37d4bd99b994c4cb189a36f1feb4af5786d0200b14e74ba27e69b7be3e1929795419d2db
+  data.tar.gz: ed1589b44cf7c83d7424ce46b5b09cb1990331aee38bee239232ed2e71b49b32a0c65e2a3fc4ad909c44cd2df1e0b81ee9e65b3191f35621ec50e1be2b499f30

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
-  - 2.2.2
-  - 2.3.1
-before_install: gem install bundler -v 1.10.6
+  - 2.6.6
+  - 2.7.1
+before_install: gem install bundler

data/README.md

@@ -135,8 +135,7 @@ git commits and tags, and push the `.gem` file to
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at
-https://github.com/dogweather/validated_object.
+Bug reports and pull requests are welcome on GitHub.
 
 
 ## License

data/lib/validated_object/version.rb

@@ -1,5 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ValidatedObject
-  VERSION = '2.0.3'
+  VERSION = '2.2.0'
 end

data/lib/validated_object.rb

@@ -1,6 +1,8 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'active_model'
+require 'sorbet-runtime'
 require 'validated_object/version'
 
 module ValidatedObject
@@ -41,8 +43,11 @@ module ValidatedObject
   # @see http://www.rubyinside.com/rails-3-0s-activemodel-how-to-give-ruby-classes-some-activerecord-magic-2937.html Rails 3.0′s ActiveModel: How To Give Ruby Classes Some ActiveRecord Magic, Peter Cooper
   class Base
     include ActiveModel::Validations
+    extend T::Sig
 
-    EMPTY_HASH = {}.freeze
+    SymbolHash = T.type_alias { T::Hash[Symbol, T.untyped] }
+
+    EMPTY_HASH = T.let({}.freeze, SymbolHash)
 
     # A private class definition, not intended to
     # be used directly. Implements a pseudo-boolean class
@@ -58,20 +63,21 @@ module ValidatedObject
     #
     # @raise [ArgumentError] if the object is not valid at the
     #   end of initialization or `attributes` is not a Hash.
-    def initialize(attributes=EMPTY_HASH)
-      raise ArgumentError, "#{attributes} is not a Hash" unless attributes.is_a?(Hash)
-
+    sig { params(attributes: SymbolHash).void }
+    def initialize(attributes = EMPTY_HASH)
       set_instance_variables from_hash: attributes
       check_validations!
-      return self
+      nil
     end
 
     # Run any validations and raise an error if invalid.
     #
     # @raise [ArgumentError] if any validations fail.
     # @return [ValidatedObject::Base] the receiver
+    sig { returns(ValidatedObject::Base) }
     def check_validations!
       raise ArgumentError, errors.full_messages.join('; ') if invalid?
+
       self
     end
 
@@ -88,47 +94,70 @@ module ValidatedObject
     #     validates :neutered, type: Boolean, allow_nil: true  # Typed but optional
     #   end
     class TypeValidator < ActiveModel::EachValidator
+      extend T::Sig
+
       # @return [nil]
+      sig do
+        params(
+          record: T.untyped,
+          attribute: T.untyped,
+          value: T.untyped
+        )
+          .void
+      end
       def validate_each(record, attribute, value)
-        expected_class = options[:with]
+        validation_options = T.let(options, SymbolHash)
+
+        expected_class = validation_options[:with]
 
         return if pseudo_boolean?(expected_class, value) ||
                   expected_class?(expected_class, value)
 
-        save_error(record, attribute, value, options)
+        save_error(record, attribute, value, validation_options)
       end
 
-
       private
 
+      sig { params(expected_class: T.untyped, value: T.untyped).returns(T.untyped) }
       def pseudo_boolean?(expected_class, value)
         expected_class == Boolean && boolean?(value)
       end
 
+      sig { params(expected_class: T.untyped, value: T.untyped).returns(T.untyped) }
       def expected_class?(expected_class, value)
         value.is_a?(expected_class)
       end
 
+      sig { params(value: T.untyped).returns(T.untyped) }
       def boolean?(value)
         value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
 
-      def save_error(record, attribute, value, options)
+      sig do
+        params(
+          record: T.untyped,
+          attribute: T.untyped,
+          value: T.untyped,
+          validation_options: SymbolHash
+        )
+          .void
+      end
+      def save_error(record, attribute, value, validation_options)
         record.errors.add attribute,
-                          options[:message] || "is a #{value.class}, not a #{options[:with]}"
+                          validation_options[:message] || "is a #{value.class}, not a #{validation_options[:with]}"
       end
     end
 
-
     private
 
+    sig { params(from_hash: SymbolHash).void }
     def set_instance_variables(from_hash:)
       from_hash.each do |variable_name, variable_value|
         # Test for the attribute reader
-        self.send variable_name.to_sym
+        send variable_name.to_sym
 
         # Set value in a way that succeeds even if attr is read-only
-        self.instance_variable_set "@#{variable_name}".to_sym, variable_value
+        instance_variable_set "@#{variable_name}".to_sym, variable_value
       end
     end
   end

data/script/demo.rb

@@ -1,3 +1,4 @@
+# typed: ignore
 require 'date'
 require 'validated_object'
 

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/activemodel.rbi

@@ -0,0 +1,210 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: ignore
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activemodel/all/activemodel.rbi
+#
+# activemodel-6.0.3.2
+
+module ActiveModel
+  def self.eager_load!; end
+  def self.gem_version; end
+  def self.version; end
+  extend ActiveSupport::Autoload
+end
+module ActiveModel::VERSION
+end
+module ActiveModel::Serializers
+  extend ActiveSupport::Autoload
+end
+module ActiveModel::Validations
+  def errors; end
+  def initialize_dup(other); end
+  def invalid?(context = nil); end
+  def raise_validation_error; end
+  def read_attribute_for_validation(*arg0); end
+  def run_validations!; end
+  def valid?(context = nil); end
+  def validate!(context = nil); end
+  def validate(context = nil); end
+  def validates_with(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::ClassMethods
+  def _parse_validates_options(options); end
+  def _validates_default_keys; end
+  def attribute_method?(attribute); end
+  def clear_validators!; end
+  def inherited(base); end
+  def validate(*args, &block); end
+  def validates!(*attributes); end
+  def validates(*attributes); end
+  def validates_each(*attr_names, &block); end
+  def validates_with(*args, &block); end
+  def validators; end
+  def validators_on(*attributes); end
+end
+module ActiveModel::Validations::Clusivity
+  def check_validity!; end
+  def delimiter; end
+  def include?(record, value); end
+  def inclusion_method(enumerable); end
+end
+class ActiveModel::Validator
+  def initialize(options = nil); end
+  def kind; end
+  def options; end
+  def self.kind; end
+  def validate(record); end
+end
+class ActiveModel::EachValidator < ActiveModel::Validator
+  def attributes; end
+  def check_validity!; end
+  def initialize(options); end
+  def validate(record); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::BlockValidator < ActiveModel::EachValidator
+  def initialize(options, &block); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::InclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+module ActiveModel::Validations::HelperMethods
+  def _merge_attributes(attr_names); end
+  def validates_absence_of(*attr_names); end
+  def validates_acceptance_of(*attr_names); end
+  def validates_confirmation_of(*attr_names); end
+  def validates_exclusion_of(*attr_names); end
+  def validates_format_of(*attr_names); end
+  def validates_inclusion_of(*attr_names); end
+  def validates_length_of(*attr_names); end
+  def validates_numericality_of(*attr_names); end
+  def validates_presence_of(*attr_names); end
+  def validates_size_of(*attr_names); end
+end
+class ActiveModel::Validations::AbsenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::NumericalityValidator < ActiveModel::EachValidator
+  def allow_only_integer?(record); end
+  def check_validity!; end
+  def filtered_options(value); end
+  def is_hexadecimal_literal?(raw_value); end
+  def is_integer?(raw_value); end
+  def is_number?(raw_value); end
+  def parse_as_number(raw_value); end
+  def record_attribute_changed_in_place?(record, attr_name); end
+  def validate_each(record, attr_name, value); end
+end
+module ActiveModel::Validations::Callbacks
+  def run_validations!; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::Callbacks::ClassMethods
+  def after_validation(*args, &block); end
+  def before_validation(*args, &block); end
+end
+class ActiveModel::Validations::ExclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+class ActiveModel::Validations::ConfirmationValidator < ActiveModel::EachValidator
+  def confirmation_value_equal?(record, attribute, value, confirmed); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::FormatValidator < ActiveModel::EachValidator
+  def check_options_validity(name); end
+  def check_validity!; end
+  def option_call(record, name); end
+  def record_error(record, attribute, name, value); end
+  def regexp_using_multiline_anchors?(regexp); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::PresenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::LengthValidator < ActiveModel::EachValidator
+  def check_validity!; end
+  def initialize(options); end
+  def skip_nil_check?(key); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator < ActiveModel::EachValidator
+  def acceptable_option?(value); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes < Module
+  def ==(other); end
+  def attributes; end
+  def define_on(klass); end
+  def included(klass); end
+  def initialize(attributes); end
+  def matches?(method_name); end
+end
+class ActiveModel::Validations::WithValidator < ActiveModel::EachValidator
+  def validate_each(record, attr, val); end
+end
+class ActiveModel::ValidationError < StandardError
+  def initialize(model); end
+  def model; end
+end
+class ActiveModel::Name
+  def !~(**, &&); end
+  def <=>(**, &&); end
+  def ==(arg); end
+  def ===(arg); end
+  def =~(**, &&); end
+  def _singularize(string); end
+  def as_json(**, &&); end
+  def cache_key; end
+  def collection; end
+  def element; end
+  def eql?(**, &&); end
+  def human(options = nil); end
+  def i18n_key; end
+  def initialize(klass, namespace = nil, name = nil); end
+  def match?(**, &&); end
+  def name; end
+  def param_key; end
+  def plural; end
+  def route_key; end
+  def singular; end
+  def singular_route_key; end
+  def to_s(**, &&); end
+  def to_str(**, &&); end
+  include Comparable
+end
+module ActiveModel::Naming
+  def model_name; end
+  def self.extended(base); end
+  def self.model_name_from_record_or_class(record_or_class); end
+  def self.param_key(record_or_class); end
+  def self.plural(record_or_class); end
+  def self.route_key(record_or_class); end
+  def self.singular(record_or_class); end
+  def self.singular_route_key(record_or_class); end
+  def self.uncountable?(record_or_class); end
+end
+module ActiveModel::Callbacks
+  def _define_after_model_callback(klass, callback); end
+  def _define_around_model_callback(klass, callback); end
+  def _define_before_model_callback(klass, callback); end
+  def define_model_callbacks(*callbacks); end
+  def self.extended(base); end
+end
+module ActiveModel::Translation
+  def human_attribute_name(attribute, options = nil); end
+  def i18n_scope; end
+  def lookup_ancestors; end
+  include ActiveModel::Naming
+end