active_record-associated_object 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '049c38f6aeb242c8ccfee9c15d3e29ace1c8f69eaf67619cdb38b09e5dd97514'
-  data.tar.gz: 911ce88d3257b0db22169f325ca2059b12ecdd8bb7121d7a37368588dce37262
+  metadata.gz: 9b5e7079fe6ffefe707c65a2a88b92c20ff3c8b91601cdef75bd638adbb73166
+  data.tar.gz: 1e59dbc65c54baa19c8bac770ebd52a469aa95855c7758c020bfd8b72a51b3f0
 SHA512:
-  metadata.gz: 0ee5964826318cb28a0a1d4c9e0a383b157e4ec0f2dd908b944c5eec68ddc7179d0d43be37bb65316c91e42318a6104b67eccd7d72194b99b4f3284312204692
-  data.tar.gz: 61df4cf5bc61dd0109650ce1aa95bc1f9e79fd99c2da6e2757429b71cda10b1423d6dda7f29310390fa0c5d01b0a5b77563de4151c277316e7a3e57edf16c699
+  metadata.gz: 7f2c7de0292ac2ce3ed011be69f6c887cf93873ab4b80c2288b4cd66ff22ec0780cb9872476656227eec164cf73ed9fc2e0ced1dcde154db6377343c408fbef5
+  data.tar.gz: 783ca5c727bb5718aa7436b0252b83b9f4c904f28829635cc117f83920a740d2361cce9708707b8ba2f084148b6a5968e6e6a6f8cca56d9b9526d4b30fa59a76

data/CHANGELOG.md

@@ -1,4 +1,59 @@
-## [Unreleased]
+## [0.3.0] - 2022-09-25
+
+- Add `performs` to help cut down Active Job boilerplate.
+
+  ```ruby
+  class Post::Publisher < ActiveRecord::AssociatedObject
+    performs :publish, queue_as: :important
+
+    def publish
+      …
+    end
+  end
+  ```
+
+  The above is the same as writing:
+
+  ```ruby
+  class Post::Publisher < ActiveRecord::AssociatedObject
+    class Job < ApplicationJob; end
+    class PublishJob < Job
+      queue_as :important
+
+      def perform(publisher, *arguments, **options)
+        publisher.publish(*arguments, **options)
+      end
+    end
+
+    def publish_later(*arguments, **options)
+      PublishJob.perform_later(self, *arguments, **options)
+    end
+
+    def publish
+      …
+    end
+  end
+  ```
+
+  See the README for more details.
+
+## [0.2.0] - 2022-04-21
+
+- Require a `has_object` call on the record side to associate an object.
+
+  ```ruby
+  class Post < ActiveRecord::Base
+    has_object :publisher
+  end
+  ```
+
+- Allow `has_object` to pass callbacks onto the associated object.
+
+  ```ruby
+  class Post < ActiveRecord::Base
+    has_object :publisher, after_touch: true, before_destroy: :prevent_errant_post_destroy
+  end
+  ```
 
 ## [0.1.0] - 2022-04-19
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_record-associated_object (0.1.0)
+    active_record-associated_object (0.3.0)
       activerecord (>= 6.1)
 
 GEM

data/README.md

