familia 2.0.0.pre12 → 2.0.0.pre13

data/lib/familia/features/quantization.rb

@@ -245,11 +245,16 @@ module Familia
     #   NoDefault.qstamp()  # Uses 10.minutes as fallback quantum
     #
     module Quantization
+
+      using Familia::Refinements::TimeUtils
+
       def self.included(base)
         Familia.trace :LOADED, self, base, caller(1..1) if Familia.debug?
         base.extend ClassMethods
       end
 
+      # Familia::Quantization::ClassMethods
+      #
       module ClassMethods
         # Generates a quantized timestamp based on the given parameters
         #

data/lib/familia/features/safe_dump.rb

@@ -1,5 +1,6 @@
 # lib/familia/features/safe_dump.rb
 
+
 # rubocop:disable ThreadSafety/ClassInstanceVariable
 #
 #   Class instance variables are used here for feature configuration
@@ -40,10 +41,16 @@ module Familia::Features
   # of symbols in the order they were defined.
   #
   module SafeDump
+    include Familia::Features::Autoloadable
+    using Familia::Refinements::SnakeCase
+
     @dump_method = :to_json
     @load_method = :from_json
 
     def self.included(base)
+      # Call the Autoloadable module's included method for post-inclusion setup
+      super
+
       Familia.trace(:LOADED, self, base, caller(1..1)) if Familia.debug?
       base.extend ClassMethods
 

data/lib/familia/features.rb

@@ -1,5 +1,8 @@
 # lib/familia/features.rb
 
+# Load the Autoloader first, then use it to load all other features
+require_relative 'autoloader'
+
 module Familia
   FeatureDefinition = Data.define(:name, :depends_on)
 
@@ -22,9 +25,9 @@ module Familia
   # feature options. When you enable a feature with options in different models,
   # each model stores its own separate configuration without interference.
   #
-  # ## Project Organization with Autoloader
+  # ## Project Organization with Autoloadable
   #
-  # For large projects, use {Familia::Features::Autoloader} to automatically load
+  # For large projects, use {Familia::Features::Autoloadable} to automatically load
   # project-specific features from a dedicated directory structure. This helps
   # organize complex models by separating features into individual files.
   #
@@ -54,14 +57,16 @@ module Familia
   #   # In your model file: app/models/customer.rb
   #   class Customer < Familia::Horreum
   #     module Features
-  #       include Familia::Features::Autoloader
+  #       include Familia::Features::Autoloadable
   #       # Automatically loads all .rb files from app/models/customer/features/
   #     end
   #   end
   #
-  # @see Familia::Features::Autoloader For automatic feature loading
+  # @see Familia::Features::Autoloadable For automatic feature loading
   #
   module Features
+    include Familia::Autoloader
+
     @features_enabled = nil
     attr_reader :features_enabled
 
@@ -131,14 +136,23 @@ module Familia
       # Add it to the list available features_enabled for Familia::Base classes.
       features_enabled << feature_name
 
-      # Store feature options if any were provided using the new pattern
-      if options.any?
+      # Always capture and store the calling location for every feature
+      calling_location = caller_locations(1, 1)&.first
+      options[:calling_location] = calling_location&.path
+
+      # Add feature options if the class supports them (Horreum classes)
+      if respond_to?(:add_feature_options)
         add_feature_options(feature_name, **options)
       end
 
       # Extend the Familia::Base subclass (e.g. Customer) with the feature module
       include feature_class
 
+      # Trigger post-inclusion autoloading for features that support it
+      if feature_class.respond_to?(:post_inclusion_autoload)
+        feature_class.post_inclusion_autoload(self, feature_name, options)
+      end
+
       # NOTE: Do we want to extend Familia::DataType here? That would make it
       # possible to call safe_dump on relations fields (e.g. list, zset, hashkey).
       #
@@ -152,13 +166,3 @@ module Familia
     end
   end
 end
-
-# Load all feature files from the features directory
-features_dir = File.join(__dir__, 'features')
-Familia.ld "[DEBUG] Loading features from #{features_dir}"
-if Dir.exist?(features_dir)
-  Dir.glob(File.join(features_dir, '*.rb')).each do |feature_file|
-    Familia.ld "[DEBUG] Loading feature #{feature_file}"
-    require_relative feature_file
-  end
-end

