otto 1.0.1 → 1.1.0.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ac5fa49c20f895e78ea8735d7a150f06e9f204529732e5f45eaad3f8e29da47
-  data.tar.gz: 37970041ad4e819fccc6f5e784414f5adb90b6dddc46d2899682a6ce9062fff7
+  metadata.gz: 28a8992b56a1b88f3202f7e3561bda9ba0f3816c26fbdd3775b3cdded2d8382c
+  data.tar.gz: 781639dfd7a1fa9a3d7e7e4693eb74a485c6cdddbdf8e8b7fe64596d1322701b
 SHA512:
-  metadata.gz: e01141e9fdf1b278935fa3270292499a828c6db703a2b98fd6493ea88d500b04a32d808969129a148f0738547a72b1a0f4d629b4e5aa25b2376b173635e8c997
-  data.tar.gz: 147c1adf29df98d71bf70a9e40a7e4c30325fe4451321f76881e78c68c0a1c8eca9a441ce58d55e7580d0a07302bf4415de69d77628e2fb8629b296ef347df88
+  metadata.gz: d25fed4875a89b4ea4f2d26552bdea920b2324401bd354fabaa4b62d640e6a2da6eb38575499018020887eeee5db68b67995f7670b7c69d4eb1ca9f0e6cd48ff
+  data.tar.gz: d07d2a99df509515630600d3c22f508e0f1018ce641aea1f52bd917b9ae5868bd63ab0466d5ee0be326942becc29ac1b1f29c15f1f202310858f7290f20384e4

data/.gitignore

@@ -0,0 +1,18 @@
+.DS_Store
+.bundle
+.byebug*
+.history
+.devcontainer
+.vscode
+*.env
+*.log
+*.md
+*.txt
+!LICENSE.txt
+.ruby-version
+appendonlydir
+etc/config
+log
+tmp
+vendor
+*.gem

data/.rubocop.yml

@@ -0,0 +1,71 @@
+##
+# This is the RuboCop configuration file.
+# It contains the rules and settings for the RuboCop linter.
+#
+# Enable/disable the cops individually. For more information,
+# refer to the RuboCop documentation:
+# https://docs.rubocop.org/rubocop/cops.html
+#
+# Running `rubocop --regenerate-todo` will update the todo file
+# with the latest state of the onion (using the same options
+# as those documented at the top of the todo file). This is
+# useful for a gradual migration of the codebase.
+#
+inherit_from: .rubocop_todo.yml
+
+require:
+  - rubocop-performance
+  - rubocop-thread_safety
+
+AllCops:
+  NewCops: enable
+  UseCache: true
+  MaxFilesInCache: 100
+  TargetRubyVersion: 3.0
+  Exclude:
+    - 'migrate/**/*.rb'
+    - 'migrate/*.rb'
+    - 'try/**/*'
+    - 'try/*.rb'
+    - 'vendor/**/*'
+
+Gemspec/DeprecatedAttributeAssignment:
+  Enabled: true
+
+Gemspec/DevelopmentDependencies:
+  Enabled: true
+
+Layout/HashAlignment:
+  Enabled: false
+
+Lint/Void:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+  Max: 20
+
+Metrics/ClassLength:
+  Enabled: true
+  Max: 200
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: true
+  Max: 40
+  CountAsOne: ['method_call']
+
+Metrics/ModuleLength:
+  Enabled: true
+  Max: 250
+  CountAsOne: ['method_call']
+
+Performance/Size:
+  Enabled: true
+  Exclude:
+  #   - lib/example.rb
+
+Style/NegatedIfElseCondition:
+  Enabled: true

data/CHANGES.txt

@@ -0,0 +1,35 @@
+OTTO, CHANGES
+
+#### 0.4.1 (2015-04-07) ###############################
+
+* FIXED: Resolved error when ACCEPT-LANGUAGES header doesn't exist
+
+#### 0.4.0 (2015-04-06) ###############################
+
+* ADDED: Locale support via env['rack.locale']
+
+#### 0.3.2 (2013-01-27) ###############################
+
+* CHANGE: send_cookie doesn't set domain
+
+#### 0.3.1 (2012-12-17) ###############################
+
+* ADDED: Otto.debug (set w/ Otto.debug= or env variable OTTO_DEBUG)
+* ADDED: RequestHelpers#ajax?
+* CHANGE: Added internal subnets to RequestHelpers#local?
+
+
+#### 0.3.0 (2011-12-17) ###############################
+
+* ADDED: Example app, better docs in readme
+* CHANGE: No default value for user agent
+
+#### 0.2.1 (2011-07-07) ###############################
+
+* ADDED: Otto#add_static_path
+
+#### 0.2.0 (2011-07-06) ###############################
+
+Initial public release
+
+

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+group "development" do
+  gem "pry-byebug"
+  gem "rubocop"
+  gem "tryouts"
+end

