rutter 0.1.2 → 0.2.0

data/lib/rutter/mount.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rutter
+  # Represents a mounted app route.
+  #
+  # @see Rutter::Route
+  #
+  # @private
+  class Mount < Route
+    # Matches the app pattern against environment.
+    #
+    # @param env [Hash]
+    #   Rack environment hash.
+    #
+    # @return [nil, String]
+    #   Returns the matching substring or nil on no match.
+    def match?(env)
+      @pattern.peek(env["PATH_INFO"])
+    end
+  end
+end

data/lib/rutter/naming.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Rutter
+  # Conveniences for inflecting and working with names in Rutter.
+  module Naming
+    module_function
+
+    # Return a downcased and underscore separated version of the string.
+    #
+    # Revised version of `Hanami::Utils::String.underscore` implementation.
+    #
+    # @param string [String]
+    #   String to be transformed.
+    #
+    # @return [String]
+    #   The transformed string.
+    #
+    # @example
+    #   string = "RutterNaming"
+    #   Rutter::Naming.underscore(string) # => 'rutter_naming'
+    def underscore(string)
+      string = +string.to_s
+      string.gsub!("::", "/")
+      string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      string.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      string.gsub!(/[[:space:]]|\-/, '\1_\2')
+      string.downcase!
+      string
+    end
+
+    # Return a CamelCase version of the string.
+    #
+    # Revised version of `Hanami::Utils::String.classify` implementation.
+    #
+    # @param string [String]
+    #   String to be transformed.
+    #
+    # @return [String]
+    #   The transformed string
+    #
+    # @example
+    #   string = "rutter_naming"
+    #   Rutter::Naming.classify(string) # => 'RutterNaming'
+    def classify(string)
+      words = underscore(string).split(%r{_|::|\/|\-}).map!(&:capitalize)
+      delimiters = underscore(string).scan(%r{_|::|\/|\-})
+      delimiters.map! { |delimiter| delimiter == "_" ? "" : "::" }
+      words.zip(delimiters).join
+    end
+
+    # Normalize the given string/symbol to a valid route name.
+    #
+    # @param string [String, Symbol]
+    #   Name to be normalized.
+    #
+    # @return [Symbol]
+    #   Normalized route name.
+    def route_name(string)
+      string = underscore(string)
+      string.tr!("/", "_")
+      string.gsub!(/[_]{2,}/, "_")
+      string.gsub!(/\A_|_\z/, "")
+      string.to_sym
+    end
+
+    # Normalize the given path.
+    #
+    # @param path [String]
+    #   Path to be normalized.
+    #
+    # @return [String]
+    #   Normalized path.
+    def cleanpath(path)
+      Pathname.new("/#{path}").cleanpath.to_s
+    end
+
+    # Join the given arguments with the separator.
+    #
+    # @overload join(part)
+    #   @param part [String, nil]
+    #     First part to join.
+    # @overload join(part)
+    #   @param ... [String, nil]
+    #     Another part to join.
+    #
+    # @param sep [String]
+    #   Part separator.
+    #
+    # @return [String]
+    def join(*part, sep: "/")
+      part.reject { |s| s.nil? || s == "" }
+          .join(sep)
+    end
+  end
+end

data/lib/rutter/route.rb

@@ -1,168 +1,111 @@
 # frozen_string_literal: true
 
-require "cgi"
+require "mustermann"
 
 module Rutter
   # Represents a single route.
   #
-  # @attr_reader method [String]
-  #   Request method to match.
-  # @attr_reader path [String]
-  #   Path to match.
-  # @attr_reader endpoint [Hash]
-  #   Route endpoint.
+  # @!attribute [r] path
+  #   @return [String] Raw path template.
+  # @!attribute [r] endpoint
+  #   @return [Hash] Route endpoint.
+  #
+  # @private
   class Route
-    # Valid request verbs.
-    VERBS = %w[GET POST PUT PATCH DELETE OPTIONS HEAD TRACE].freeze
-
-    attr_reader :method, :path, :endpoint
+    attr_reader :path
+    attr_reader :endpoint
 
     # Initializes the route.
     #