data/lib/familia/field_type.rb

@@ -29,6 +29,8 @@ module Familia
   class FieldType
     attr_reader :name, :options, :method_name, :fast_method_name, :on_conflict, :loggable
 
+    using Familia::Refinements::TimeUtils
+
     # Initialize a new field type
     #
     # @param name [Symbol] The field name

data/lib/familia/horreum/core/serialization.rb

@@ -470,7 +470,7 @@ module Familia
         # If the distinguisher returns nil, try using the dump_method but only
         # use JSON serialization for complex types that need it.
         if prepared.nil? && (val.is_a?(Hash) || val.is_a?(Array))
-          prepared = val.respond_to?(dump_method) ? val.send(dump_method) : JSON.dump(val)
+          prepared = val.respond_to?(dump_method) ? val.send(dump_method) : Familia::JsonSerializer.dump(val)
         end
 
         # If both the distinguisher and dump_method return nil, log an error
@@ -493,11 +493,11 @@ module Familia
 
         # Try to parse as JSON first for complex types
         begin
-          parsed = JSON.parse(val, symbolize_names: symbolize)
+          parsed = Familia::JsonSerializer.parse(val, symbolize_names: symbolize)
           # Only return parsed value if it's a complex type (Hash/Array)
           # Simple values should remain as strings
           return parsed if parsed.is_a?(Hash) || parsed.is_a?(Array)
-        rescue JSON::ParserError
+        rescue Familia::SerializerError
           # Not valid JSON, return as-is
         end
 

data/lib/familia/horreum/subclass/definition.rb

@@ -46,6 +46,8 @@ module Familia
       include Familia::Settings
       include Familia::Horreum::RelatedFieldsManagement # Provides DataType field methods
 
+      using Familia::Refinements::SnakeCase
+
       # Sets or retrieves the unique identifier field for the class.
       #
       # This method defines or returns the field or method that contains the unique
@@ -183,10 +185,7 @@ module Familia
       #
       # @return [String] The underscored class name as a string
       def config_name
-        name.split('::').last
-            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            .downcase
+        name.snake_case
       end
 
       def dump_method

data/lib/familia/horreum.rb

@@ -31,6 +31,8 @@ module Familia
     include Familia::Horreum::Core
     include Familia::Horreum::Settings
 
+    using Familia::Refinements::TimeUtils
+
     # Singleton Class Context
     #
     # The code within this block operates on the singleton class (also known as

data/lib/familia/json_serializer.rb

@@ -0,0 +1,70 @@
+# lib/familia/json_serializer.rb
+
+module Familia
+  # JsonSerializer provides a high-performance JSON interface using OJ
+  #
+  # This module wraps OJ with a clean API that can be easily swapped out
+  # or benchmarked against other JSON implementations. Uses OJ's :strict
+  # mode for RFC 7159 compliant JSON output.
+  #
+  # @example Basic usage
+  #   data = { name: 'test', value: 123 }
+  #   json = Familia::JsonSerializer.dump(data)
+  #   parsed = Familia::JsonSerializer.parse(json, symbolize_names: true)
+  #
+  module JsonSerializer
+
+    class << self
+      # Parse JSON string into Ruby objects
+      #
+      # @param source [String] JSON string to parse
+      # @param opts [Hash] parsing options
+      # @option opts [Boolean] :symbolize_names convert hash keys to symbols
+      # @return [Object] parsed Ruby object
+      # @raise [SerializerError] if JSON is malformed
+      def parse(source, opts = {})
+        return nil if source.nil? || source == ''
+
+        symbolize_names = opts[:symbolize_names] || opts['symbolize_names']
+
+        if symbolize_names
+          Oj.load(source, mode: :strict, symbol_keys: true)
+        else
+          Oj.load(source, mode: :strict)
+        end
+      rescue Oj::ParseError, Oj::Error, EncodingError => e
+        raise SerializerError, e.message
+      end
+
+      # Serialize Ruby object to JSON string
+      #
+      # @param obj [Object] Ruby object to serialize
+      # @return [String] JSON string
+      def dump(obj)
+        Oj.dump(obj, mode: :strict)
+      rescue Oj::Error, TypeError, EncodingError => e
+        raise SerializerError, e.message
+      end
+
+      # Alias for dump for JSON gem compatibility
+      #
+      # @param obj [Object] Ruby object to serialize
+      # @return [String] JSON string
+      def generate(obj)
+        Oj.dump(obj, mode: :strict)
+      rescue Oj::Error, TypeError, EncodingError => e
+        raise SerializerError, e.message
+      end
+
+      # Serialize Ruby object to pretty-formatted JSON string
+      #
+      # @param obj [Object] Ruby object to serialize
+      # @return [String] pretty-formatted JSON string
+      def pretty_generate(obj)
+        Oj.dump(obj, mode: :strict, indent: 2)
+      rescue Oj::Error, TypeError, EncodingError => e
+        raise SerializerError, e.message
+      end
+    end
+  end
+end