data/Gemfile.lock

@@ -0,0 +1,66 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.6)
+      public_suffix (>= 2.0.2, < 6.0)
+    ast (2.4.2)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    drydock (0.6.9)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    method_source (1.0.0)
+    parallel (1.24.0)
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    public_suffix (5.0.5)
+    racc (1.7.3)
+    rack (3.0.10)
+    rainbow (3.1.1)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rubocop (1.62.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.2)
+      parser (>= 3.3.0.4)
+    ruby-progressbar (1.13.0)
+    storable (0.10.0)
+    sysinfo (0.10.0)
+      drydock (< 1.0)
+      storable (~> 0.10)
+    tryouts (2.2.0)
+      sysinfo (~> 0.10)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  arm64-darwin-22
+  ruby
+
+DEPENDENCIES
+  addressable
+  pry-byebug
+  rack
+  rubocop
+  tryouts
+
+RUBY VERSION
+   ruby 3.2.0p0
+
+BUNDLED WITH
+   2.5.7

data/VERSION.yml

@@ -1,3 +1,3 @@
-:MAJOR: 0
-:MINOR: 4
-:PATCH: 1
+:MAJOR: 1
+:MINOR: 1
+:PATCH: 0

data/lib/otto/helpers/request.rb

@@ -0,0 +1,61 @@
+class Otto
+  module RequestHelpers
+    def user_agent
+      env['HTTP_USER_AGENT']
+    end
+    def client_ipaddress
+      env['HTTP_X_FORWARDED_FOR'].to_s.split(/,\s*/).first ||
+      env['HTTP_X_REAL_IP'] || env['REMOTE_ADDR']
+    end
+    def request_method
+      env['REQUEST_METHOD']
+    end
+    def current_server
+      [current_server_name, env['SERVER_PORT']].join(':')
+    end
+    def current_server_name
+      env['SERVER_NAME']
+    end
+    def http_host
+      env['HTTP_HOST']
+    end
+    def request_path
+      env['REQUEST_PATH']
+    end
+    def request_uri
+      env['REQUEST_URI']
+    end
+    def root_path
+      env['SCRIPT_NAME']
+    end
+    def absolute_suri host=current_server_name
+      prefix = local? ? 'http://' : 'https://'
+      [prefix, host, request_path].join
+    end
+    def local?
+      Otto.env?(:dev, :development) &&
+       (client_ipaddress == '127.0.0.1' ||
+       !client_ipaddress.match(/^10\.0\./).nil? ||
+       !client_ipaddress.match(/^192\.168\./).nil?)
+    end
+    def secure?
+      # X-Scheme is set by nginx
+      # X-FORWARDED-PROTO is set by elastic load balancer
+      (env['HTTP_X_FORWARDED_PROTO'] == 'https' || env['HTTP_X_SCHEME'] == "https")
+    end
+    # See: http://stackoverflow.com/questions/10013812/how-to-prevent-jquery-ajax-from-following-a-redirect-after-a-post
+    def ajax?
+      env['HTTP_X_REQUESTED_WITH'].to_s.downcase == 'xmlhttprequest'
+    end
+    def cookie name
+      cookies[name.to_s]
+    end
+    def cookie? name
+      !cookie(name).to_s.empty?
+    end
+    def current_absolute_uri
+      prefix = secure? && !local? ? 'https://' : 'http://'
+      [prefix, http_host, request_path].join
+    end
+  end
+end

data/lib/otto/helpers/response.rb

@@ -0,0 +1,22 @@
+class Otto
+  module ResponseHelpers
+    attr_accessor :request
+    def send_secure_cookie name, value, ttl
+      send_cookie name, value, ttl, true
+    end
+    def send_cookie name, value, ttl, secure=true
+      secure = false if request.local?
+      opts = {
+        :value    => value,
+        :path     => '/',
+        :expires  => (Time.now.utc + ttl + 10),
+        :secure   => secure
+      }
+      #opts[:domain] = request.env['SERVER_NAME']
+      set_cookie name, opts
+    end
+    def delete_cookie name
+      send_cookie name, nil, -1.day
+    end
+  end
+end

