roda-endpoints 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5d5c0b50d6405cc257a76d098dd673351ade2d4
-  data.tar.gz: 432c3139a367f1907a69c6310bb8188015bb247c
+  metadata.gz: aecfae0fdfb0156f3821d1273697d8ec24b698f6
+  data.tar.gz: 8218ec6e8c89ab3a3967b23f14148a14e3098fcc
 SHA512:
-  metadata.gz: ed59766efaca29ac760dc05cab86b6e979878db4895a1142803fd00e6ef022e925b9b0190208a83d722d2159aa906ef0120b26a77711cd7314e5a9d2049369d2
-  data.tar.gz: 29c953dea3afb2f38a06505bf3d7d54c616fb56387b8f821fcb97078e7f6f06e4641e8184062d41b8aed0acd934a799422ae3fe2a7bcdf4e4092d4e0d3f5a3e9
+  metadata.gz: 5d247edfad454ac8b11e196bbb1f88b91c663ea881a4241af55edb079c2f8cd9dfced72fea2f9a1cafd2ad8750b3e0d78a13b993aee7448ae29fbe7beea8e92c
+  data.tar.gz: a7055fce9bc21bf0bd3d5054cd6d218029c1cfba764b48ee06c0e80243f84603a256ae08202345115bcbd32ed9d2c044c930c5fae347cd38f56dfef565cad153

data/lib/roda/endpoints/endpoint/class_interface.rb

@@ -37,6 +37,15 @@ class Roda
           child.defaults = defaults.dup
           child.statuses = statuses.dup
           child.verbs = verbs.dup
+          # child.verbs.each do |verb|
+          #  key = "operations.#{child.type}.#{verb}"
+          #  implementation = "operations.#{type}.#{verb}"
+          #  container.register key do
+          #    Endpoints.container.resolve implementation
+          #  end
+          # end
+          child.transactions = transactions.dup
+          child.route(&@route_block)
           super
         end
 
@@ -49,10 +58,12 @@ class Roda
           @type ||= Inflecto.underscore(Inflecto.demodulize(name)).to_sym
         end
 
-        # @param [Symbol] name
+        # @param [Symbol] verb
         # @param [Proc] block
         # @return [Symbol] name of the defined method
-        def verb(name, rescue_from: [], &block)
+        def verb(verb, rescue_from: [], &block)
+          self.verbs ||= superclass.verbs
+          (self.verbs += [verb]).freeze
           rescue_from = Array(rescue_from).flatten
           if rescue_from.any?
             block = proc do |*args|
@@ -63,10 +74,8 @@ class Roda
               end
             end
           end
-          define_method(name, &block)
-          container.register "operations.#{type}.#{name}", block
-          self.verbs ||= superclass.verbs
-          (self.verbs += [name]).freeze
+          define_method(verb, &block)
+          container.register "operations.#{type}.#{verb}", block
         end
 
         # @param [String, Symbol] key
@@ -117,6 +126,8 @@ class Roda
         def transactions
           @transactions ||= []
         end
+
+        attr_writer :transactions
       end
     end
   end

data/lib/roda/endpoints/endpoint/collection.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'roda/endpoints/endpoint'
 require 'roda/endpoints/endpoint/data'
 require 'roda/endpoints/endpoint/caching'
+require 'roda/endpoints/endpoint'
 require 'inflecto'
 require 'rom/sql'
 
@@ -10,13 +10,12 @@ class Roda
   module Endpoints
     class Endpoint
       # HTTP endpoint representing a collection of items of the same type.
-      class Collection < Endpoint
-        include Data
+      class Collection < Roda::Endpoints::Endpoint
+        prepend Data
         prepend Caching
 
         self.attributes += %i(item)
         self.defaults = defaults.merge(
-          type: :collection,
           last_modified: :last_modified
         )
 
@@ -28,28 +27,28 @@ class Roda
           @last_modified ? repository.public_send(@last_modified) : super
         end
 
