smart_properties 1.13.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fbf78f2b4f868f64a7e675336305c7f68579ec33
-  data.tar.gz: 12eeb1777b492bfb56f4d3fe68e0b2fbea222d88
+SHA256:
+  metadata.gz: 76b840210991bfec855a2e1159426635bc29e3994269bf305b5f0a8fe40fb0cf
+  data.tar.gz: f10d37b213920338b36b8a2da7bbecc1e8e0caf1d6eecf66084b6cbb4914a95e
 SHA512:
-  metadata.gz: 67139c47fcc6da96c64d3d4489cfc16144f5cdb8772ece8b96e493a3aed6b127de5197003d7695f1d61365e7b2154a5983c2653c9b33e9529ac3d5f4702293b1
-  data.tar.gz: 926f1575ffe3723a502ae0f2d427df880d638fafc47ff5870a19df87e81103cf435bf4f2931d583a08e9f7095e1ac41e2d2d7fcab6c54b628b728522f6777b64
+  metadata.gz: 30f8ed85cd3db3e2c17ddc30b63f85cba5541d26d8c8747a92529320531c11a58ae20435f08175061faedc7edf8f3bad2899ff32f2aa36465d4de2a78c8ca75e
+  data.tar.gz: fb602a52c408989d44c9ef0dd232f5891c6bc96f64444d077d498bb06ed1f63dfa671712abfe9ab0680214fb442ee4b029b6e0e518df01a35860e5fc6c072151

data/.github/workflows/testing.yml

@@ -0,0 +1,24 @@
+name: Testing
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.6
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

@@ -15,6 +15,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea/
 
 .rspec
-.rvmrc
+.rvmrc

data/.ruby-version

@@ -0,0 +1 @@
+2.6.6

data/README.md

@@ -171,6 +171,16 @@ class Article
 end
 ```
 
+There are also a set of common validation helpers you may use. These common
+cases are provided to help avoid rewriting validation logic that occurs
+often. These validations can be found in the `SmartProperties::Validations` module.
+
+```ruby
+class Article
+  property :view_count, accepts: Ancestor.must_be(type: Number)
+end
+```
+
 #### Default values
 
 There is also support for default values. Simply use the `:default`
@@ -220,7 +230,7 @@ class Person
 end
 ```
 
-#### Custom readers
+#### Custom reader naming
 
 In Ruby, predicate methods by convention end with a `?`.
 This convention is violated in the example above, but can easily be fixed by supplying a custom `reader` name:
@@ -235,6 +245,22 @@ end
 To ensure backwards compatibility, boolean properties do not automatically change their reader name.
 It is thus your responsibility to configure the property properly.
 
+#### Custom reader implementation
+
+For convenience, it is possible to use the `super` method to access the original reader when overriding a reader.
+This is recommended over direct access to the instance variable.
+
+```ruby
+class Person
+  property :name
+  property! :address
+
+  def name
+    super || address.name
+  end
+end
+```
+
 ### Constructor argument forwarding
 
 The `SmartProperties` initializer forwards anything to the super constructor

data/dev.yml

@@ -0,0 +1,7 @@
+---
+name: smart-properties
+up:
+- ruby: 2.4.1
+- bundler
+commands:
+  test: bundle exec rake test

data/experiments/initialization_performance.rb

@@ -0,0 +1,34 @@
+require 'benchmark'
+require_relative '../lib/smart_properties'
+
+class A
+  include SmartProperties
+  property :a
+end
+
+class B < A
+  property :b
+end
+
+class C < B
+  property :c
+end
+
+class A2
+  def initialize(**attrs)
+    attrs.each { |k, v| send("#{k}=", v) }
+  end
+  attr_accessor :a
+end
+
+class B2 < A2
+  attr_accessor :b
+end
+
+class C2 < B2
+  attr_accessor :c
+end
+
+puts Benchmark.measure { 1_000_000.times { C.new(a: 1, b: 2, c: 3) } }
+# puts Benchmark.measure { 1_000_000.times { C2.new(a: 1, b: 2, c: 3) } }
+