data/lib/otto/route.rb

@@ -0,0 +1,97 @@
+
+class Otto
+  # Otto::Route
+  #
+  # A Route is a definition of a URL path and the method to call when
+  # that path is requested. Each route represents a single line in a
+  # routes file.
+  #
+  # e.g.
+  #
+  #      GET   /uri/path      YourApp.method
+  #      GET   /uri/path2     YourApp#method
+  #
+  #
+  class Route
+    module ClassMethods
+      attr_accessor :otto
+    end
+    attr_reader :verb, :path, :pattern, :method, :klass, :name, :definition, :keys, :kind
+    attr_accessor :otto
+    def initialize verb, path, definition
+      @verb, @path, @definition = verb.to_s.upcase.to_sym, path, definition
+      @pattern, @keys = *compile(@path)
+      if !@definition.index('.').nil?
+        @klass, @name = @definition.split('.')
+        @kind = :class
+      elsif !@definition.index('#').nil?
+        @klass, @name = @definition.split('#')
+        @kind = :instance
+      else
+        raise ArgumentError, "Bad definition: #{@definition}"
+      end
+      @klass = eval(@klass)
+      #@method = eval(@klass).method(@name)
+    end
+    def pattern_regexp
+      Regexp.new(@path.gsub(/\/\*/, '/.+'))
+    end
+    def call(env, extra_params={})
+      extra_params ||= {}
+      req = Rack::Request.new(env)
+      res = Rack::Response.new
+      req.extend Otto::RequestHelpers
+      res.extend Otto::ResponseHelpers
+      res.request = req
+      req.params.merge! extra_params
+      req.params.replace Otto::Static.indifferent_params(req.params)
+      klass.extend Otto::Route::ClassMethods
+      klass.otto = self.otto
+      Otto.logger.debug "Route class: #{klass}"
+      case kind
+      when :instance
+        inst = klass.new req, res
+        inst.send(name)
+      when :class
+        klass.send(name, req, res)
+      else
+        raise RuntimeError, "Unsupported kind for #{@definition}: #{kind}"
+      end
+      res.body = [res.body] unless res.body.respond_to?(:each)
+      res.finish
+    end
+    # Brazenly borrowed from Sinatra::Base:
+    # https://github.com/sinatra/sinatra/blob/v1.2.6/lib/sinatra/base.rb#L1156
+    def compile(path)
+      keys = []
+      if path.respond_to? :to_str
+        special_chars = %w{. + ( ) $}
+        pattern =
+          path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            case match
+            when "*"
+              keys << 'splat'
+              "(.*?)"
+            when *special_chars
+              Regexp.escape(match)
+            else
+              keys << $2[1..-1]
+              "([^/?#]+)"
+            end
+          end
+        # Wrap the regex in parens so the regex works properly.
+        # They can fail when there's an | for example (matching only the last one).
+        # Note: this means we also need to remove the first matched value.
+        [/\A(#{pattern})\z/, keys]
+      elsif path.respond_to?(:keys) && path.respond_to?(:match)
+        [path, path.keys]
+      elsif path.respond_to?(:names) && path.respond_to?(:match)
+        [path, path.names]
+      elsif path.respond_to? :match
+        [path, keys]
+      else
+        raise TypeError, path
+      end
+    end
+  end
+end

data/lib/otto/static.rb

@@ -0,0 +1,36 @@
+
+class Otto
+
+  module Static
+    extend self
+    def server_error
+      [500, {'Content-Type'=>'text/plain'}, ["Server error"]]
+    end
+    def not_found
+      [404, {'Content-Type'=>'text/plain'}, ["Not Found"]]
+    end
+    # Enable string or symbol key access to the nested params hash.
+    def indifferent_params(params)
+      if params.is_a?(Hash)
+        params = indifferent_hash.merge(params)
+        params.each do |key, value|
+          next unless value.is_a?(Hash) || value.is_a?(Array)
+          params[key] = indifferent_params(value)
+        end
+      elsif params.is_a?(Array)
+        params.collect! do |value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            indifferent_params(value)
+          else
+            value
+          end
+        end
+      end
+    end
+    # Creates a Hash with indifferent access.
+    def indifferent_hash
+      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+    end
+  end
+
+end

data/lib/otto/version.rb

@@ -0,0 +1,22 @@
+#
+
+class Otto
+  # Otto::VERSION
+  #
+  module VERSION
+    def self.to_s
+      load_config
+      version = self.version
+      [version[:MAJOR], version[:MINOR], version[:PATCH]].join('.')
+    end
+
+    def self.inspect
+      to_s
+    end
+
+    def self.load_config
+      require 'yaml'
+      self.version ||= YAML.load_file(File.join(LIB_HOME, '..', 'VERSION.yml'))
+    end
+  end
+end

data/lib/otto.rb

@@ -1,45 +1,44 @@
+require 'logger'
 
 require 'rack/request'
 require 'rack/response'
 require 'rack/utils'
 require 'addressable/uri'
 
+require_relative 'otto/route'
+require_relative 'otto/static'
+require_relative 'otto/helpers/request'
+require_relative 'otto/helpers/response'
+require_relative 'otto/version'
+
+# Otto is a simple Rack router that allows you to define routes in a file
+#
+#
 class Otto
-  @debug = ENV['OTTO_DEBUG'] == 'true'
-  LIB_HOME = File.expand_path File.dirname(__FILE__) unless defined?(Otto::LIB_HOME)
+  LIB_HOME = __dir__ unless defined?(Otto::LIB_HOME)
 
-  module VERSION
-    def self.to_s
-      load_config
-      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
-    end
-    def self.inspect
-      to_s
-    end
-    def self.load_config
-      require 'yaml'
-      @version ||= YAML.load_file(File.join(LIB_HOME, '..', 'VERSION.yml'))
-    end
-  end
-end
+  @debug = ENV['OTTO_DEBUG'] == 'true'
+  @logger = Logger.new($stdout, Logger::INFO)
 
-class Otto
   attr_reader :routes, :routes_literal, :routes_static, :route_definitions
   attr_reader :option, :static_route
   attr_accessor :not_found, :server_error
+
   def initialize path=nil, opts={}
-    @routes_static =  { :GET => {} }
-    @routes =         { :GET => [] }
-    @routes_literal = { :GET => {} }
+    @routes_static =  { GET: {} }
+    @routes =         { GET: [] }
+    @routes_literal = { GET: {} }
     @route_definitions = {}
     @option = opts.merge({
-      :public => nil,
-      :locale => 'en'
+      public: nil,
+      locale: 'en'
     })
+    Otto.logger.debug "new Otto: #{opts}" if Otto.debug
     load(path) unless path.nil?
     super()
   end
   alias_method :options, :option
+
   def load path
     path = File.expand_path(path)
     raise ArgumentError, "Bad path: #{path}" unless File.exist?(path)
@@ -51,13 +50,14 @@ class Otto
         route.otto = self
         path_clean = path.gsub /\/$/, ''
         @route_definitions[route.definition] = route
-        STDERR.puts "route: #{route.pattern}" if Otto.debug
+        Otto.logger.debug "route: #{route.pattern}" if Otto.debug
         @routes[route.verb] ||= []
         @routes[route.verb] << route
         @routes_literal[route.verb] ||= {}
         @routes_literal[route.verb][path_clean] = route
-      rescue => ex
-        STDERR.puts "Bad route in #{path}: #{entry}"
+
+      rescue StandardError => ex
+        Otto.logger.error "Bad route in #{path}: #{entry}"
       end
     }
     self
@@ -79,7 +79,7 @@ class Otto
       # Files in the root directory can refer to themselves
       base_path = path if base_path == '/'
       static_path = File.join(option[:public], base_path)
-      STDERR.puts "new static route: #{base_path} (#{path})" if Otto.debug
+      Otto.logger.debug "new static route: #{base_path} (#{path})" if Otto.debug
       routes_static[:GET][base_path] = base_path
     end
   end
@@ -100,15 +100,15 @@ class Otto
     literal_routes = routes_literal[http_verb] || {}
     literal_routes.merge! routes_literal[:GET] if http_verb == :HEAD
     if static_route && http_verb == :GET && routes_static[:GET].member?(base_path)
-      #STDERR.puts " request: #{path_info} (static)"
+      #Otto.logger.debug " request: #{path_info} (static)"
       static_route.call(env)
     elsif literal_routes.has_key?(path_info_clean)
       route = literal_routes[path_info_clean]
-      #STDERR.puts " request: #{http_verb} #{path_info} (literal route: #{route.verb} #{route.path})"
+      #Otto.logger.debug " request: #{http_verb} #{path_info} (literal route: #{route.verb} #{route.path})"
       route.call(env)
     elsif static_route && http_verb == :GET && safe_file?(path_info)
       static_path = File.join(option[:public], base_path)
-      STDERR.puts " new static route: #{base_path} (#{path_info})"
+      Otto.logger.debug " new static route: #{base_path} (#{path_info})"
       routes_static[:GET][base_path] = base_path
       static_route.call(env)
     else
@@ -117,7 +117,7 @@ class Otto
       valid_routes = routes[http_verb] || []
       valid_routes.push *routes[:GET] if http_verb == :HEAD
       valid_routes.each { |route|
-        #STDERR.puts " request: #{http_verb} #{path_info} (trying route: #{route.verb} #{route.pattern})"
+        #Otto.logger.debug " request: #{http_verb} #{path_info} (trying route: #{route.verb} #{route.pattern})"
         if (match = route.pattern.match(path_info))
           values = match.captures.to_a
           # The first capture returned is the entire matched string b/c
@@ -151,7 +151,7 @@ class Otto
       end
     end
   rescue => ex
-    STDERR.puts ex.message, ex.backtrace
+    Otto.logger.error ex.message, ex.backtrace
     if found_route = literal_routes['/500']
       found_route.call env
     else
@@ -159,7 +159,6 @@ class Otto
     end
   end
 
-
   # Return the URI path for the given +route_definition+
   # e.g.
   #
@@ -199,130 +198,15 @@ class Otto
         locale
       }.reverse
     end
-    STDERR.puts "locale: #{locales} (#{accept_langs})" if Otto.debug
+    Otto.logger.debug "locale: #{locales} (#{accept_langs})" if Otto.debug
     locales.empty? ? nil : locales
   end
 
-  module Static
-    extend self
-    def server_error
-      [500, {'Content-Type'=>'text/plain'}, ["Server error"]]
-    end
-    def not_found
-      [404, {'Content-Type'=>'text/plain'}, ["Not Found"]]
-    end
-    # Enable string or symbol key access to the nested params hash.
-    def indifferent_params(params)
-      if params.is_a?(Hash)
-        params = indifferent_hash.merge(params)
-        params.each do |key, value|
-          next unless value.is_a?(Hash) || value.is_a?(Array)
-          params[key] = indifferent_params(value)
-        end
-      elsif params.is_a?(Array)
-        params.collect! do |value|
-          if value.is_a?(Hash) || value.is_a?(Array)
-            indifferent_params(value)
-          else
-            value
-          end
-        end
-      end
-    end
-    # Creates a Hash with indifferent access.
-    def indifferent_hash
-      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
-    end
-  end
-  #
-  # e.g.
-  #
-  #      GET   /uri/path      YourApp.method
-  #      GET   /uri/path2     YourApp#method
-  #
-  class Route
-    module ClassMethods
-      attr_accessor :otto
-    end
-    attr_reader :verb, :path, :pattern, :method, :klass, :name, :definition, :keys, :kind
-    attr_accessor :otto
-    def initialize verb, path, definition
-      @verb, @path, @definition = verb.to_s.upcase.to_sym, path, definition
-      @pattern, @keys = *compile(@path)
-      if !@definition.index('.').nil?
-        @klass, @name = @definition.split('.')
-        @kind = :class
-      elsif !@definition.index('#').nil?
-        @klass, @name = @definition.split('#')
-        @kind = :instance
-      else
-        raise ArgumentError, "Bad definition: #{@definition}"
-      end
-      @klass = eval(@klass)
-      #@method = eval(@klass).method(@name)
-    end
-    def pattern_regexp
-      Regexp.new(@path.gsub(/\/\*/, '/.+'))
-    end
-    def call(env, extra_params={})
-      extra_params ||= {}
-      req = Rack::Request.new(env)
-      res = Rack::Response.new
-      req.extend Otto::RequestHelpers
-      res.extend Otto::ResponseHelpers
-      res.request = req
-      req.params.merge! extra_params
-      req.params.replace Otto::Static.indifferent_params(req.params)
-      klass.extend Otto::Route::ClassMethods
-      klass.otto = self.otto
-      case kind
-      when :instance
-        inst = klass.new req, res
-        inst.send(name)
-      when :class
-        klass.send(name, req, res)
-      else
-        raise RuntimeError, "Unsupported kind for #{@definition}: #{kind}"
-      end
-      res.body = [res.body] unless res.body.respond_to?(:each)
-      res.finish
-    end
-    # Brazenly borrowed from Sinatra::Base:
-    # https://github.com/sinatra/sinatra/blob/v1.2.6/lib/sinatra/base.rb#L1156
-    def compile(path)
-      keys = []
-      if path.respond_to? :to_str
-        special_chars = %w{. + ( ) $}
-        pattern =
-          path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
-            case match
-            when "*"
-              keys << 'splat'
-              "(.*?)"
-            when *special_chars
-              Regexp.escape(match)
-            else
-              keys << $2[1..-1]
-              "([^/?#]+)"
-            end
-          end
-        # Wrap the regex in parens so the regex works properly.
-        # They can fail when there's an | for example (matching only the last one).
-        # Note: this means we also need to remove the first matched value.
-        [/\A(#{pattern})\z/, keys]
-      elsif path.respond_to?(:keys) && path.respond_to?(:match)
-        [path, path.keys]
-      elsif path.respond_to?(:names) && path.respond_to?(:match)
-        [path, path.names]
-      elsif path.respond_to? :match
-        [path, keys]
-      else
-        raise TypeError, path
-      end
-    end
-  end
   class << self
-    attr_accessor :debug
+    attr_accessor :debug, :logger
+  end
+
+  module ClassMethods
     def default
       @default ||= Otto.new
       @default
@@ -340,88 +224,5 @@ class Otto
       !guesses.flatten.select { |n| ENV['RACK_ENV'].to_s == n.to_s }.empty?
     end
   end
-  module RequestHelpers
-    def user_agent
-      env['HTTP_USER_AGENT']
-    end
-    # HTTP_X_FORWARDED_FOR is from the ELB (non-https only)
-    # and it can take the form: 74.121.244.2, 10.252.130.147
-    # HTTP_X_REAL_IP is from nginx
-    # REMOTE_ADDR is from thin
-    # There's no way to get the client IP address in HTTPS.
-    def client_ipaddress
-      env['HTTP_X_FORWARDED_FOR'].to_s.split(/,\s*/).first ||
-      env['HTTP_X_REAL_IP'] || env['REMOTE_ADDR']
-    end
-    def request_method
-      env['REQUEST_METHOD']
-    end
-    def current_server
-      [current_server_name, env['SERVER_PORT']].join(':')
-    end
-    def current_server_name
-      env['SERVER_NAME']
-    end
-    def http_host
-      env['HTTP_HOST']
-    end
-    def request_path
-      env['REQUEST_PATH']
-    end
-    def request_uri
-      env['REQUEST_URI']
-    end
-    def root_path
-      env['SCRIPT_NAME']
-    end
-    def absolute_suri host=current_server_name
-      prefix = local? ? 'http://' : 'https://'
-      [prefix, host, request_path].join
-    end
-    def local?
-      Otto.env?(:dev, :development) &&
-       (client_ipaddress == '127.0.0.1' ||
-       !client_ipaddress.match(/^10\.0\./).nil? ||
-       !client_ipaddress.match(/^192\.168\./).nil?)
-    end
-    def secure?
-      # X-Scheme is set by nginx
-      # X-FORWARDED-PROTO is set by elastic load balancer
-      (env['HTTP_X_FORWARDED_PROTO'] == 'https' || env['HTTP_X_SCHEME'] == "https")
-    end
-    # See: http://stackoverflow.com/questions/10013812/how-to-prevent-jquery-ajax-from-following-a-redirect-after-a-post
-    def ajax?
-      env['HTTP_X_REQUESTED_WITH'].to_s.downcase == 'xmlhttprequest'
-    end
-    def cookie name
-      cookies[name.to_s]
-    end
-    def cookie? name
-      !cookie(name).to_s.empty?
-    end
-    def current_absolute_uri
-      prefix = secure? && !local? ? 'https://' : 'http://'
-      [prefix, http_host, request_path].join
-    end
-  end
-  module ResponseHelpers
-    attr_accessor :request
-    def send_secure_cookie name, value, ttl
-      send_cookie name, value, ttl, true
-    end
-    def send_cookie name, value, ttl, secure=true
-      secure = false if request.local?
-      opts = {
-        :value    => value,
-        :path     => '/',
-        :expires  => (Time.now.utc + ttl + 10),
-        :secure   => secure
-      }
-      #opts[:domain] = request.env['SERVER_NAME']
-      set_cookie name, opts
-    end
-    def delete_cookie name
-      send_cookie name, nil, -1.day
-    end
-  end
+  extend ClassMethods
 end

data/otto.gemspec

@@ -1,32 +1,22 @@
 # -*- encoding: utf-8 -*-
 
-Gem::Specification.new do |s|
-  s.name = "otto"
-  s.version = "1.0.1"
-  s.summary = "Auto-define your rack-apps in plaintext."
-  s.description = "Otto: #{s.summary}"
-  s.email = "gems@solutious.com"
-  s.authors = ["Delano Mandelbaum"]
-  s.license = "MIT"
-  s.files = [
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "VERSION.yml",
-    "example/app.rb",
-    "example/config.ru",
-    "example/public/favicon.ico",
-    "example/public/img/otto.jpg",
-    "example/routes",
-    "lib/otto.rb",
-    "otto.gemspec"
-  ]
-  s.homepage = "https://github.com/delano/otto"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "3.2.22" # Update to the latest version
+Gem::Specification.new do |spec|
+  spec.name = "otto"
+  spec.version = "1.1.0-alpha1"
+  spec.summary = "Auto-define your rack-apps in plaintext."
+  spec.description = "Otto: #{spec.summary}"
+  spec.email = "gems@solutious.com"
+  spec.authors = ["Delano Mandelbaum"]
+  spec.license = "MIT"
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.homepage = "https://github.com/delano/otto"
+  spec.require_paths = ["lib"]
+  spec.rubygems_version = "3.2.22" # Update to the latest version
 
-  s.required_ruby_version = '>= 2.6.8'
+  spec.required_ruby_version = ['>= 2.6.8', '< 4.0']
 
-  s.add_dependency 'addressable', '>= 2.2.6'
-  s.add_dependency 'rack', '>= 1.2.1'
+  spec.add_dependency 'addressable', '>= 2.2.6'
+  spec.add_dependency 'rack', '>= 1.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: otto
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0.pre.alpha1
 platform: ruby
 authors:
 - Delano Mandelbaum
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-05 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -44,9 +44,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGES.txt
+- Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
-- Rakefile
 - VERSION.yml
 - example/app.rb
 - example/config.ru
@@ -54,6 +58,11 @@ files:
 - example/public/img/otto.jpg
 - example/routes
 - lib/otto.rb
+- lib/otto/helpers/request.rb
+- lib/otto/helpers/response.rb
+- lib/otto/route.rb
+- lib/otto/static.rb
+- lib/otto/version.rb
 - otto.gemspec
 homepage: https://github.com/delano/otto
 licenses:
@@ -68,13 +77,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: 2.6.8
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.5.15
 signing_key:
 specification_version: 4
 summary: Auto-define your rack-apps in plaintext.

data/Rakefile

@@ -1,43 +0,0 @@
-require "rubygems"
-require "rake"
-require "rake/clean"
-require 'yaml'
-
-require 'rdoc/task'
-
-config = YAML.load_file("VERSION.yml")
-task :default => ["build"]
-CLEAN.include [ 'pkg', 'doc' ]
-name = "otto"
-
-begin
-  require "jeweler"
-  Jeweler::Tasks.new do |gem|
-    gem.version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}"
-    gem.name = "otto"
-    gem.rubyforge_project = gem.name
-    gem.summary = "Auto-define your rack-apps in plaintext."
-    gem.description = "Auto-define your rack-apps in plaintext."
-    gem.email = "delano@solutious.com"
-    gem.homepage = "http://github.com/delano/otto"
-    gem.authors = ["Delano Mandelbaum"]
-    gem.add_dependency('rack',          '>= 1.2.1')
-    gem.add_dependency('addressable',    '>= 2.2.6')
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-
-RDoc::Task.new do |rdoc|
-  version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}"
-  rdoc.rdoc_dir = "doc"
-  rdoc.title = "otto #{version}"
-  rdoc.rdoc_files.include("README*")
-  rdoc.rdoc_files.include("LICENSE.txt")
-  rdoc.rdoc_files.include("bin/*.rb")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-end
-
-