fragmentary 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61a94b394035bb4b3ec317316e46fa77ca925cc15a162a76d6401500e6636b5d
-  data.tar.gz: 8db2f91e9a9b23f3ccdafbc2f800695e653426a656887959f807c80eca10c901
+  metadata.gz: e4f080639f4562093503dc31128557031c54fc9b3b8c7dca5502a3146645b6a2
+  data.tar.gz: e2a5964a78778703ffc96e57d9b760db87b61d1273643c4d5a85f598f7c6ea74
 SHA512:
-  metadata.gz: bc4f5da40872cfb5327af28cb81862e61ba201258bc8338fa6ad9871439dac0133af4c102c10b09cd0ed25acb883c53d428ba3632085ac4b67cb7f662ccf6c16
-  data.tar.gz: '0628b394849e14ed4fed5ebe18e7b59a4badfe83d16b63f24965e6e6a2a4d656aec57f627000d70286c79152d2d028fb231c0b7c89a2eabfffb455140f7404e6'
+  metadata.gz: 68f38663f547ca5961615e046c4f420d99a1d2d8a04b2b43cd143ceea17a3618787d5a58295bcd133b143aa0e1e23936fe2f91519e7def427edfcfe5b4b7e2c5
+  data.tar.gz: 932884c05012d780804cd4f6c50819b5b9f8abf90d0535be50d938291300aa5a5c5f26dea327febb7592c43f9805902670fb6967d98e749a0382709fe89ec959

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+### 0.5.0
+- Update to support Rails 7.x and Ruby 3.x
+- Asynchronous internal application requests enqueued while executing a Fragmentary::Handler are now offloaded to a separate async process to prevent them delaying other processes.
+- When sending asynchronous internal requests, any queue_suffix that is present is included in the request parameters so that if the request spawns secondary requests, they can be run on the same ActiveJob queue (requires appropriate handling of the queue_suffix parameter by the application).
+- Allows queued internal application requests to be removed from queues for an individual application instance.
+- Destroying a fragment now destroys all of its children as well.
+- The session scheme for internal requests is set to 'https' if the host_root_url of the request_queue sending the request requires it.
+- Allows multiple session_users per user_type for internal application requests, each assigned to different user_groups, e.g. multiple 'admin' users, multiple 'signed_in' users etc.
+- Allows RequestQueue.send_all to take additional arguments for delay, queue_suffix, priority and user_group
+
+### 0.4.1
+- Fixes a problem with session initialization when sending requests generated by Handler subclasses
+
 ### 0.4.0
 - Uses ActiveJob as the interface for asynchronous processes instead of using Delayed::Job directly.
 - Updates Rails dependency to ~>6.0 as earlier versions lack support for the custom job serialization needed to use ActiveJob. Accordingly, Rails 5.x and earlier are no longer supported.

data/README.md

@@ -18,7 +18,7 @@ In simple cases, Rails' native support for fragment caching assumes that a fragm
 ```
 The content is stored in the cache using a _key_ value derived from the record's `id` attribute. The key identifies where the cached content is stored. In addition, a _version_ value derived from the record's `updated_at` attribute is stored along with the content [^1]. If any attributes of the record change, the `updated_at` attribute also changes; the next time a browser requests the content, a mismatch will exist between the calculated and stored values of the version, causing the cache to expire and the fragment to be re-rendered using the current data.
 
-[^1]: Prior to Rails 5.2, the value of `updated_at` was incorporated into the cache key rather that the version. That behavior is still available by setting `config.active_record.cache_versioning = false` in `config/application.rb`. 
+[^1]: Prior to Rails 5.2, the value of `updated_at` was incorporated into the cache key rather than the version. That behavior is still available by setting `config.active_record.cache_versioning = false` in `config/application.rb`.
 
 For data models with a `has_one` or `has_many` association, nested (Russian Doll) caching is possible with the inner fragment representing the associated record. For example if a product has many games -
 ```