data/lib/familia/logging.rb

@@ -17,7 +17,7 @@ module Familia
 
     # Get the severity letter from the thread local variable or use
     # the default. The thread local variable is set in the trace
-    # method in the LoggerTraceRefinement module. The name of the
+    # method in the Familia::Refinements::LoggerTrace module. The name of the
     # variable `severity_letter` is arbitrary and could be anything.
     severity_letter = Thread.current[:severity_letter] || severity_letter
 
@@ -36,7 +36,7 @@ module Familia
   # == Methods:
   # trace::
   #   Logs a message at the TRACE level. This method is only available if the
-  #   LoggerTraceRefinement is used.
+  #   Familia::Refinements::LoggerTrace is used.
   #
   # debug::
   #   Logs a message at the DEBUG level. This is used for low-level system information
@@ -59,14 +59,14 @@ module Familia
   #   that will presumably lead the application to abort.
   #
   # == Usage:
-  # To use the Logging module, you need to include the LoggerTraceRefinement module
+  # To use the Logging module, you need to include the Familia::Refinements::LoggerTrace module
   # and use the `using` keyword to enable the refinement. This will add the TRACE
   # log level and the trace method to the Logger class.
   #
   # Example:
   #   require 'logger'
   #
-  #   module LoggerTraceRefinement
+  #   module Familia::Refinements::LoggerTrace
   #     refine Logger do
   #       TRACE = 0
   #
@@ -76,7 +76,7 @@ module Familia
   #     end
   #   end
   #
-  #   using LoggerTraceRefinement
+  #   using Familia::Refinements::LoggerTrace
   #
   #   logger = Logger.new(STDOUT)
   #   logger.trace("This is a trace message")
@@ -86,13 +86,13 @@ module Familia
   #   logger.error("This is an error message")
   #   logger.fatal("This is a fatal message")
   #
-  # In this example, the LoggerTraceRefinement module is defined with a refinement
+  # In this example, the Familia::Refinements::LoggerTrace module is defined with a refinement
   # for the Logger class. The TRACE constant and trace method are added to the Logger
   # class within the refinement. The `using` keyword is used to apply the refinement
   # in the scope where it's needed.
   #
   # == Conditions:
-  # The trace method and TRACE log level are only available if the LoggerTraceRefinement
+  # The trace method and TRACE log level are only available if the Familia::Refinements::LoggerTrace
   # module is used with the `using` keyword. Without this, the Logger class will not
   # have the trace method or the TRACE log level.
   #
@@ -103,7 +103,9 @@ module Familia
     attr_reader :logger
 
     # Gives our logger the ability to use our trace method.
-    using LoggerTraceRefinement if LoggerTraceRefinement::ENABLED
+    if Familia::Refinements::LoggerTrace::ENABLED
+      using Familia::Refinements::LoggerTrace
+    end
 
     def info(*msg)
       @logger.info(*msg)
@@ -140,13 +142,13 @@ module Familia
     #
     # @return [nil]
     #
-    # @note This method only executes if LoggerTraceRefinement::ENABLED is true.
+    # @note This method only executes if Familia::Refinements::LoggerTrace::ENABLED is true.
     # @note The dbclient can be a Database object, Redis::Future (used in
     #   pipelined and multi blocks), or nil (when the database connection isn't
     #   relevant).
     #
     def trace(label, dbclient, ident, context = nil)
-      return unless LoggerTraceRefinement::ENABLED
+      return unless Familia::Refinements::LoggerTrace::ENABLED
 
       # Usually dbclient is a Database object, but it could be
       # a Redis::Future which is what is used inside of pipelined

