dry_eraser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0718a1c418f7f1feca5be58f45f2c32ab487ff586f8b97e4175efdf9cddca0f
+  data.tar.gz: 05da8722b1acd307abbd9ab6abe6178df011fa31118a33ed7df2f458b063df7c
+SHA512:
+  metadata.gz: 70b6a52e481683c215be73929fbd2c57e760c0caa07557c2da77ba74e4e9103b76f9bb11a314d2db1848e8b65b9ec6932f1e6b7adc645d00210cf13b94769b17
+  data.tar.gz: 9dfbc408b00b82e15a47c34d974b7d1c289e4ecfdddeeefddd717ce9f2026cf5fa5aa86926a12dcee9c9f8ddac79caf7d7b461560bded5886b0aceacd416fb83

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## 0.0.1
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Justin Searls
+
+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,109 @@
+# dry_eraser
+
+**`dry_eraser` provides a _dry_ run before you _erase_ your models.**
+
+This gem is for people who think it's weird that Rails offers so many ways to
+validate models before you create and update them, but all it gives you is a
+`before_destroy` hook if before permanently destroying them.
+
+Think of `dry_eraser` as adding validation for `ActiveRecord#destroy`. To that
+end, it defines `dry_erase` and `dry_erasable?` methods for your models that
+behave similarly to `validates` and `valid?`. This way, you won't have to
+remember how to register a `before_destroy` callback. Or that `throw(:abort)` is
+the magical incantation to cancel the callback chain. If you're suspicious of
+pulling in a dependency for something like this (and you should be), the fact
+its [implementation is 50 lines soaking wet](lib/dry_eraser.rb) might put you at
+ease.
+
+Here's how to use it.
+
+## Install
+
+Add it to your Gemfile:
+
+```ruby
+gem "dry_eraser"
+```
+
+That's it. Rails should load it automatically.
+
+## Usage
+
+Whenever there's a situation in which you know you _don't_ want a `destroy`
+operation to go through, you can specify it by calling the `dry_erase` class
+method on your model.
+
+Let's take an example `Whiteboard` model. Suppose it has a boolean attribute
+called `someone_wrote_do_not_erase_on_me` and you want to be sure `destroy` operations
+are aborted when that attribute is true.
+
+You could:
+
+```ruby
+class Whiteboard < ActiveRecord::Base
+  dry_erase :no_one_said_not_to_erase_it
+
+  private
+
+  def no_one_said_not_to_erase_it
+    if someone_wrote_do_not_erase_on_me?
+      errors.add(:someone_wrote_do_not_erase_on_me, "so I can't erase it")
+    end
+  end
+end
+```
+
+This way, whenever `someone_wrote_do_not_erase_on_me?` is true, `destroy` will
+return `false` (just like `save` returns false when validations fail).
+
+This, combined with the fact that `dry_erase` determines success based on the
+absence or presence of `errors` on the model instance will allow you to write
+code that branches on whether destroy succeeded, just like you would for `save`
+or `update`:
+
+```ruby
+whiteboard = Whiteboard.create!(someone_wrote_do_not_erase_on_me: true)
+if whiteboard.destroy
+  flash[:notice] = "Whiteboard deleted!"
+  redirect_to whiteboards_path
+else
+  flash[:error] = whiteboard.errors.full_messages
+  render :show, status: :unprocessable_entity
+end
+```
+
+If you don't want to call `destroy` to know whether a model is safe to destroy,
+you can also call `dry_erasable?` and it'll populate the `errors` object all
+the same:
+
+```ruby
+whiteboard = Whiteboard.create!(someone_wrote_do_not_erase_on_me: true
+whiteboard.dry_erasable?
+=> false
+whiteboard.errors.full_messages.first
+=> "Someone wrote do not erase on me so I can't erase it"
+```
+
+## Other stuff you can pass to `dry_erase`
+
+The `dry_erase` method can take one or more of any of the following:
+
+* A symbol or string name of an instance method on the model
+* A class that has a no-arg constructor and a `dry_erase(model)` method
+* An object that responds to a `dry_erase(model)` model
+* An object (e.g. a proc or lambda) that responds to `call(model)`
+
+You can see all of these uses in the gem's [test fixture]():
+
+```ruby
+# You can put more than one on one line
+dry_erase :must_have_content, AnnoyingCoworkerMessageEraser
+
+# Or pass a lambda
+dry_erase ->(model) { model.content == "🖍️" && model.errors.add(:base, "No crayon, c'mon!") }
+
+# Or an instance of a class that requires static configuration
+dry_erase ForeignKeyEraser.new(Classroom, :whiteboard)
+```
+
+And that's about it.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require "standard/rake"
+require "tldr/rake"
+
+task default: [:tldr, "standard:fix"]

data/lib/dry_eraser/version.rb

@@ -0,0 +1,3 @@
+module DryEraser
+  VERSION = "0.0.1"
+end

data/lib/dry_eraser.rb

@@ -0,0 +1,52 @@
+require "rails/railtie"
+require "active_support/concern"
+require_relative "dry_eraser/version"
+
+module DryEraser
+  class Railtie < Rails::Railtie
+    initializer "dry_eraser.initialize" do
+      ActiveSupport.on_load(:active_record) do
+        include DryEraser::ModelExtensions
+      end
+    end
+  end
+
+  module ModelExtensions
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :dry_erasers, default: []
+      before_destroy :check_dry_erasers
+    end
+
+    module ClassMethods
+      def dry_erase(*classes_or_instances_or_method_names)
+        self.dry_erasers += classes_or_instances_or_method_names
+      end
+    end
+
+    def dry_erasable?
+      errors.clear
+
+      self.class.dry_erasers.each do |dry_eraser|
+        case dry_eraser
+        in Class
+          dry_eraser.new.dry_erase(self)
+        in ->(it) { it.respond_to?(:dry_erase) }
+          dry_eraser.dry_erase(self)
+        in ->(it) { it.respond_to?(:call) }
+          dry_eraser.call(self)
+        in Symbol | String
+          send(dry_eraser)
+        else
+          raise ArgumentError, "Invalid dry eraser: #{dry_eraser.inspect}"
+        end
+      end
+
+      errors.empty?
+    end
+
+    def check_dry_erasers
+      throw(:abort) unless dry_erasable?
+    end
+  end
+end

data/sig/dry_eraser.rbs

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

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: dry_eraser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Searls
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  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'
+- !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:
+email:
+- searls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/dry_eraser.rb
+- lib/dry_eraser/version.rb
+- sig/dry_eraser.rbs
+- tmp/.keep
+homepage: https://github.com/searls/dry_eraser
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/searls/dry_eraser
+  source_code_uri: https://github.com/searls/dry_eraser
+  changelog_uri: https://github.com/searls/dry_eraser/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: Like Active Record's validation feature, but for destroying models
+test_files: []