rack-tail 0.0.1 → 1.0.0

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+Do this to generate your change history
+
+    git log --pretty=format:'  * %h - %s (%an, %ad)'
+
+### 1.0.0 (9 April 2014)
+
+* 4e008e1 - Adding more tests around headers (bethesque, Wed Apr 9 09:25:07 2014 +1000)
+* 9e3c82e - Refactored request handling to use an object with class methods (bethesque, Wed Apr 9 09:12:07 2014 +1000)
+* 203214f - Adding more tests (bethesque, Wed Apr 9 08:44:47 2014 +1000)
+* 530ee19 - Renamed Rack::TailFile to Rack::Tail (bethesque, Tue Apr 8 12:47:52 2014 +1000)
+* 1414ef9 - Removing realpath from root calculations (bethesque, Tue Apr 8 07:45:56 2014 +1000)
+* d015a68 - Added a 403 response when trying to access a file outside of the root (bethesque, Tue Apr 8 07:43:12 2014 +1000)
+* 80e128d - Initial commit (bethesque, Mon Apr 7 15:01:17 2014 +1000)

data/lib/rack/tail.rb

@@ -1,176 +1,19 @@
 require "rack/tail/version"
-
-require 'elif'
-require 'time'
-require 'rack/utils'
-require 'rack/mime'
+require "rack/tail/app"
 
 module Rack
-  # Rack::File serves files below the +root+ directory given, according to the
+
+  # Rack::Tail is shamelessly ripped off Rake::File
+
+  # Rack::Tail serves files below the +root+ directory given, according to the
   # path info of the Rack request.
   # e.g. when Rack::File.new("/etc") is used, you can access 'passwd' file
   # as http://localhost:9292/passwd
-  #
-  # Handlers can detect if bodies are a Rack::File, and use mechanisms
-  # like sendfile on the +path+.
-
-  class Tail
-
-    SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
-    ALLOWED_VERBS = %w[GET HEAD]
-
-    attr_accessor :root
-    attr_accessor :path
-    attr_accessor :cache_control
-
-    alias :to_path :path
-
-    def initialize(root, headers={}, default_mime = 'text/plain')
-      @root = root
-      @headers = headers
-      @default_mime = default_mime
-    end
-
-    def call(env)
-      dup._call(env)
-    end
-
-    F = ::File
-
-    def _call(env)
-      return fail(405, "Method Not Allowed") unless method_allowed?(env)
-      return fail(403, "Forbidden") unless path_is_within_root?(env)
-
-      @path = file_path(env)
-
-      if available?
-        serving(env)
-      else
-        fail(404, "File not found: #{path_info_for(env)}")
-      end
-    end
-
-    def method_allowed? env
-      ALLOWED_VERBS.include? env["REQUEST_METHOD"]
-    end
-
-    def available?
-      begin
-        F.file?(@path) && F.readable?(@path)
-      rescue SystemCallError
-        false
-      end
-    end
-
-    def path_info_for env
-      Utils.unescape(env["PATH_INFO"])
-    end
-
-    def path_is_within_root? env
-      root = root env
-      target = target_file env
-      !target.relative_path_from(root).to_s.split(SEPS).any?{|p| p == ".."}
-    end
-
-    def target_file env
-      path_info = Pathname.new("").join(*path_info_for(env).split(SEPS))
-      root = root env
-      root.join(path_info)
-    end
-
-    def root env
-      Pathname.new(@root)
-    end
-
-    def file_path(env)
-      target_file env
-    end
-
-    def serving(env)
-      last_modified = F.mtime(@path).httpdate
-      return [304, {}, []] if env['HTTP_IF_MODIFIED_SINCE'] == last_modified
-
-      headers = { "Last-Modified" => last_modified }
-      mime = Mime.mime_type(F.extname(@path), @default_mime)
-      headers["Content-Type"] = mime if mime
-
-      # Set custom headers
-      @headers.each { |field, content| headers[field] = content } if @headers
-
-      response = [ 200, headers, env["REQUEST_METHOD"] == "HEAD" ? [] : self ]
-      response[1]["Content-Length"] = requested_size(env, response).to_s
-      response
-    end
-
-    def requested_lines_size(env)
-      (env.fetch("QUERY_STRING")[/\d+/] || 50).to_i
-    end
-
-    def tail_size_for line_count
-      elif = Elif.new(@path)
-      tail_size = 0
-      line_count.times do
-        begin
-          tail_size += Rack::Utils.bytesize(elif.readline)
-        rescue EOFError
-          return tail_size
-        end
-      end
-      tail_size - 1 # Don't include the first \n
-    end
-
-
-    def requested_size(env, response)
-      # NOTE:
-      #   We check via File::size? whether this file provides size info
-      #   via stat (e.g. /proc files often don't), otherwise we have to
-      #   figure it out by reading the whole file into memory.
-      size = F.size?(@path) || Utils.bytesize(F.read(@path))
-
-      #TODO handle invalid lines
-      tail_size = tail_size_for requested_lines_size(env)
-
-      if tail_size == size
-        response[0] = 200
-        @range = 0..size-1
-      else
-        start_byte = size - tail_size - 1
-        @range = start_byte..size-1
-        response[0] = 206
-        response[1]["Content-Range"] = "bytes #{@range.begin}-#{@range.end}/#{size}"
-        size = @range.end - @range.begin + 1
-      end
-
-      size
-    end
-
-    def each
-      F.open(@path, "rb") do |file|
-        file.seek(@range.begin)
-        remaining_len = @range.end-@range.begin+1
-        while remaining_len > 0
-          part = file.read([8192, remaining_len].min)
-          break unless part
-          remaining_len -= part.length
-
-          yield part
-        end
-      end
-    end
 
