artisanal-model 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 74c99f3a53173417323c014e30722f54063402e2ed9a2e1e615131ff8ed02402
+  data.tar.gz: 33422ea03f1cdedad2ab332e4874525a367d9a344743cdd65378ad2f425b56a7
+SHA512:
+  metadata.gz: 713b969405ef5bc54e0604e6f99fbca0e154051836588e6208a5fb9e283eab7cf38825f321e4cb4dcbf184bfe948a7acbf3a33fead7270d58b604c46e43badef
+  data.tar.gz: 3a606d437f1db3d241c3530b08e1be9d461525dea970861a2dc5d7fde4db5970a836c0019944a498d0b0728f7d70d0dbe0bb335b634705b97cc7a1205d002721

data/.circleci/config.yml

@@ -0,0 +1,17 @@
+version: 2.1
+
+orbs:
+  gem: goldstar/publish-gem@1.0.1
+
+workflows:
+  main:
+    jobs:
+      - gem/test
+      - gem/build-and-deploy:
+          context: packagecloud
+          requires:
+            - gem/test
+          filters:
+            branches:
+              only: master
+          packagecloud-repo: goldstar/production

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/*.gem
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.7
+before_install: gem install bundler -v 1.17.1

data/Gemfile

@@ -0,0 +1,19 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in artisanal-model.gemspec
+gemspec
+
+group :benchmarks do
+  if RUBY_VERSION < "2.4"
+    gem "activesupport", "< 5"
+  else
+    gem "activesupport"
+  end
+
+  gem "benchmark-ips", "~> 2.5"
+  gem "dry-initializer"
+  gem "hashie"
+  gem "virtus"
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Jared Hoyt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,333 @@
+# artisanal-model
+
+Artisanal::Model is a light-weight attribute modeling DSL that wraps [dry-initializer](https://dry-rb.org/gems/dry-initializer/), providing extra configuration and a slightly cleaner DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'artisanal-model'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install artisanal-model
+    
+## Configuration
+
+Artisanal::Model configuration is done on a per-model basis. There is no global configuration (at this time):
+
+```ruby
+class Model
+  include Artisanal::Model(writable: true)
+end
+```
+
+The configuration will be carried down to subclasses automatically. However, and subclass can override any settings with the `configure` method:
+
+```ruby
+class Person < Model
+  artisanal_model.configure { |config| config.writable = false }
+  # ... or
+  artisanal_model.config.writable = false
+end
+```
+
+#### `defaults(hash)`
+
+The `defaults` setting allows you to provide default values to the `attribute` dsl method. For example, if you would like all attributes to be optional and private:
+
+```ruby
+class Model
+  include Artisanal::Model(defaults: { optional: true, reader: :private })
+end
+```
+
+See the [dry-initializer](https://dry-rb.org/gems/dry-initializer/) documentation for a list of most of the options that can be passed to the `attribute` method.
+
+#### `writable(boolean, default: false)`
+
+Setting `writable` to true will enable the mass-assignment `#assign_attributes` method as well as add `writer: true` to the `defaults` configuration option.
+
+You can also manually add `writer: true` to `defaults` without setting `writable` to true. This would give you attribute writers but skip creating the mass-assignment method.
+
+#### `undefined(boolean, default: false)`
+
+Setting `undefined` to true will configure dry-initializer to differentiate between `nil` values and undefineds. It will also automatically filter out undefined values when serializing your model to a hash.
+
+See dry-initializer [Skip Undefined](https://dry-rb.org/gems/dry-initializer/skip-undefined/) documentation for more information.
+
+#### `symbolize(boolean, default: false)`
+
+Setting `symbolize` to true will make artisanal-model intern the keys of any attributes passed in during initialization and mass-assignment. Only attributes belonging to the model will be symbolized; all
+other keys will be left as strings.
+
+See the [integration test](blob/master/spec/artisanal/integration/stringified_arguments_spec.rb) for more details.
+See the [benchmarks](#benchmarks) for the performance impact of "indifferent access".
+
+## Examples
+
+For the following examples, consider the following `Model` class with some default  configuration.
+
+```ruby
+class Model
+  include Artisanal::Model(
+    defaults: { optional: true, type: Dry::Types::Any }
+  )
+end
+```
+
+You can define attributes on your models using Artisanal::Model's `attribute` dsl method:
+
+```ruby
+class Person < Model
+  attribute :first_name
+  attribute :last_name
+  attribute :email
+end
+
+Person.new(first_name: 'John', last_name: 'Smith', email: 'john@example.com').tap do |person|
+  person.first_name #=> 'John'
+  person.email #=> 'john@example.com'
+end
+```
+
+Also, the keys passed into the initializer do not need to be symbolized ahead of time. Artisanal::Model will take care of that for you before passing them into dry-initializer:
+
+```ruby
+Person.new('first_name' => 'John').tap do |person|
+  person.first_name #=> 'John'
+end
+```
+
+### dry-initializer
+
+For the most part, the parameters available to the `attribute` method are the same ones available to dry-initializer's [option method](https://dry-rb.org/gems/dry-initializer/params-and-options/). These allow you to do things like coerce values, rename incoming fields, set defaults, define required fields, and set method access control.
+
+```ruby
+class Person < Model
+  attribute :first_name, default: -> { 'Bob' }
+  attribute :last_name, optional: false
+  attribute :email, from: :email_address
+  attribute :phone, reader: :private
+  attribute :age, ->(value, person) { value.to_i }
+end
+
+attrs = {
+  last_name: 'Smith',
+  email_address: 'john@example.com',
+  phone: '555.123.4567',
+  age: '37'
+}
+
+Person.new(attrs).tap do |person|
+  person.first_name #=> 'Bob'
+  person.email #=> 'john@example.com'
+  person.phone #=> NoMethodError: private method `phone' called for...
+  person.age #=> 37
+end
+
+Person.new(first_name: 'Steve')
+#=> KeyError: Person: option 'last_name' is required
+```
+
+### aliased fields
+
+The dry-initializer gem already lets you use the `:as` option to give your field a new name. To make this a little more straightforward, artisanal-model adds a `:from` option that is the inverse of `:as`:
+
+```ruby
+class Person < Model
+  attribute :email_address, as: :email
+  # is the same as  ...
+  attribute :email, from: :email_address
+end
+
+Person.new(email_address: 'john@example.com').email #=> 'john@example.com'
+```
+
+### coercions
+
+In addition to the functionality dry-initializer provides, Artisanal::Model also adds some niceties that make the dsl a little less verbose. For example, coercions in dry-initializer are required to be a callable type (e.g. a proc or a [dry-type](https://dry-rb.org/gems/dry-types/)).
+
+However, Artisanal::Model will allow you to specify a class or an array and will wrap the type coercion with a proc in the background:
+
+```ruby
+class Address < Model
+  attribute :street
+  attribute :city
+  attribute :state
+  attribute :zip
+end
+
+class Tag < Model
+  attribute :name
+end
+
+class Person < Model  
+  attribute :name
+  attribute :address, Address
+  attribute :tags, Array[Tag]
+  attribute :emails, Set[Dry::Types['string']]
+end
+
+attrs = {
+  name: 'John Smith',
+  address: {
+    street: '123 Main St.',
+    city: 'Portland',
+    state: 'OR',
+    zip: '97213'
+  },
+  tags: [
+    { name: 'Ruby' },
+    { name: 'Developer' }
+  ],
+  email: ['john@example.com', 'jsmith@example.com']
+}
+
+Person.new(attrs).tap do |person|
+  person.name #=> 'John Smith'
+  
+  person.address.street #=> '123 Main St.'
+  person.address.zip #=> '97213'
+  
+  person.tags.count #=> 2
+  person.tags.first.name #=> 'Ruby'
+end
+```
+
+### writers
+
+Artisanal::Model can also add writer methods that aren't provided from dry-initializer:
+
+```ruby
+# Model.include Artisanal::Model(writable: true, ...)
+
+class Person < Model
+  attribute :name
+  attribute :email, writer: false 
+  attribute :phone, writer: :protected # the same as adding `protected :phone`
+  attribute :age,   writer: :private   # the same as adding `private :age`
+end
+
+attrs = {
+  name: 'John',
+  email: 'john@example.com',
+  phone: '555.123.4567',
+  age: '37'
+}
+
+Person.new(attrs).tap do |person|
+  person.name = 'Bob'
+  person.name #=> 'Bob'
+
+  person.email = 'bob@example.com'  # => NoMethodError: undefined method `email' called for ...
+  person.phone = '555.987.6543'     # => NoMethodError: protected method `phone' called for ...
+  person.age = '21'                 # => NoMethodError: private method `age' called for ...
+end
+```
+
+Notice that any other value except for `false`, `:protected` and `:private` provides a public writer.
+
+With `writable` enabled, models will also have a `assign_attributes` method to do attribute mass-assignment:
+
+```ruby
+class Person < Model
+  attribute :name
+  attribute :email
+  attribute :age
+end
+  
+Person.new(name: 'John Smith', email: 'john@example.com', age: '37').tap do |person|
+  person.name #=> 'John Smith'
+  
+  person.assign_attributes(name: 'Bob Johnson', email: 'bob@example.com')
+
+  person.name #=> 'Bob Johnson'
+  person.email #=> 'bob@example.com'
+  person.age #=> '37'
+end
+```
+
+### serialization
+
+Artisanal::Models can also be converted back into hashes for storage or representation purposes. By default, the result will only include public attributes, but `to_h` will also let you request private attributes as well:
+
+```ruby
+class Person < Model
+  attribute :name
+  attribute :email
+  attribute :phone, reader: :private
+  attribute :age, reader: :protected
+end
+
+Person.new(name: 'John Smith', phone: '555.123.4567', age: '37').tap do |person|
+  person.to_h                               #=> { name: 'John Smith', email: nil }
+  person.to_h(scope: :private)              #=> { phone: '555.123.4567' }
+  person.to_h(scope: [:public, :protected]) #=> { name: 'John Smith', email: nil, age: '37' }
+  person.to_h(scope: :all)                  #=> { name: 'John Smith', email: nil, phone: '555.123.4567', age: '37' }
+end
+```
+
+### undefined attributes
+
+Dry-initializer [differentiates](https://dry-rb.org/gems/dry-initializer/skip-undefined/) between a `nil` value passed in for an attribute and nothing passed in at all. 
+
+This can be turned off through Artisanal::Model for performance reasons if you don't care about the differences between `nil` and undefined. However, if turned on, serializing to a hash will also exclude undefined values by default:
+
+```ruby
+# Model.include Artisanal::Model(undefined: true, ...)
+
+class Person < Model
+  attribute :name
+  attribute :email
+  attribute :phone
+end
+
+Person.new(name: 'John Smith', phone: nil).tap do |person|
+  person.to_h                          #=> { name: 'John Smith', phone: nil }
+  person.to_h(include_undefined: true) #=> { name: 'John Smith', email: nil, phone: nil }
+end
+```
+
+## Benchmarks
+
+Comparing artisanal-model with plain ruby, dry-initializer, hashie, and virtus:
+
+```
+Calculating -------------------------------------
+          plain Ruby      2.493M (± 2.8%) i/s -     37.407M in  15.016557s
+     dry-initializer    402.247k (± 2.7%) i/s -      6.051M in  15.054567s
+     artisanal-model    322.343k (± 3.2%) i/s -      4.843M in  15.040670s
+artisanal-model (WITH WRITERS)
+                        329.785k (± 2.6%) i/s -      4.965M in  15.066329s
+artisanal-model (WITH INDIFFERENT ACCESS)
+                        284.767k (± 2.2%) i/s -      4.292M in  15.078616s
+              hashie     37.250k (± 1.8%) i/s -    559.827k in  15.034072s
+              virtus    136.092k (± 2.0%) i/s -      2.049M in  15.059855s
+
+Comparison:
+          plain Ruby:  2492919.5 i/s
+     dry-initializer:   402247.4 i/s - 6.20x  slower
+artisanal-model (WITH WRITERS):   329785.0 i/s - 7.56x  slower
+     artisanal-model:   322342.7 i/s - 7.73x  slower
+artisanal-model (WITH INDIFFERENT ACCESS):   284766.8 i/s - 8.75x  slower
+              virtus:   136092.4 i/s - 18.32x  slower
+              hashie:    37250.4 i/s - 66.92x  slower
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/goldstar/artisanal-model.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/artisanal-model.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "artisanal/model/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "artisanal-model"
+  spec.version       = Artisanal::Model::VERSION
+  spec.authors       = ["Jared Hoyt, Matthew Peychich"]
+  spec.email         = ["jaredhoyt@gmail.com, mpeychich@mac.com"]
+
+  spec.summary       = %q{A light attributes wrapper for dry-initializer}
+  spec.description   = %q{A light attributes wrapper for dry-initializer}
+  spec.homepage      = "https://github.com/goldstar/artisanal-model"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.4"
+
+  spec.add_runtime_dependency "dry-initializer", ">= 2.5.0"
+
+  spec.add_development_dependency "dry-types", ">= 0.13.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "rb-readline"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec_junit_formatter"
+  spec.add_development_dependency "rspec-its", "~> 1.2"
+end

data/benchmarks/with_virtus_and_hashie.rb

@@ -0,0 +1,107 @@
+Bundler.require(:benchmarks)
+
+class PlainRubyTest
+  attr_reader :foo, :bar, :baz
+
+  def initialize(foo: "FOO", bar: "BAR", baz_old: "BAZ")
+    @foo = foo
+    @bar = bar
+    @baz = baz_old
+    raise TypeError unless String === @foo
+    raise TypeError unless String === @bar
+  end
+end
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer[undefined: false]
+
+  option :foo, proc(&:to_s), default: -> { "FOO" }
+  option :bar, proc(&:to_s), default: -> { "BAR" }
+  option :baz_old, proc(&:to_s), default: -> { "BAZ" }, as: :baz
+end
+
+require "artisanal-model"
+class ArtisanalTest
+  include Artisanal::Model
+
+  attribute :foo, proc(&:to_s), default: -> { "FOO" }
+  attribute :bar, proc(&:to_s), default: -> { "BAR" }
+  attribute :baz, proc(&:to_s), default: -> { "BAR" }, from: :baz_old
+end
+
+require "artisanal-model"
+class ArtisanalTestWithWriters
+  include Artisanal::Model(writable: true)
+
+  attribute :foo, proc(&:to_s), default: -> { "FOO" }
+  attribute :bar, proc(&:to_s), default: -> { "BAR" }
+  attribute :baz, proc(&:to_s), default: -> { "BAR" }, from: :baz_old
+end
+
+require "artisanal-model"
+class ArtisanalTestWithIndifferentAccess
+  include Artisanal::Model(symbolize: true)
+
+  attribute :foo, proc(&:to_s), default: -> { "FOO" }
+  attribute :bar, proc(&:to_s), default: -> { "BAR" }
+  attribute :baz, proc(&:to_s), default: -> { "BAR" }, from: :baz_old
+end
+
+require "hashie"
+class HashieTest < Hashie::Trash
+  include Hashie::Extensions::Dash::Coercion
+  include Hashie::Extensions::IndifferentAccess
+  include Hashie::Extensions::MethodAccess
+
+  property :foo, coerce: proc(&:to_s), default: "FOO"
+  property :bar, coerce: proc(&:to_s), default: "BAR"
+  property :baz, coerce: proc(&:to_s), default: "BAR", from: :baz_old
+end
+
+require "virtus"
+class VirtusTest
+  include Virtus.model
+
+  attribute :foo, String, default: "FOO"
+  attribute :bar, String, default: "BAR"
+  attribute :baz_old, String, default: "BAR"
+
+  alias_method :baz, :baz_old
+end
+
+puts "Benchmark for example models with virtus and hashie"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("plain Ruby") do
+    PlainRubyTest.new
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new
+  end
+
+  x.report("artisanal-model") do
+    ArtisanalTest.new
+  end
+
+  x.report("artisanal-model (WITH WRITERS)") do
+    ArtisanalTestWithWriters.new
+  end
+
+  x.report("artisanal-model (WITH INDIFFERENT ACCESS)") do
+    ArtisanalTestWithIndifferentAccess.new
+  end
+
+  x.report("hashie") do
+    HashieTest.new
+  end
+
+  x.report("virtus") do
+    VirtusTest.new
+  end
+
+  x.compare!
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "artisanal/model"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/artisanal/model/attribute.rb

@@ -0,0 +1,86 @@
+module Artisanal::Model
+  class Attribute < Module
+    attr_reader :name, :type, :options
+
+    def initialize(name, coercer=nil, **options)
+      @name, @options = name, options
+      @type = coercer || options[:type]
+
+      # Convert :from option to :as
+      if options.has_key? :from
+        @name, options[:as] = options[:from], name
+      end
+
+      # Add default values for certain types
+      unless options.has_key?(:default)
+        options.merge!(default: type_default)
+      end
+
+      raise ArgumentError.new("type missing for attribute #{name}") if type.nil?
+    end
+
+    def included(base)
+      # Create dry-initializer option
+      base.option(name, **options.merge(type: type_builder))
+
+      # Create writer method
+      define_writer(base, name) if options[:writer]
+    end
+
+    protected
+
+    def class_coercer(type)
+      if type.respond_to? :artisanal_model
+        ->(value, parent) { value.is_a?(type) ? value : type.new(value, parent) }
+      else
+        ->(value) { value.is_a?(type) ? value : type.new(value) }
+      end
+    end
+
+    def define_writer(base, target)
+      define_method("#{target}=") do |value|
+        coercer = artisanal_model.schema[target].type
+        arity = coercer.is_a?(Proc) ? coercer.arity : coercer.method(:call).arity
+        args = arity.abs == 1 ? [value] : [value, self]
+
+        coercer.call(*args).tap { |result| instance_variable_set("@#{target}", result) }
+      end
+
+      # Scope writer to protected or private
+      if [:protected, :private].include? options[:writer]
+        base.send(options[:writer], "#{target}=")
+      end
+    end
+
+    def enumerable_coercer(type)
+      coercer = type_builder(type.first)
+      arity = coercer.is_a?(Proc) ? coercer.arity : coercer.method(:call).arity
+
+      if arity.abs == 1
+        ->(collection) { type.class.new(collection.map { |value| coercer.call(value) }) }
+      else
+        ->(collection, parent) { type.class.new(collection.map { |value| coercer.call(value, parent) }) }
+      end
+    end
+
+    def type_builder(type=self.type)
+      case type
+      when Class
+        class_coercer(type)
+      when Enumerable
+        enumerable_coercer(type)
+      else
+        type
+      end
+    end
+
+    def type_default
+      case type
+      when Array
+        -> { Array.new }
+      when Set
+        -> { Set.new }
+      end
+    end
+  end
+end

data/lib/artisanal/model/builder.rb

@@ -0,0 +1,40 @@
+require 'dry-initializer'
+
+module Artisanal::Model
+  require_relative 'dsl'
+
+  class Builder < Module
+    attr_reader :config
+
+    def initialize(options={})
+      @config = Config.new(options)
+    end
+
+    def included(base)
+      base.extend Dry::Initializer[undefined: config.undefined?]
+      base.extend Artisanal::Model::DSL
+
+      # Make attributes mutable
+      define_writers if config.writable?
+
+      # Store artisanal model config
+      base.artisanal_model.config = config
+    end
+
+    protected
+
+    def define_writers
+      # Add writers to all attributes
+      config.defaults[:writer] = true unless config.defaults.has_key? :writer
+
+      # Define mass-assignment method
+      define_method(:assign_attributes) do |attrs|
+        attrs = artisanal_model.symbolize(attrs)
+
+        (attrs.keys & artisanal_model.schema.keys).each do |key|
+          public_send("#{key}=", attrs[key]) if respond_to? "#{key}="
+        end
+      end
+    end
+  end
+end

data/lib/artisanal/model/config.rb

@@ -0,0 +1,17 @@
+module Artisanal::Model
+  class Config
+    attr_reader :options, :defaults, :writable, :undefined, :symbolize
+
+    alias_method :writable?, :writable
+    alias_method :undefined?, :undefined
+    alias_method :symbolize?, :symbolize
+
+    def initialize(options={})
+      @options = options
+      @defaults = { optional: true }.merge(options.fetch(:defaults, {}))
+      @writable = options.fetch(:writable, false)
+      @undefined = options.fetch(:undefined, false)
+      @symbolize = options.fetch(:symbolize, false)
+    end
+  end
+end

data/lib/artisanal/model/dsl.rb

@@ -0,0 +1,43 @@
+module Artisanal::Model
+  require_relative 'initializer'
+  require_relative 'model'
+
+  module DSL
+    def self.extended(base)
+      base.prepend Initializer
+      base.include InstanceMethods
+    end
+
+    def inherited(subclass)
+      subclass.include Artisanal::Model(**artisanal_model.config.options)
+      super(subclass)
+    end
+
+    def artisanal_model
+      @artisanal_model ||= Model.new(self)
+    end
+
+    def schema
+      artisanal_model.schema
+    end
+
+    def attribute(*args, **kwargs)
+      artisanal_model.attribute(*args, **kwargs)
+    end
+
+    module InstanceMethods
+      def artisanal_model
+        self.class.artisanal_model
+      end
+
+      def attributes(*args)
+        artisanal_model.attributes(self, *args)
+      end
+
+      def to_h(**args)
+        artisanal_model.to_h(self, **args)
+      end
+    end
+  end
+end
+

data/lib/artisanal/model/initializer.rb

@@ -0,0 +1,7 @@
+module Artisanal::Model
+  module Initializer
+    def initialize(attributes={}, parent=nil)
+      super(**artisanal_model.symbolize(attributes))
+    end
+  end
+end

data/lib/artisanal/model/model.rb

@@ -0,0 +1,93 @@
+require 'forwardable'
+
+module Artisanal::Model
+  require_relative 'attribute'
+
+  class Model
+    extend Forwardable
+
+    attr_reader :klass
+    attr_writer :config
+
+    delegate [:dry_initializer] => :klass
+    delegate [:definitions, :null] => :dry_initializer
+
+    alias_method :schema, :definitions
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def attribute(name, type=nil, **opts)
+      klass.include Attribute.new(name, type, **config.defaults.merge(opts))
+    end
+
+    def attributes(instance, **kwargs)
+      scope = kwargs.fetch(:scope, :public)
+      include_undefined = kwargs.fetch(:include_undefined, false)
+      schema.values.each_with_object({}) do |item, attrs|
+        next unless attribute_in_scope?(instance, item.target, scope)
+        next unless include_undefined || attribute_defined?(instance, item.target)
+
+        attrs[item.target] = instance.send(item.target)
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def symbolize(attributes={})
+      attributes = attributes.to_h
+
+      return attributes unless config.symbolize?
+
+      attributes.dup.tap do |attrs|
+        (attribute_names & attrs.keys).each do |key|
+          attrs[key.intern] = attrs.delete(key)
+        end
+      end
+    end
+
+    def to_h(instance, **args)
+      attributes(instance, **args).each_with_object({}) do |(key, value), result|
+        if value.is_a? Hash
+          result[key] = value
+        elsif value.is_a? Enumerable
+          result[key] = value.map { |v| v.respond_to?(:to_h) ? v.to_h(**args) : v }
+        elsif !value.nil? && value.respond_to?(:to_h)
+          result[key] = value.to_h(**args)
+        else
+          result[key] = value
+        end
+      end
+    end
+
+    protected
+
+    def attribute_defined?(instance, name)
+      instance.instance_variable_get("@#{name}") != Dry::Initializer::UNDEFINED
+    end
+
+    def attribute_in_scope?(instance, name, scope)
+      scope = Array(scope)
+
+      (instance.respond_to?(name, true) && scope.include?(:all)) ||
+        (scope.include?(:public) && instance.public_methods.include?(name)) ||
+        (scope.include?(:protected) && instance.protected_methods.include?(name)) ||
+        (scope.include?(:private) && instance.private_methods.include?(name))
+    end
+
+    def attribute_names
+      @attribute_names ||= schema.keys.map(&:to_s)
+    end
+
+    def method_missing(method, *args)
+      if dry_initializer.respond_to?(method)
+        dry_initializer.send(method, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/artisanal/model/version.rb

@@ -0,0 +1,5 @@
+module Artisanal
+  module Model
+    VERSION = "0.2.0"
+  end
+end

data/lib/artisanal/model.rb

@@ -0,0 +1,15 @@
+module Artisanal
+  require_relative "model/builder"
+  require_relative 'model/config'
+  require_relative "model/version"
+
+  def self.Model(**opts)
+    Model::Builder.new(**opts)
+  end
+
+  module Model
+    def self.included(base)
+      base.include Artisanal::Model()
+    end
+  end
+end

data/lib/artisanal-model.rb

@@ -0,0 +1 @@
+require_relative 'artisanal/model'

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: artisanal-model
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Jared Hoyt, Matthew Peychich
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rb-readline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: A light attributes wrapper for dry-initializer
+email:
+- jaredhoyt@gmail.com, mpeychich@mac.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- artisanal-model.gemspec
+- benchmarks/with_virtus_and_hashie.rb
+- bin/console
+- bin/setup
+- lib/artisanal-model.rb
+- lib/artisanal/model.rb
+- lib/artisanal/model/attribute.rb
+- lib/artisanal/model/builder.rb
+- lib/artisanal/model/config.rb
+- lib/artisanal/model/dsl.rb
+- lib/artisanal/model/initializer.rb
+- lib/artisanal/model/model.rb
+- lib/artisanal/model/version.rb
+homepage: https://github.com/goldstar/artisanal-model
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key:
+specification_version: 4
+summary: A light attributes wrapper for dry-initializer
+test_files: []