-        def child(**params)
-          with(
-            type: Item,
-            name: resource_name,
-            **params
-          )
+        # @param [Symbol] name
+        # @param [Hash] params
+        def child(name: item_name, type: Item, **params)
+          super(name: name, type: type, **params)
         end
 
         # @return [Symbol]
-        def resource_name
-          Inflecto.singularize(name).to_sym
+        def item_name
+          @item_name ||= Inflecto.singularize(name).to_sym
         end
 
+        # @route /{collection.name}
         route do |r, endpoint| # r.collection :articles do |articles|
           r.last_modified endpoint.last_modified if endpoint.last_modified
 
           endpoint.verbs.each do |verb|
-            # @route #{verb} /:name
+            # @route #{verb} /{collection.name}
             r.public_send(verb, transaction: verb)
-
-            r.child **endpoint.item if endpoint.item # child by: :id
           end
+
+          # @route #{verb} /{collection.name}/{id}
+          r.child **endpoint.item if endpoint.item # child by: :id
         end
 
         verb :get do |params|
@@ -57,7 +56,7 @@ class Roda
         end
 
         verb :post do |params|
-          params = params[resource_name] || {}
+          params = params[item_name] || {}
           Right(repository.create(**params))
         end
 

data/lib/roda/endpoints/endpoint/data.rb

@@ -14,6 +14,9 @@ class Roda
           super(name: name, **attributes)
         end
 
+        # @return [String]
+        attr_reader :repository_key
+
         # @return [ROM::Repository]
         def repository
           container[@repository_key] if @repository_key

data/lib/roda/endpoints/endpoint/item.rb

@@ -1,116 +1,35 @@
 # frozen_string_literal: true
 
-require 'roda/endpoints/endpoint'
+require 'roda/endpoints/endpoint/singleton'
 require 'roda/endpoints/endpoint/data'
-require 'roda/endpoints/endpoint/caching'
 
 class Roda
   module Endpoints
     class Endpoint
       # HTTP endpoint representing a specific item of collection uniquely
       # identified by some parameter.
-      class Item < Endpoint
-        include Data
-        include Caching
+      class Item < Singleton
+        prepend Data
 
-        self.attributes += %i(id by finder last_modified)
+        self.attributes += %i(id by on)
         self.defaults = defaults.merge(
           by: :fetch,
-          finder: lambda do
-            repository.public_send(by, id)
-          end,
-          last_modified: :updated_at
+          on: :id,
+          finder: -> { repository.public_send(by, id) }
         )
 
         # @return [Symbol]
         attr_reader :by
 
-        # @return [Symbol]
-        attr_reader :id
-
-        # @return [Symbol]
-        attr_reader :finder
+        # @return [Integer]
+        def id
+          captures.first
+        end
 
         # @return [Endpoint::Collection]
         def collection
           parent
         end
-
-        # @return [ROM::Struct]
-        def entity
-          @entity ||= fetch_entity
-        end
-
-        def fetch_entity
-          instance_exec(&finder)
-        end
-
-        def last_modified
-          @last_modified ? entity.public_send(@last_modified) : super
-        end
-
-        route do |r, endpoint|
-          endpoint.verbs.each do |verb|
-            # @route #{verb} /{collection.name}/{id}
-            # STDOUT.puts [verb].pretty_inspect
-            r.public_send(verb, transaction: verb)
-          end
-        end
-
-        transaction :get do |endpoint|
-          step :retrieve, with: endpoint.operation_for(:get)
-        end
-
-        transaction :patch do |endpoint|
-          step :validate, with: endpoint.validation_for(:patch)
-          step :persist, with: endpoint.operation_for(:patch)
-        end
-
-        transaction :put do |endpoint|
-          step :validate, with: endpoint.validation_for(:put)
-          # step :reset, with: 'endpoints.operations.reset'
-          step :persist, with: endpoint.operation_for(:put)
-        end
-
-        transaction :delete do |endpoint|
-          step :validate, with: endpoint.validation_for(:delete)
-          step :persist, with: endpoint.operation_for(:delete)
-        end
-
-        # @route GET /{collection.name}/{id}
-        # @param [Hash] params
-        # @return [Dry::Monads::Either]
-        verb :get do |_params|
-          Right(entity)
-        end
-
-        # @route PATCH /{collection.name}/{id}
-        # @return [Dry::Monads::Either]
-        verb :patch do |params|
-          changeset = params[name]
-          Right(repository.update(id, changeset))
-        end
-
-        # @route PUT /{collection.name}/{id}
-        # @return [Dry::Monads::Either]
-        verb :put do |params|
-          changeset = entity.to_hash.keys.each_with_object(
-            {}
-          ) do |key, changeset|
-            changeset[key] = nil
-          end.merge(params[name] || {})
-          Right(repository.update(id, changeset))
-        end
-
-        # @route DELETE /{collection.name}/{id}
-        # @return [Dry::Monads::Either]
-        verb :delete do |_params|
-          if (result = repository.delete(id))
-            Right(nil)
-          else
-            Left(result)
-          end
-        end
       end
     end
   end