@@ -712,7 +712,7 @@ end
 
 Another scenario that occasionally arises is when internal requests created in the course of executing methods defined in a `subscribe_to` block include the path to the same page that the controller is going to render anyway in the normal course of responding to the user's current browser request. In effect, that one internal request is redundant. Although it generally won't cause any real harm to send a redundant request (remember the internal request is usually dispatched asynchronously, so it won't interfere with the synchronous response), redundancy is redundancy and you may wish to avoid it.
 
-In this case, it is possible within the controller to remove a request that has already been queued, after the application data has been created, updated or destroyed, by using the class method `Fragment.remove_queued_request`. The method takes two named parameters, the path of the request to be removed and the current user object, with the latter allowing it to remove the request from the correct queue, e.g.
+In this case, it is possible within the controller to remove a request that has already been queued, after the application data has been created, updated or destroyed, by using the class method `Fragment.remove_queued_request`. The method takes two required keyword parameters, the path of the request to be removed and the current user object, with the latter allowing it to remove the request from only queues corresponding to the current_user's user_type, e.g.
 
 ```
 class ProductsController < ApplicationController
@@ -732,6 +732,12 @@ class ProductsController < ApplicationController
   end
 end
 ```
+As written above, `remove_queued_request` will remove the specified request from all queues defined for the `user_type` of the current user. If you have multiple application instances defined, a request_queue for that user_type will exist for each instance. If you only want to remove the request from the queue for a specific instance, you can include an additional optional keyword parameter `:host_url` specifiying the root_url of that instance, e.g.
+```
+...
+      ProductTemplate.remove_queued_request(:request_path => "/products/#{@product.id}", :user => current_user, :host_url => Fragmentary.application_root_url)
+...
+```
 
 ### Handling AJAX Requests
 
@@ -857,12 +863,6 @@ Again, this configuration will be different for each instance, and so in our cas
 
 Note that if you configure [Delayed::Job](https://github.com/collectiveidea/delayed_job) (or other backend) to work only from specific queues, you'll need to make sure that _any_ asynchronous tasks created by your application are submitted to one of those queues.
 
-## Dependencies
-
-  - Fragmentary is currently being used in production with Rails 6.0. Versions >=0.4 do not work with earlier versions of Rails for a couple of reasons:
-    - The version of ActiveJob in Rails 5.x does not support the custom serialization needed to enqueue asynchronous tasks for sending internal requests. A repository branch 'delayed_job' is available that uses the [Delayed::Job](https://github.com/collectiveidea/delayed_job) gem directly (i.e. without ActiveJob) and this works well with Rails 5.x. However, this branch is no longer maintained.
-    - The API for the Rails `ActionDispatch::Integration::Session` class, which is used to handle internal application requests, was changed in Rails 5.0. Consequently the current version of Fragmentary is incompatible with Rails 4.x and earlier. We do have a 'Rails.4.2' branch in the repository that uses the older API. However, this branch is no longer maintained.
-
 ## Timestamps
 
 Fragmentary allows HTML comments to be optionally inserted into cached fragments identifying the time at which the fragment was last cached. Simply add `config.insert_timestamps = true` to the configuration block in your `config/initializers/fragmentary.rb` file.
@@ -889,6 +889,12 @@ The `Fragment` class and its subclasses provide a number of utility instance met
   - `delete_cache` - removes the fragment's content from the cache.
   - `delete_cache_tree` - recursively removes from the cache all content for the fragment and its descendants.
 
+## Dependencies
+
+  - Fragmentary is currently being used in production with Rails 6.0. Versions >=0.4 do not work with earlier versions of Rails for a couple of reasons:
+    - The version of ActiveJob in Rails 5.x does not support the custom serialization needed to enqueue asynchronous tasks for sending internal requests. A repository branch 'delayed_job' is available that uses the [Delayed::Job](https://github.com/collectiveidea/delayed_job) gem directly (i.e. without ActiveJob) and this works well with Rails 5.x. However, this branch is no longer maintained.
+    - The API for the Rails `ActionDispatch::Integration::Session` class, which is used to handle internal application requests, was changed in Rails 5.0. Consequently the current version of Fragmentary is incompatible with Rails 4.x and earlier. We do have a 'Rails.4.2' branch in the repository that uses the older API. However, this branch is no longer maintained.
+
 ## Contributing
 
 Bug reports and usage questions are welcome at https://github.com/MarkMT/fragmentary.

data/fragmentary.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "rails", "~> 6.0"
+  spec.add_runtime_dependency "rails", ">= 6.0"
   spec.add_runtime_dependency "wisper-activerecord", "~> 1.0"
   spec.add_runtime_dependency "http", "~> 3.0.0"
   spec.add_runtime_dependency "nokogiri"

data/lib/fragmentary/config.rb

@@ -1,10 +1,14 @@
 module Fragmentary
 
   class Config
+
     include Singleton
+
     attr_accessor :current_user_method, :get_sign_in_path, :post_sign_in_path, :sign_out_path,
-                  :users, :default_user_type_mapping, :session_users, :application_root_url_column,
-                  :remote_urls, :insert_timestamps, :deployed_at, :release_name
+                  :users, :default_user_type_mapping, :user_types, :remote_urls, :insert_timestamps,
+                  :deployed_at, :release_name
+
+    attr_reader :user_types, :application_root_url_column
 
     def initialize
       # default
@@ -18,8 +22,7 @@ module Fragmentary
 
     def session_users=(session_users)
       raise "config.session_users must be a Hash" unless session_users.is_a?(Hash)
-      Fragmentary.parse_session_users(session_users)
-      @session_users = session_users
+      @user_types = Fragmentary.parse_session_users(session_users)
     end
 
     def application_root_url_column=(column_name)
@@ -33,12 +36,15 @@ module Fragmentary
 
   # Parse a set of session_user options, creating session_users where needed, and return a set of user_type keys.
   # session_users may take several forms:
-  #   (1) a hash whose keys are user_type strings and whose values have the form {:credentials => credentials},
-  #       where 'credentials' is either a hash of parameters to be submitted when logging in or a proc that
-  #       returns those parameters.
+  #   (1) a hash whose keys are user_type strings and whose values consist of either:
+  #       (a) a hash with the form {:credentials => credentials},
+  #           where 'credentials' is either a hash of parameters to be submitted when logging in or a proc that
+  #           returns those parameters.
+  #       (b) an array of hashes, each of the form {:credentials => credentials, :group => group_name}
+  #           where the ':group' element of the hash is optional
   #   (2) an array of hashes as described in (1) above.
   #   (3) an array of user_type strings corresponding to SessionUser objects already defined.
-  #   (4) an array containing a mixture of user_type strings and hashes as described in (1) above.
+  #   (4) an array containing a mixture of user_type strings as described in (3) and hashes as described in (1) above.
   # Non-hash elements that don't represent existing SessionUser objects should raise an exception. Array
   # elements that are hashes should be parsed to create new SessionUser objects. Raise an exception on
   # any attempt to redefine an existing user_type.
@@ -58,11 +64,15 @@ module Fragmentary
         end
       end
     elsif session_users.is_a?(Hash)
-      session_users.each_with_object([]) do |(k,v), acc|
-        # k is the user_type, v is an options hash that typically looks like  {:credentials => login_credentials} where
-        # login_credentials is either a hash of parameters to be submitted at login or a proc that returns those parameters.
+      session_users.each_with_object([])  do |(user_type, users), acc|
+        # users is either an options hash that typically looks like  {:credentials => credentials} or an array of such hashes,
+        # where credentials is either a hash of parameters to be submitted at login or a proc that returns those parameters.
         # In the latter case, the proc is executed when we actually log in to create a new session for the specified user.
-        acc << k if user = SessionUser.new(k,v)
+        users = [users] unless users.is_a?(Array)
+        users.each do |options|
+          SessionUser.create(user_type, options)
+        end
+        acc << user_type
       end
     end
   end

data/lib/fragmentary/fragment.rb

@@ -13,13 +13,13 @@ module Fragmentary
       base.class_eval do
         include ActionView::Helpers::CacheHelper
 
-        belongs_to :parent, :class_name => name
-        belongs_to :root, :class_name => name
+        belongs_to :parent, :class_name => name, :optional => true  # because a root fragment doesn't have a parent
+        belongs_to :root, :class_name => name, :optional => true    # or a root_id
         has_many :children, :class_name => name, :foreign_key => :parent_id, :dependent => :destroy
-        belongs_to :user
+        belongs_to :user, :optional => true  # because only fragments that declare 'needs_user_id' require one
 
         # Don't touch the parent when we create the child - the child was created by
-        # renderng the parent, which occured because the parent was touched, thus
+        # rendering the parent, which occured because the parent was touched, thus
         # triggering the current request. Touching it again would result in a
         # redundant duplicate request.
         after_commit :touch_parent, :on => [:update, :destroy]
@@ -52,7 +52,8 @@ module Fragmentary
           raise ArgumentError, "You passed Fragment #{fragment.id} to Fragment.root, but it's a child of Fragment #{fragment.parent_id}" if fragment.parent_id
         else
           klass, search_attributes, options = base_class.attributes(options)
-          fragment = klass.where(search_attributes).includes(:children).first_or_initialize(options); fragment.save if fragment.new_record?
+          fragment = klass.where(search_attributes).includes(:children).first_or_initialize(options);
+          fragment.save if fragment.new_record?
           fragment.set_indexed_children if fragment.child_search_key
         end
         fragment
@@ -166,8 +167,13 @@ module Fragmentary
         super
       end
 
-      def remove_queued_request(user:, request_path:)
-        request_queues.each{|key, hsh| hsh[user_type(user)].remove_path(request_path)}
+      def remove_queued_request(host_url: nil, user:, request_path:)
+        u_type = user_type(user)
+        if host_url.is_a?(String) and (queue = request_queues[host_url][u_type])
+          queue.remove_path(request_path)
+        else
+          request_queues.each{|key, hsh| hsh[u_type].remove_path(request_path)}
+        end
       end
 
       def subscriber
@@ -209,7 +215,7 @@ module Fragmentary
           end
           @user_types = Fragmentary.parse_session_users(options[:session_users] || options[:types] || options[:user_types])
           def self.user_types
-            @user_types || Fragmentary.config.session_users.keys
+            @user_types || Fragmentary.config.user_types
           end
         end
       end
@@ -493,14 +499,15 @@ module Fragmentary
       self.class.cache_store
     end
 
-    def touch(*args, no_request: false)
+    def touch(*args, no_request: false, **kwargs)
       @no_request = no_request  # stored for use in #touch_parent via the after_commit callback
       request_queues.each{|key, hsh| hsh.each{|key2, queue| queue << request}} if request && !no_request
-      super(*args)
+      super(*args, **kwargs)
     end
 
     # delete the associated cache content before destroying the fragment
     def destroy(options = {})
+      children.each(&:destroy)
       options.delete(:delete_matches) ? delete_matched_cache : delete_cache
       @no_request = options.delete(:no_request)  # stored for use in #touch_parent via the after_commit callback
       super()
@@ -596,7 +603,9 @@ module Fragmentary
 
     private
     def touch_parent
-      parent.try(:touch, {:no_request => @no_request}) unless previous_changes["memo"]
+      if parent
+        parent.touch(no_request: @no_request) unless previous_changes["memo"]
+      end
       @no_request = false
     end
 

data/lib/fragmentary/handler.rb

@@ -1,26 +1,4 @@
 module Fragmentary
-
-  class HandlerSerializer < ActiveJob::Serializers::ObjectSerializer
-
-    def serialize?(arg)
-      arg.is_a? Fragmentary::Handler
-    end
-
-    def serialize(handler)
-      super(
-        {
-        :class_name => handler.class.name,
-        :args => handler.args
-        }
-      )
-    end
-
-    def deserialize(hsh)
-      hsh[:class_name].constantize.new(hsh[:args])
-    end
-
-  end
-
   class Handler
     def self.all
       @@all
@@ -31,14 +9,14 @@ module Fragmentary
     end
     self.clear
 
-    def self.create(**args)
+    def self.create(args)
       @@all << (handler = self.new(args))
       handler
     end
 
     attr_reader :args
 
-    def initialize(**args)
+    def initialize(args)
       @args = args
     end
 

data/lib/fragmentary/jobs/dispatch_handlers_job.rb

@@ -6,12 +6,10 @@ module Fragmentary
 
     def perform(tasks)
       tasks.each do |task|
-        Rails.logger.info "***** Dispatching task for handler class #{task.class.name}"
+        Rails.logger.info "\n***** Dispatching task for handler class #{task.class.name}"
         task.call
       end
-      RequestQueue.all.each do |queue|
-        queue.start
-      end
+      RequestQueue.send_all(:between => 10.seconds, :priority => 10)
     end
 
   end

data/lib/fragmentary/jobs/send_requests_job.rb

@@ -12,7 +12,7 @@ module Fragmentary
       @between = between
       @queue_suffix = queue_suffix
       @priority = priority
-      @between ? @queue.send_next_request : @queue.send_all_requests
+      (@between && @between.is_a?(ActiveSupport::Duration)) ? @queue.send_next_request : @queue.send_all_requests
     end
 
     def schedule_next

data/lib/fragmentary/publisher.rb

@@ -39,7 +39,9 @@ module Fragmentary
       end
 
       def after_destroy_broadcast
+        Rails.logger.info "\n***** #{start = Time.now} broadcasting :after_destroy from #{self.class.name} #{self.id}\n"
         broadcast(:after_destroy, self)
+        Rails.logger.info "\n***** #{Time.now} broadcast :after_destroy from #{self.class.name} #{self.id} took #{(Time.now - start) * 1000} ms\n"
       end
 
       def after_commit_broadcast

data/lib/fragmentary/request_queue.rb

@@ -6,15 +6,19 @@ module Fragmentary
       @@all ||= []
     end
 
-    def self.send_all(between: nil)
-      unless between
-        all.each{|q| q.start}
+    def self.send_all(delay: nil, between: nil, queue_suffix: '', priority: 0, user_group: 'default')
+      unless delay or between
+        all.each{|q| q.start(queue_suffix: queue_suffix, priority: priority, user_group: user_group)}
       else
+        delay ||= 0.seconds
+        between ||= 0.seconds
+        unless delay.is_a? ActiveSupport::Duration
+          raise TypeError, "Fragmentary::RequestQueue.send_all requires the keyword argument :delay to be of class ActiveSupport::Duration. The value provided is of class #{delay.class.name}."
+        end
         unless between.is_a? ActiveSupport::Duration
           raise TypeError, "Fragmentary::RequestQueue.send_all requires the keyword argument :between to be of class ActiveSupport::Duration. The value provided is of class #{between.class.name}."
         end
-        delay = 0.seconds
-        all.each{|q| q.start(:delay => delay += between)}
+        all.each{|q| q.start(delay: (delay += between), queue_suffix: queue_suffix, priority: priority, user_group: user_group)}
       end
     end
 
@@ -57,12 +61,12 @@ module Fragmentary
       @sender ||= Sender.new(self)
     end
 
-    def send(**args)
-      sender.start(args)
+    def send(**kwargs)
+      sender.start(**kwargs)
     end
 
-    def method_missing(method, *args)
-      sender.send(method, *args)
+    def method_missing(method, *args, **kwargs)
+      sender.send(method, *args, **kwargs)
     end
 
     class Sender
@@ -87,15 +91,17 @@ module Fragmentary
 
       end
 
-      attr_reader :queue, :target, :delay, :between, :queue_suffix, :priority
+      attr_reader :queue, :target, :delay, :between, :queue_suffix, :priority, :user_group, :queue_name
 
       def initialize(queue)
         @queue = queue
         @target = Target.new(queue.host_root_url)
+        @user_group = 'default'
+        @queue_name = @target.queue_name
       end
 
       def session_user
-        @session_user ||= Fragmentary::SessionUser.fetch(queue.user_type)
+        @session_user ||= Fragmentary::SessionUser.fetch(queue.user_type, user_group)
       end
 
       def session
@@ -103,9 +109,16 @@ module Fragmentary
       end
 
       # Send all requests, either directly or by schedule
-      def start(delay: nil, between: nil, queue_suffix: '', priority: 0)
+      # Note that the :between argument here represents the time between sending consecutive *requests*, whereas in RequestQueue#send_all it
+      # represents the time between starting consecutive queues.
+      # The :between argument here is deprecated. There is no :between value passed from RequestQueue.send_all to RequestQueue::Sender#start
+      def start(delay: nil, between: nil, queue_suffix: '', priority: 0, user_group: 'default')
         Rails.logger.info "\n***** Processing request queue for user_type '#{queue.user_type}'\n"
-        @delay = delay; @between = between; @queue_suffix = queue_suffix; @priority = priority
+        @delay = delay
+        @between = between
+        @queue_suffix = queue_suffix
+        @priority = priority
+        @user_group = user_group
         if @delay or @between
           schedule_requests(@delay)
           # sending requests by schedule makes a copy of the sender and queue objects for
@@ -124,13 +137,16 @@ module Fragmentary
       def send_next_request
         if queue.size > 0
           request = queue.next_request
-          session.send_request(:method => request.method, :path => request.path, :parameters => request.parameters, :options => request.options)
+          parameters = (request.parameters || {}).merge(:queue_suffix => queue_suffix)
+          session.send_request(:method => request.method, :path => request.path, :parameters => parameters, :options => request.options)
         end
       end
 
       private
 
-      def send_all_requests
+      def send_all_requests(user_group: 'default')
+        @user_group = user_group
+        clear_session
         while queue.size > 0
           send_next_request
         end
@@ -140,7 +156,7 @@ module Fragmentary
         if queue.size > 0
           clear_session
           job = SendRequestsJob.new(queue, delay: delay, between: between, queue_suffix: queue_suffix, priority: priority)
-          job.enqueue(:wait => delay, :queue => target.queue_name + queue_suffix, :priority => priority)
+          job.enqueue({:wait => delay, :queue => queue_name + queue_suffix, :priority => priority})
         end
       end
 

data/lib/fragmentary/session_user.rb

@@ -2,26 +2,34 @@ module Fragmentary
 
   class SessionUser
 
+    attr_reader :options, :user_type
+
     def self.all
-      @@all ||= Hash.new
+      @@all ||= Hash.new { |hsh, user_type| hsh[user_type] = Hash.new }
     end
+    private_class_method :all
+    private_class_method :new
 
-    def self.fetch(key)
-      all[key]
+    def self.fetch(user_type, user_group = 'default')
+      all[user_type][user_group]
     end
 
-    def initialize(user_type, options={})
-      if user = self.class.fetch(user_type)
-        if user.options != options
-          raise RangeError, "You can't redefine an existing SessionUser object: #{user_type.inspect}"
-        else
-          user
-        end
+    def self.create(user_type, options={})
+      user_group = options[:group] || options[:user_group] || 'default'
+      if user = fetch(user_type, user_group)
+        raise RangeError, "You can't redefine an existing SessionUser object: #{user_type.inspect}" unless user.options == options
       else
-        @user_type = user_type
+        @user_type = user_type   # this probably not really necessary
         @options = options
-        self.class.all.merge!({user_type => self})
+        user = new(user_type, options)
+        all[user_type].merge!(user_group => user)
       end
+      user
+    end
+
+    def initialize(user_type, options={})
+      @user_type = user_type   # this probably not really necessary
+      @options = options
     end
 
     def credentials

data/lib/fragmentary/subscriber.rb

@@ -2,19 +2,32 @@ require 'fragmentary/subscription'
 
 module Fragmentary
 
-  # Each fragment subclass has a unique Subscriber instance reponsible for handling subscriptions
-  # to publishers. Each subscriber maintains a hash of Subscriptions, one for each publisher it
-  # subscribes to. The 'subscribe_to' method instantiates each new Subscription in turn and executes
-  # its block against against the Subscriber in order to define handlers for each publisher event
-  # of interest. Any other method invoked within a handler is delegated to the client, i.e. the
-  # fragment subclass that the subscriber is reponsible for.
+  # Each fragment subclass has a unique Subscriber instance responsible for handling subscriptions
+  # to publishers. The subscriber is instantiated the first time it is referenced within the subscribe_to
+  # method called on the fragment. That method calls a method of the same name on the subscriber, which
+  # instantiates a new Subscription for each publisher it subscribes to and executes its block against
+  # the subscriber, thus defining handlers for each publisher event of interest on the subscriber,
+  # (rather than the fragment). Any other method invoked within a handler is delegated to the client, i.e.
+  # the Fragment subclass that the subscriber is responsible for.
+  #
+  # A separate subscription exists for each combination of publisher and subscriber (and thus Fragment subclass).
+  # When a subscription is instantiated for a given publisher, it registers itself with a Subscription::Proxy
+  # for that publisher. The proxy, is instantiated the first time it is referenced by a subscription to a
+  # particular publisher, and it subscribes on behalf of all its registered subscriptions to Wisper events
+  # broadcast by that publisher.
+  #
+  # The Proxy class contains the methods such as 'after_create', 'after_update' etc that are called automatically
+  # by Wisper when the publisher broacdcasts the corresponding events. These methods each invoke methods of the
+  # same name on each of proxy's registered subscriptions, and it is these that in turn invoke the methods
+  # defined by the subscribe_to blocks on the susbcriber associated with the subscription.
   class Subscriber
     attr_reader :client, :subscriptions
 
     def initialize(client)
       @client = client
       @subscriptions = Hash.new do |h, key|
-        if Object.const_defined?(key) and (publisher = key.constantize) < ActiveRecord::Base
+        publisher = key.constantize  # Ensures that the model is loaded so that the const below is defined.
+        if Object.const_defined?(key) and publisher < ActiveRecord::Base
           h[key] = Subscription.new(publisher, self)
         else
           nil

data/lib/fragmentary/subscription.rb

@@ -76,11 +76,13 @@ module Fragmentary
 
     private
     def call_method(method, record)
-      Rails.logger.info "***** Calling #{method.inspect} on #{subscriber.client.name} with record #{record.class.name} #{record.id}"
-      start = Time.now
-      subscriber.public_send(method, record) if subscriber.respond_to? method
-      finish = Time.now
-      Rails.logger.info "***** #{method.inspect} duration: #{(finish - start) * 1000}ms\n\n"
+      if subscriber.respond_to? method
+        Rails.logger.info "***** Calling #{method.inspect} on #{subscriber.client.name} with record #{record.class.name} #{record.id}"
+        start = Time.now
+        subscriber.public_send(method, record)
+        finish = Time.now
+        Rails.logger.info "***** #{method.inspect} duration: #{(finish - start) * 1000}ms\n\n"
+      end
     end
 
   end

data/lib/fragmentary/user_session.rb

@@ -17,6 +17,7 @@ module Fragmentary
       @user = user
       @target = URI.parse(target)
       @session.host! session_host
+      @session.https! if (@target.scheme == 'https')
       sign_in if session_credentials
       instance_eval(&block) if block_given?
     end
@@ -43,6 +44,7 @@ module Fragmentary
 
     def relative_url_root
       @relative_url_root ||= Rails.application.config.relative_url_root
+      @relative_url_root ||= Rails.application.routes.default_url_options[:relative_url_root].try(:gsub, /\/$/,'')
     end
 
     def session_options
@@ -56,9 +58,9 @@ module Fragmentary
     def sign_in
       raise "Can't sign in without user credentials" unless session_credentials
       send_request(:method => :get, :path => session_sign_in_path, :options => session_options)  # necessary in order to get the csrf token
-      # NOTE: In Rails 5, params is changed to a named argument, i.e. :params => {...}. Will need to be changed.
       # Note that request is called on session, returning an ActionDispatch::Request; request.session is an ActionDispatch::Request::Session
       puts "      * Signing in as #{session_credentials.inspect}"
+      Rails.logger.info "      * Signing in as #{session_credentials.inspect}"
       parameters = session_credentials.merge(:authenticity_token => request.session[:_csrf_token])
       send_request(:method => :post, :path => session_sign_in_path, :parameters => parameters, :options => session_options)
       if @session.redirect?
@@ -89,7 +91,7 @@ module Fragmentary
         puts "      * Sending request '#{method.to_s} #{path}'" + (!parameters.nil? ? " with #{parameters.inspect}" : "")
         Rails.logger.info "      * Sending request '#{method.to_s} #{path}'" + (!parameters.nil? ? " with #{parameters.inspect}" : "")
       end
-      @session.send(method, path, options)
+      @session.send(method, path, **options)
     end
 
     def sign_out
@@ -143,6 +145,7 @@ module Fragmentary
       # The first request retrieves the authentication token
       response = send_request(:method => :get, :path => Fragmentary.config.get_sign_in_path)
       puts "      * Signing in as #{@credentials.inspect}"
+      Rails.logger.info "      * Signing in as #{@credentials.inspect}"
       response = send_request(:method => :post, :path => Fragmentary.config.post_sign_in_path,
                               :parameters => @credentials.merge(:authenticity_token => @authenticity_token),
                               :options => {:headers => {:accept => "text/html,application/xhtml+xml,application/xml"}})

data/lib/fragmentary/version.rb

@@ -1,3 +1,3 @@
 module Fragmentary
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: fragmentary
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Mark Thomson
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-22 00:00:00.000000000 Z
+date: 2026-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
@@ -149,7 +149,7 @@ homepage: https://github.com/MarkMT/fragmentary
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -164,8 +164,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
-signing_key: 
+rubygems_version: 3.3.22
+signing_key:
 specification_version: 4
 summary: Fragment modeling and caching for Rails
 test_files: []