rewritten 0.15.2 → 0.16.0

data/lib/rack/subdomain.rb

@@ -1,39 +1,31 @@
 require 'rack'
 
 module Rack
-
   module Rewritten
-
     class Subdomain
-
       def initialize(app, *fqdns)
         @app = app
         @fqdns = fqdns
       end
 
       def call(env)
-        puts "-> Rack::Rewritten::Subdomain"
+        puts '-> Rack::Rewritten::Subdomain'
         req = Rack::Request.new(env)
 
         @fqdns.each do |n|
           if req.host =~ /(.+)\.#{n}$/
-            if $1 == 'www'
+            if Regexp.last_match(1) == 'www'
               break
             else
-              env["SUBDOMAIN"] = $1
-              env["FQDN"] = n 
+              env['SUBDOMAIN'] = Regexp.last_match(1)
+              env['FQDN'] = n
               break
             end
           end
         end
 
-        @app.call(env) 
+        @app.call(env)
       end
-
     end
-
   end
-
 end
-
-

data/lib/rack/url.rb

@@ -1,11 +1,8 @@
 require 'rack'
 
 module Rack
-
   module Rewritten
-
     class Url
-
       attr_accessor :base_url
 
       def initialize(app, &block)
@@ -17,37 +14,39 @@ module Rack
         instance_eval(&block) if block_given?
       end
 
-      def is_internal_target?(url)
-        url.nil? or url.start_with?('/') or url.start_with?(@base_url)
+      def internal_target?(url)
+        url.nil? || url.start_with?('/') || url.start_with?(@base_url)
       end
 
-      def is_external_target?(url)
-        !is_internal_target?(url)
+      def external_target?(url)
+        !internal_target?(url)
       end
 
       def call(env)
         req = Rack::Request.new(env)
 
-        subdomain = env["SUBDOMAIN"] ? "#{env["SUBDOMAIN"]}:" : ""
+        subdomain = env['SUBDOMAIN'] ? "#{env['SUBDOMAIN']}:" : ''
 
         path = "#{subdomain}#{req.path_info}"
         path.downcase! if downcase_before_lookup?
 
         target_url = ::Rewritten.translate(path)
 
-        if is_external_target?(target_url)
+        if external_target?(target_url)
           r = Rack::Response.new
           r.redirect(target_url, 301)
           r.finish
-        elsif ::Rewritten.includes?(path.chomp("/")) or backwards=( translate_backwards? && ::Rewritten.exist_translation_for?(path) )
+        elsif ::Rewritten.includes?(req.fullpath) || ::Rewritten.includes?(path.chomp('/')) || backwards = (translate_backwards? && ::Rewritten.exist_translation_for?(path))
 
-          to = ::Rewritten.includes?(path.chomp("/")) || path
+          to = ::Rewritten.includes?(req.fullpath)
+          to ||= ::Rewritten.includes?(path.chomp('/')) || path
 
           current_path = ::Rewritten.get_current_translation(to)
-          current_path = current_path.split(":").last
+          current_path = current_path.split(':').last
+          current_path_with_query = current_path
           current_path = current_path.split('?')[0]
 
-          if (current_path == req.path_info) or (::Rewritten.base_from(req.path_info) == current_path) or ::Rewritten.has_flag?(path, 'L')
+          if (req.fullpath == current_path_with_query || current_path == req.path_info) || (::Rewritten.base_from(req.path_info) == current_path) || ::Rewritten.flag?(path, 'L')
             # if this is the current path, rewrite path and parameters
             tpath, tparams = split_to_path_params(to)
             env['QUERY_STRING'] = Rack::Utils.build_nested_query(tparams.merge(req.params))
@@ -59,12 +58,12 @@ module Rack
 
             r = Rack::Response.new
 
