ruby_routes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d9f05718781115fc2cc1d8851ddea52d0af3fa46f7a937335398b518ea0116e9
+  data.tar.gz: 12b51d5138dbbdec4b46d66f20489e167a721f67f58ed80652add4a2e9aa606b
+SHA512:
+  metadata.gz: 32c7fab4ab209b6c2c1a5d50531d9f248f8413fb1409c6ebec9173eb538149c2a5f358e6bad85c0ed6993ed6b91a62a46f8d3551881ffaba4551b80df79c13a2
+  data.tar.gz: dd96665fc956cf1a76444e75287c2661b3629c0d0cc5546f44ed464533a50b8ff830e354d1caa83782c53855446f6e0043039ae09489fef8b5f33eeaa73329c0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Router Gem Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,305 @@
+# Ruby Routes Gem
+
+A lightweight, flexible routing system for Ruby that provides a Rails-like DSL for defining and matching HTTP routes.
+
+## Features
+
+- **Rails-like DSL**: Familiar syntax for defining routes
+- **HTTP Method Support**: GET, POST, PUT, PATCH, DELETE, and custom methods
+- **RESTful Resources**: Automatic generation of RESTful routes
+- **Nested Routes**: Support for nested resources and namespaces
+- **Route Constraints**: Add constraints to routes (regex, etc.)
+- **Named Routes**: Generate URLs from route names
+- **Path Generation**: Build URLs with parameters
+- **Scope Support**: Group routes with common options
+- **Concerns**: Reusable route groups
+- **Lightweight**: Minimal dependencies, fast performance
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby_routes'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install ruby_routes
+```
+
+## Basic Usage
+
+### Simple Routes
+
+```ruby
+require 'ruby_routes'
+
+router = RubyRoutes.draw do
+  get '/', to: 'home#index'
+  get '/about', to: 'pages#about'
+  post '/users', to: 'users#create'
+  put '/users/:id', to: 'users#update'
+  delete '/users/:id', to: 'users#destroy'
+end
+```
+
+### RESTful Resources
+
+```ruby
+router = RubyRoutes.draw do
+  resources :users
+  resources :posts
+  resources :comments
+end
+```
+
+This creates the following routes:
+- `GET /users` → `users#index`
+- `GET /users/new` → `users#new`
+- `POST /users` → `users#create`
+- `GET /users/:id` → `users#show`
+- `GET /users/:id/edit` → `users#edit`
+- `PUT /users/:id` → `users#update`
+- `PATCH /users/:id` → `users#update`
+- `DELETE /users/:id` → `users#destroy`
+
+### Named Routes
+
+```ruby
+router = RubyRoutes.draw do
+  get '/users', as: :users, to: 'users#index'
+  get '/users/:id', as: :user, to: 'users#show'
+  post '/users', as: :create_user, to: 'users#create'
+end
+
+# Generate paths
+router.route_set.generate_path(:users)           # => "/users"
+router.route_set.generate_path(:user, id: '123') # => "/users/123"
+```
+
+### Namespaces
+
+```ruby
+router = RubyRoutes.draw do
+  namespace :admin do
+    resources :users
+    resources :posts
+  end
+end
+
+# Creates routes like:
+# GET /admin/users → admin/users#index
+# GET /admin/users/:id → admin/users#show
+# etc.
+```
+
+### Nested Resources
+
+```ruby
+router = RubyRoutes.draw do
+  resources :categories do
+    resources :products
+  end
+end
+
+# Creates routes like:
+# GET /categories/:category_id/products → products#index
+# GET /categories/:category_id/products/:id → products#show
+# etc.
+```
+
+### Scopes and Constraints
+
+```ruby
+router = RubyRoutes.draw do
+  scope constraints: { id: /\d+/ } do
+    get '/users/:id', to: 'users#show'
+  end
+  
+  scope defaults: { format: 'html' } do
+    get '/posts', to: 'posts#index'
+  end
+end
+```
+
+### Concerns
+
+```ruby
+router = RubyRoutes.draw do
+  concern :commentable do
+    resources :comments
+  end
+  
+  resources :posts do
+    concerns :commentable
+  end
+  
+  resources :articles do
+    concerns :commentable
+  end
+end
+```
+
+### Root Route
+
+```ruby
+router = RubyRoutes.draw do
+  root to: 'home#index'
+end
+```
+
+## Route Matching
+
+```ruby
+router = RubyRoutes.draw do
+  get '/users/:id', to: 'users#show'
+  post '/users', to: 'users#create'
+end
+
+# Match a request
+result = router.route_set.match('GET', '/users/123')
+if result
+  puts "Controller: #{result[:controller]}"
+  puts "Action: #{result[:action]}"
+  puts "Params: #{result[:params]}"
+  # => Controller: users
+  # => Action: show
+  # => Params: {"id"=>"123"}
+end
+```
+
+## Path Generation
+
+```ruby
+router = RubyRoutes.draw do
+  get '/users/:id', as: :user, to: 'users#show'
+  get '/posts/:id/comments/:comment_id', as: :post_comment, to: 'comments#show'
+end
+
+# Generate paths
+router.route_set.generate_path(:user, id: '123')
+# => "/users/123"
+
+router.route_set.generate_path(:post_comment, id: '456', comment_id: '789')
+# => "/posts/456/comments/789"
+```
+
+## Integration with Rack
+
+```ruby
+require 'rack'
+require 'ruby_routes'
+
+# Define routes
+router = RubyRoutes.draw do
+  get '/', to: 'home#index'
+  get '/users', to: 'users#index'
+  get '/users/:id', to: 'users#show'
+end
+
+# Create Rack app
+class RubyRoutesApp
+  def initialize(router)
+    @router = router
+  end
+  
+  def call(env)
+    request_method = env['REQUEST_METHOD']
+    request_path = env['PATH_INFO']
+    
+    route_info = @router.route_set.match(request_method, request_path)
+    
+    if route_info
+      # Handle the request
+      controller = route_info[:controller]
+      action = route_info[:action]
+      params = route_info[:params]
+      
+      # Your controller logic here
+      [200, {'Content-Type' => 'text/html'}, ["Hello from #{controller}##{action}"]]
+    else
+      [404, {'Content-Type' => 'text/html'}, ['Not Found']]
+    end
+  end
+end
+
+# Run the app
+app = RubyRoutesApp.new(router)
+Rack::Handler::WEBrick.run app, Port: 9292
+```
+
+## API Reference
+
+### RubyRoutes.draw(&block)
+
+Creates a new router instance and yields to the block for route definition.
+
+### HTTP Methods
+
+- `get(path, options = {})`
+- `post(path, options = {})`
+- `put(path, options = {})`
+- `patch(path, options = {})`
+- `delete(path, options = {})`
+- `match(path, options = {})`
+
+### Resource Methods
+
+- `resources(name, options = {})` - Creates RESTful routes for a collection
+- `resource(name, options = {})` - Creates RESTful routes for a singular resource
+
+### Options
+
+- `to: 'controller#action'` - Specifies controller and action
+- `controller: 'name'` - Specifies controller name
+- `action: 'name'` - Specifies action name
+- `as: :name` - Names the route for path generation
+- `via: :method` - Specifies HTTP method(s)
+- `constraints: {}` - Adds route constraints
+- `defaults: {}` - Sets default parameters
+
+### RouteSet Methods
+
+- `match(method, path)` - Matches a request to a route
+- `generate_path(name, params = {})` - Generates path from named route
+- `find_route(method, path)` - Finds a specific route
+- `find_named_route(name)` - Finds a named route
+
+## Examples
+
+See the `examples/` directory for more detailed examples:
+
+- `examples/basic_usage.rb` - Basic routing examples
+- `examples/rack_integration.rb` - Full Rack application example
+
+## Testing
+
+Run the test suite:
+
+```bash
+bundle exec rspec
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -am 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Create a new Pull Request
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](LICENSE).
+
+## Acknowledgments
+
+This gem was inspired by Rails routing and aims to provide a lightweight alternative for Ruby applications that need flexible routing without the full Rails framework.

data/lib/ruby_routes/route.rb

@@ -0,0 +1,96 @@
+module RubyRoutes
+  class Route
+    attr_reader :path, :methods, :controller, :action, :name, :constraints, :defaults
+
+    def initialize(path, options = {})
+      @path = normalize_path(path)
+      @methods = Array(options[:via] || :get).map(&:to_s).map(&:upcase)
+      @controller = extract_controller(options)
+      @action = options[:action] || extract_action(options[:to])
+      @name = options[:as]
+      @constraints = options[:constraints] || {}
+      @defaults = options[:defaults] || {}
+
+      validate_route!
+    end
+
+    def match?(request_method, request_path)
+      return false unless methods.include?(request_method.to_s.upcase)
+
+      path_params = extract_path_params(request_path)
+      path_params != nil
+    end
+
+    def extract_params(request_path)
+      path_params = extract_path_params(request_path)
+      return {} unless path_params
+
+      params = path_params.dup
+      # Convert symbol keys to string keys for consistency
+      string_defaults = defaults.transform_keys(&:to_s)
+      params.merge!(string_defaults)
+      params
+    end
+
+    def named?
+      !name.nil?
+    end
+
+    def resource?
+      path.match?(/\/:id$/) || path.match?(/\/:id\./)
+    end
+
+    def collection?
+      !resource?
+    end
+
+    private
+
+    def normalize_path(path)
+      path = "/#{path}" unless path.start_with?('/')
+      # Remove trailing slash unless it's the root path
+      path = path.chomp('/') unless path == '/'
+      path
+    end
+
+    def extract_controller(options)
+      if options[:to]
+        options[:to].to_s.split('#').first
+      else
+        options[:controller]
+      end
+    end
+
+    def extract_action(to)
+      return nil unless to
+      to.to_s.split('#').last
+    end
+
+    def extract_path_params(request_path)
+      route_parts = path.split('/')
+      request_parts = request_path.split('/')
+
+      return nil if route_parts.length != request_parts.length
+
+      params = {}
+      route_parts.each_with_index do |route_part, index|
+        request_part = request_parts[index]
+
+        if route_part.start_with?(':')
+          param_name = route_part[1..-1]
+          params[param_name] = request_part
+        elsif route_part != request_part
+          return nil
+        end
+      end
+
+      params
+    end
+
+    def validate_route!
+      raise InvalidRoute, "Controller is required" if controller.nil?
+      raise InvalidRoute, "Action is required" if action.nil?
+      raise InvalidRoute, "Invalid HTTP method: #{methods}" if methods.empty?
+    end
+  end
+end

data/lib/ruby_routes/route_set.rb

@@ -0,0 +1,80 @@
+module RubyRoutes
+  class RouteSet
+    attr_reader :routes
+
+    def initialize
+      @routes = []
+      @named_routes = {}
+    end
+
+    def add_route(route)
+      @routes << route
+      @named_routes[route.name] = route if route.named?
+      route
+    end
+
+    def find_route(request_method, request_path)
+      @routes.find { |route| route.match?(request_method, request_path) }
+    end
+
+    def find_named_route(name)
+      @named_routes[name] or raise RouteNotFound, "No route named '#{name}'"
+    end
+
+    def match(request_method, request_path)
+      route = find_route(request_method, request_path)
+      return nil unless route
+
+      {
+        route: route,
+        params: route.extract_params(request_path),
+        controller: route.controller,
+        action: route.action
+      }
+    end
+
+    def recognize_path(path, method = :get)
+      match(method, path)
+    end
+
+    def generate_path(name, params = {})
+      route = find_named_route(name)
+      generate_path_from_route(route, params)
+    end
+
+    def generate_path_from_route(route, params = {})
+      path = route.path.dup
+
+      params.each do |key, value|
+        path.gsub!(":#{key}", value.to_s)
+      end
+
+      # Remove any remaining :param placeholders
+      path.gsub!(/\/:[^\/]+/, '')
+      path.gsub!(/\/$/, '') if path != '/'
+
+      path
+    end
+
+    def clear!
+      @routes.clear
+      @named_routes.clear
+    end
+
+    def size
+      @routes.size
+    end
+
+    def empty?
+      @routes.empty?
+    end
+
+    def each(&block)
+      @routes.each(&block)
+    end
+
+    def include?(route)
+      @routes.include?(route)
+    end
+  end
+end

data/lib/ruby_routes/router.rb

@@ -0,0 +1,205 @@
+module RubyRoutes
+  class Router
+    attr_reader :route_set
+
+    def initialize(&block)
+      @route_set = RouteSet.new
+      @scope_stack = []
+      instance_eval(&block) if block_given?
+    end
+
+    # Basic route definition
+    def get(path, options = {})
+      add_route(path, options.merge(via: :get))
+    end
+
+    def post(path, options = {})
+      add_route(path, options.merge(via: :post))
+    end
+
+    def put(path, options = {})
+      add_route(path, options.merge(via: :put))
+    end
+
+    def patch(path, options = {})
+      add_route(path, options.merge(via: :patch))
+    end
+
+    def delete(path, options = {})
+      add_route(path, options.merge(via: :delete))
+    end
+
+    def match(path, options = {})
+      add_route(path, options)
+    end
+
+    # Resources routing (Rails-like)
+    def resources(name, options = {}, &block)
+      singular = name.to_s.singularize
+      plural = name.to_s.pluralize
+
+      # Collection routes
+      get "/#{plural}", options.merge(to: "#{plural}#index")
+      get "/#{plural}/new", options.merge(to: "#{plural}#new")
+      post "/#{plural}", options.merge(to: "#{plural}#create")
+
+      # Member routes
+      get "/#{plural}/:id", options.merge(to: "#{plural}#show")
+      get "/#{plural}/:id/edit", options.merge(to: "#{plural}#edit")
+      put "/#{plural}/:id", options.merge(to: "#{plural}#update")
+      patch "/#{plural}/:id", options.merge(to: "#{plural}#update")
+      delete "/#{plural}/:id", options.merge(to: "#{plural}#destroy")
+
+      # Nested resources if specified
+      if options[:nested]
+        nested_name = options[:nested]
+        nested_singular = nested_name.to_s.singularize
+        nested_plural = nested_name.to_s.pluralize
+
+        get "/#{plural}/:id/#{nested_plural}", options.merge(to: "#{nested_plural}#index")
+        get "/#{plural}/:id/#{nested_plural}/new", options.merge(to: "#{nested_plural}#new")
+        post "/#{plural}/:id/#{nested_plural}", options.merge(to: "#{nested_plural}#create")
+        get "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#show")
+        get "/#{plural}/:id/#{nested_plural}/:nested_id/edit", options.merge(to: "#{nested_plural}#edit")
+        put "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#update")
+        patch "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#update")
+        delete "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#update")
+        delete "/#{plural}/:id/#{nested_plural}/:nested_id", options.merge(to: "#{nested_plural}#destroy")
+      end
+
+      # Handle concerns if block is given
+      if block_given?
+        # Push a scope for nested resources
+        @scope_stack.push({ path: "/#{plural}/:id" })
+        # Execute the block in the context of this router instance
+        instance_eval(&block)
+        @scope_stack.pop
+      end
+    end
+
+    def resource(name, options = {})
+      singular = name.to_s.singularize
+
+      get "/#{singular}", options.merge(to: "#{singular}#show")
+      get "/#{singular}/new", options.merge(to: "#{singular}#new")
+      post "/#{singular}", options.merge(to: "#{singular}#create")
+      get "/#{singular}/edit", options.merge(to: "#{singular}#edit")
+      put "/#{singular}", options.merge(to: "#{singular}#update")
+      patch "/#{singular}", options.merge(to: "#{singular}#update")
+      delete "/#{singular}", options.merge(to: "#{singular}#destroy")
+    end
+
+    # Namespace support
+    def namespace(name, options = {}, &block)
+      @scope_stack.push({ path: "/#{name}", module: name })
+
+      if block_given?
+        instance_eval(&block)
+      end
+
+      @scope_stack.pop
+    end
+
+    # Scope support
+    def scope(options = {}, &block)
+      @scope_stack.push(options)
+
+      if block_given?
+        instance_eval(&block)
+      end
+
+      @scope_stack.pop
+    end
+
+    # Root route
+    def root(options = {})
+      add_route("/", options.merge(via: :get))
+    end
+
+    # Concerns (reusable route groups)
+    def concerns(*names, &block)
+      names.each do |name|
+        concern = @concerns[name]
+        raise "Concern '#{name}' not found" unless concern
+
+        instance_eval(&concern)
+      end
+
+      if block_given?
+        instance_eval(&block)
+      end
+    end
+
+    def concern(name, &block)
+      @concerns ||= {}
+      @concerns[name] = block
+    end
+
+    # Route constraints
+    def constraints(constraints = {}, &block)
+      @scope_stack.push({ constraints: constraints })
+
+      if block_given?
+        instance_eval(&block)
+      end
+
+      @scope_stack.pop
+    end
+
+    # Defaults
+    def defaults(defaults = {}, &block)
+      @scope_stack.push({ defaults: defaults })
+
+      if block_given?
+        instance_eval(&block)
+      end
+
+      @scope_stack.pop
+    end
+
+    # Mount other applications
+    def mount(app, at: nil)
+      path = at || "/#{app}"
+      add_route("#{path}/*path", to: app, via: :all)
+    end
+
+    private
+
+    def add_route(path, options = {})
+      # Apply current scope
+      scoped_options = apply_scope(path, options)
+
+      # Create and add the route
+      route = Route.new(scoped_options[:path], scoped_options)
+      @route_set.add_route(route)
+      route
+    end
+
+    def apply_scope(path, options)
+      scoped_options = options.dup
+      scoped_path = path
+
+      @scope_stack.reverse_each do |scope|
+        if scope[:path]
+          scoped_path = "#{scope[:path]}#{scoped_path}"
+        end
+
+        if scope[:module] && scoped_options[:to]
+          controller = scoped_options[:to].to_s.split('#').first
+          scoped_options[:to] = "#{scope[:module]}/#{controller}##{scoped_options[:to].to_s.split('#').last}"
+        end
+
+        if scope[:constraints]
+          scoped_options[:constraints] = (scoped_options[:constraints] || {}).merge(scope[:constraints])
+        end
+
+        if scope[:defaults]
+          scoped_options[:defaults] = (scoped_options[:defaults] || {}).merge(scope[:defaults])
+        end
+      end
+
+      scoped_options[:path] = scoped_path
+      scoped_options
+    end
+  end
+end

data/lib/ruby_routes/string_extensions.rb

@@ -0,0 +1,26 @@
+class String
+  def singularize
+    case self
+    when /ies$/
+      self.sub(/ies$/, 'y')
+    when /s$/
+      self.sub(/s$/, '')
+    else
+      self
+    end
+  end
+
+  def pluralize
+    case self
+    when /y$/
+      self.sub(/y$/, 'ies')
+    when /sh$/, /ch$/, /x$/, /z$/
+      self + 'es'
+    when /s$/
+      # Words ending in 's' are already plural
+      self
+    else
+      self + 's'
+    end
+  end
+end

data/lib/ruby_routes/url_helpers.rb

@@ -0,0 +1,55 @@
+module RubyRoutes
+  module UrlHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def url_helpers
+        @url_helpers ||= Module.new
+      end
+
+      def add_url_helper(name, route)
+        url_helpers.define_method(name) do |*args|
+          params = args.first || {}
+          route_set.generate_path_from_route(route, params)
+        end
+      end
+    end
+
+    def url_helpers
+      self.class.url_helpers
+    end
+
+    def path_to(name, params = {})
+      route = route_set.find_named_route(name)
+      route_set.generate_path_from_route(route, params)
+    end
+
+    def url_to(name, params = {})
+      path = path_to(name, params)
+      "http://localhost#{path}"
+    end
+
+    def link_to(name, text, params = {})
+      path = path_to(name, params)
+      "<a href=\"#{path}\">#{text}</a>"
+    end
+
+    def button_to(name, text, params = {})
+      path = path_to(name, params)
+      method = params.delete(:method) || :post
+
+      html = "<form action=\"#{path}\" method=\"#{method}\">"
+      html += "<input type=\"hidden\" name=\"_method\" value=\"#{method}\">" if method != :get
+      html += "<button type=\"submit\">#{text}</button>"
+      html += "</form>"
+      html
+    end
+
+    def redirect_to(name, params = {})
+      path = path_to(name, params)
+      { status: 302, location: path }
+    end
+  end
+end

data/lib/ruby_routes/version.rb

@@ -0,0 +1,3 @@
+module RubyRoutes
+  VERSION = "0.1.0"
+end

data/lib/ruby_routes.rb

@@ -0,0 +1,22 @@
+require_relative "ruby_routes/version"
+require_relative "ruby_routes/string_extensions"
+require_relative "ruby_routes/route"
+require_relative "ruby_routes/route_set"
+require_relative "ruby_routes/url_helpers"
+require_relative "ruby_routes/router"
+
+module RubyRoutes
+  class Error < StandardError; end
+  class RouteNotFound < Error; end
+  class InvalidRoute < Error; end
+
+  # Create a new router instance
+  def self.new(&block)
+    RubyRoutes::Router.new(&block)
+  end
+
+  # Define the routes using a block
+  def self.draw(&block)
+    RubyRoutes::Router.new(&block)
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: ruby_routes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yosef Benny Widyokarsono
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: A lightweight, flexible routing system that provides a Rails-like DSL
+  for defining and matching HTTP routes
+email:
+- yosefbennywidyo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ruby_routes.rb
+- lib/ruby_routes/route.rb
+- lib/ruby_routes/route_set.rb
+- lib/ruby_routes/router.rb
+- lib/ruby_routes/string_extensions.rb
+- lib/ruby_routes/url_helpers.rb
+- lib/ruby_routes/version.rb
+homepage: https://github.com/yosefbennywidyo/ruby_routes
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: A Rails-like routing system for Ruby
+test_files: []