-    # @param method [Symbol, String]
-    #   Requets method to match.
     # @param path [String]
-    #   Path template.
-    # @param endpoint [String, Proc, Hash]
-    #    Route endpoint.
-    # @param controller_suffix [String, false]
-    #   Suffix for string controllers.
-    #
-    # @return [self]
+    #   Path template to match.
+    # @param endpoint [#call]
+    #   Rack endpoint.
+    # @param constraints [Hash]
+    #   Route segment constraints.
     #
-    # @raise [ArgumentError]
-    #   If request method is unknown.
+    # @return [void]
     #
     # @private
-    def initialize(method, path, endpoint, controller_suffix: nil)
-      @method = method.to_s.upcase
-
-      unless VERBS.include?(method)
-        raise ArgumentError, "invalid verb: '#{method}'"
-      end
-
-      @controller_suffix = controller_suffix || ""
-      @path = normalize_path(path)
-      @dynamic = false
-      @pattern = path_to_pattern(@path).freeze
-      @endpoint = build_endpoint_hash(endpoint).freeze
-
+    def initialize(path, endpoint, constraints = nil)
+      @path = Naming.cleanpath(path)
+      @endpoint = endpoint_to_hash(endpoint)
+      @pattern = ::Mustermann.new(@path, capture: constraints)
       freeze
     end
 
-    # Matches the given path to the route pattern.
+    # Matches the route pattern against environment.
     #
-    # @param path_info [String]
-    #   Requested path to match against.
+    # @param env [Hash]
+    #   Rack environment hash.
     #
     # @return [Boolean]
-    def match?(path_info)
-      @dynamic ? path_info.match?(@pattern) : path_info == @path
+    def match?(env)
+      @pattern === env["PATH_INFO"] # rubocop:disable Style/CaseEquality
     end
 
-    # Extract params from the given path.
+    # Generates a path from the given arguments.
     #
-    # NOTE: If the path does not match, `nil` is returned.
+    # @overload expand(key: value)
+    #   @param key [String, Integer, Array]
+    #     Key value.
+    # @overload expand(key: value, key2: value2)
+    #   @param key2 [String, Integer, Array]
+    #     Key value.
     #
-    # @param path [String]
-    #   Requested path to extract params from.
+    # @return [String]
+    #   Generated path.
     #
-    # @return [nil, Hash<String => String>]
-    def params(path)
-      return unless (result = path.match(@pattern))
-      values = result.captures.map { |v| CGI.unescape(v) if v }
-      Hash[result.names.zip(values)]
+    # @raise [ArguemntError]
+    #   If the path cannot be generated. Mostly due to missing key(s).
+    def expand(**args)
+      @pattern.expand(:append, **args)
+    rescue ::Mustermann::ExpandError => e
+      raise ArgumentError, e.message
     end
 
-    # Expands the pattern with the given arguments.
-    #
-    # @param params [Hash]
-    #   Expand parameters.
-    #
-    # @return [String] Expanded string.
-    #
-    # @example basic example
-    #   route = Route.new("GET", "/books/:id/:title", -> {})
-    #
-    #   route.expand(id: 54, title: "eloquent-ruby")
-    #     # => "/books/54/eloquent-ruby"
+    # Extract params from the given path.
     #
-    # @example with query
-    #   route = Route.new("GET", "/books/:id/reviews", -> {})
+    # @param path [String]
+    #   Path used to extract params from.
     #
-    #   route.expand(id: 54, status: "approved")
-    #     # => "/books/54/reviews?status=approved"
-    def expand(params = {})
-      string = if @dynamic
-        new_path = path.gsub(SEGMENT_MATCH) do |match|
-          params.delete(match[1..-1].to_sym)
-        end
-        new_path.gsub(/\(|\)/, "")
-      else
-        path.dup
-      end
-
-      string = normalize_path(string)
-      return string if params.empty?
-
-      "#{string}?#{Rack::Utils.build_nested_query(params)}"
+    # @return [Hash]
+    def params(path)
+      @pattern.params(path)
     end
 
-    private
-
-    # Segment for dynamic parts.
+    # Calls the endpoint.
     #