data/lib/roda/endpoints/endpoint/lookup.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'roda/endpoints/endpoint/namespace'
+
+class Roda
+  module Endpoints
+    class Endpoint
+      # Lookup everything in the container.
+      module Lookup
+        prepend Namespace
+
+        # @return [Dry::Container::Mixin]
+        def container
+          @container || parent&.container || Roda::Endpoints.roda_class
+        end
+
+        # @param [<String>] paths
+        def lookup(*paths, key: nil, scope: nil, default: nil)
+          if key && scope
+            paths += lookup_keys(key: key, scope: scope, default: default)
+          end
+          paths.flatten.detect { |full_key| container.key?(full_key) }
+        end
+
+        # @param [#to_s] key
+        # @param [#to_s] scope
+        def lookup_keys(key:, scope: nil, default: nil, lookup: lookup_path)
+          scope = "#{scope}." unless scope.to_s.end_with?('.')
+          keys = []
+          Array(key).flatten.map do |sect|
+            lookup.each do |choice|
+              [sect, default].compact.each do |value|
+                full_key = "#{scope}#{choice}.#{value}"
+                yield full_key if block_given?
+                keys << full_key
+              end
+            end
+          end
+          keys
+        end
+
+        def lookup_path
+          path = [ns]
+          endpoint = self.class
+          while endpoint < Roda::Endpoints::Endpoint
+            path << endpoint.type
+            endpoint = endpoint.superclass
+          end
+          path
+        end
+
+        # @param [Symbol] verb
+        # @return [String]
+        def operation_for(verb)
+          lookup key: verb, scope: 'operations.'
+        end
+
+        # @param [Symbol] verb
+        # @return [String]
+        def validation_for(verb)
+          lookup(key: verb, default: 'any', scope: 'validations.') ||
+            provide_default_validation!
+        end
+
+        # @param [Symbol] verb
+        # @return [String]
+        def transaction_for(verb)
+          lookup key: verb, scope: 'transactions'
+        end
+      end
+    end
+  end
+end

data/lib/roda/endpoints/endpoint/namespace.rb

@@ -19,7 +19,7 @@ class Roda
           @ns = ns
           unless parent == Undefined
             @parent = parent
-            @ns = "#{parent.ns}.#{ns}"
+            @ns = [parent.ns, ns].compact.join('.')
           end
           super(name: name, **attributes)
         end
@@ -32,16 +32,6 @@ class Roda
 
         # @return [Endpoint]
         attr_reader :parent
-
-        # @return [ROM::Repository]
-        def repository
-          container[@repository_key] if @repository_key
-        end
-
-        # @return [{Symbol=>Object}]
-        def to_hash
-          super.merge(repository: @repository_key)
-        end
       end
     end
   end