data/lib/smart_properties.rb

@@ -91,6 +91,13 @@ module SmartProperties
     protected :property!
   end
 
+  module ModuleMethods
+    def included(target)
+      super
+      target.include(SmartProperties)
+    end
+  end
+
   class << self
     private
 
@@ -102,6 +109,7 @@ module SmartProperties
     #
     def included(base)
       base.extend(ClassMethods)
+      base.extend(ModuleMethods) if base.is_a?(Module)
     end
   end
 
@@ -153,9 +161,22 @@ module SmartProperties
 
     raise SmartProperties::InitializationError.new(self, missing_properties) unless missing_properties.empty?
   end
+
+  def [](name)
+    return if name.nil?
+    name = name.to_sym
+    reader = self.class.properties[name].reader
+    public_send(reader) if self.class.properties.key?(name)
+  end
+
+  def []=(name, value)
+    return if name.nil?
+    public_send(:"#{name.to_sym}=", value) if self.class.properties.key?(name)
+  end
 end
 
 require_relative 'smart_properties/property_collection'
 require_relative 'smart_properties/property'
 require_relative 'smart_properties/errors'
 require_relative 'smart_properties/version'
+require_relative 'smart_properties/validations'

data/lib/smart_properties/property.rb

@@ -1,28 +1,14 @@
 module SmartProperties
   class Property
     MODULE_REFERENCE = :"@_smart_properties_method_scope"
-
-    # Defines the two index methods #[] and #[]=. This module will be included
-    # in the SmartProperties method scope.
-    module IndexMethods
-      def [](name)
-        return if name.nil?
-        name = name.to_sym
-        reader = self.class.properties[name].reader
-        public_send(reader) if self.class.properties.key?(name)
-      end
-
-      def []=(name, value)
-        return if name.nil?
-        public_send(:"#{name.to_sym}=", value) if self.class.properties.key?(name)
-      end
-    end
+    ALLOWED_DEFAULT_CLASSES = [Proc, Numeric, String, Range, TrueClass, FalseClass, NilClass, Symbol, Module].freeze
 
     attr_reader :name
     attr_reader :converter
     attr_reader :accepter
     attr_reader :reader
     attr_reader :instance_variable_name
+    attr_reader :writable
 
     def self.define(scope, name, options = {})
       new(name, options).tap { |p| p.define(scope) }
@@ -37,10 +23,16 @@ module SmartProperties
       @accepter  = attrs.delete(:accepts)
       @required  = attrs.delete(:required)
       @reader    = attrs.delete(:reader)
+      @writable  = attrs.delete(:writable)
       @reader    ||= @name
 
       @instance_variable_name = :"@#{name}"
 
+      unless ALLOWED_DEFAULT_CLASSES.any? { |cls| @default.is_a?(cls) }
+        raise ConfigurationError, "Default attribute value #{@default.inspect} cannot be specified as literal, "\
+          "use the syntax `default: -> { ... }` instead."
+      end
+
       unless attrs.empty?
         raise ConfigurationError, "SmartProperties do not support the following configuration options: #{attrs.keys.map { |m| m.to_s }.sort.join(', ')}."
       end
@@ -62,14 +54,25 @@ module SmartProperties
       !null_object?(get(scope))
     end
 
+    def writable?
+      return true if @writable.nil?
+      @writable
+    end
+
     def convert(scope, value)
       return value unless converter
       return value if null_object?(value)
-      scope.instance_exec(value, &converter)
+
+      case converter
+      when Symbol
+        converter.to_proc.call(value)
+      else
+        scope.instance_exec(value, &converter)
+      end
     end
 
     def default(scope)
-      @default.kind_of?(Proc) ? scope.instance_exec(&@default) : @default
+      @default.kind_of?(Proc) ? scope.instance_exec(&@default) : @default.dup
     end
 
     def accepts?(value, scope)