data/lib/familia/refinements/logger_trace.rb

@@ -0,0 +1,57 @@
+# lib/familia/refinements/logger_trace.rb
+
+require 'pathname'
+require 'logger'
+
+# Controls whether tracing is enabled via an environment variable
+FAMILIA_TRACE = ENV.fetch('FAMILIA_TRACE', 'false').downcase
+
+# Familia::Refinements::LoggerTrace
+#
+# This module adds a 'trace' log level to the Ruby Logger class.
+# It is enabled when the FAMILIA_TRACE environment variable is set to
+# '1', 'true', or 'yes' (case-insensitive).
+#
+# @example Enabling trace logging
+#   # Set environment variable
+#   ENV['FAMILIA_TRACE'] = 'true'
+#
+#   # In your Ruby code
+#   require 'logger'
+#   using Familia::Refinements::LoggerTrace
+#
+#   logger = Logger.new(STDOUT)
+#   logger.trace("This is a trace message")
+#
+module Familia
+  module Refinements
+
+    # Familia::Refinements::LoggerTrace
+    module LoggerTrace
+      unless defined?(ENABLED)
+        # Indicates whether trace logging is enabled
+        ENABLED = %w[1 true yes].include?(FAMILIA_TRACE).freeze
+        # The numeric level for trace logging (same as DEBUG)
+        TRACE = 0
+      end
+
+      refine Logger do
+        ##
+        # Logs a message at the TRACE level.
+        #
+        # @param progname [String] The program name to include in the log message
+        # @yield A block that evaluates to the message to log
+        # @return [true] Always returns true
+        #
+        # @example Logging a trace message
+        #   logger.trace("MyApp") { "Detailed trace information" }
+        def trace(progname = nil, &block)
+          Thread.current[:severity_letter] = 'T'
+          add(Familia::Refinements::LoggerTrace::TRACE, nil, progname, &block)
+        ensure
+          Thread.current[:severity_letter] = nil
+        end
+      end
+    end
+  end
+end

data/lib/familia/refinements/snake_case.rb

@@ -0,0 +1,40 @@
+# lib/familia/refinements/snake_case.rb
+
+module Familia
+  module Refinements
+    module SnakeCase
+      # We refine String rather than Class or Module because this method operates on
+      # string representations of class names (like those from `Class#name`) rather
+      # than the class objects themselves. Refining String is safer because it
+      # limits its scope to only the subset string manipulation contexts where it is
+      # used.
+      #
+      # Appropriate for converting Ruby class names to database table names, config
+      # keys, part of a path or any other snake_case identifiers. The only situation
+      # it is not appropriate for is investigating actual snakes.
+      refine String do
+        # Converts a string from PascalCase/camelCase to snake_case format.
+        #
+        # @return [String] the snake_case version of the string
+        #
+        # @example Converting simple CamelCase
+        #   "FirstName".snake_case #=> "first_name"
+        #
+        # @example Converting PascalCase with acronyms
+        #   XMLHttpRequest.name.snake_case #=> "xml_http_request"
+        #
+        # @example Converting namespaced class names
+        #   "MyApp::UserAccount".snake_case #=> "user_account"
+        #
+        # @example Handling mixed case with numbers
+        #   "parseHTML5Document".snake_case #=> "parse_html5_document"
+        def snake_case
+          split('::').last
+                     .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                     .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                     .downcase
+        end
+      end
+    end
+  end
+end

data/lib/familia/refinements/time_utils.rb