@@ -7,37 +7,126 @@ Associate a Ruby PORO with an Active Record class and have it quack like one. Bu
 ```ruby
 # app/models/post.rb
 class Post < ActiveRecord::Base
+  # `has_object` defines a `publisher` method that calls Post::Publisher.new(post).
+  has_object :publisher
 end
 
-# Create a standard PORO, but derive attributes from the Post:: namespace and its primary key.
+# app/models/post/publisher.rb
+class Post::Publisher
+  def initialize(post)
+    @post = post
+  end
+end
+```
+
+If you want Active Job, GlobalID and Kredis integration you can also have `Post::Publisher` inherit from `ActiveRecord::AssociatedObject`. This extends the standard PORO with details from the `Post::` namespace and the post primary key.
+
+```ruby
 # app/models/post/publisher.rb
 class Post::Publisher < ActiveRecord::AssociatedObject
+  # ActiveRecord::AssociatedObject defines initialize(post) automatically. It's derived from the `Post::` namespace.
+
   kredis_datetime :publish_at # Kredis integration generates a "post:publishers:<post_id>:publish_at" key.
 
-  # Both a general `record` method and a `post` method is available to access the associated post.
-  def publish_now
+  # `performs` builds a `Post::Publisher::PublishJob` and routes configs over to it.
+  performs :publish, queue_as: :important, discard_on: SomeError do
+    retry_on TimeoutError, wait: :exponentially_longer
+  end
+
+  def publish
+    # `transaction` is syntactic sugar for `post.transaction` here.
     transaction do
+      # A `post` method is generated to access the associated post. There's also a `record` alias available.
       post.update! published: true
       post.subscribers.post_published post
     end
   end
+end
+```
+
+### How `performs` removes Active Job boilerplate
 
-  def publish_later
-    PublishJob.set(wait_until: publish_at).perform_later self
+With an associated object like this:
+
+```ruby
+class Post::Publisher < ActiveRecord::AssociatedObject
+  performs queue_as: :important
+  performs :publish
+  performs :retract
+
+  def publish
+  end
+
+  def retract(reason:)
   end
 end
+```
+
+is equivalent to:
 
-# Post now has a publisher too.
-Post.first.publisher # => Post::Publisher.new(self) # Where self is Post.first.
+```ruby
+class Post::Publisher < ActiveRecord::AssociatedObject
+  # `performs` without a method defines a general job to share between method jobs.
+  class Job < ApplicationJob
+    queue_as :important
+  end
 
-class Post::Publisher::PublishJob < ActiveJob::Base
-  def perform(publisher)
-     # Automatic integration via GlobalID means you don't have to do `post.publisher`.
-    publisher.publish_now
+  # Individual method jobs inherit from the `Post::Publisher::Job` defined above.
+  class PublishJob < Job
+    def perform(publisher, *arguments, **options)
+      # GlobalID integration means associated objects can be passed into jobs like Active Records, i.e. we don't have to do `post.publisher`.
+      publisher.publish(*arguments, **options)
+    end
+  end
+
+  class RetractJob < Job
+    def perform(publisher, *arguments, **options)
+      publisher.retract(*arguments, **options)
+    end
+  end
+
+  def publish_later(*arguments, **options)
+    PublishJob.perform_later(self, *arguments, **options)
+  end
+
+  def retract_later(*arguments, **options)
+    RetractJob.perform_later(self, *arguments, **options)
+  end
+end
+```
+
+### Passing callbacks onto the associated object
+
+`has_object` accepts a hash of callbacks to pass.
+
+```ruby
+class Post < ActiveRecord::Base
+  # Callbacks can be passed too to a specific method.
+  has_object :publisher, after_touch: true, before_destroy: :prevent_errant_post_destroy
+
+  # The above is the same as writing:
+  after_touch { publisher.after_touch }
+  before_destroy { publisher.prevent_errant_post_destroy }
+end
+
+class Post::Publisher < ActiveRecord::AssociatedObject
+  def after_touch
+    # Respond to the after_touch on the Post.
+  end
+
+  def prevent_errant_post_destroy
+    # Passed callbacks can throw :abort too, and in this example prevent post.destroy.
+    throw :abort if haha_business?
   end
 end
 ```
 
+## Risks of depending on this gem
+
+This gem is relatively tiny and I'm not expecting more significant changes on it, for right now. It's unofficial and not affiliated with Rails core.
+
+Though it's written and maintained by an ex-Rails core person, so I know my way in and out of Rails and how to safely extend it.
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -56,7 +145,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/[USERNAME]/active_record-associated_object.
+Bug reports and pull requests are welcome on GitHub at https://github.com/kaspth/active_record-associated_object.
 
 ## License
 

data/lib/active_record/associated_object/object_association.rb