-    # @private
-    DYNAMIC_SEGMENT = "[^/.,;?]+"
-
-    # Segment for wildcards.
+    # @param env [Hash]
+    #   Rack's environment hash.
     #
-    # @private
-    WILDCARD_SEGMENT = ".*"
-
-    # Match segment regexp.
+    # @return [Array]
+    #   Rack response array.
     #
     # @private
-    SEGMENT_MATCH = /((:|\*)[\w]+)/
-
-    # @private
-    def path_to_pattern(path)
-      pattern = path.dup
-
-      if pattern.include?("(")
-        @dynamic = true
-        pattern = pattern.gsub("(", "(?:").gsub(")", ")?")
-      end
-
-      pattern = pattern.gsub(SEGMENT_MATCH) do |match|
-        @dynamic = true
-        segment = match[0] == ":" ? DYNAMIC_SEGMENT : WILDCARD_SEGMENT
-        "(?<#{match[1..-1]}>#{segment})"
-      end
-
-      /\A#{pattern}\z/
+    def call(env)
+      env["rutter.params"] ||= {}
+      env["rutter.params"].merge!(params(env["PATH_INFO"]))
+      env["rutter.action"] = @endpoint[:action]
+
+      ctrl = @endpoint[:controller]
+      ctrl = ::Object.const_get(ctrl) if ctrl.is_a?(String)
+      ctrl.call(env)
     end
 
-    # @private
-    def normalize_path(path)
-      path = path.gsub(%r{[\/]{2,}}, "/")
-                 .gsub(%r{\A[\/]+|[\/]+\z}, "")
-                 .downcase
-
-      "/#{path}"
-    end
+    private
 
     # @private
-    def build_endpoint_hash(endpoint)
-      if endpoint.is_a?(String)
-        ctrl, action = endpoint.gsub(/[:]{3,}/, "::")
-                               .gsub(/\A[:]+|[:]+\z/, "")
-                               .split("#")
-
-        { controller: "#{ctrl}#{@controller_suffix}", action: action }
-      else
-        { controller: endpoint, action: nil }
-      end
+    def endpoint_to_hash(endpoint)
+      ctrl, action = if endpoint.is_a?(String)
+                       ctrl, action = endpoint.split("#")
+                       ctrl = Naming.classify(ctrl)
+                       [ctrl, action]
+                     else
+                       [endpoint, nil]
+                     end
+
+      { controller: ctrl, action: action }
     end
   end
 end

data/lib/rutter/routes.rb

@@ -3,24 +3,51 @@
 require "forwardable"
 
 module Rutter
-  # Routes helper.
+  # Routes URL builder.
+  #
+  # @see Rutter::Builder#path
+  # @see Rutter::Builder#url
+  #
+  # @example
+  #   router = Rutter.new(base: "http://rutter.org") do
+  #     get "/login", to: "sessions#new", as: :login
+  #     get "/books/:id", to: "books#show", as: :book
+  #   end.freeze
+  #
+  #   routes = Rutter::Routes.new(router)
+  #
+  #   routes.login_path
+  #     # => "/login"
+  #   routes.login_path(return_to: "/")
+  #     # => "/login?return_to=/"
+  #   routes.book_path(id: 82)
+  #     # => "/books/82"
+  #
+  #   routes.login_url
+  #     # => "http://rutter.org/login"
+  #   routes.login_url(return_to: "/")
+  #     # => "http://rutter.org/login?return_to=/"
+  #   routes.book_url(id: 82)
+  #     # => "http://rutter.org/books/82"
   class Routes
     extend Forwardable
 
-    # Delegate path and url method to the builder.
+    # Delegate path and url method to the router.
     #
     # @see Rutter::Builder#path
     # @see Rutter::Builder#url
-    def_delegators :@builder, :path, :url
+    def_delegators :@router, :path, :url
 
     # Initializes the helper.
     #
-    # @param builder [Rutter::Builder]
-    #   Route builder object.
+    # @param router [Rutter::Builder]
+    #   Route router object.
     #
-    # @return [self]
-    def initialize(builder)
-      @builder = builder
+    # @return [void]
+    #
+    # @private
+    def initialize(router)
+      @router = router
     end
 
     protected