-            new_path = env["rack.url_scheme"].dup
-            new_path << "://"
-            new_path << env["HTTP_HOST"].dup.sub(/^#{subdomain.chomp(':')}\./, '')
+            new_path = env['rack.url_scheme'].dup
+            new_path << '://'
+            new_path << env['HTTP_HOST'].dup.sub(/^#{subdomain.chomp(':')}\./, '')
             new_path << current_path
             new_path << ::Rewritten.appendix(path) unless backwards
-            new_path << '?' << env["QUERY_STRING"] unless (env["QUERY_STRING"]||'').empty?
+            new_path << '?' << env['QUERY_STRING'] unless (env['QUERY_STRING'] || '').empty?
 
             r.redirect(new_path, 301)
             a = r.finish
@@ -85,24 +84,20 @@ module Rack
         @translate_backwards
       end
 
-      def translate_backwards=(yes_or_no)
-        @translate_backwards = yes_or_no
-      end
+      attr_writer :translate_backwards
 
       def downcase_before_lookup?
         @downcase_before_lookup
       end
 
-      def downcase_before_lookup=(yes_or_no)
-        @downcase_before_lookup = yes_or_no
-      end
+      attr_writer :downcase_before_lookup
 
       def translate_partial?
         @translate_partial
       end
 
       def translate_partial=(yes_or_no)
-        $stderr.puts "DEPRECATED. Please use Rewritten.translate_partial"
+        $stderr.puts 'DEPRECATED. Please use Rewritten.translate_partial'
         ::Rewritten.translate_partial = yes_or_no
       end
     end

data/lib/rewritten.rb

@@ -24,26 +24,24 @@ module Rewritten
     case server
     when String
       if server =~ /redis\:\/\//
-        redis = Redis.connect(:url => server, :thread_safe => true)
+        redis = Redis.connect(url: server, thread_safe: true)
       else
         server, namespace = server.split('/', 2)
         host, port, db = server.split(':')
-        redis = Redis.new(:host => host, :port => port,
-          :thread_safe => true, :db => db)
+        redis = Redis.new(host: host, port: port,
+                          thread_safe: true, db: db)
       end
       namespace ||= :rewritten
 
-      @redis = Redis::Namespace.new(namespace, :redis => redis)
+      @redis = Redis::Namespace.new(namespace, redis: redis)
     when Redis::Namespace
       @redis = server
     else
-      @redis = Redis::Namespace.new(:rewritten, :redis => server)
+      @redis = Redis::Namespace.new(:rewritten, redis: server)
     end
   end
 
-  def translate_partial=(yes_or_no)
-    @translate_partial = yes_or_no
-  end
+  attr_writer :translate_partial
 
   def translate_partial?
     @translate_partial
@@ -53,8 +51,8 @@ module Rewritten
   # create a new one.
   def redis
     return @redis if @redis
-    self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
-    self.redis
+    self.redis = Redis.respond_to?(:connect) ? Redis.connect : 'localhost:6379'
+    redis
   end
 
   def redis_id
@@ -62,7 +60,7 @@ module Rewritten
     if redis.respond_to?(:server)
       redis.server
     elsif redis.respond_to?(:nodes) # distributed
-      redis.nodes.map { |n| n.id }.join(', ')
+      redis.nodes.map(&:id).join(', ')
     else
       redis.client.id
     end
@@ -81,9 +79,7 @@ module Rewritten
 
   # Set a proc that will be called in the parent process before the
   # worker forks for the first time.
-  def before_first_fork=(before_first_fork)
-    @before_first_fork = before_first_fork
-  end
+  attr_writer :before_first_fork
 
   # The `before_fork` hook will be run in the **parent** process
   # before every job, so be careful- any changes you make will be
@@ -96,9 +92,7 @@ module Rewritten
   end
 
   # Set the before_fork proc.
-  def before_fork=(before_fork)
-    @before_fork = before_fork
-  end
+  attr_writer :before_fork
 
   # The `after_fork` hook will be run in the child process and is passed
   # the current job. Any changes you make, therefore, will only live as
@@ -111,9 +105,7 @@ module Rewritten
   end
 
   # Set the after_fork proc.
-  def after_fork=(after_fork)
-    @after_fork = after_fork
-  end
+  attr_writer :after_fork
 
   def to_s
     "Rewritten Client connected to #{redis_id}"
@@ -127,12 +119,10 @@ module Rewritten
   end
   alias_method :inline, :inline?
 
-  def inline=(inline)
-    @inline = inline
-  end
+  attr_writer :inline
 
   #
-  # translations 
+  # translations
   #
 
   def add_translation(line, to)
@@ -143,14 +133,14 @@ module Rewritten
     redis.hset("from:#{from}", :to, to)
     redis.hset("from:#{from}", :flags, flags) if flags
 
-    redis.sadd(:froms, from) 
-    redis.sadd(:tos, to) 
+    redis.sadd(:froms, from)
+    redis.sadd(:tos, to)
     score = redis.zcard("to:#{to}") || 0
-    redis.zadd("to:#{to}", score, from)  
+    redis.zadd("to:#{to}", score, from)
   end
 
   def add_translations(to, froms)
-    froms.each {|from|  add_translation(from, to)}
+    froms.each { |from|  add_translation(from, to) }
   end
 
   def num_translations(to)
@@ -195,29 +185,26 @@ module Rewritten
     Rewritten.redis.zrange("to:#{to}", 0, -1)
   end
 
-  def get_current_translation(path, tail=nil)
-
+  def get_current_translation(path, tail = nil)
     uri = URI.parse(path)
 
     # find directly
     translation = Rewritten.z_range("to:#{path}", -1)
-   
-    unless translation 
-      translation = Rewritten.z_range("to:#{uri.path}", -1)
-    end
+
+    translation = Rewritten.z_range("to:#{uri.path}", -1) unless translation
 
     if translation.nil?
       if translate_partial? && path.count('/') > 1
         parts = path.split('/')
-        shorter_path = parts.slice(0, parts.size-1).join('/')
-        appendix = parts.last + (tail ? "/" + tail : "")
-        return get_current_translation(shorter_path, appendix) 
+        shorter_path = parts.slice(0, parts.size - 1).join('/')
+        appendix = parts.last + (tail ? '/' + tail : '')
+        return get_current_translation(shorter_path, appendix)
       else
         return path
       end
     end
 
-    complete_path = (tail ? translation+"/"+tail : translation)
+    complete_path = (tail ? translation + '/' + tail : translation)
     translated_uri = URI.parse(complete_path)
     uri.path = translated_uri.path
     uri.query = [translated_uri.query, uri.query].compact.join('&')
@@ -225,10 +212,8 @@ module Rewritten
     uri.to_s
   end
 
-
   # infinitive for translations only!
   def infinitive(some_from)
-
     some_from ||= ''
 
     conjugated = some_from.chomp('/')
@@ -236,9 +221,9 @@ module Rewritten
     to = translate(conjugated)
     to = translate(conjugated.split('?')[0]) unless to
 
-    if to.nil? && translate_partial? && conjugated.count('/') > 1 
+    if to.nil? && translate_partial? && conjugated.count('/') > 1
       parts = conjugated.split('/')
-      shorter_path = parts.slice(0, parts.size-1).join('/')
+      shorter_path = parts.slice(0, parts.size - 1).join('/')
       infinitive(shorter_path)
     else
       conjugated = get_current_translation(to) if to
@@ -255,23 +240,21 @@ module Rewritten
       base_from
     elsif translate_partial? && base_from.count('/') > 1
       parts = base_from.split('/')
-      base_from(parts.slice(0,parts.size-1).join('/'))
-    else
-      nil
-    end
+      base_from(parts.slice(0, parts.size - 1).join('/'))
+        end
   end
 
   def appendix(some_from)
     base = base_from(some_from) || ''
-    result = some_from.partition( base ).last
+    result = some_from.partition(base).last
     result.chomp('/')
   end
 
   def get_flag_string(from)
-    Rewritten.redis.hget("from:#{from}", :flags)||""
+    Rewritten.redis.hget("from:#{from}", :flags) || ''
   end
 
-  def has_flag?(from, c)
+  def flag?(from, c)
     return false unless Rewritten.redis.exists("from:#{from}")
     get_flag_string(from).index(c) != nil
   end
@@ -279,12 +262,11 @@ module Rewritten
   def full_line(from)
     flags = get_flag_string(from)
 
-    if flags == ""
+    if flags == ''
       from
     else
-      "#{from} [#{flags}]" 
+      "#{from} [#{flags}]"
     end
-
   end
 
   def exist_translation_for?(path)
@@ -292,26 +274,24 @@ module Rewritten
   end
 
   def add_hit(path, code, content_type)
-    h = {:path => path, :code => code, :content_type => content_type}
-    Rewritten.redis.sadd("hits", encode(h) )
+    h = { path: path, code: code, content_type: content_type }
+    Rewritten.redis.sadd('hits', encode(h))
   end
 
   def all_hits
-    Rewritten.redis.smembers("hits").map{|e| decode(e)}
+    Rewritten.redis.smembers('hits').map { |e| decode(e) }
   end
 
   def includes?(path)
-
     result = Rewritten.redis.hget("from:#{path.chomp('/')}", :to)
     result = Rewritten.redis.hget("from:#{path.split('?')[0]}", :to) unless result
 
     if result.nil? && translate_partial? && path.count('/') > 1
       parts = path.split('/')
-      includes?( parts.slice(0,parts.size-1).join('/') )
+      includes?(parts.slice(0, parts.size - 1).join('/'))
     else
       result
     end
-
   end
 
   # return the number of froms
@@ -325,7 +305,7 @@ module Rewritten
     if count == 1
       redis.zrange(key, start, start)[0]
     else
-      Array(redis.zrange(key, start, start+count-1)).map do |item|
+      Array(redis.zrange(key, start, start + count - 1)).map do |item|
         item
       end
     end
@@ -337,7 +317,7 @@ module Rewritten
   end
 
   # Returns an array of all known URL targets.
-  def targets 
+  def targets
     Array(redis.smembers(:targets))
   end
 
@@ -353,29 +333,28 @@ module Rewritten
     redis.sadd(:queues, queue.to_s)
   end
 
-  
   #
   # stats
   #
 
   # Returns a hash, similar to redis-rb's #info, of interesting stats.
   def info
-    return {
-      :pending   => queues.inject(0) { |m,k| m + size(k) },
+    {
+      pending: queues.inject(0) { |m, k| m + size(k) },
       #:processed => Stat[:processed],
       #:queues    => queues.size,
       #:workers   => workers.size.to_i,
       #:working   => working.size,
       #:failed    => Stat[:failed],
-      :servers   => [redis_id],
-      :environment  => ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      servers: [redis_id],
+      environment: ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     }
   end
 
   # Returns an array of all known Resque keys in Redis. Redis' KEYS operation
   # is O(N) for the keyspace, so be careful - this can be slow for big databases.
   def keys
-    redis.keys("*").map do |key|
+    redis.keys('*').map do |key|
       key.sub("#{redis.namespace}:", '')
     end
   end
@@ -383,7 +362,4 @@ module Rewritten
   def per_page
     20
   end
-
-  
 end
-