@@ -0,0 +1,23 @@
+module ActiveRecord::AssociatedObject::ObjectAssociation
+  using Module.new {
+    refine Module do
+      def extend_source_from(chunks, &block)
+        location = caller_locations(1, 1).first
+        source_chunks = Array(chunks).flat_map(&block)
+        class_eval source_chunks.join("\n\n"), location.path, location.lineno
+      end
+    end
+  }
+
+  def has_object(*names, **callbacks)
+    extend_source_from(names) do |name|
+      "def #{name}; @#{name} ||= #{self.name}::#{name.to_s.classify}.new(self); end"
+    end
+
+    extend_source_from(names) do |name|
+      callbacks.map do |callback, method|
+        "#{callback} { #{name}.#{method == true ? callback : method} }"
+      end
+    end
+  end
+end

data/lib/active_record/associated_object/performs.rb

@@ -0,0 +1,36 @@
+module ActiveRecord::AssociatedObject::Performs
+  def performs(method = nil, **configs, &block)
+    @job ||= safe_define("Job") { ApplicationJob }
+
+    if method.nil?
+      apply_performs_to(@job, **configs, &block)
+    else
+      job = safe_define("#{method}_job".classify) { @job }
+      apply_performs_to(job, **configs, &block)
+
+      job.class_eval <<~RUBY, __FILE__, __LINE__ + 1 unless job.instance_method(:perform).owner == job
+        def perform(object, *arguments, **options)
+          object.#{method}(*arguments, **options)
+        end
+      RUBY
+
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{method}_later(*arguments, **options)
+          #{job}.perform_later(self, *arguments, **options)
+        end
+      RUBY
+    end
+  end
+
+  private
+    def safe_define(name)
+      name.safe_constantize || const_set(name, Class.new(yield))
+    end
+
+    def apply_performs_to(job_class, **configs, &block)
+      job_class.class_eval do
+        configs.each { public_send(_1, _2) }
+        yield if block_given?
+      end
+    end
+end

data/lib/active_record/associated_object/railtie.rb

@@ -2,5 +2,17 @@ class ActiveRecord::AssociatedObject::Railtie < Rails::Railtie
   initializer "integrations.include" do
     ActiveRecord::AssociatedObject.include Kredis::Attributes       if defined?(Kredis)
     ActiveRecord::AssociatedObject.include GlobalID::Identification if defined?(GlobalID)
+
+    ActiveSupport.on_load :active_job do
+      require "active_record/associated_object/performs"
+      ActiveRecord::AssociatedObject.extend ActiveRecord::AssociatedObject::Performs
+    end
+  end
+
+  initializer "object_association.setup" do
+    ActiveSupport.on_load :active_record do
+      require "active_record/associated_object/object_association"
+      extend ActiveRecord::AssociatedObject::ObjectAssociation
+    end
   end
 end

data/lib/active_record/associated_object/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   class AssociatedObject
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/active_record/associated_object.rb

@@ -13,12 +13,6 @@ class ActiveRecord::AssociatedObject
       define_singleton_method(:record_klass)   { record_klass }
       define_singleton_method(:attribute_name) { attribute_name }
       delegate :record_klass, :attribute_name, to: :class
-
-      record_klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{attribute_name}
-          @#{attribute_name} ||= #{klass}.new(self)
-        end
-      RUBY
     end
 
     def respond_to_missing?(...) = record_klass.respond_to?(...) || super

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-associated_object
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-20 00:00:00.000000000 Z
+date: 2022-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,6 +39,8 @@ files:
 - Rakefile
 - active_record-associated_object.gemspec
 - lib/active_record/associated_object.rb
+- lib/active_record/associated_object/object_association.rb
+- lib/active_record/associated_object/performs.rb
 - lib/active_record/associated_object/railtie.rb
 - lib/active_record/associated_object/version.rb
 homepage: https://github.com/kaspth/active_record-associated_object
@@ -63,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.11
+rubygems_version: 3.3.21
 signing_key:
 specification_version: 4
 summary: Associate a Ruby PORO with an Active Record class and have it quack like