acts_as_ditto 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4431085c0b3038f16f982d08995f253b6142fc757ff81b9577face8a3d7837d
+  data.tar.gz: 232a203d533035d92ec0d2f3ed76322e9c9296b94e18141b1988513852402591
+SHA512:
+  metadata.gz: 55d514d95ab78c2e971075d71976460d4360d07aad3fe6e0bbf333bd59ff854017b7fedb82e930d581d1105cedcb7d0e76e3f0a481701dd217f785423f3ec041
+  data.tar.gz: '091c62145f730ca95efb5a2e20240126c2d2d69d288f995d8ab6a485149741070b393c2a55512997d85fd632b228c3c10abf1b4eb370d3b55bdbacac66f25bd1'

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## [Unreleased]
+
+## [1.0.0] - 2026-08-28
+
+- Initial release.
+- `acts_as_ditto` DSL for configuring how a model duplicates.
+- Configuration options: `clone_associations`, `nullify`, `reset_to_default`,
+  `override`, `prefix`/`suffix`, and `transform`.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"acts_as_ditto" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels:
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact me at ["jaeggi@puzzle.ch"](mailto:"jaeggi@puzzle.ch").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Niklas Jäggi
+
+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,115 @@
+# Ditto
+
+Ditto adds an `acts_as_ditto` DSL to your ActiveRecord models for duplicating
+records with custom control
+
+Similar to `.dup`, but with the options like resetting attributes, applying static
+overrides, running custom transformations, or recursively cloning associations.
+
+And yes, the name comes from the Pokemon [Ditto](https://www.pokemon.com/us/pokedex/ditto), which can use its unique move transform to mirror any opposing Pokemon :D
+
+## Installation
+
+Install the gem and add it to the application's Gemfile by executing:
+
+```bash
+bundle add acts_as_ditto
+```
+
+## Usage
+
+Call `acts_as_ditto` on a model, then duplicate records with `#ditto` or `#ditto!`:
+
+```ruby
+class Invoice < ApplicationRecord
+  acts_as_ditto do
+    override status: "draft"
+  end
+end
+```
+
+### Duplicating associatons
+
+Recursively duplicates the given associations along with the record.
+
+```ruby
+acts_as_ditto do
+  clone_associations :posts, :address
+end
+```
+
+The associated model doesn't need `acts_as_ditto` itself, if it does, its own custom 
+configuration is used, otherwise they're duplicated as is.
+
+To duplicate multiple layers of associations, every model needs an `acts_as_ditto` configuration
+that configures which associations get cloned.
+
+### Nullifying attributes
+
+Reset the given attributes to `nil` on the duplicate.
+
+```ruby
+acts_as_ditto do
+  nullify :email
+end
+```
+
+### Reset attributes to column defaults
+
+Reset the given attributes to their column default on the duplicate.
+
+```ruby
+acts_as_ditto do
+  reset_to_default :status
+end
+```
+
+### Overwrite attributes with hardcoded values
+
+Overwrites the given attributes with hardcoded values on the duplicate.
+
+```ruby
+acts_as_ditto do
+  override status: "draft"
+end
+```
+
+### Prefix or Suffix attributes
+
+Prepend or append a string to an attributes current value.
+
+```ruby
+acts_as_ditto do
+  prefix :name, "Copy of "
+  suffix :name, " (Copy)"
+end
+```
+
+### Transform attribute values
+
+Transform attribute values with a block, yielded the record and the attribute's
+original value.
+
+```ruby
+acts_as_ditto do
+  transform :secret_number do |_record, old_value|
+    old_value.reverse
+  end
+end
+```
+
+## Inspiration
+
+Ditto was inspired by [amoeba](https://github.com/amoeba-rb/amoeba), which solves the same problem with similar DSL logic.
+
+Ditto is opt-in rather than opt-out: you list exactly which associations to
+clone with `clone_associations`, instead of enabling everything and excluding
+what you don't want.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/njaeggi/acts_as_ditto. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/njaeggi/acts_as_ditto/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+namespace :spec do
+  desc "Run the spec suite against every supported database adapter"
+  task :all do
+    adapters = { "sqlite3" => nil, "postgresql" => "postgresql", "mysql" => "mysql" }
+
+    adapters.each do |db, bundle_with|
+      puts "\n Running specs against #{db}"
+      env = { "DB" => db }
+      env["BUNDLE_WITH"] = bundle_with if bundle_with
+
+      system(env, "bundle install --quiet") || abort("bundle install failed for #{db}")
+      system(env, "bundle exec rspec") || abort("Specs failed against #{db}")
+    end
+  end
+end
+
+task default: %i[spec rubocop]

data/lib/acts_as_ditto.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+require_relative "ditto/version"
+require_relative "ditto/configuration"
+require_relative "ditto/duplicator"
+require_relative "ditto/acts_as_ditto"
+
+module Ditto
+  class Error < StandardError; end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include Ditto::ActsAsDitto
+end

data/lib/ditto/acts_as_ditto.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Ditto
+  # Add the ditto instance methods
+  module InstanceMethods
+    def ditto
+      Ditto::Duplicator.new(self, self.class.ditto_configuration).duplicate
+    end
+
+    def ditto!
+      ditto.tap(&:save!)
+    end
+  end
+
+  # Adds `acts_as_ditto` to ActiveRecord models.
+  module ActsAsDitto
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def acts_as_ditto(&block)
+        configuration = Ditto::Configuration.new
+        configuration.instance_eval(&block) if block
+
+        class_attribute :ditto_configuration, instance_writer: false, default: configuration
+        include Ditto::InstanceMethods
+      end
+    end
+  end
+end

data/lib/ditto/configuration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ditto
+  # Holds the ditto configuration for the model
+  class Configuration
+    attr_reader :cloned_associations, :nullified_attributes, :static_values,
+                :prefixes, :suffixes, :transformations, :defaulted_attributes
+
+    def initialize
+      @cloned_associations = []
+      @nullified_attributes = []
+      @static_values = {}
+      @prefixes = {}
+      @suffixes = {}
+      @transformations = {}
+      @defaulted_attributes = []
+    end
+
+    def clone_associations(*names)
+      @cloned_associations.concat(names.map(&:to_sym))
+    end
+
+    def nullify(*attributes)
+      @nullified_attributes.concat(attributes.map(&:to_sym))
+    end
+
+    def override(attributes = {})
+      @static_values.merge!(attributes.transform_keys(&:to_sym))
+    end
+
+    def prefix(attribute, value)
+      @prefixes[attribute.to_sym] = value
+    end
+
+    def suffix(attribute, value)
+      @suffixes[attribute.to_sym] = value
+    end
+
+    def reset_to_default(*attributes)
+      @defaulted_attributes.concat(attributes.map(&:to_sym))
+    end
+
+    def transform(attribute, &block)
+      raise ArgumentError, "transform requires a block" unless block
+
+      @transformations[attribute.to_sym] = block
+    end
+  end
+end

data/lib/ditto/duplicator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Ditto
+  # Builds a duplicate of a record based on `Ditto::Configuration`.
+  class Duplicator
+    def initialize(record, configuration)
+      @record = record
+      @configuration = configuration
+    end
+
+    def duplicate
+      new_record = @record.dup
+
+      reset_attributes_to_default(new_record)
+      nullify_attributes(new_record)
+      apply_static_values(new_record)
+      apply_prefixes(new_record)
+      apply_suffixes(new_record)
+      apply_transformations(new_record)
+      clone_associations(new_record)
+
+      new_record
+    end
+
+    private
+
+    def reset_attributes_to_default(new_record)
+      @configuration.defaulted_attributes.each do
+        new_record[_1] = new_record.class.column_defaults[_1.to_s]
+      end
+    end
+
+    def nullify_attributes(new_record)
+      @configuration.nullified_attributes.each { new_record[_1] = nil }
+    end
+
+    def apply_static_values(new_record)
+      @configuration.static_values.each { |attribute, value| new_record[attribute] = value }
+    end
+
+    def apply_prefixes(new_record)
+      @configuration.prefixes.each do |attribute, value|
+        new_record[attribute] = "#{value}#{new_record[attribute]}"
+      end
+    end
+
+    def apply_suffixes(new_record)
+      @configuration.suffixes.each do |attribute, value|
+        new_record[attribute] = "#{new_record[attribute]}#{value}"
+      end
+    end
+
+    def apply_transformations(new_record)
+      @configuration.transformations.each do |attribute, block|
+        new_record[attribute] = block.call(@record, @record[attribute])
+      end
+    end
+
+    def clone_associations(new_record)
+      @configuration.cloned_associations.each do |name|
+        reflection = @record.class.reflect_on_association(name)
+        next unless reflection
+
+        if reflection.collection?
+          clone_collection_association(new_record, name)
+        else
+          clone_singular_association(new_record, name)
+        end
+      end
+    end
+
+    def clone_collection_association(new_record, name)
+      @record.public_send(name).each do |associated_record|
+        new_record.public_send(name) << duplicate_of(associated_record)
+      end
+    end
+
+    def clone_singular_association(new_record, name)
+      associated_record = @record.public_send(name)
+      return unless associated_record
+
+      new_record.public_send(:"#{name}=", duplicate_of(associated_record))
+    end
+
+    # Duplicates an associated record with its own ditto configuration
+    # if it has one, otherwise uses an empty ditto configuration which
+    # mirros a plain dup
+    def duplicate_of(record)
+      configuration =
+        if record.class.respond_to?(:ditto_configuration)
+          record.class.ditto_configuration
+        else
+          Configuration.new
+        end
+
+      self.class.new(record, configuration).duplicate
+    end
+  end
+end

data/lib/ditto/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ditto
+  VERSION = "1.0.0"
+end

data/sig/acts_as_ditto.rbs

@@ -0,0 +1,4 @@
+module Ditto
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_ditto
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Niklas Jäggi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+description: Ditto adds an acts_as_ditto DSL to ActiveRecord models for duplicating
+  records with custom control over nullified attributes, static overrides, transformations,
+  and recursively cloned associations.
+email:
+- jaeggi@puzzle.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/acts_as_ditto.rb
+- lib/ditto/acts_as_ditto.rb
+- lib/ditto/configuration.rb
+- lib/ditto/duplicator.rb
+- lib/ditto/version.rb
+- sig/acts_as_ditto.rbs
+homepage: https://github.com/njaeggi/acts_as_ditto
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/njaeggi/acts_as_ditto
+  source_code_uri: https://github.com/njaeggi/acts_as_ditto/tree/main
+  changelog_uri: https://github.com/njaeggi/acts_as_ditto/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Configurable ActiveRecord duplication.
+test_files: []