portrayal 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afdba4b2e460ce31fb430639e1270683d61d2b41bcb276a056e042ac8de8c61d
-  data.tar.gz: 39f66cc7e9224d04660d3cc1e1317f9c66752e2fd739eeb9068f10751275f9f8
+  metadata.gz: acf906a0356260f40fbe25b94b12f72f8c696ee723dff3c2f7dc0f3817154fd0
+  data.tar.gz: 0bb4b5a5d4982a59f6e66cd7fa2fe7eeec93b7880537c9e605c47f2d1b0df009
 SHA512:
-  metadata.gz: 894bcfa84622297c663f9fa88c4f829a8475fa092caff07d047768adef1a110e5726747f53a284e6d823c57ead388a14fc4e5d0bb68342c463a170a725fa9442
-  data.tar.gz: 19dc417df48b783a7847957fdc8899c143b0e92ac4aaef35f1b07342d7d02fbea1091d504d9d47318c7baee0cf538616209555903307f5e8aace2267fd777fce
+  metadata.gz: 5d3543a802ba4dad5b8c746fa2e187b0debb95bd52354509bb29c2d88e6977d622aeafc8fca3db0a65811a9918c7044985c3355bea78799a0b7730b84da28e21
+  data.tar.gz: 66f61afd2be1633c12739d49db088265d90279b622b4f4bf050bba2c4d7dc6444ce232e16be00485702ef9285fe2507758d8fdfee447414ac35bc44fe07a5e89

data/.github/workflows/rspec.yml

@@ -6,11 +6,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.4', '2.5', '2.6', '2.7', '3.0' ]
+        ruby: [ '2.4', '2.5', '2.6', '2.7', '3.0', '3.2' ]
 
     name: Ruby ${{ matrix.ruby }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}

data/CHANGELOG.md

@@ -2,6 +2,25 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
 
+## 0.9.0 - 2023-05-06
+
+None of these changes should break anything for you, only speed things up, unless you're doing something very weird.
+
+* Rewrite internals to improve runtime performance. No longer depend on `portrayal.attributes`, instead generating ruby code that references keywords literally (much more efficient).
+* All attr_readers and other methods such as `eql?`, `==`, `freeze`, etc are now included as a module, rather than class_eval'ed into your class. This lets you use `super` when overriding them.
+* Class method `portrayal` now appears when you call `extend Portrayal`, and not after the first `keyword` declaration. (Instance methods are still added upon `keyword`.)
+* Remove `portrayal[]` shortcut that accessed `portrayal.schema` (use `portrayal.schema[]` directly instead).
+* Remove `portrayal.render_initialize`.
+* Add `portrayal.module`, which is the module included in your struct.
+* Add `portrayal.render_module_code`, which renders the code for the module.
+* Bring back class comparison to `==` (reverses a change in 0.3.0). Upon further research, it seems class comparison is always necessary.
+* Methods `==`, `eql?`, `hash`, `initialize_dup`, `initialize_clone`, and `freeze` now operate on @instance @variables, not reader method return values.
+* Methods `deconstruct` and `deconstruct_keys` now quietly exclude private/protected keywords.
+
+## 0.8.0 - 2023-01-27
+
+* Add pattern matching support (`#deconstruct` and `#deconstruct_keys`).
+
 ## 0.7.1 - 2021-03-22
 
 * Fix default procs' behavior when overriding keywords in subclasses. Portrayal relies on an ordered ruby hash to initialize keywords in the correct order. However, if overriding the same keyword in a subclass (by declaring it again), it didn't move keyword to the bottom of the hash, so this would happen:
@@ -31,31 +50,31 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## 0.6.0 - 2020-08-10
 