@@ -99,7 +102,7 @@ module SmartProperties
         if klass.instance_variable_defined?(MODULE_REFERENCE)
           klass.instance_variable_get(MODULE_REFERENCE)
         else
-          m = Module.new { include IndexMethods }
+          m = Module.new
           klass.send(:include, m)
           klass.instance_variable_set(MODULE_REFERENCE, m)
           m
@@ -108,8 +111,11 @@ module SmartProperties
       scope.send(:define_method, reader) do
         property.get(self)
       end
-      scope.send(:define_method, :"#{name}=") do |value|
-        property.set(self, value)
+
+      if writable?
+        scope.send(:define_method, :"#{name}=") do |value|
+          property.set(self, value)
+        end
       end
     end
 
@@ -132,21 +138,38 @@ module SmartProperties
       scope.instance_variable_get(instance_variable_name)
     end
 
+    def to_h
+      {
+        accepter: @accepter,
+        converter: @converter,
+        default: @default,
+        instance_variable_name: @instance_variable_name,
+        name: @name,
+        reader: @reader,
+        required: @required
+      }
+    end
+
     private
 
     def null_object?(object)
-      return true if object == nil
-      return true if object.nil?
-      false
+      object.nil?
     rescue NoMethodError => error
       # BasicObject does not respond to #nil? by default, so we need to double
       # check if somebody implemented it and it fails internally or if the
-      # error occured because the method is actually not present. In the former
-      # case, we want to raise the exception because there is something wrong
-      # with the implementation of object#nil?. In the latter case we treat the
-      # object as truthy because we don't know better.
-      raise error if (class << object; self; end).public_instance_methods.include?(:nil?)
-      false
+      # error occured because the method is actually not present.
+      
+      # This is a workaround for the fact that #singleton_class is defined on Object, but not BasicObject.
+      the_singleton_class = (class << object; self; end)
+      
+      if the_singleton_class.public_instance_methods.include?(:nil?)
+        # object defines #nil?, but it raised NoMethodError,
+        # something is wrong with the implementation, so raise the exception.
+        raise error 
+      else
+        # treat the object as truthy because we don't know better.
+        false 
+      end
     end
   end
 end

data/lib/smart_properties/property_collection.rb

@@ -5,16 +5,18 @@ module SmartProperties
     attr_reader :parent
 
     def self.for(scope)
-      parent = scope.ancestors[1..-1].find do |ancestor|
-        ancestor.ancestors.include?(SmartProperties) && ancestor != SmartProperties
+      parents = scope.ancestors[1..-1].select do |ancestor|
+        ancestor.ancestors.include?(SmartProperties) &&
+          ancestor != scope &&
+          ancestor != SmartProperties
       end
 
-      if parent.nil?
-        new
-      else
-        parent.properties.register(collection = new)
-        collection
+      parents.reduce(collection = new) do |previous, current|
+        current.properties.register(previous)
+        current.properties
       end
+
+      collection
     end
 
     def initialize

data/lib/smart_properties/validations.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SmartProperties
+  module Validations
+  end
+end
+
+require_relative 'validations/ancestor'

data/lib/smart_properties/validations/ancestor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module SmartProperties
+  module Validations
+    class Ancestor
+      include SmartProperties
+
+      property! :type, accepts: ->(type) { type.is_a?(Class) }
+
+      def validate(klass)
+        klass.is_a?(Class) && klass < type
+      end
+
+      def to_proc
+        validator = self
+        ->(klass) { validator.validate(klass) }
+      end
+
+      def to_s
+        "subclasses of #{type.to_s}"
+      end
+
+      class << self
+        alias_method :must_be, :new
+      end
+    end
+  end
+end

data/lib/smart_properties/version.rb

@@ -1,3 +1,3 @@
 module SmartProperties
-  VERSION = "1.13.0"
+  VERSION = "1.16.0"
 end