-    private
+  module Tail
 
-    def fail(status, body)
-      body += "\n"
-      [
-        status,
-        {
-          "Content-Type" => "text/plain",
-          "Content-Length" => body.size.to_s,
-          "X-Cascade" => "pass"
-        },
-        [body]
-      ]
+    def self.new(root, headers={}, default_mime = 'text/plain', default_lines = 50)
+      App.new(root, headers, default_mime, default_lines)
     end
 
   end

data/lib/rack/tail/app.rb

@@ -0,0 +1,28 @@
+require "rack/tail/request_handler"
+
+module Rack
+
+  module Tail
+
+    class App
+
+      attr_accessor :cache_control
+      attr_reader :root
+
+      def initialize(root, headers, default_mime, default_lines)
+        @root = root
+        @headers = headers
+        @default_mime = default_mime
+        @default_lines = default_lines
+      end
+
+      def call(env)
+        RequestHandler.new(env, @root, @headers, @default_mime, @default_lines).call
+      end
+
+    end
+
+  end
+
+end
+

data/lib/rack/tail/request_handler.rb

@@ -0,0 +1,154 @@
+require 'elif'
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+
+module Rack
+  module Tail
+
+    class RequestHandler
+
+      SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
+      ALLOWED_VERBS = %w[GET HEAD]
+
+      attr_accessor :env
+      attr_accessor :root
+      attr_accessor :range
+      attr_accessor :path
+      attr_accessor :default_lines
+
+      def initialize(env, root, headers, default_mime, default_lines)
+        @root = Pathname.new(root)
+        @headers = headers
+        @default_mime = default_mime
+        @default_lines = default_lines
+        @env = env
+      end
+
+      F = ::File
+
+      def call
+        return fail(405, "Method Not Allowed") unless method_allowed?
+        return fail(403, "Forbidden") unless path_is_within_root?
+
+        if available?
+          serving
+        else
+          fail(404, "File not found: #{path_info}")
+        end
+      end
+
+      def method_allowed?
+        ALLOWED_VERBS.include? env["REQUEST_METHOD"]
+      end
+
+      def available?
+        begin
+          F.file?(path) && F.readable?(path)
+        rescue SystemCallError
+          false
+        end
+      end
+
+      def path_info
+        Utils.unescape(env["PATH_INFO"])
+      end
+
+      def path_is_within_root?
+        !path.relative_path_from(root).to_s.split(SEPS).any?{|p| p == ".."}
+      end
+
+      def path
+        @path ||= root.join(Pathname.new("").join(*path_info.split(SEPS)))
+      end
+
+      def serving
+        last_modified = F.mtime(path).httpdate
+        return [304, {}, []] if env['HTTP_IF_MODIFIED_SINCE'] == last_modified
+
+        headers = { "Last-Modified" => last_modified }
+        mime = Mime.mime_type(F.extname(path), @default_mime)
+        headers["Content-Type"] = mime if mime
+
+        # Set custom headers
+        @headers.each { |field, content| headers[field] = content } if @headers
+
+        response = [ 200, headers, env["REQUEST_METHOD"] == "HEAD" ? [] : self ]
+        response[1]["Content-Length"] = requested_size(response).to_s
+        response
+      end
+
+      def requested_lines_size
+        (env.fetch("QUERY_STRING")[/\d+/] || default_lines).to_i
+      end
+
+      def tail_size_for line_count
+        elif = Elif.new(path)
+        tail_size = 0
+        line_count.times do
+          begin
+            tail_size += Rack::Utils.bytesize(elif.readline)
+          rescue EOFError
+            return tail_size
+          end
+        end
+        tail_size - 1 # Don't include the first \n
+      end
+
+
+      def requested_size(response)
+        # NOTE:
+        #   We check via File::size? whether this file provides size info
+        #   via stat (e.g. /proc files often don't), otherwise we have to
+        #   figure it out by reading the whole file into memory.
+        size = F.size?(path) || Utils.bytesize(F.read(path))
+
+        # TODO handle invalid lines eg. lines=-3
+        tail_size = tail_size_for requested_lines_size
+
+        if tail_size == size
+          response[0] = 200
+          @range = 0..size-1
+        else
+          start_byte = size - tail_size - 1
+          @range = start_byte..size-1
+          response[0] = 206
+          response[1]["Content-Range"] = "bytes #{@range.begin}-#{@range.end}/#{size}"
+          size = @range.end - @range.begin + 1
+        end
+
+        size
+      end
+
+      def each
+        F.open(path, "rb") do |file|
+          file.seek(range.begin)
+          remaining_len = range.end-range.begin+1
+          while remaining_len > 0
+            part = file.read([8192, remaining_len].min)
+            break unless part
+            remaining_len -= part.length
+
+            yield part
+          end
+        end
+      end
+
+      private
+
+      def fail(status, body)
+        body += "\n"
+        [
+          status,
+          {
+            "Content-Type" => "text/plain",
+            "Content-Length" => body.size.to_s,
+            "X-Cascade" => "pass"
+          },
+          [body]
+        ]
+      end
+
+    end
+  end
+end

