sourced-message 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8202b720a3a57bf15a429a136797186c2bc8bd2721a7539e2f08495e7078923
-  data.tar.gz: 6532b0db8f33fb6aa9ba4d585d5b0424fd089be4917e994f4a1abd341db132b4
+  metadata.gz: 80569ac57d96516a6efd3bd8c09ef862a7c48d9e661fb82404476608995c6350
+  data.tar.gz: a480b3c5007cab3ad87f242a5828a548e294150ef2ad65b5afdc2dc98d53423c
 SHA512:
-  metadata.gz: ba7bafee643414f03b642074c521257fb731f663dc653d6ddedb3c6ca2d26304e727d7c719fac830d196aee3e1086aed22d126759c4671a3242fcc6c89fff5a8
-  data.tar.gz: 5f979cf196b3d6e0bc3b37ddc5b85f0a9284b1d8fad4a15a877ca835b18a747e49d9c1e5a5a0ad0b4acaaffe8b7bbb02411ee34f888445a30f6f3835c6eb267b
+  metadata.gz: bae04d8962a7e19f8f21985b674b29e0ddb90987934a51504e8eeba4e357b7925b983c4e9cee10b719b0598ecae963af0dccbd79efb0679a44ace463184e6c37
+  data.tar.gz: df823ccc2eab96eaddba05255f0776b069dfa57004bb58f2337f9de8aeedd29fe3d30ed04ed7e72ac0211c0e6195110cb19bbd735014fefd76013aa975349f24

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+- `Message#at` with a duration string (`'1h30m'`) raised `ArgumentError` ("Cannot
+  determine timezone from \"BST\"") in the hour the clocks go back. The duration's
+  seconds are now added to `Time.now`, exactly. Durations in months or years, which
+  aren't a fixed number of seconds, raise `ArgumentError`.
+- `Message::Registry` raises `DuplicateTypeError` when two classes with different names
+  claim one type string, instead of silently replacing the registered class. Registering
+  a type again is still allowed when the names are equal (a code reloader redefining a
+  constant) or either class is anonymous (throwaway classes in specs; a constant in an
+  anonymous module counts as anonymous until the module is named). `.define`
+  registers a class before it's assigned to its constant, so the comparison waits until
+  the new class has a name: the next registration of the type, its lookup (`[]`,
+  `Message.from`, codec `decode`) or `#all` (codec `compile!`) raises.
+
 ## [0.5.0]
 
 - `Message#tags`: an envelope attribute (`Types::Tags`, Symbol keys and String values,

data/README.md

@@ -372,10 +372,11 @@ Scheduling a message into the past raises `Sourced::Message::PastMessageDateErro
 msg.at(Time.now - 60) # => raises Sourced::Message::PastMessageDateError
 ```
 
-Passing a string that isn't a duration (e.g. an absolute date) raises `ArgumentError`:
+Passing a string that isn't a duration (e.g. an absolute date) raises `ArgumentError`, as does a duration in months or years, which vary in length (give days instead):
 
 ```ruby
 msg.in('2026-12-31T10:00:00') # => raises ArgumentError
+msg.in('1M')                  # => raises ArgumentError; msg.in('30d') instead
 ```
 
 ### Pattern matching with `case`/`when`

data/lib/sourced/message.rb

@@ -22,7 +22,7 @@ module Sourced
   # +Sourced::Message.registry[type]+ resolves a type registered under any
   # subclass. Resolve from this root to see the whole tree.
   class Message < Plumb::Types::Data
-    VERSION = '0.5.0'
+    VERSION = '0.5.2'
 
     EMPTY_ARRAY = [].freeze
 
@@ -54,6 +54,8 @@ module Sourced
     TagConflictError = Class.new(ArgumentError)
     # Raised by {#at} when a message would be scheduled in the past.
     PastMessageDateError = Class.new(ArgumentError)
+    # Raised by {Registry} when two classes with different names claim one type string.
+    DuplicateTypeError = Class.new(ArgumentError)
     LaxTime = Types::Time | Types::String.build(::Time, :parse).policy(:rescue, ::ArgumentError)
 
     attribute :id, Types::AutoUUID
@@ -68,11 +70,19 @@ module Sourced
     attribute :payload, Types::Static[nil]
 
     # Lookup table mapping type strings to message subclasses.
+    #
+    # Registering a type again replaces its class: a code reloader redefines a
+    # constant, and specs define throwaway anonymous messages reusing type
+    # strings. Two classes with different permanent names claiming one type are
+    # a bug, and raise {DuplicateTypeError}. {.define} registers a class before
+    # it's assigned to its constant, so the replaced class is kept until its
+    # successor has a name, and compared on the next registration or lookup.
     class Registry
       # @param message_class [Class] the root message class for this registry
       def initialize(message_class)
         @message_class = message_class
         @lookup = {}
+        @replaced = {}
       end
 
       # @return [Array<String>] registered type strings
@@ -85,7 +95,14 @@ module Sourced
       #
       # @param key [String] message type string
       # @param klass [Class] message subclass
+      # @raise [DuplicateTypeError] if a class with a different name holds the type
       def []=(key, klass)
+        check!(key)
+        previous = @lookup[key]
+        if previous && named(previous) && !previous.equal?(klass)
+          duplicate!(key, previous, klass) if named(klass) && named(klass) != named(previous)
+          @replaced[key] = previous unless named(klass)
+        end
         @lookup[key] = klass
       end
 
@@ -94,7 +111,9 @@ module Sourced
       #
       # @param key [String] message type string
       # @return [Class, nil]
+      # @raise [DuplicateTypeError] if a class with a different name holds the type
       def [](key)
+        check!(key) unless @replaced.empty?
         klass = lookup[key]
         return klass if klass
 
@@ -109,9 +128,11 @@ module Sourced
       #
       # @return [Enumerator<Class>] if no block given
       # @yield [Class] each registered message class
+      # @raise [DuplicateTypeError] if a class with a different name holds a type
       def all(&block)
         return enum_for(:all) unless block
 
+        @replaced.keys.each { |key| check!(key) }
         lookup.each_value(&block)
         subclasses.each { |c| c.registry.all(&block) }
       end
@@ -119,6 +140,29 @@ module Sourced
       private
 
       attr_reader :lookup, :message_class
+
+      # Compare the class a type replaced with the one holding it, once the latter has a name.
+      def check!(key)
+        replaced = @replaced[key]
+        return unless replaced
+
+        current = @lookup[key]
+        return unless named(current)
+
+        @replaced.delete(key)
+        duplicate!(key, replaced, current) unless named(current) == named(replaced)
+      end
+
+      # A class's permanent name. A constant set in an anonymous module has a
+      # temporary one (+"#<Class:0x...>::Foo"+) until the module is named.
+      def named(klass)
+        name = klass.name
+        name unless name.nil? || name.start_with?('#<')
+      end
+
+      def duplicate!(key, registered, klass)
+        raise DuplicateTypeError, "message type #{key.inspect} is claimed by both #{registered.name} and #{klass.name}"
+      end
     end
 
     # @return [Registry] the message type registry for this class
@@ -242,7 +286,9 @@ module Sourced
     #   target.
     # - +Integer+ — interpreted as seconds; added to +Time.now+.
     # - +String+ — parsed via +Fugit.parse_duration+ as a duration (e.g.
-    #   +'5m'+, +'1h30m'+, +'PT5M'+) and added to +Time.now+.
+    #   +'5m'+, +'1h30m'+, +'PT5M'+), up to weeks, and its seconds added to
+    #   +Time.now+. Months and years aren't a fixed number of seconds, so
+    #   they raise +ArgumentError+.
     #
     # Raises {PastMessageDateError} when the resolved target is
     # before +created_at+.
@@ -251,11 +297,7 @@ module Sourced
                when Integer
                  Time.now + value
                when String
-                 parsed = Fugit.parse_duration(value) or
-                   raise ArgumentError,
-                         "Message#at: String argument must be an ISO8601 / Fugit duration " \
-                         "(e.g. '5m', 'PT1H30M'); got #{value.inspect}"
-                 parsed.add_to_time(Time.now).to_local_time
+                 Time.now + duration_seconds(value)
                else
                  value
                end
@@ -331,6 +373,21 @@ module Sourced
       attrs[:causation_id] = attrs[:id] unless attrs[:causation_id]
       attrs
     end
+
+    # A duration string's seconds, up to weeks.
+    def duration_seconds(value)
+      duration = Fugit.parse_duration(value) or
+        raise ArgumentError,
+              "Message#at: String argument must be an ISO8601 / Fugit duration " \
+              "(e.g. '5m', 'PT1H30M'); got #{value.inspect}"
+      if duration.h.key?(:yea) || duration.h.key?(:mon)
+        raise ArgumentError,
+              "Message#at: can't delay by months or years, which vary in length; " \
+              "give days (e.g. '30d'); got #{value.inspect}"
+      end
+
+      duration.to_sec
+    end
   end
 
   class Command < Message; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sourced-message
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Ismael Celis