Allow to configure custom inflector

Author: flash-gordon

lib/rom/associations/definitions/abstract.rb

@@ -7,6 +7,7 @@
 require "rom/initializer"
 require "rom/relation/name"
 require "rom/associations/through_identifier"
+require "rom/support/inflector"
 
 module ROM
   module Associations
@@ -94,7 +95,12 @@ def self.process_options(target, options)
           through = options[:through]
 
           if through
-            options[:through] = ThroughIdentifier[through, target.relation, options[:assoc]]
+            options[:through] = ThroughIdentifier[
+              through,
+              target.relation,
+              options[:assoc],
+              inflector: options.fetch(:inflector, Inflector)
+            ]
           end
 
           options[:name] = target.relation

lib/rom/associations/through_identifier.rb

@@ -16,13 +16,13 @@ class ThroughIdentifier
       attr_reader :assoc_name
 
       # @api private
-      def self.[](source, target, assoc_name = nil)
-        new(source, target, assoc_name || default_assoc_name(target))
+      def self.[](source, target, assoc_name = nil, inflector: Inflector)
+        new(source, target, assoc_name || default_assoc_name(target, inflector: inflector))
       end
 
       # @api private
-      def self.default_assoc_name(relation)
-        Inflector.singularize(relation).to_sym
+      def self.default_assoc_name(relation, inflector:)
+        inflector.singularize(relation).to_sym
       end
 
       # @api private

lib/rom/command_compiler.rb

@@ -66,6 +66,11 @@ def self.registry
     #   @return [Cache] local cache instance
     option :cache, default: -> { Cache.new }
 
+    # @!attribute [r] inflector
+    #   @return [Dry::Inflector] String inflector
+    #   @api private
+    option :inflector, default: -> { Inflector }
+
     # Return a specific command type for a given adapter and relation AST
     #
     # This class holds its own registry where all generated commands are being
@@ -102,7 +107,8 @@ def call(*args)
         command = ROM::Commands::Graph.build(registry, graph_opts)
 
         if command.graph?
-          CommandProxy.new(command)
+          root = inflector.singularize(command.name.relation).to_sym
+          CommandProxy.new(command, root)
         elsif command.lazy?
           command.unwrap
         else
@@ -114,7 +120,7 @@ def call(*args)
 
     # @api private
     def type
-      @_type ||= Commands.const_get(Inflector.classify(id))[adapter]
+      @_type ||= Commands.const_get(inflector.classify(id))[adapter]
     rescue NameError
       nil
     end
@@ -139,7 +145,7 @@ def visit_relation(node, parent_relation = nil)
           if meta[:combine_type] == :many
             name
           else
-            {Inflector.singularize(name).to_sym => name}
+            {inflector.singularize(name).to_sym => name}
           end
 
         mapping =
@@ -190,7 +196,7 @@ def visit_attribute(*_args)
     def register_command(rel_name, type, rel_meta, parent_relation = nil)
       relation = relations[rel_name]
 
-      type.create_class(rel_name, type) do |klass|
+      type.create_class(rel_name, type, inflector: inflector) do |klass|
         klass.result(rel_meta.fetch(:combine_type, result))
 
         meta.each do |name, value|
@@ -237,7 +243,7 @@ def setup_associates(klass, relation, _meta, parent_relation)
         if relation.associations.key?(parent_relation)
           parent_relation
         else
-          singular_name = Inflector.singularize(parent_relation).to_sym
+          singular_name = inflector.singularize(parent_relation).to_sym
           singular_name if relation.associations.key?(singular_name)
         end
 

lib/rom/command_proxy.rb

@@ -8,10 +8,12 @@ module ROM
   #
   # @api private
   class CommandProxy
-    attr_reader :command, :root
+    attr_reader :command
+
+    attr_reader :root
 
     # @api private
-    def initialize(command, root = Inflector.singularize(command.name.relation).to_sym)
+    def initialize(command, root)
       @command = command
       @root = root
     end
@@ -23,7 +25,7 @@ def call(input)
 
     # @api private
     def >>(other)
-      self.class.new(command >> other)
+      self.class.new(command >> other, root)
     end
 
     # @api private

lib/rom/commands/class_interface.rb

@@ -85,9 +85,9 @@ def build(relation, **options)
       # @return [Class, Object]
       #
       # @api public
-      def create_class(name, type, &block)
+      def create_class(name, type, inflector: Inflector, &block)
         klass = Dry::Core::ClassBuilder
-          .new(name: "#{Inflector.classify(type)}[:#{name}]", parent: type)
+          .new(name: "#{inflector.classify(type)}[:#{name}]", parent: type)
           .call
 
         if block

