otto 1.0.2 → 1.1.0.pre.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d33bafcf0fe1f9d883228b47ead7a87fe489ce46dace419a2192fd01b29724ba
-  data.tar.gz: e1c72eca01acae97e35910750884ef9c15c4af53d40167fadaa4ab6ec56865d3
+  metadata.gz: 23a54df729acf5a96e337f0d096aee18376e579771e85e0f3f02d9355b049baf
+  data.tar.gz: 871c1bebc912b19fda8f3730f905d29077f6aa5e88ab9a087a95be3ccf29d312
 SHA512:
-  metadata.gz: 976fc4b60c7db36d6a9ee0fd2e73d5b677f824af90a30d6f5d3d19173e3e41b0b381e6fa4d4a4da17948e0612d60c33ca59ed66925cf957bc5b47ecfbb5af0bd
-  data.tar.gz: 77d740c93c30f7bf63d711711ae350711c48807b2f8521167b532e9246eb8abde19235ffac97a3ee79f3142f273f8edc32b891c67b441db8bb50ea68672a0ca6
+  metadata.gz: 903a3264f15fdcf38b523c7c380dc3b6897f9670a1573c9a9a22edfc1e8e6d61f3f30f89fbb0e78b3db11dee2e824d423444d98d3010f03530e577410bade70c
+  data.tar.gz: c096b04cf99f7bf7d18c6441c625f4a304b1b98d8c04d83ee58f2a71f047196ea2dacae75abcfe04ad97324b40d169a952a1c1f4555e388c9c426e2d628e53a9

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,4 @@
 :MAJOR: 1
-:MINOR: 0
-:PATCH: 2
+:MINOR: 1
+:PATCH: 0
+:PRE: alpha2

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,27 @@
+#
+
+class Otto
+  # Otto::VERSION
+  #
+  module VERSION
+    def self.to_a
+      load_config
+      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]]
+    end
+
+    def self.to_s
+      version = to_a.join('.')
+      "#{version}-#{@version[:PRE]}" if @version[:PRE]
+    end
+
+    def self.inspect
+      to_s
+    end
+
+    def self.load_config
+      return if @version
+      require 'yaml'
+      @version = YAML.load_file(File.join(__dir__, '..', '..', '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,8 @@ class Otto
       end
     end
   rescue => ex
-    STDERR.puts ex.message, ex.backtrace
+    Otto.logger.error "#{ex.class}: #{ex.message} #{ex.backtrace.join("\n")}"
+
     if found_route = literal_routes['/500']
       found_route.call env
     else
@@ -159,7 +160,6 @@ class Otto
     end
   end
 
-
   # Return the URI path for the given +route_definition+
   # e.g.
   #
@@ -199,130 +199,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 +225,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,31 +1,24 @@
 # -*- encoding: utf-8 -*-
 
+require_relative 'lib/otto/version'
+
 Gem::Specification.new do |spec|
   spec.name = "otto"
-  spec.version = "1.0.2"
+  spec.version = Otto::VERSION.to_s
   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 = [
-    "LICENSE.txt",
-    "README.md",
-    "VERSION.yml",
-    "example/app.rb",
-    "example/config.ru",
-    "example/public/favicon.ico",
-    "example/public/img/otto.jpg",
-    "example/routes",
-    "lib/otto.rb",
-    "otto.gemspec"
-  ]
+  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
+  spec.rubygems_version = "3.5.15" # Update to the latest version
 
   spec.required_ruby_version = ['>= 2.6.8', '< 4.0']
 
-  spec.add_dependency 'addressable', '>= 2.2.6'
-  spec.add_dependency 'rack', '>= 1.2.1'
+  spec.add_runtime_dependency 'addressable', '~> 2.2', '>= 2.2.6'
+  spec.add_runtime_dependency 'rack', '~> 1.2', '>= 1.2.1'
 end

metadata

@@ -1,19 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: otto
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0.pre.alpha2
 platform: ruby
 authors:
 - Delano Mandelbaum
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.6
@@ -21,6 +24,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.6
@@ -28,6 +34,9 @@ dependencies:
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.1
@@ -35,6 +44,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.1
@@ -44,6 +56,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGES.txt
+- Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - VERSION.yml
@@ -53,6 +70,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:
@@ -76,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.15
 signing_key:
 specification_version: 4
 summary: Auto-define your rack-apps in plaintext.