data/smart_properties.gemspec

@@ -12,6 +12,10 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{SmartProperties – Ruby accessors on steroids}
   gem.homepage      = ""
 
+  gem.metadata = {
+    "source_code_uri" => "https://github.com/t6d/smart_properties"
+  }
+
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
@@ -20,6 +24,6 @@ Gem::Specification.new do |gem|
   gem.version       = SmartProperties::VERSION
 
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rake", "~> 13.0"
   gem.add_development_dependency "pry"
 end

data/spec/base_spec.rb

@@ -41,12 +41,19 @@ RSpec.describe SmartProperties do
       default_title = double(to_title: 'chunky')
 
       DummyClass.new do
-        property :title, converts: :to_title, accepts: String, required: true, default: default_title
+        property :title, converts: :to_title, accepts: String, required: true, default: -> { default_title }
       end
     end
 
     it { is_expected.to have_smart_property(:title) }
 
+    it "should return a property's configuration with #to_h" do
+      expect(klass.properties.values.first.to_h).to match(
+        accepter: String, converter: :to_title, default: an_instance_of(Proc),
+        instance_variable_name: :@title, name: :title, reader: :title, required: true
+      )
+    end
+
     context "an instance of this class when initialized with no arguments" do
       subject(:instance) { klass.new }
 
@@ -157,4 +164,34 @@ RSpec.describe SmartProperties do
       end
     end
   end
+
+  context "when used to build a class that has a property called relation for an arbitrary Relation class" do
+    class Relation
+      attr_reader :equality_tested
+
+      def initialize
+        @equality_tested = false
+      end
+
+      def ==(_)
+        @equality_tested = true
+        false
+      end
+    end
+
+    subject(:klass) do
+      DummyClass.new do
+        property :relation, accepts: Relation, required: true
+      end
+    end
+
+    context 'with an instance of Relation' do
+      let(:relation) { Relation.new }
+
+      it 'should not execute #== on the object' do
+        instance = klass.new(relation: relation)
+        expect(relation.equality_tested).to eq(false)
+      end
+    end
+  end
 end

data/spec/configuration_error_spec.rb

@@ -13,5 +13,38 @@ RSpec.describe SmartProperties, 'configuration error' do
 
       expect(&invalid_property_definition).to raise_error(SmartProperties::ConfigurationError, "SmartProperties do not support the following configuration options: invalid_option_1, invalid_option_2, invalid_option_3.")
     end
+
+    it "should accept default values that can't be mutated" do
+      valid_property_definition = lambda do
+        klass.class_eval do
+          property :proc, default: -> { }
+          property :numeric_float, default: 1.23
+          property :numeric_int, default: 456
+          property :string, default: "abc"
+          property :range, default: 123...456
+          property :bool_true, default: true
+          property :bool_false, default: false
+          property :nil, default: nil
+          property :symbol, default: :abc
+          property :module, default: Integer
+        end
+      end
+
+      expect(&valid_property_definition).not_to raise_error
+    end
+
+    it "should not accept default values that may be mutated" do
+      invalid_property_definition = lambda do
+        klass.class_eval do
+          property :title, default: []
+        end
+      end
+
+      expect(&invalid_property_definition).to(
+        raise_error(SmartProperties::ConfigurationError,
+          "Default attribute value [] cannot be specified as literal, "\
+            "use the syntax `default: -> { ... }` instead.")
+      )
+    end
   end
 end

data/spec/default_values_spec.rb

@@ -48,4 +48,72 @@ RSpec.describe SmartProperties, 'default values' do
       end
     end
   end