lib/rom/configuration.rb

@@ -6,6 +6,7 @@
 require "rom/setup"
 require "rom/configuration_dsl"
 require "rom/support/notifications"
+require "rom/support/inflector"
 
 module ROM
   class Configuration
@@ -38,7 +39,7 @@ class Configuration
 
     def_delegators :@setup, :register_relation, :register_command, :register_mapper, :register_plugin,
                    :command_classes, :mapper_classes,
-                   :auto_registration
+                   :auto_registration, :inflector, :inflector=
 
     def_delegators :@environment, :gateways, :gateways_map, :configure, :config
 

lib/rom/configuration_dsl/command.rb

@@ -16,10 +16,11 @@ class Command
       # @api private
       def self.build_class(name, relation, options = EMPTY_HASH, &block)
         type = options.fetch(:type) { name }
-        command_type = Inflector.classify(type)
+        inflector = options.fetch(:inflector) { Inflector }
+        command_type = inflector.classify(type)
         adapter = options.fetch(:adapter)
         parent = ROM::Command.adapter_namespace(adapter).const_get(command_type)
-        class_name = generate_class_name(adapter, command_type, relation)
+        class_name = generate_class_name(adapter, command_type, relation, inflector)
 
         Dry::Core::ClassBuilder.new(name: class_name, parent: parent).call do |klass|
           klass.register_as(name)
@@ -31,11 +32,11 @@ def self.build_class(name, relation, options = EMPTY_HASH, &block)
       # Create a command subclass name based on adapter, type and relation
       #
       # @api private
-      def self.generate_class_name(adapter, command_type, relation)
+      def self.generate_class_name(adapter, command_type, relation, inflector)
         pieces = ["ROM"]
-        pieces << Inflector.classify(adapter)
+        pieces << inflector.classify(adapter)
         pieces << "Commands"
-        pieces << "#{command_type}[#{Inflector.classify(relation)}s]"
+        pieces << "#{command_type}[#{inflector.classify(relation)}s]"
         pieces.join("::")
       end
     end

lib/rom/configuration_dsl/relation.rb

@@ -15,7 +15,8 @@ class Relation
       #
       # @api private
       def self.build_class(name, options = EMPTY_HASH)
-        class_name = "ROM::Relation[#{Inflector.camelize(name)}]"
+        inflector = options.fetch(:inflector) { Inflector }
+        class_name = "ROM::Relation[#{inflector.camelize(name)}]"
         adapter = options.fetch(:adapter)
 
         Dry::Core::ClassBuilder.new(name: class_name, parent: ROM::Relation[adapter]).call do |klass|

lib/rom/create_container.rb

@@ -34,7 +34,8 @@ def finalize(environment, setup)
         mappers: setup.mapper_classes,
         plugins: setup.plugins,
         notifications: setup.notifications,
-        config: environment.config.dup.freeze
+        config: environment.config.dup.freeze,
+        inflector: setup.inflector
       )
 
       finalize.run!

lib/rom/relation.rb

@@ -6,6 +6,7 @@
 require "rom/constants"
 require "rom/initializer"
 require "rom/support/memoizable"
+require "rom/support/inflector"
 
 require "rom/relation/class_interface"
 
@@ -136,17 +137,26 @@ class Relation
     #   @api public
     param :dataset
 
+    # @!attribute [r] inflector
+    #   @return [Dry::Inflector] String inflector
+    #   @api private
+    option :inflector, reader: true, default: -> { Inflector }
+
     # @!attribute [r] schema
     #   @return [Schema] relation schema, defaults to class-level canonical
     #                    schema (if it was defined) and sets an empty one as
     #                    the fallback
     #   @api public
-    option :schema, default: -> { self.class.schema || self.class.default_schema }
+    option :schema, default: -> {
+      self.class.schema || self.class.default_schema(inflector: inflector)
+    }
 
     # @!attribute [r] name
     #   @return [Object] The relation name
     #   @api public
-    option :name, default: -> { self.class.schema ? self.class.schema.name : self.class.default_name }
+    option :name, default: -> {
+      self.class.schema ? self.class.schema.name : self.class.default_name(inflector)
+    }
 
     # @!attribute [r] input_schema
     #   @return [Object#[]] tuple processing function, uses schema or defaults to Hash[]
@@ -596,7 +606,7 @@ def foreign_key(name)
       if attr
         attr.name
       else
-        :"#{Inflector.singularize(name.dataset)}_id"
+        :"#{inflector.singularize(name.dataset)}_id"
       end
     end