-* Return keyword name from `keyword`, allowing usage such as `private keyword :foo`. [[commit]](https://github.com/scottscheapflights/portrayal/commit/9e9db2cafc7eae14789c5b84f70efd18898ace76)
+* Return keyword name from `keyword`, allowing usage such as `private keyword :foo`. [[commit]](https://github.com/maxim/portrayal/commit/9e9db2cafc7eae14789c5b84f70efd18898ace76)
 
 ## 0.5.0 - 2020-05-28
 
-* Add option `define` for overriding nested class name. [[commit]](https://github.com/scottscheapflights/portrayal/commit/665ad297fb71fcdf5f641c672a457ccbe29e4a49)
+* Add option `define` for overriding nested class name. [[commit]](https://github.com/maxim/portrayal/commit/665ad297fb71fcdf5f641c672a457ccbe29e4a49)
 
 ## 0.4.0 - 2020-05-16
 
-* Portrayal schema is deep-duped to subclasses. [[commit]](https://github.com/scottscheapflights/portrayal/commit/f346483a379ce9fbdece72cde8b0844f2d22b1cd)
+* Portrayal schema is deep-duped to subclasses. [[commit]](https://github.com/maxim/portrayal/commit/f346483a379ce9fbdece72cde8b0844f2d22b1cd)
 
 ## 0.3.1 - 2020-05-11
 
-* Fix the issue introduced in 0.3.0 where `==` and `eql?` were always treating rhs as another portrayal class. [[commit]](https://github.com/scottscheapflights/portrayal/commit/f6ec8f373c6582f7e8d8f872d289222e4a58f8f6)
+* Fix the issue introduced in 0.3.0 where `==` and `eql?` were always treating rhs as another portrayal class. [[commit]](https://github.com/maxim/portrayal/commit/f6ec8f373c6582f7e8d8f872d289222e4a58f8f6)
 
 ## 0.3.0 - 2020-05-09 (yanked)
 
-* No longer compare classes in `==`, use `eql?` for that. [[commit]](https://github.com/scottscheapflights/portrayal/commit/9c5a37e4fb91e35d23b22e208344452930452af7)
-* Define a protected writer for every keyword - useful when applying changes after `dup`/`clone`. [[commit]](https://github.com/scottscheapflights/portrayal/commit/1c0fa6c6357a09760dae39165e864238d231a08e)
-* Add definition of `#hash` to fix hash equality. Now `hash[object]` will match if `object` is of the same class with the same keywords and values. [[commit]](https://github.com/scottscheapflights/portrayal/commit/ba9e390ab4aea4733ba084ac273da448e313ea53)
-* Make `#freeze` propagate to all keyword values. [[commit]](https://github.com/scottscheapflights/portrayal/commit/0a734411a6eac08e2355c4277e09a2a70800d032)
-* Make `#dup` and `#clone` propagate to all keyword values. [[commit]](https://github.com/scottscheapflights/portrayal/commit/010632d87d81a8d5b5ea5ff27d3d209cc667b0a5)
+* No longer compare classes in `==`, use `eql?` for that. [[commit]](https://github.com/maxim/portrayal/commit/9c5a37e4fb91e35d23b22e208344452930452af7)
+* Define a protected writer for every keyword - useful when applying changes after `dup`/`clone`. [[commit]](https://github.com/maxim/portrayal/commit/1c0fa6c6357a09760dae39165e864238d231a08e)
+* Add definition of `#hash` to fix hash equality. Now `hash[object]` will match if `object` is of the same class with the same keywords and values. [[commit]](https://github.com/maxim/portrayal/commit/ba9e390ab4aea4733ba084ac273da448e313ea53)
+* Make `#freeze` propagate to all keyword values. [[commit]](https://github.com/maxim/portrayal/commit/0a734411a6eac08e2355c4277e09a2a70800d032)
+* Make `#dup` and `#clone` propagate to all keyword values. [[commit]](https://github.com/maxim/portrayal/commit/010632d87d81a8d5b5ea5ff27d3d209cc667b0a5)
 
 ## 0.2.0 - 2019-07-03
 
-* It's now possible to specify non-lambda default values, like `default: "foo"`. There is now also a distinction between a proc and a lambda default. Procs are `call`-ed, while lambdas or any other types are returned as-is. In the majority of cases defaults are static values, and there is no need for the performance overhead of making all defaults into anonymous functions. [[commit]](https://github.com/scottscheapflights/portrayal/commit/a1cc9d0fd40e413210f61b945d37b81c87280fee)
+* It's now possible to specify non-lambda default values, like `default: "foo"`. There is now also a distinction between a proc and a lambda default. Procs are `call`-ed, while lambdas or any other types are returned as-is. In the majority of cases defaults are static values, and there is no need for the performance overhead of making all defaults into anonymous functions. [[commit]](https://github.com/maxim/portrayal/commit/a1cc9d0fd40e413210f61b945d37b81c87280fee)
 
 ## 0.1.0
 

data/README.md

@@ -1,4 +1,4 @@
-![RSpec](https://github.com/scottscheapflights/portrayal/workflows/RSpec/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/portrayal.svg)](https://badge.fury.io/rb/portrayal) ![RSpec](https://github.com/maxim/portrayal/workflows/RSpec/badge.svg)
 
 # Portrayal
 
@@ -8,7 +8,7 @@ Inspired by:
   - Piotr Solnica's [virtus](https://github.com/solnic/virtus)
   - Everything [Michel Martens](https://github.com/soveran)
 
-Portrayal is a minimalist gem (~120 loc, no dependencies) for building struct-like classes. It provides a small yet powerful step up from plain ruby with its one and only `keyword` method.
+Portrayal is a minimalist gem (~110 loc, no dependencies) for building struct-like classes. It provides a small yet powerful step up from plain ruby with its one and only `keyword` method.
 
 ```ruby
 class Person < MySuperClass
@@ -38,6 +38,7 @@ When you call `keyword`:
 * It defines `#hash` for hash equality
 * It defines `#dup` and `#clone` that propagate to all keyword values
 * It defines `#freeze` that propagates to all keyword values
+* It defines `#deconstruct` and `#deconstruct_keys` for pattern matching
 * It creates a nested class when you supply a block
 * It inherits parent's superclass when creating a nested class
 
@@ -76,6 +77,14 @@ class Person < MySuperClass
     super
   end
 
+  def deconstruct
+    [ name, age, favorite_fruit, address ]
+  end
+
+  def deconstruct_keys(*)
+    { name: name, age: age, favorite_fruit: favorite_fruit, address: address }
+  end
+
   def initialize_dup(source)
     @name = source.name.dup
     @age = source.age.dup
@@ -123,6 +132,14 @@ class Person < MySuperClass
       super
     end
 
+    def deconstruct
+      [ street, city ]
+    end
+
+    def deconstruct_keys(*)
+      { street: street, city: city }
+    end
+
     def initialize_dup(source)
       @street = source.street.dup
       @city = source.city.dup
@@ -307,9 +324,38 @@ However, if you try calling `Employee.from_contact(contact)` it will error out,
 
 If you add `**kwargs` to `Person.from_contact` and pass them through to new, then you are now able to call `Employee.from_contact(contact, employee_id: 'some_id')`
 
-### Schema
+### Pattern Matching
+
+If your Ruby has pattern matching, you can pattern match portrayal objects. Both array- and hash-style matching are supported.
+
+```ruby
+class Point
+  extend Portrayal
+
+  keyword :x
+  keyword :y
+end
+
+point = Point.new(x: 5, y: 10)
+
+case point
+in 5, 10
+  'matched'
+else
+  'did not match'
+end # => "matched"
+
+case point
+in x:, y: 10
+  'matched'
+else
+  'did not match'
+end # => "matched"
+```
+
+### Introspection
 
-Every class that has at least one keyword defined in it automatically receives a class method called `portrayal`. This method is a schema of your object with some additional helpers.
+Every class that extends Portrayal receives a method called `portrayal`. This method is a schema of your object with some additional helpers.
 
 #### `portrayal.keywords`
 
@@ -319,7 +365,7 @@ Get all keyword names.
 Address.portrayal.keywords # => [:street, :city, :postcode, :country]
 ```
 
-#### `portrayal.attributes`
+#### `portrayal.attributes(object)`
 
 Get all names + values as a hash.
 
@@ -342,12 +388,14 @@ Portrayal steps back from things like type enforcement, coercion, and writer met
 
 #### Good Constructors
 
-The fact that we keep these portrayal structs read-only (nothing stops you from adding writers, but I will personally frown upon you), all of the responsibility of building them shifts into constructors. This is a good thing, because good constructors clearly define their dependencies, as well as giving us ample room for performing coercion.
+Since a portrayal object is read-only (nothing stops you from adding writers, but I will personally frown upon you), you must set all its values in a constructor. This is a good thing, because it lets us study, coerce, and validate all the passed-in arguments in one convenient place. We're assured that once instantiated, the object is valid. And of course we can have multiple constructors if needed. They serve as adapters for different kinds of input.
 
 ```ruby
 class Address < ApplicationStruct
   class << self
     def from_form(params)
+      raise ArgumentError, 'invalid postcode' unless postcode =~ /\A\d+\z/
+
       new \
         street:   params[:street].to_s,
         city:     params[:city].to_s,
@@ -371,16 +419,18 @@ class Address < ApplicationStruct
 end
 ```
 
-Good constructors can also depend on one another to successively break down dependnecies into essential parts. This is similar to how in functional languages one can use recursion and pattern matching.
+Good constructors can depend on one another to successively convert arguments into keywords. This is similar to how in functional languages one can use recursion and pattern matching.
 
 ```ruby
 class Email < ApplicationStruct
   class << self
+    # Extract parts of an email from JSON, and kick it over to from_parts.
     def from_publishing_service_json(json)
       subject, header, body, footer = *JSON.parse(json)
       from_parts(subject: subject, header: header, body: body, footer: footer)
     end
 
+    # Combine parts into the final keywords: subject and body.
     def from_parts(subject:, header:, body:, footer:)
       new(subject: subject, body: "#{header}#{body}#{footer}")
     end
@@ -414,15 +464,45 @@ class Address < ApplicationStruct
 end
 ```
 
+If a particular constructor doesn't belong on your object (i.e. a 3rd party module is responsible for parsing its own data and producing your object) — you don't need to have a special constructor. Remember that each portrayal object comes with `.new`, which accepts every keyword directly. Let the module do all the parsing on its side and call `.new` with final values.
+
 #### No Reinventing The Wheel
 
-Portrayal leans on Ruby to take care of enforcing required keyword arguments, and setting keyword argument defaults. It actually generates standard ruby keyword arguments for you behind the scenes. You can even see the code by checking `YourClass.portrayal.definition_of_initialize`.
+Portrayal leans on Ruby's built-in features as much as possible. For initialize and default values it generates standard ruby keyword arguments. You can see all the code portrayal generates for your objects by running `YourClass.portrayal.render_module_code`.
 
 ```irb
-Address.portrayal.definition_of_initialize
-=> "def initialize(street:,city:,postcode:,country: self.class.portrayal.call_default(:country)); @street = street; @city = city; @postcode = postcode; @country = country end"
+[1] pry(main)> puts Address.portrayal.render_module_code
+attr_accessor :street, :city, :postcode, :country
+protected :street=, :city=, :postcode=, :country=
+def initialize(street:, city:, postcode:, country: self.class.portrayal.schema[:country]); @street = street.is_a?(::Portrayal::Default) ? street.(self) : street; @city = city.is_a?(::Portrayal::Default) ? city.(self) : city; @postcode = postcode.is_a?(::Portrayal::Default) ? postcode.(self) : postcode; @country = country.is_a?(::Portrayal::Default) ? country.(self) : country end
+def hash; [self.class, {street: @street, city: @city, postcode: @postcode, country: @country}].hash end
+def ==(other); self.class == other.class && @street == other.instance_variable_get('@street') && @city == other.instance_variable_get('@city') && @postcode == other.instance_variable_get('@postcode') && @country == other.instance_variable_get('@country') end
+alias eql? ==
+def freeze; @street.freeze; @city.freeze; @postcode.freeze; @country.freeze; super end
+def initialize_dup(src); @street = src.instance_variable_get('@street').dup; @city = src.instance_variable_get('@city').dup; @postcode = src.instance_variable_get('@postcode').dup; @country = src.instance_variable_get('@country').dup; super end
+def initialize_clone(src); @street = src.instance_variable_get('@street').clone; @city = src.instance_variable_get('@city').clone; @postcode = src.instance_variable_get('@postcode').clone; @country = src.instance_variable_get('@country').clone; super end
+def deconstruct
+  public_syms = [:street, :city, :postcode, :country].select { |s| self.class.public_method_defined?(s) }
+  public_syms.map { |s| public_send(s) }
+end
+def deconstruct_keys(keys)
+  filtered_keys = [:street, :city, :postcode, :country].select {|s| self.class.public_method_defined?(s) }
+  filtered_keys &= keys if Array === keys
+  Hash[filtered_keys.map { |k| [k, public_send(k)] }]
+end
 ```
 
+#### Implementation decisions
+
+Here are some key architectural decisions that took a lot of thinking. If you have good counter-arguments please make an issue, or contact me on [mastodon](https://ruby.social/@maxim) / [twitter](https://twitter.com/hakunin).
+
+1. **Why do methods `#==`, `#eql?`, `#hash` rely on @instance @variables instead of calling reader methods?**  
+   Portrayal makes a careful assumption on what most people would expect from object equality: a comparison of type and runtime state (which is what instance variables are). Portrayal avoids comparing object structure and method return values, because it's too situational whether they should participate in equality or not. If you have such a situation, you're welcome to redefine `==` in your class.
+2. **Why do methods `clone` and `dup` copy @instance @variables instead of calling reader methods?**  
+   As with the reason for `==`, when we clone an object, we want to clone its type and runtime state. Not the artifacts of its structure. It's too presumptious for a clone to assume that method outputs are authoritative. If objects are written deterministically, then by cloning their inner runtime state we should get the same reader method outputs anyway. If you are doing something else, you're welcome to redefine `initialize_clone`/`initialize_dup` in your class.
+3. **Why does pattern matching (`deconstruct`/`deconstruct_keys`) call reader methods rather than reading @instance @variables?**  
+   Unlike equality or object replication, in case of pattern matching we're no longer trying to figure out object's identity, rather we are now an external caller working directly with the values that an object exposes. That's why portrayal lets pattern matching depend on reader methods that get to decide how to expose data outwardly, while making a conscious effort to exclude private and protected readers. You're welcome to override `deconstruct` and `deconstruct_keys` in your class if you'd like to do something different.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -431,7 +511,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/scottscheapflights/portrayal. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/maxim/portrayal. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -439,4 +519,4 @@ The gem is available as open source under the terms of the [Apache License Versi
 
 ## Code of Conduct
 
-Everyone interacting in the Portrayal project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/scottscheapflights/portrayal/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Portrayal project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/maxim/portrayal/blob/main/CODE_OF_CONDUCT.md).

data/bin/bench

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'portrayal'
+require 'benchmark/ips'
+
+class Address1
+  extend Portrayal
+
+  keyword :street
+  keyword :city
+  keyword :postal_code
+
+  def ==(other)
+    self.class.portrayal.attributes(self) ==
+      other.class.portrayal.attributes(other)
+  end
+end
+
+class Address2
+  extend Portrayal
+
+  keyword :street
+  keyword :city
+  keyword :postal_code
+end
+
+Address2.portrayal.module.module_eval <<-RUBY
+  def ==(o)
+    street == o.street && city == o.city && postal_code == o.postal_code
+  end
+RUBY
+
+class Address3
+  extend Portrayal
+
+  keyword :street
+  keyword :city
+  keyword :postal_code
+
+  def ==(o)
+    { street: street, city: city, postal_code: postal_code } ==
+      { street: o.street, city: o.city, postal_code: o.postal_code }
+  end
+end
+
+a1 = Address1.new(street: 'street', city: 'city', postal_code: 123)
+a2 = Address2.new(street: 'street', city: 'city', postal_code: 123)
+a3 = Address3.new(street: 'street', city: 'city', postal_code: 123)
+
+
+Benchmark.ips do |x|
+  x.report("equality-via-hash-construction") {
+    a1 == a1
+  }
+
+  x.report("equality-via-boolean-expression") {
+    a2 == a2
+  }
+
+  x.report("equality-via-hash-literal") {
+    a3 == a3
+  }
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("hash of literal Hash") {
+    { foo: 'foo', bar: 'bar', baz: 'baz' }.hash
+  }
+
+  x.report("hash of literal Array") {
+    [ [:foo, 'foo'], [:bar, 'bar'], [:baz, 'baz'] ].hash
+  }
+
+  x.compare!
+end

data/bin/loc

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+find lib -name '*.rb' | xargs wc -l

data/bin/module

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'portrayal'
+
+class Address
+  extend Portrayal
+
+  keyword :street
+  keyword :city
+  keyword :postcode
+  keyword :country, default: nil
+end
+
+puts Address.portrayal.render_module_code

data/lib/portrayal/default.rb

@@ -1,13 +1,12 @@
-module Portrayal
-  class Default
-    attr_reader :value
+class Portrayal::Default
+  attr_reader :value
+  protected :value
 
-    def initialize(value)
-      @value = value
-      @callable = value.is_a?(Proc) && !value.lambda?
-    end
-
-    def call?; @callable end
-    def initialize_dup(src); super; @value = src.value.dup end
+  def initialize(value)
+    @value = value
+    @callable = value.is_a?(Proc) && !value.lambda?
   end
+
+  def call(obj); @callable ? obj.instance_exec(&value) : value end
+  def initialize_dup(src); @value = src.value.dup; super end
 end

data/lib/portrayal/schema.rb

@@ -1,72 +1,72 @@
 require 'portrayal/default'
 
-module Portrayal
-  class Schema
-    attr_reader :schema
+class Portrayal::Schema
+  attr_reader :schema, :module
+  NULL = Object.new.freeze
 
-    DEFINITION_OF_OBJECT_ENHANCEMENTS = <<~RUBY.freeze
-      def eql?(other); self.class == other.class && self == other end
-      def hash; [self.class, self.class.portrayal.attributes(self)].hash end
+  def initialize;       @schema = {}; @module = Module.new                end
+  def keywords;         @schema.keys                                      end
+  def attributes(obj);  Hash[keywords.map { |k| [k, obj.send(k)] }]       end
+  def camelize(string); string.to_s.gsub(/(?:^|_+)([^_])/) { $1.upcase }  end
 
-      def ==(other)
-        return super unless other.class.is_a?(Portrayal)
-
-        self.class.portrayal.attributes(self) ==
-          self.class.portrayal.attributes(other)
-      end
-
-      def freeze
-        self.class.portrayal.attributes(self).values.each(&:freeze)
-        super
-      end
-
-      def initialize_dup(source)
-        self.class.portrayal.attributes(source).each do |key, value|
-          instance_variable_set("@\#{key}", value.dup)
-        end
-        super
-      end
-
-      def initialize_clone(source)
-        self.class.portrayal.attributes(source).each do |key, value|
-          instance_variable_set("@\#{key}", value.clone)
-        end
-        super
-      end
-    RUBY
-
-    def initialize; @schema = {}  end
-    def keywords;   @schema.keys  end
-    def [](name);   @schema[name] end
-
-    def attributes(object)
-      Hash[object.class.portrayal.keywords.map { |k| [k, object.send(k)] }]
-    end
+  def initialize_dup(src)
+    @schema = src.schema.transform_values(&:dup)
+    @module = src.module.dup
+    super
+  end
 
-    def camelize(string); string.to_s.gsub(/(?:^|_+)([^_])/) { $1.upcase } end
+  def add_keyword(name, default)
+    name = name.to_sym
+    @schema.delete(name) # Forcing keyword to be added at the end of the hash.
+    @schema[name] = default.equal?(NULL) ? nil : Portrayal::Default.new(default)
+    @module.module_eval(render_module_code)
+  end
 
-    def add_keyword(name, default)
-      name = name.to_sym
-      @schema.delete(name) # Forcing keyword to be added at the end of the hash.
-      @schema[name] = default.equal?(NULL) ? nil : Default.new(default)
-    end
+  def render_module_code
+    args, inits, syms, hash, eqls, dups, clones, setters, freezes =
+      '', '', '', '', '', '', '', '', ''
 
-    def initialize_dup(other)
-      super; @schema = other.schema.transform_values(&:dup)
+    @schema.each do |k, default|
+      args  << "#{k}:#{default && " self.class.portrayal.schema[:#{k}]"}, "
+      inits << "@#{k} = #{k}.is_a?(::Portrayal::Default) ? #{k}.(self) : #{k}; "
+      syms  << ":#{k}, "
+      hash  << "#{k}: @#{k}, "
+      eqls  << "@#{k} == other.instance_variable_get('@#{k}') && "
+      dups  << "@#{k} = src.instance_variable_get('@#{k}').dup; "
+      clones  << "@#{k} = src.instance_variable_get('@#{k}').clone; "
+      setters << ":#{k}=, "
+      freezes << "@#{k}.freeze; "
     end
 
-    def definition_of_initialize
-      init_args = @schema.map { |name, default|
-        "#{name}:#{default && " self.class.portrayal[:#{name}]"}"
-      }.join(', ')
-
-      init_assigns = @schema.keys.map { |name|
-        "@#{name} = #{name}.is_a?(::Portrayal::Default) ? " \
-          "(#{name}.call? ? instance_exec(&#{name}.value) : #{name}.value) : " \
-          "#{name}"
-      }.join('; ')
+    args.chomp!(', ')    # key1:, key2: self.class.portrayal.schema[:key2]
+    inits.chomp!('; ')   # Assignments in initialize
+    syms.chomp!(', ')    # :key1, :key2
+    hash.chomp!(', ')    # key1: @key1, key2: @key2
+    eqls.chomp!(' && ')  # @key1 == other.instance_variable_get('@key1') &&
+    dups.chomp!('; ')    # @key1 = src.instance_variable_get('@key1').dup;
+    clones.chomp!('; ')  # @key1 = src.instance_variable_get('@key1').clone;
+    setters.chomp!(', ') # :key1=, :key2=
+    freezes.chomp!('; ') # @key1.freeze; @key2.freeze
 
-      "def initialize(#{init_args}); #{init_assigns} end"
-    end
+    <<-RUBY
+attr_accessor #{syms}
+protected #{setters}
+def initialize(#{args}); #{inits} end
+def hash; [self.class, {#{hash}}].hash end
+def ==(other); self.class == other.class && #{eqls} end
+alias eql? ==
+def freeze; #{freezes}; super end
+def initialize_dup(src); #{dups}; super end
+def initialize_clone(src); #{clones}; super end
+def deconstruct
+  public_syms = [#{syms}].select { |s| self.class.public_method_defined?(s) }
+  public_syms.map { |s| public_send(s) }
+end
+def deconstruct_keys(keys)
+  filtered_keys = [#{syms}].select {|s| self.class.public_method_defined?(s) }
+  filtered_keys &= keys if Array === keys
+  Hash[filtered_keys.map { |k| [k, public_send(k)] }]
+end
+    RUBY
   end
 end

data/lib/portrayal/version.rb

@@ -1,3 +1,3 @@
 module Portrayal
-  VERSION = '0.7.1'
+  VERSION = '0.9.0'
 end

data/lib/portrayal.rb

@@ -2,32 +2,20 @@ require 'portrayal/version'
 require 'portrayal/schema'
 
 module Portrayal
-  NULL = :_portrayal_value_not_set
+  attr_reader :portrayal
+  def self.extended(c); c.instance_variable_set(:@portrayal, Schema.new) end
 
-  def keyword(name, default: NULL, define: nil, &block)
-    unless respond_to?(:portrayal)
-      class << self
-        attr_reader :portrayal
-        def inherited(base)
-          base.instance_variable_set('@portrayal', portrayal.dup)
-        end
-      end
-
-      @portrayal = Schema.new
-      class_eval(Schema::DEFINITION_OF_OBJECT_ENHANCEMENTS)
-    end
-
-    attr_accessor name
-    protected "#{name}="
+  def inherited(c)
+    c.instance_variable_set(:@portrayal, portrayal.dup)
+    c.include(c.portrayal.module)
+  end
 
+  def keyword(name, default: Schema::NULL, define: nil, &block)
+    include portrayal.module
     portrayal.add_keyword(name, default)
-    class_eval(portrayal.definition_of_initialize)
-
-    if block_given?
-      kw_class = Class.new(superclass) { extend Portrayal }
-      const_set(define || portrayal.camelize(name), kw_class).class_eval(&block)
-    end
-
+    return name unless block_given?
+    nested = Class.new(superclass) { extend ::Portrayal }
+    const_set(define || portrayal.camelize(name), nested).class_eval(&block)
     name
   end
 end

data/portrayal.gemspec

@@ -3,17 +3,17 @@ require_relative 'lib/portrayal/version'
 Gem::Specification.new do |spec|
   spec.name    = 'portrayal'
   spec.version = Portrayal::VERSION
-  spec.authors = ['Maxim Chernyak']
-  spec.email   = ['madfancier@gmail.com']
+  spec.authors = ['Max Chernyak']
+  spec.email   = ['hello@max.engineer']
 
   spec.summary     = 'A minimal builder for struct-like classes'
   spec.description = 'Inspired by dry-initializer and virtus, portrayal is a minimalist gem that takes a somewhat different approach to building struct-like classes. It steps away from types, coersion, and writer methods in favor of encouraging well-designed constructors. Read more in the Philosophy section of the README.'
-  spec.homepage    = 'https://github.com/scottscheapflights/portrayal'
+  spec.homepage    = 'https://github.com/maxim/portrayal'
   spec.license     = 'Apache-2.0'
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['changelog_uri'] = 'https://github.com/scottscheapflights/portrayal/blob/main/CHANGELOG.md'
+  spec.metadata['changelog_uri'] = 'https://github.com/maxim/portrayal/blob/main/CHANGELOG.md'
 
   spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
   spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 2.1'
   spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.9'
-  spec.add_development_dependency 'pry', '~> 0.13'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'pry', '~> 0.14'
+  spec.add_development_dependency 'benchmark-ips', '~> 2.11'
 end

metadata

@@ -1,77 +1,77 @@
 --- !ruby/object:Gem::Specification
 name: portrayal
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.9.0
 platform: ruby
 authors:
-- Maxim Chernyak
+- Max Chernyak
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-22 00:00:00.000000000 Z
+date: 2023-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '3.12'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '0.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '0.14'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '2.11'
 description: Inspired by dry-initializer and virtus, portrayal is a minimalist gem
   that takes a somewhat different approach to building struct-like classes. It steps
   away from types, coersion, and writer methods in favor of encouraging well-designed
   constructors. Read more in the Philosophy section of the README.
 email:
-- madfancier@gmail.com
+- hello@max.engineer
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -85,20 +85,23 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/bench
 - bin/console
+- bin/loc
+- bin/module
 - bin/setup
 - lib/portrayal.rb
 - lib/portrayal/default.rb
 - lib/portrayal/schema.rb
 - lib/portrayal/version.rb
 - portrayal.gemspec
-homepage: https://github.com/scottscheapflights/portrayal
+homepage: https://github.com/maxim/portrayal
 licenses:
 - Apache-2.0
 metadata:
-  homepage_uri: https://github.com/scottscheapflights/portrayal
-  source_code_uri: https://github.com/scottscheapflights/portrayal
-  changelog_uri: https://github.com/scottscheapflights/portrayal/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/maxim/portrayal
+  source_code_uri: https://github.com/maxim/portrayal
+  changelog_uri: https://github.com/maxim/portrayal/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -114,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.4.2
 signing_key:
 specification_version: 4
 summary: A minimal builder for struct-like classes