@@ -0,0 +1,248 @@
+# lib/familia/refinements/time_utils.rb
+
+module Familia
+  module Refinements
+
+    # Familia::Refinements::TimeUtils
+    module TimeUtils
+      # Time unit constants
+      PER_MICROSECOND = 0.000001
+      PER_MILLISECOND = 0.001
+      PER_MINUTE      = 60.0
+      PER_HOUR        = 3600.0
+      PER_DAY         = 86_400.0
+      PER_WEEK        = 604_800.0
+      PER_YEAR        = 31_556_952.0 # 365.2425 days (Gregorian year)
+      PER_MONTH       = PER_YEAR / 12.0 # 30.437 days (consistent with Gregorian year)
+
+      UNIT_METHODS = {
+        'y' => :years,
+        'year' => :years,
+        'years' => :years,
+        'mo' => :months,
+        'month' => :months,
+        'months' => :months,
+        'w' => :weeks,
+        'week' => :weeks,
+        'weeks' => :weeks,
+        'd' => :days,
+        'day' => :days,
+        'days' => :days,
+        'h' => :hours,
+        'hour' => :hours,
+        'hours' => :hours,
+        'm' => :minutes,
+        'minute' => :minutes,
+        'minutes' => :minutes,
+        'ms' => :milliseconds,
+        'millisecond' => :milliseconds,
+        'milliseconds' => :milliseconds,
+        'us' => :microseconds,
+        'microsecond' => :microseconds,
+        'microseconds' => :microseconds,
+        'μs' => :microseconds,
+      }.freeze
+
+      refine Numeric do
+        def microseconds = seconds * PER_MICROSECOND
+        def milliseconds = seconds * PER_MILLISECOND
+        def seconds      = self
+        def minutes      = seconds * PER_MINUTE
+        def hours        = seconds * PER_HOUR
+        def days         = seconds * PER_DAY
+        def weeks        = seconds * PER_WEEK
+        def months       = seconds * PER_MONTH
+        def years        = seconds * PER_YEAR
+
+        # Aliases with singular forms
+        alias_method :microsecond, :microseconds
+        alias_method :millisecond, :milliseconds
+        alias_method :second,      :seconds
+        alias_method :minute,      :minutes
+        alias_method :hour,        :hours
+        alias_method :day,         :days
+        alias_method :week,        :weeks
+        alias_method :month,       :months
+        alias_method :year,        :years
+
+        # Fun aliases
+        alias_method :ms, :milliseconds
+        alias_method :μs, :microseconds
+
+        # Seconds -> other time units
+        def in_years        = seconds / PER_YEAR
+        def in_months       = seconds / PER_MONTH
+        def in_weeks        = seconds / PER_WEEK
+        def in_days         = seconds / PER_DAY
+        def in_hours        = seconds / PER_HOUR
+        def in_minutes      = seconds / PER_MINUTE
+        def in_milliseconds = seconds / PER_MILLISECOND
+        def in_microseconds = seconds / PER_MICROSECOND
+        # For semantic purposes
+        def in_seconds      = seconds
+
+        # Time manipulation
+        def ago         = Time.now.utc - seconds
+        def from_now    = Time.now.utc + seconds
+        def before(time) = time - seconds
+        def after(time)  = time + seconds
+        def in_time = Time.at(seconds).utc
+
+        # Milliseconds conversion
+        def to_ms = seconds * 1000.0
+
+        # Converts seconds to specified time unit
+        #
+        # @param u [String, Symbol] Unit to convert to
+        # @return [Float] Converted time value
+        def in_seconds(u = nil)
+          return self unless u
+
+          case UNIT_METHODS.fetch(u.to_s.downcase, nil)
+          when :milliseconds then self * PER_MILLISECOND
+          when :microseconds then self * PER_MICROSECOND
+          when :minutes then self * PER_MINUTE
+          when :hours then self * PER_HOUR
+          when :days then self * PER_DAY
+          when :weeks then self * PER_WEEK
+          when :months then self * PER_MONTH
+          when :years then self * PER_YEAR
+          else self
+          end
+        end
+
+        # Converts the number to a human-readable string representation
+        #
+        # @return [String] A formatted string e.g. "1 day" or "10 seconds"
+        #
+        # @example
+        #   10.to_humanize #=> "10 seconds"
+        #   60.to_humanize #=> "1 minute"
+        #   3600.to_humanize #=> "1 hour"
+        #   86400.to_humanize #=> "1 day"
+        def humanize
+          gte_zero = positive? || zero?
+          duration = (gte_zero ? self : abs) # let's keep it positive up in here
+          text = case (s = duration.to_i)
+                in 0..59 then "#{s} second#{'s' if s != 1}"
+                in 60..3599 then "#{s /= 60} minute#{'s' if s != 1}"
+                in 3600..86_399 then "#{s /= 3600} hour#{'s' if s != 1}"
+                else "#{s /= 86_400} day#{'s' if s != 1}"
+                end
+          gte_zero ? text : "#{text} ago"
+        end
+
+        # Converts the number to a human-readable byte representation using binary units
+        #
+        # @return [String] A formatted string of bytes, KiB, MiB, GiB, or TiB
+        #
+        # @example
+        #   1024.to_bytes      #=> "1.00 KiB"
+        #   2_097_152.to_bytes #=> "2.00 MiB"
+        #   3_221_225_472.to_bytes #=> "3.00 GiB"
+        #
+        def to_bytes
+          units = %w[B KiB MiB GiB TiB]
+          size  = abs.to_f
+          unit  = 0
+
+          while size >= 1024 && unit < units.length - 1
+            size /= 1024
+            unit += 1
+          end
+
+          format('%3.2f %s', size, units[unit])
+        end
+
+        # Calculates age of timestamp in specified unit from reference time
+        #
+        # @param unit [String, Symbol] Time unit ('days', 'hours', 'minutes', 'weeks')
+        # @param from_time [Time, nil] Reference time (defaults to Time.now.utc)
+        # @return [Float] Age in specified unit
+        # @example
+        #   timestamp = 2.days.ago.to_i
+        #   timestamp.age_in(:days)         #=> ~2.0
+        #   timestamp.age_in('hours')       #=> ~48.0
+        #   timestamp.age_in(:days, 1.day.ago) #=> ~1.0
+        def age_in(unit, from_time = nil)
+          from_time ||= Time.now.utc
+          age_seconds = from_time.to_f - to_f
+          case UNIT_METHODS.fetch(unit.to_s.downcase, nil)
+          when :days then age_seconds / PER_DAY
+          when :hours then age_seconds / PER_HOUR
+          when :minutes then age_seconds / PER_MINUTE
+          when :weeks then age_seconds / PER_WEEK
+          when :months then age_seconds / PER_MONTH
+          when :years then age_seconds / PER_YEAR
+          else age_seconds
+          end
+        end
+
+        # Convenience methods for `age_in(unit)` calls.
+        #
+        # @param from_time [Time, nil] Reference time (defaults to Time.now.utc)
+        # @return [Float] Age in days
+        # @example
+        #   timestamp.days_old    #=> 2.5
+        def days_old(*) = age_in(:days, *)
+        def hours_old(*) = age_in(:hours, *)
+        def minutes_old(*) = age_in(:minutes, *)
+        def weeks_old(*) = age_in(:weeks, *)
+        def months_old(*) = age_in(:months, *)
+        def years_old(*) = age_in(:years, *)
+
+        # Checks if timestamp is older than specified duration in seconds
+        #
+        # @param duration [Numeric] Duration in seconds to compare against
+        # @return [Boolean] true if timestamp is older than duration
+        # @note Both older_than? and newer_than? can return false when timestamp
+        #   is within the same second. Use within? to check this case.
+        #
+        # @example
+        #   Time.now.older_than?(1.second)    #=> false
+        def older_than?(duration)
+          self < (Time.now.utc.to_f - duration)
+        end
+
+        # Checks if timestamp is newer than specified duration in the future
+        #
+        # @example
+        #   Time.now.newer_than?(1.second)    #=> false
+        def newer_than?(duration)
+          self > (Time.now.utc.to_f + duration)
+        end
+
+        # Checks if timestamp is within specified duration of now (past or future)
+        #
+        # @param duration [Numeric] Duration in seconds to compare against
+        # @return [Boolean] true if timestamp is within duration of now
+        # @example
+        #   30.minutes.ago.to_i.within?(1.hour)     #=> true
+        #   30.minutes.from_now.to_i.within?(1.hour) #=> true
+        #   2.hours.ago.to_i.within?(1.hour)        #=> false
+        def within?(duration)
+          (self - Time.now.utc.to_f).abs <= duration
+        end
+      end
+
+      refine ::String do
+        # Converts string time representation to seconds
+        #
+        # @example
+        #   "60m".in_seconds #=> 3600.0
+        #   "2.5h".in_seconds #=> 9000.0
+        #   "1y".in_seconds #=> 31536000.0
+        #
+        # @return [Float, nil] Time in seconds or nil if invalid
+        def in_seconds
+          q, u = scan(/([\d.]+)([a-zA-Zμs]+)?/).flatten
+          return nil unless q
+
+          q   = q.to_f
+          u ||= 's'
+          q.in_seconds(u)
+        end
+      end
+    end
+  end
+end