+
+  context "when defining a new property with a literal default value" do
+    context 'with a numeric default' do
+      subject(:klass) { DummyClass.new { property :var, default: 123 } }
+
+      it 'accepts the default and returns it' do
+        instance = klass.new
+        expect(instance.var).to(be(123))
+      end
+    end
+
+    context 'with a string default' do
+      DEFAULT_VALUE = 'a string'
+      subject(:klass) { DummyClass.new { property :var, default: DEFAULT_VALUE } }
+
+      it 'accepts the default and returns it' do
+        instance = klass.new
+        expect(instance.var).to(eq(DEFAULT_VALUE))
+      end
+
+      it 'returns a copy of the string' do
+        instance = klass.new
+        expect(instance.var).to_not(be(DEFAULT_VALUE))
+      end
+
+      it 'mutating the instance variable does not mutate the original' do
+        instance = klass.new
+        instance.var[0] = 'o'
+        expect(DEFAULT_VALUE).to(eq('a string'))
+      end
+    end
+
+    context 'with a range default' do
+      subject(:klass) { DummyClass.new { property :var, default: 1..2 } }
+
+      it 'accepts the default and returns it' do
+        instance = klass.new
+        expect(instance.var).to(eq(1..2))
+      end
+    end
+
+    context 'with a true default' do
+      subject(:klass) { DummyClass.new { property :var, default: true } }
+
+      it 'accepts the default and returns it' do
+        instance = klass.new
+        expect(instance.var).to(be(true))
+      end
+    end
+
+    context 'with a false default' do
+      subject(:klass) { DummyClass.new { property :var, default: false } }
+
+      it 'accepts the default and returns it' do
+        instance = klass.new
+        expect(instance.var).to(be(false))
+      end
+    end
+
+    context 'with a symbol default' do
+      subject(:klass) { DummyClass.new { property :var, default: :foo } }
+
+      it 'accepts the default and returns it' do
+        instance = klass.new
+        expect(instance.var).to(be(:foo))
+      end
+    end
+  end
 end

data/spec/inheritance_spec.rb

@@ -225,4 +225,34 @@ RSpec.describe SmartProperties, 'intheritance' do
       end
     end
   end
+
+  it "supports multiple inheritance through modules" do
+    m = Module.new do
+      include SmartProperties
+      property :m, default: 1
+    end
+
+    n = Module.new do
+      include SmartProperties
+      property :n, default: 2
+    end
+
+    o = Module.new {}
+
+    klass = Class.new do
+      include m
+      include o
+      include n
+    end
+
+    n.module_eval do
+      property :p, default: 3
+    end
+
+    instance = klass.new
+
+    expect(instance.m).to eq(1)
+    expect(instance.n).to eq(2)
+    expect(instance.p).to eq(3)
+  end
 end

data/spec/property_collection_caching_spec.rb

@@ -26,4 +26,14 @@ RSpec.describe SmartProperties, "property collection caching:" do
     expect(subsubclass.properties.keys - expected_names).to be_empty
     expect(subsubclass.properties.to_hash.keys - expected_names).to be_empty
   end
+
+  specify "a SmartProperty enabled object should not check itself for properties if prepended" do
+    expect do
+      base_class = DummyClass.new {
+        prepend Module.new
+        property :title
+      }
+      expect(base_class.new).to have_smart_property(:title)
+    end.not_to raise_error(SystemStackError)
+  end
 end