data/lib/rack/tail/version.rb

@@ -1,7 +1,7 @@
 module Rack
 
-  class Tail
-    VERSION = "0.0.1"
+  module Tail
+    VERSION = "1.0.0"
   end
 
 end

data/spec/fixtures/test

@@ -0,0 +1,5 @@
+1
+2
+3
+4
+5

data/spec/lib/rack/tail_spec.rb

@@ -1,63 +1,111 @@
 require 'rack/tail'
 require 'rack/test'
+
 describe Rack::Tail do
 
   include Rack::Test::Methods
 
-  def app
-    Rack::Tail.new root
-  end
+  let(:app) { Rack::Tail.new root, headers, mime_type, default_lines }
 
   let(:root) { './spec/fixtures' }
   let(:file_path) { root + file_name }
   let(:file_name) { "/test.txt" }
-  let(:file_contents) { File.read(file_path )}
+  let(:file_contents) { File.readlines(file_path).last(default_lines).join}
+  let(:default_lines) { File.readlines(file_path).count + 1 }
+  let(:mime_type) { 'content-type' }
+  let(:headers) { {"X-Custom-Header" => "blah"} }
+
+
 
   describe "GET" do
 
-    context "when the number of lines required is not specified" do
+    before do
+      subject
+    end
+
+    subject { get file_name }
+
+
+    it "adds the configured headers" do
+      expect(last_response.headers["X-Custom-Header"]).to eq "blah"
+    end
+
+    context "when the content type of the file can be determined" do
+      it "sets the content type" do
+        expect(last_response.headers['Content-Type']).to eq 'text/plain'
+      end
+    end
+
+    context "when the content type can't be determined" do
+      let(:file_name) { "/test" }
 
-      subject { get file_name }
+      context "when the default mime type is not specified" do
+
+        let(:app) { Rack::Tail.new root }
+
+        it "sets the content type to text/plain" do
+          expect(last_response.headers['Content-Type']).to eq 'text/plain'
+        end
+      end
+
+      context "when the default mime type is specified" do
+
+        it "uses the default mime type" do
+          expect(last_response.headers['Content-Type']).to eq mime_type
+        end
+      end
+
+    end
+
+    context "when the number of lines required is not specified and the default lines is less than the entire file" do
+
+      let(:default_lines) { 3 }
+
+      it "returns the default number of lines" do
+        expect(last_response.body).to eq(file_contents)
+      end
+
+      it "sets a status of 206" do
+        expect(last_response.status).to eq 206
+      end
+    end
+
+    context "when the number of lines required is not specified and the default lines is more than the number of lines in the file" do
 
       it "returns the entire file" do
