rom 5.4.2 → 6.0.0.alpha1

data/lib/rom/support/inflector.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+module ROM
+  module InflectorMethods
+    # ZeitwerkCompatibility
+    def camelize(name, *)
+      super(name)
+    end
+
+    # Default for inferring ids from class names or any string/symbol
+    def component_id(value)
+      name = (value.is_a?(Class) ? (value.name || value.superclass.name) : value).to_s
+      underscore(demodulize(name)).to_sym
+    end
+
+    # Default for inferring namespace from class names or any string/symbol
+    def namespace(value)
+      name = (value.is_a?(Class) ? (value.name || value.superclass.name) : value).to_s
+      pluralize(underscore(demodulize(name))).to_sym
+    end
+  end
+
+  Inflector = Dry::Inflector.new do |i|
+    i.plural(/people\z/i, "people")
+    i.plural(/schema\z/i, "schemas")
+  end
+
+  Inflector.extend(InflectorMethods)
+end

data/lib/rom/support/memoizable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ROM
+  # @api private
+  module Memoizable
+    MEMOIZED_HASH = {}.freeze
+
+    module ClassInterface
+      # @api private
+      def memoize(*names)
+        prepend(Memoizer.new(self, names))
+      end
+
+      def new(*)
+        obj = super
+        obj.instance_variable_set(:@__memoized__, MEMOIZED_HASH.dup)
+        obj
+      end
+      ruby2_keywords(:new) if respond_to?(:ruby2_keywords, true)
+    end
+
+    def self.included(klass)
+      super
+      klass.extend(ClassInterface)
+    end
+
+    attr_reader :__memoized__
+
+    # @api private
+    class Memoizer < Module
+      attr_reader :klass
+      attr_reader :names
+
+      # @api private
+      def initialize(klass, names)
+        @names = names
+        @klass = klass
+        define_memoizable_names!
+      end
+
+      private
+
+      # @api private
+      def define_memoizable_names!
+        names.each do |name|
+          meth = klass.instance_method(name)
+
+          if meth.parameters.empty?
+            define_method(name) do
+              __memoized__[name] ||= super()
+            end
+          else
+            define_method(name) do |*args|
+              __memoized__[:"#{name}_#{args.hash}"] ||= super(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/support/notifications.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+require "rom/constants"
+
+module ROM
+  # Notification subsystem
+  #
+  # This is an abstract event bus that implements a simple pub/sub protocol.
+  # The Notifications module is used in the setup process to decouple
+  # different modules from each other.
+  #
+  # @example
+  #   class Setup
+  #     extend ROM::Notifications
+  #
+  #     register_event('setup.before_setup')
+  #     register_event('setup.after_setup')
+  #
+  #     def initialize
+  #       @bus = Notifications.event_bus(:setup)
+  #     end
+  #
+  #     def setup
+  #       @bus.trigger('setup.before_setup', at: Time.now)
+  #       # ...
+  #       @bus.trigger('setup.after_setup', at: Time.now)
+  #     end
+  #   end
+  #
+  #   class Plugin
+  #     extend ROM::Notifications::Listener
+  #
+  #     subscribe('setup.after_setup') do |event|
+  #       puts "Loaded at #{event.at.iso8601}"
+  #     end
+  #   end
+  #
+  module Notifications
+    LISTENERS_HASH = Hash.new { |h, k| h[k] = [] }
+
+    # Extension used for classes that can trigger events
+    #
+    # @api public
+    module Publisher
+      # Subscribe to events.
+      # If the query parameter is provided, filters events by payload.
+      #
+      # @param [String] event_id The event key
+      # @param [Hash] query An optional event filter
+      # @yield [block] The callback
+      # @return [Object] self
+      #
+      # @api public
+      def subscribe(event_id, query = EMPTY_HASH, &block)
+        listeners[self] << [event_id, block, query]
+        self
+      end
+
+      # Trigger an event
+      #
+      # @param [String] event_id The event key
+      # @param [Hash] payload An optional payload
+      #
+      # @api public
+      def trigger(event_id, payload = EMPTY_HASH)
+        event = events[event_id]
+
+        event_listeners = listeners.values.flatten(1).group_by(&:first)
+
+        return unless event_listeners.key?(event_id)
+
+        event_listeners[event_id].each do |(_, listener, query)|
+          event.payload(payload).trigger(listener, query)
+        end
+      end
+    end
+
+    # Event object
+    #
+    # @api public
+    class Event
+      include Dry::Equalizer(:id, :payload)
+
+      # @!attribute [r] id
+      #   @return [Symbol] The event identifier
+      attr_reader :id
+
+      # Initialize a new event
+      #
+      # @param [Symbol] id The event identifier
+      # @param [Hash] payload Optional payload
+      #
+      # @return [Event]
+      #
+      # @api private
+      def initialize(id, payload = EMPTY_HASH)
+        @id = id
+        @payload = payload
+      end
+
+      # Get data from the payload
+      #
+      # @param [String,Symbol] name
+      #
+      # @api public
+      def [](name)
+        @payload.fetch(name)
+      end
+
+      # Coerce an event to a hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        @payload
+      end
+      alias_method :to_hash, :to_h
+
+      # Get or set a payload
+      #
+      # @overload
+      #   @return [Hash] payload
+      #
+      # @overload payload(data)
+      #   @param [Hash] data A new payload
+      #   @return [Event] A copy of the event with the provided payload
+      #
+      # @api public
+      def payload(data = nil)
+        if data
+          self.class.new(id, @payload.merge(data))
+        else
+          @payload
+        end
+      end
+
+      # Trigger the event
+      #
+      # @param [#call] listener
+      # @param [Hash] query
+      #
+      # @api private
+      def trigger(listener, query = EMPTY_HASH)
+        listener.(self) if trigger?(query)
+      end
+
+      # @api private
+      def trigger?(query)
+        query.empty? || query.all? { |key, value| @payload[key] == value }
+      end
+    end
+
+    extend Publisher
+
+    # Register an event
+    #
+    # @param [String] id A unique event key
+    # @param [Hash] info
+    #
+    # @api public
+    def register_event(id, info = EMPTY_HASH)
+      Notifications.events[id] = Event.new(id, info)
+    end
+
+    # @api private
+    def self.events
+      @__events__ ||= {}
+    end
+
+    # @api private
+    def self.listeners
+      @__listeners__ ||= LISTENERS_HASH.dup
+    end
+
+    # Build an event bus
+    #
+    # @param [Symbol] id Bus key
+    # @return [Notifications::EventBus] A new bus
+    #
+    # @api public
+    def self.event_bus(id)
+      EventBus.new(id, events: events.dup)
+    end
+
+    # Extension for objects that can listen to events
+    #
+    # @api public
+    module Listener
+      # Subscribe to events
+      #
+      # @param [String] event_id The event key
+      # @param [Hash] query An optional event filter
+      # @return [Object] self
+      #
+      # @api public
+      def subscribe(event_id, query = EMPTY_HASH, &block)
+        Notifications.listeners[self] << [event_id, block, query]
+      end
+    end
+
+    # Event bus
+    #
+    # An event bus stores listeners (callbacks) and events
+    #
+    # @api public
+    class EventBus
+      include Publisher
+
+      # @!attribute [r] id
+      #   @return [Symbol] The bus identifier
+      attr_reader :id
+
+      # @!attribute [r] events
+      #   @return [Hash] A hash with events registered within a bus
+      attr_reader :events
+
+      # @!attribute [r] listeners
+      #   @return [Hash] A hash with event listeners registered within a bus
+      attr_reader :listeners
+
+      # Initialize a new event bus
+      #
+      # @param [Symbol] id The bus identifier
+      # @param [Hash] events A hash with events
+      # @param [Hash] listeners A hash with listeners
+      #
+      # @api public
+      def initialize(id, events: EMPTY_HASH)
+        @id = id
+        @listeners = LISTENERS_HASH.dup
+        @events = events
+      end
+    end
+  end
+end

data/lib/rom/transaction.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ROM
+  # @api private
+  class Transaction
+    # @api private
+    Rollback = Class.new(StandardError)
+
+    # @api private
+    def run(**)
+      yield(self)
+    rescue Rollback
+      # noop
+    end
+
+    # Unconditionally roll back the current transaction
+    #
+    # @api public
+    def rollback!
+      raise Rollback
+    end
+
+    # @api private
+    NoOp = Transaction.new.freeze
+  end
+end

data/lib/rom/transformer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "dry/transformer"
+
+require "rom/plugins/class_methods"
+
+require_relative "components/provider"
+require_relative "processor/transformer"
+
+module ROM
+  # Transformer is a data mapper which uses `Dry::Transformer`'s DSL to define transformations.
+  #
+  # @api public
+  class Transformer < Dry::Transformer[Processor::Transformer::Functions]
+    extend ROM::Provider(type: :mapper)
+    extend Plugins::ClassMethods
+
+    # Define transformation pipeline
+    #
+    # @example
+    #   class UsersMapper < ROM::Transformer
+    #     map do
+    #       rename_keys user_id: :id
+    #       deep_stringify_keys
+    #     end
+    #   end
+    #
+    # @return [self]
+    #
+    # @api public
+    def self.map(&block)
+      define! do
+        map_array(&block)
+      end
+    end
+
+    # Build a mapper instance
+    #
+    # @return [Transformer]
+    #
+    # @api public
+    def self.build
+      new
+    end
+  end
+end

data/lib/rom/types.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "dry-types"
+require "json"
+
+module ROM
+  # Default namespace with built-in attribute types
+  #
+  # @api public
+  #
+  module Types
+    include Dry::Types(default: :nominal)
+
+    # @api private
+    def self.included(other)
+      other.extend(Methods)
+      super
+    end
+
+    # Type extensions
+    #
+    # @api public
+    module Methods
+      # Shortcut for defining a foreign key attribute type
+      #
+      # @param [Symbol] relation The name of the target relation
+      # @param [Object] type The type of an attribute
+      #
+      # @return [Dry::Types::Nominal]
+      #
+      # @api public
+      def ForeignKey(relation, type = Types::Integer)
+        type.meta(foreign_key: true, target: relation)
+      end
+    end
+
+    # @!parse module Coercible;end
+
+    # Define a json-to-hash attribute type
+    #
+    # @return [Dry::Types::Constructor]
+    #
+    # @api public
+    def Coercible.JSONHash(symbol_keys: false, type: Types::Hash)
+      Types.Constructor(type) do |value|
+        ::JSON.parse(value.to_s, symbolize_names: symbol_keys)
+      rescue ::JSON::ParserError
+        value
+      end
+    end
+
+    # Define a hash-to-json attribute type
+    #
+    # @return [Dry::Types::Constructor]
+    #
+    # @api public
+    def Coercible.HashJSON(type: Types::String)
+      Types.Constructor(type) { |value| ::JSON.dump(value) }
+    end
+
+    # Define a json type with json-to-hash read type
+    #
+    # @return [Dry::Types::Constructor]
+    #
+    # @api public
+    def Coercible.JSON(symbol_keys: false)
+      self.HashJSON.meta(read: self.JSONHash(symbol_keys: symbol_keys))
+    end
+
+    Coercible::JSON = Coercible.JSON
+    Coercible::JSONHash = Coercible.JSONHash
+    Coercible::HashJSON = Coercible.HashJSON
+  end
+end

data/lib/rom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ROM
-  VERSION = '5.4.2'
+  VERSION = "6.0.0.alpha1"
 end

data/lib/rom-changeset.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "rom/changeset"
+require "rom/plugins/relation/changeset"

data/lib/rom-core.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "rom/core"

data/lib/rom-repository.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "rom/core"
+require "rom/repository"

data/lib/rom.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require 'rom-core'
-require 'rom-repository'
-require 'rom-changeset'
+require "rom-core"
+require "rom-repository"
+require "rom-changeset"