data/spec/validations/ancestor_validation_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'smart_properties/validations/ancestor'
+
+RSpec.describe SmartProperties::Validations::Ancestor, 'validates ancestor' do
+  context 'used to validate the ancestor of a smart_properties value' do
+    let!(:test_base) do
+      Class.new do
+        def self.to_s
+          'TestBase'
+        end
+      end
+    end
+
+    subject(:klass) do
+      test_base_ref = test_base
+
+      DummyClass.new do
+        property :visible, accepts: SmartProperties::Validations::Ancestor.must_be(type: test_base_ref)
+      end
+    end
+
+    it 'should return an error for any non Class based value' do
+      expect { subject.new(visible: true) }
+        .to raise_error(SmartProperties::InvalidValueError, /Only accepts: subclasses of TestBase/)
+    end
+
+    it 'should return an error for any Class instance instead of a class type' do
+      non_ancestor_class = Class.new
+
+      expect { subject.new(visible: non_ancestor_class.new) }
+        .to raise_error(SmartProperties::InvalidValueError, /Only accepts: subclasses of TestBase/)
+    end
+
+
+    it 'should return an error for any Class instance instead of a class type even if it is a child' do
+      test_base_child = Class.new(test_base)
+
+      expect { subject.new(visible: test_base_child.new) }
+        .to raise_error(SmartProperties::InvalidValueError, /Only accepts: subclasses of TestBase/)
+    end
+
+    it 'should return an error for a Class type that is not a child of the required ancestor' do
+      non_ancestor_class = Class.new
+
+      expect { subject.new(visible: non_ancestor_class) }
+        .to raise_error(SmartProperties::InvalidValueError, /Only accepts: subclasses of TestBase/)
+    end
+
+    it 'should return an error if the class is the ancestor itself' do
+      expect { subject.new(visible: test_base) }
+        .to raise_error(SmartProperties::InvalidValueError, /Only accepts: subclasses of TestBase/)
+    end
+
+    it 'should succeed if the given class is a subtype ' do
+      test_valid_class = Class.new(test_base)
+
+      expect { subject.new(visible: test_valid_class) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/writable_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SmartProperties, 'writable properties' do
+  context 'when a property is defined as not writable there should be no accessor for the property' do
+    subject(:klass) { DummyClass.new { property :id, writable: false } }
+
+    it "should throw a no method error when trying to set the property" do
+      new_class_instance = klass.new(id: 42)
+
+      expect(new_class_instance.id).to eq(42)
+      expect { new_class_instance.id = 50 }.to raise_error(NoMethodError)
+      expect(new_class_instance.id).to eq(42)
+    end
+  end
+
+  context 'when a property is defined as writable there should be an accessor available' do
+    subject(:klass) { DummyClass.new { property :id, writable: true } }
+
+    it "should allow changing of the property" do
+      new_class_instance = klass.new(id: 42)
+
+      new_class_instance.id = 50
+      expect(new_class_instance.id).to eq(50)
+    end
+  end
+
+  context 'when writable is not defined on the property it should default to being writable' do
+    subject(:klass) { DummyClass.new { property :id } }
+
+    it "should allow changing of the property" do
+      new_class_instance = klass.new(id: 42)
+
+      new_class_instance.id = 50
+      expect(new_class_instance.id).to eq(50)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_properties
 version: !ruby/object:Gem::Version
-  version: 1.13.0
+  version: 1.16.0
 platform: ruby
 authors:
 - Konstantin Tennhard
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-10-13 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -62,16 +62,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/testing.yml"
 - ".gitignore"
+- ".ruby-version"
 - ".yardopts"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- dev.yml
+- experiments/initialization_performance.rb
 - lib/smart_properties.rb
 - lib/smart_properties/errors.rb
 - lib/smart_properties/property.rb
 - lib/smart_properties/property_collection.rb
+- lib/smart_properties/validations.rb
+- lib/smart_properties/validations/ancestor.rb
 - lib/smart_properties/version.rb
 - smart_properties.gemspec
 - spec/acceptance_checking_spec.rb
@@ -86,10 +92,13 @@ files:
 - spec/spec_helper.rb
 - spec/support/dummy_class.rb
 - spec/support/smart_property_matcher.rb
+- spec/validations/ancestor_validation_spec.rb
+- spec/writable_spec.rb
 homepage: ''
 licenses: []
-metadata: {}
-post_install_message: 
+metadata:
+  source_code_uri: https://github.com/t6d/smart_properties
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,9 +113,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: SmartProperties – Ruby accessors on steroids
 test_files:
@@ -122,3 +130,5 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/dummy_class.rb
 - spec/support/smart_property_matcher.rb
+- spec/validations/ancestor_validation_spec.rb
+- spec/writable_spec.rb