@@ -29,7 +56,7 @@ module Rutter
     def method_missing(method_name, *args)
       named_route, type = method_name.to_s.split(/\_(path|url)\z/)
       return super unless type
-      @builder.public_send(type, named_route.to_sym, *args)
+      @router.public_send(type, named_route.to_sym, *args)
     end
 
     # @private

data/lib/rutter/scope.rb

@@ -1,67 +1,66 @@
 # frozen_string_literal: true
 
 module Rutter
-  # Scoped set of routes.
+  # Represents a scoped set.
+  #
+  # @see Rutter::Builder#scope
+  #
+  # @private
   class Scope
     # Initializes the scope.
     #
     # @param router [Rutter::Builder]
-    #   Root router object.
-    # @option opts [String] :path (nil)
-    #   Path prefix
-    # @option opts [String] :namespace (nil)
-    #   Namespace prefix
-    # @option opts [String, Symbol] :as (nil)
-    #   Name prefix
+    #   Router object.
+    # @param path [String]
+    #   Scope path prefix.
+    # @param namespace [String, Symbol]
+    #   Scope namespace.
+    # @param as [Symbol]
+    #   Scope name prefix.
+    #
     # @yield
-    #   Scope context.
+    #   Block is evaluated inside the created scope context.
     #
-    # @return [self]
+    # @return [void]
     #
     # @private
-    def initialize(router, **opts, &block)
+    def initialize(router, path: nil, namespace: nil, as: nil, &block)
       @router = router
-      @path_prefix = opts[:path]
-      @namespace_prefix = opts[:namespace]
-      @name_prefix = opts[:as]
+      @path = path
+      @namespace = namespace
+      @as = as
 
       instance_eval(&block) if block_given?
     end
 
-    # @see Rutter::Builder#scope
-    def scope(**opts, &block)
-      opts[:as] = "#{@name_prefix}_#{opts[:as]}" if @name_prefix
-      opts[:path] = "#{@path_prefix}/#{opts[:path]}" if @path_prefix
-
-      if @namespace_prefix
-        opts[:namespace] = "#{@namespace_prefix}::#{opts[:namespace]}"
-      end
-
-      Scope.new(@router, **opts, &block)
+    # @see Rutter::Builder#mount
+    def mount(app, at:)
+      @router.mount app, at: Naming.join(@path, at)
     end
 
-    # @see Rutter::Builder#mount
-    def mount(app, at:, **opts)
-      at = "#{@path_prefix}/#{at}" if @path_prefix
-      @router.mount app, at: at, **opts
+    # @see Rutter::Builder#scope
+    def scope(path: nil, namespace: nil, as: nil, &block)
+      Scope.new(self, path: path, namespace: namespace, as: as, &block)
     end
 
-    # @see Rutter::Builder#root
-    def root(to:, as: :root)
-      get "/", to: to, as: as
+    # @see Rutter::Builder#namespace
+    def namespace(name, &block)
+      scope path: name, namespace: name, as: name, &block
     end
 
     # @see Rutter::Builder#add
-    Route::VERBS.each do |verb|
-      verb_method = verb.downcase
-      define_method verb_method do |path, **opts|
-        path = "#{@path_prefix}/#{path}" if @path_prefix
-        opts[:as] = "#{@name_prefix}_#{opts[:as]}" if opts[:as]
-        if @namespace_prefix && opts[:to].is_a?(String)
-          opts[:to] = "#{@namespace_prefix}::#{opts[:to]}"
-        end
+    def add(verb, path, to:, as: nil, constraints: nil)
+      path = Naming.join(@path, path)
+      to = Naming.join(@namespace, to) if to.is_a?(String)
+      as = Naming.join(@as, as) if as
 
-        @router.public_send verb_method, path, **opts
+      @router.add verb, path, to: to, as: as, constraints: constraints
+    end
+
+    # @see Rutter::Builder#add
+    VERBS.each do |verb|
+      define_method verb.downcase do |path, to:, as: nil, constraints: nil|
+        add verb, path, to: to, as: as, constraints: constraints
       end
     end
   end