data/lib/roda/endpoints/endpoint/singleton.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'roda/endpoints/endpoint'
+require 'roda/endpoints/endpoint/data'
+require 'roda/endpoints/endpoint/caching'
+
+class Roda
+  module Endpoints
+    class Endpoint
+      # HTTP endpoint representing a specific item of collection uniquely
+      # identified by some parameter.
+      class Singleton < Roda::Endpoints::Endpoint
+        prepend Caching
+
+        self.attributes += %i(finder last_modified)
+        self.defaults = defaults.merge(last_modified: :updated_at)
+
+        # @return [Symbol]
+        attr_reader :finder
+
+        # @return [ROM::Struct]
+        def entity
+          @entity ||= fetch_entity
+        end
+
+        attr_writer :entity
+
+        # @return [ROM::Struct]
+        def fetch_entity
+          instance_exec(&finder)
+        end
+
+        # @return [Time]
+        def last_modified
+          @last_modified ? entity.public_send(@last_modified) : super
+        end
+
+        route do |r, endpoint|
+          endpoint.verbs.each do |verb|
+            # @route #{verb} /{collection.name}/{id}
+            r.public_send(verb, transaction: verb)
+          end
+        end
+
+        transaction :get do |endpoint|
+          step :retrieve, with: endpoint.operation_for(:get)
+        end
+
+        transaction :patch do |endpoint|
+          step :validate, with: endpoint.validation_for(:patch)
+          step :persist, with: endpoint.operation_for(:patch)
+        end
+
+        transaction :put do |endpoint|
+          step :validate, with: endpoint.validation_for(:put)
+          # step :reset, with: 'endpoints.operations.reset'
+          step :persist, with: endpoint.operation_for(:put)
+        end
+
+        transaction :delete do |endpoint|
+          step :validate, with: endpoint.validation_for(:delete)
+          step :persist, with: endpoint.operation_for(:delete)
+        end
+
+        # @route GET /{collection.name}/{id}
+        # @!method get(params)
+        #   @param [Hash] params
+        #   @return [Dry::Monads::Either]
+        verb :get do |_params|
+          Right(entity)
+        end
+
+        # @route PATCH /{collection.name}/{id}
+        # @!method patch(params)
+        #   @param [Hash] params
+        #   @return [Dry::Monads::Either]
+        verb :patch do |params|
+          changeset = params[name]
+          Right(repository.update(id, changeset))
+        end
+
+        # @route PUT /{collection.name}/{id}
+        # @!method put(params)
+        #   @param [Hash] params
+        #   @return [Dry::Monads::Either]
+        verb :put do |params|
+          changeset = entity.to_hash.keys.each_with_object({}) do |key, changes|
+            changes[key] = nil
+          end.merge(params[name] || {})
+          Right(repository.update(id, changeset))
+        end
+
+        # @route DELETE /{collection.name}/{id}
+        # @!method delete(params)
+        #   @param [Hash] params
+        #   @return [Dry::Monads::Either]
+        verb :delete do |_params|
+          if (result = repository.delete(id))
+            Right(nil)
+          else
+            Left(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/endpoints/endpoint/transactions.rb

@@ -23,15 +23,6 @@ class Roda
           @transactions
         end
 
-        # @param [Symbol] verb
-        # @return [String]
-        def transaction_for(verb)
-          %W(
-            transactions.#{ns}.#{verb}
-            transactions.#{type}.#{verb}
-          ).detect { |key| container.key?(key) }
-        end
-
         # @param [Symbol, String] name
         # @param [Proc] block
         def step(name, only: [], **kwargs, &block)

data/lib/roda/endpoints/endpoint/validations.rb

@@ -12,13 +12,12 @@ class Roda
       module Validations
         include Functions::Shortcut
 
-        # @param [Class] child
-        def self.included(child)
-          child.defaults = child.defaults.merge(validation: 'validation').freeze
-          super
+        def defaults(verb = :any, **attributes)
+          key = "validations.defaults.#{ns}.#{verb}" if key.is_a?(Symbol)
+          container.register key, attributes
         end
 
-        # @param [String, Symbol] key
+        # @param [String, Symbol] verb
         # @param [Proc] block
         #
         # @example
@@ -36,11 +35,11 @@ class Roda
         #       require(:confirm_changes).
         #     end
         #   end
-        def validate(key = :default, &block)
-          defaults = "validations.defaults.#{ns}.#{key}"
-          key = "validations.#{ns}.#{key}"
+        def validate(verb = :any, &block)
+          defaults = "validations.defaults.#{ns}.#{verb}"
+          verb = "validations.#{ns}.#{verb}"
           schema = Dry::Validation.Form(&block)
-          container.register(key) do |params|
+          container.register(verb) do |params|
             if container.key?(defaults)
               params = f(:deep_merge).call(params, container[defaults])
             end
@@ -56,11 +55,6 @@ class Roda
 
         # rubocop:enable Metrics/MethodLength
 
-        def defaults(verb = :default, **attributes)
-          key = "validations.defaults.#{ns}.#{verb}" if key.is_a?(Symbol)
-          container.register key, attributes
-        end
-
         # @param [Symbol] verb
         # @return [Dry::Validation::Schema::Form]
         def validation(verb)
@@ -73,24 +67,19 @@ class Roda
         end
 
         def provide_default_validation!
-          validate {} unless container.key?("validations.#{ns}.default")
+          validate {} unless container.key?("validations.#{ns}.any")
         end
 
-        # @param [Symbol] verb
-        # @return [String]
-        def validation_for(verb)
-          validation = %W(
-            validations.#{ns}.#{verb}
-            validations.#{ns}.default
-          ).detect do |key|
-            container.key?(key)
+        def prepare_validations!
+          return if @validations_prepared
+          (verbs - %i(get head options)).each do |verb|
+            key = "validations.#{ns}.#{verb}"
+            default = "validations.#{ns}.any"
+            unless container.key?(key) || container.key?(default)
+              provide_default_validation!
+            end
           end
-          validation = provide_default_validation! unless validation
-          validation
-        end
-
-        def validate!(verb, params)
-          validation(verb).call(params)
+          @validations_prepared = true
         end
       end
     end

data/lib/roda/endpoints/endpoint/verbs.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 class Roda
   module Endpoints
     # Generic HTTP endpoint abstraction.
     class Endpoint
       # Accessing data inside of endpoint.
       module Verbs
-        extend Forwardable
-
-        # @param [<Symbol>] only
-        # @param [<Symbol>] except
         # @param attributes [{Symbol=>Object}]
-        def initialize(only: implemented_verbs, except: [], **attributes)
+        def initialize(**attributes)
+          @verbs = verbs_to_implement(**attributes)
+          super(**attributes)
+        end
+
+        # @param only [<Symbol>]
+        # @param except [<Symbol>]
+        def verbs_to_implement(only: implemented_verbs, except: [], **_kwargs)
           only = Array(only).flatten
           except = Array(except).flatten
           if ((unknown_only = only - implemented_verbs) +
@@ -21,8 +22,7 @@ class Roda
             params = { only: unknown_only, except: unknown_except }
             raise ArgumentError, "unknown verbs in params: #{params}"
           end
-          @verbs = only - except
-          super(**attributes)
+          only - except
         end
 
         # @return [<Symbol>]
@@ -33,12 +33,28 @@ class Roda
         # @return [<Symbol>]
         attr_reader :verbs
 
-        def verb(name, **kwargs, &block)
-          key = "operations.#{ns}.#{name}"
-          container.register key, &block
-          singleton_class.verb(name, **kwargs, &container[key])
+        # @param [#to_s] verb
+        # @param [Hash] kwargs
+        # @param [Proc] block
+        def verb(verb, **kwargs, &block)
+          key = "operations.#{ns}.#{verb}"
+          block ||= container[key]
+          singleton_class.verb(verb, **kwargs, &block)
+        end
+
+        def prepare_verbs!
+          return if @verbs_prepared
+          verbs.each do |verb|
+            key = "operations.#{ns}.#{verb}"
+            next if container.key?(key)
+            endpoint = self
+            operation = method(verb)
+            container.register key do |*args|
+              endpoint.instance_exec(*args, &operation)
+            end
+          end
+          @verbs_prepared = true
         end
-        def_delegator :singleton_class, :verb
       end
     end
   end

data/lib/roda/endpoints/endpoint.rb

@@ -2,8 +2,8 @@
 
 require 'roda/endpoints'
 require 'roda/endpoints/endpoint/class_interface'
+require 'roda/endpoints/endpoint/lookup'
 require 'roda/endpoints/endpoint/namespace'
-require 'roda/endpoints/endpoint/operations'
 require 'roda/endpoints/endpoint/transactions'
 require 'roda/endpoints/endpoint/validations'
 require 'roda/endpoints/endpoint/verbs'
@@ -18,6 +18,7 @@ class Roda
 
       autoload :Collection, 'roda/endpoints/endpoint/collection'
       autoload :Item, 'roda/endpoints/endpoint/item'
+      autoload :Singleton, 'roda/endpoints/endpoint/singleton'
 
       self.attributes = %i(container type).freeze
       self.defaults = EMPTY_HASH
@@ -42,33 +43,37 @@ class Roda
       prepend Namespace
       prepend Verbs
       prepend Validations
-      prepend Operations
       include Transactions
+      prepend Lookup
 
-      # @return [Dry::Container::Mixin]
-      def container
-        @container || parent&.container
-      end
+      attr_accessor :captures
 
       # @return [Symbol]
-      attr_reader :type
+      def type
+        self.class.type
+      end
 
-      # @param [{Symbol=>Object}] attributes
-      # @param [:collection, :item] type
-      # @param [{Symbol=>Object}] attributes
+      # @param type [:collection, :item]
+      # @param attributes [{Symbol=>Object}]
       def with(type: self.class, **attributes)
         type.new to_hash.merge(attributes).merge(inheritable_attributes)
       end
 
+      # @param [Class(Endpoint)] type
+      # @param [Hash] params
+      def child(type: Singleton, **params)
+        with(type: type, **params)
+      end
+
+      # @return [{Symbol=>Object}]
       def inheritable_attributes
-        {
-          parent: self,
-          container: container
-        }
+        { parent: self, container: container }
       end
 
       # @return [Proc]
       def route
+        prepare_validations!
+        prepare_verbs!
         self.class.route
       end
 

data/lib/roda/endpoints/transactions.rb

@@ -7,8 +7,7 @@ require 'forwardable'
 
 class Roda
   module Endpoints
-    # The DSL for defining {Transactions transactions} used inside of
-    # The {Platform}.
+    # The DSL for defining {Transactions transactions} for endpoints.
     class Transactions
       extend Dry::Configurable
       extend Forwardable

data/lib/roda/endpoints/version.rb

@@ -2,6 +2,6 @@
 
 class Roda
   module Endpoints
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/roda/endpoints.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'roda/endpoints/version'
 require 'dry/core/constants'
+require 'dry/container'
 
 class Roda
   # Endpoints abstractions
@@ -15,6 +16,10 @@ class Roda
     def self.container
       @container ||= Dry::Container.new
     end
+
+    class << self
+      attr_accessor :roda_class
+    end
   end
 end
 

data/lib/roda/plugins/endpoints.rb

@@ -11,7 +11,7 @@ class Roda
     # Endpoints plugin for {Roda}
     module Endpoints
       # @param [Class(Roda)] app
-      def self.load_dependencies(app)
+      def self.load_dependencies(app, **_opts)
         app.plugin :all_verbs
         app.plugin :head
         app.plugin :caching
@@ -22,19 +22,49 @@ class Roda
         app.plugin :json_parser
         app.plugin :indifferent_params
         app.plugin :json, classes: [Array, Hash, ROM::Struct]
-        return if app.respond_to?(:[])
-        require 'dry-container'
-        app.extend Dry::Container::Mixin
         app.plugin :flow
       end
 
+      # @param [Class(Roda)] app
+      # @param [Hash] opts
+      def self.configure(app, container: app, **opts)
+        opts = (app.opts[:endpoints] || {}).merge(opts)
+        unless container.respond_to? :resolve
+          require 'dry-container'
+          container.extend Dry::Container::Mixin
+        end
+        app.opts[:endpoints] = opts.merge(container: container)
+        Roda::Endpoints.roda_class ||= app
+      end
+
+      # {ClassMethods#register `Roda.register`} &&
+      # {ClassMethods#merge `Roda.merge`}
+      module ClassMethods
+        # @param [String, Symbol] name
+        # @param [Array] args
+        # @param [Proc] block
+        def register(name, *args, &block)
+          opts[:container].register(name, *args, &block)
+        end
+
+        # @param [String, Symbol] name
+        # @param [Array] args
+        # @param [Proc] block
+        def merge(name, *args, &block)
+          opts[:container].merge(name, *args, &block)
+        end
+      end
+
       # `Roda::RodaRequest` instant extensions.
+      # rubocop:disable Metrics/ModuleLength
       module RequestMethods
         # Implements collection endpoint using given args
         #
         # @param name [Symbol]
         # @param item [{Symbol=>Object}]
         # @param kwargs [{Symbol=>Object}]
+        # @param type [Class(Roda::Endpoints::Endpoint::Collection)]
+        # @param on [String, Symbol]
         # @param (see Endpoint::Collection#initialize)
         # @see Endpoint::Collection.defaults
         # @yieldparam endpoint [Collection]
@@ -64,31 +94,28 @@ class Roda
         #
         #     r.child :id, only: %i(get delete)
         #   end
-        def collection(name, item: { by: :id }, path: name, **kwargs)
-          endpoint = Roda::Endpoints::Endpoint::Collection.new(
-            name: name,
-            container: roda_class,
-            item: item,
-            **kwargs
-          )
-          endpoints.push endpoint
-          on path.to_s do
-            # @route /:name
+        def collection(name,
+                       item: { on: :id },
+                       type: Roda::Endpoints::Endpoint::Collection,
+                       on: name.to_s,
+                       **kwargs)
+          endpoint name: name,
+                   item: item,
+                   type: type,
+                   on: on,
+                   **kwargs do |endpoint|
             yield endpoint if block_given?
-            instance_exec(self, endpoint, &endpoint.route)
           end
-          endpoints.pop #=> endpoint
         end
 
         # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-        # @param [Symbol] by
-        # @param [Endpoint::Collection] collection
-        # @param [Hash] kwargs
+        # @param on [Symbol]
+        # @param kwargs [Hash]
         #
         # @example
         #   r.collection :articles do |articles|
-        #     r.child :id
+        #     r.item :id
         #   end
         #
         #   # is equivalent to
@@ -105,24 +132,75 @@ class Roda
         #       end
         #     end
         #   end
-        def child(by: :id, collection: endpoint, **kwargs)
+        def item(on: :id,
+                 type: Roda::Endpoints::Endpoint::Item,
+                 **kwargs)
+          unless current_endpoint.is_a?(Roda::Endpoints::Endpoint::Collection)
+            raise ArgumentError,
+                  "#{self.class}#item called not within a collection endpoint"
+          end
           # @route /{collection.name}/{id}
-          on by do |identifier|
-            item = collection.child(id: identifier, identifier: by, **kwargs)
-            endpoints.push item
-            yield item if block_given?
-            instance_exec(self, item, &item.route)
-            endpoints.pop
+          endpoint(
+            on: on,
+            name: current_endpoint.item_name,
+            type: type,
+            **kwargs
+          ) do |endpoint|
+            yield endpoint if block_given?
+          end
+        end
+
+        # @overload singleton(name, entity, type:, **kwargs)
+        # @overload singleton(name:, entity:, type:, **kwargs)
+        def singleton(*args,
+                      name: args.first,
+                      entity: args.last,
+                      type: Roda::Endpoints::Endpoint::Singleton,
+                      **kwargs)
+          endpoint(
+            name: name,
+            entity: entity,
+            type: type,
+            **kwargs
+          ) do |endpoint|
+            yield endpoint if block_given?
           end
         end
 
         private
 
+        # @param [Class(Roda::Endpoints::Endpoint::Singleton)] type
+        # @param [Dry::Container::Mixin, #register, #resolve, #merge] container
+        # @param [Roda::Endpoints::Endpoint] parent
+        # @param [Hash] kwargs
+        # rubocop:disable Metrics/ParameterLists
+        def endpoint(name:,
+                     type:,
+                     container: roda_class.opts[:endpoints][:container],
+                     parent: current_endpoint,
+                     on: name,
+                     **kwargs)
+          on on do |*captures|
+            with_current_endpoint parent.child(
+              name: name,
+              type: type,
+              container: container,
+              parent: parent,
+              on: on,
+              captures: captures,
+              **kwargs
+            ) do |endpoint|
+              yield endpoint if block_given?
+              instance_exec(self, endpoint, &endpoint.route)
+            end
+          end
+        end
+
         # @param [Symbol] verb
         def match_transaction(verb)
-          resolve endpoint.transactions.key_for(verb) do |transaction|
+          resolve current_endpoint.transactions.key_for(verb) do |transaction|
             transaction.call(params) do |m|
-              statuses = endpoint.class.statuses[verb]
+              statuses = current_endpoint.class.statuses[verb]
 
               m.success do |result|
                 response.status = statuses[:success]
@@ -143,17 +221,26 @@ class Roda
         end
 
         # @return [Endpoint]
-        def endpoint
+        def current_endpoint
           endpoints.last
         end
 
         # @return [<Endpoint>]
         def endpoints
           @endpoints ||= [Roda::Endpoints::Endpoint.new(
-            name: :root, container: roda_class
+            name: :root,
+            ns: nil,
+            container: roda_class.opts[:endpoints][:container]
           )]
         end
+
+        def with_current_endpoint(endpoint)
+          endpoints.push endpoint
+          yield endpoint
+          endpoints.pop
+        end
       end
+      # rubocop:enable Metrics/ModuleLength
     end
 
     register_plugin :endpoints, Endpoints

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roda-endpoints
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Semyonov
@@ -340,8 +340,9 @@ files:
 - lib/roda/endpoints/endpoint/collection.rb
 - lib/roda/endpoints/endpoint/data.rb
 - lib/roda/endpoints/endpoint/item.rb
+- lib/roda/endpoints/endpoint/lookup.rb
 - lib/roda/endpoints/endpoint/namespace.rb
-- lib/roda/endpoints/endpoint/operations.rb
+- lib/roda/endpoints/endpoint/singleton.rb
 - lib/roda/endpoints/endpoint/transactions.rb
 - lib/roda/endpoints/endpoint/validations.rb
 - lib/roda/endpoints/endpoint/verbs.rb

data/lib/roda/endpoints/endpoint/operations.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-class Roda
-  module Endpoints
-    # Generic HTTP endpoint abstraction.
-    class Endpoint
-      # Parameters validations for {Endpoints} based on `Dry::Validation` gem.
-      module Operations
-        def initialize(**kwargs)
-          super(**kwargs)
-          container.merge(Endpoints.container)
-          self.class.verbs.each do |verb|
-            container.register "operations.#{ns}.#{verb}", &method(verb)
-          end
-        end
-
-        # @param [Symbol] verb
-        # @return [String]
-        def operation_for(verb)
-          %W(
-            operations.#{ns}.#{verb}
-            operations.#{type}.#{verb}
-          ).detect { |key| container.key?(key) }
-        end
-      end
-    end
-  end
-end