-        subject
         expect(last_response.body).to eq(file_contents)
       end
 
       it "sets a status of 200" do
-        subject
         expect(last_response.status).to eq 200
       end
     end
 
-    context "when a number of lines is specified" do
+    context "when a number of lines is specified that is less than the number of lines in the file" do
       let(:file_contents) { File.readlines(file_path).last(2).join }
 
       subject { get file_name, "lines" => "2" }
 
       it "returns the last lines" do
-        subject
         expect(last_response.body).to eq(file_contents)
       end
 
       it "sets a status of 206" do
-        subject
         expect(last_response.status).to eq 206
       end
     end
 
     context "when a number of lines is specified that is more than the number of lines in the file" do
 
-      subject { get file_name, "lines" => "50" }
+      subject { get file_name, "lines" => "40" }
       let(:file_contents) { File.read(file_path )}
+      let(:default_lines) { 1 }
 
       it "returns the entire file" do
-        subject
         expect(last_response.body).to eq(file_contents)
       end
 
       it "sets a status of 200" do
-        subject
         expect(last_response.status).to eq 200
       end
     end
@@ -66,7 +114,6 @@ describe Rack::Tail do
       subject { get "something.txt" }
 
       it "sets a status of 404" do
-        subject
         expect(last_response.status).to eq 404
       end
     end
@@ -75,12 +122,10 @@ describe Rack::Tail do
       subject { get "../lib/rack/tail_file_spec.rb" }
 
       it "returns a 403 Forbidden" do
-        subject
         expect(last_response.status).to eq 403
       end
 
       it "does not return the file" do
-        subject
         expect(last_response.body).to_not eq(file_contents)
       end
     end
@@ -90,44 +135,56 @@ describe Rack::Tail do
       subject { get "../fixtures/blah/..#{file_name}" }
 
       it "returns a 200 Success" do
-        subject
-        expect(last_response.status).to eq 200
+        expect(last_response).to be_successful
       end
     end
   end
 
   describe "HEAD" do
 
+    before do
+      subject
+    end
+
     subject { head file_name }
 
-    context "when the number of lines required is not specified" do
-      let(:file_contents) { File.read(file_path )}
+    context "when the number of lines required is not specified and the default is less than the number of lines in the file" do
+
+      it "returns an empty body" do
+        expect(last_response.body.size).to eq 0
+      end
+
+      xit "sets a status of 206" do
+        expect(last_response.status).to eq 206
+      end
+    end
+
+    context "when the number of lines required is not specified and the default is more than the number of lines in the file" do
+
+      let(:default_lines) { File.readlines(file_path).count + 1 }
 
       it "returns an empty body" do
-        subject
         expect(last_response.body.size).to eq 0
       end
 
       it "sets a status of 200" do
-        subject
         expect(last_response.status).to eq 200
       end
     end
 
-    context "when a number of lines is specified" do
-      let(:file_contents) { File.readlines(file_path).last(2).join }
+    context "when a number of lines is specified that is less than the number of lines in the file" do
 
       subject { head file_name, "lines" => "2" }
+      let(:default_lines) { File.readlines(file_path).count + 1 }
 
       it "returns an empty body" do
-        subject
         expect(last_response.body.size).to eq 0
       end
 
       xit "sets a status of 206" do
-        subject
         expect(last_response.status).to eq 206
       end
+
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-tail
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -116,13 +116,17 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/rack/tail.rb
+- lib/rack/tail/app.rb
+- lib/rack/tail/request_handler.rb
 - lib/rack/tail/version.rb
 - rack-tail_file.gemspec
+- spec/fixtures/test
 - spec/fixtures/test.txt
 - spec/lib/rack/tail_spec.rb
 homepage: ''
@@ -140,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2096215012195119719
+      hash: -4478541751073078281
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -149,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2096215012195119719
+      hash: -4478541751073078281
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -157,5 +161,6 @@ signing_key:
 specification_version: 3
 summary: A rack app that serves the last lines of a file
 test_files:
+- spec/fixtures/test
 - spec/fixtures/test.txt
 - spec/lib/rack/tail_spec.rb