rack-staticifier 0.1.6

data/README.rdoc

@@ -0,0 +1,38 @@
+= Rack::Staticifier
+
+Rack::Staticifier is Rack middleware for staticly caching responses.
+
+== Install
+
+  $ gem sources -a http://gems.github.com
+  $ sudo gem install remi-rack-staticifier
+
+== Usage
+
+  require 'rack/staticifier'
+
+  # this will cache ALL responses in a 'cache' directory
+  use Rack::Staticifier
+
+  # this will cache ALL responses in a 'public/my/cached/stuff' directory
+  use Rack::Staticifier, :root => 'public/my/cached/stuff'
+
+  # this will only cache requests with 'foo' in the URL
+  use Rack::Staticifier do |env, response|
+    env['PATH_INFO'].include?('foo')
+  end
+
+  # this will only cache requests with 'hi' in the response body
+  use Rack::Staticifier do |env, response|
+    # response is a regular Rack response, eg. [200, {}, ['hi there']]
+    body = ''
+    response.last.each {|string| body << string }
+    body.include?('hi')
+  end
+
+  # this will only cache requests with 'foo' in the URL (incase you don't want to pass a block)
+  use Rack::Staticifier, :cache_if => lambda { |env, response| env['PATH_INFO'].include?('foo') }
+
+== TODO
+
+* compare to Rack::ResponseCache (in rack-contrib) ... maybe that can replace this, or vice-versa?

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+puts "\nGem: rack-staticifier\n\n"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = 'rack-staticifier'
+    s.summary     = 'Staticly cache requests to any Rack application'
+    s.email       = 'remi@remitaylor.com'
+    s.homepage    = 'http://github.com/remi/rack-staticifier'
+    s.description = 'Staticly cache requests to any Rack application - perfect for creating static sites/blogs/etc!'
+    s.authors     = %w( remi )
+    s.files       = FileList['[A-Z]*', '{lib,spec,bin,examples}/**/*'] 
+    # s.rubyforge_project = 'gemname'
+    # s.extra_rdoc_files = %w( README.rdoc )
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+# require 'hanna'
+# require 'darkfish-rdoc'
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'rack-staticifier'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  # rdoc.options += ["--template=#{`allison --path`}"]  # sudo gem install allison
+  # rdoc.options += %w( -f darkfish )                   # sudo gem install darkfish-rdoc
+  # rdoc.options += %w( -T hanna )                      # sudo gem install mislav-hanna
+  rdoc.options += %w( -m README.rdoc ) # the initial page displayed
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('rack-staticifier.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 6
+:major: 0
+:minor: 1

data/examples/blog-to-staticify/config.ru

@@ -0,0 +1,3 @@
+require 'my-blog'
+
+run Sinatra::Application

data/examples/blog-to-staticify/my-blog.rb

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+
+%w( rubygems sinatra maruku ).each {|lib| require lib }
+
+get '/' do
+  "welcome to my blog!"
+end
+
+get '/:name.html' do
+  file = File.join File.dirname(__FILE__), 'posts', "#{ params['name'] }.mkd"
+  if File.file? file
+    Maruku.new(File.read(file)).to_html
+  else
+    status 404
+    "Not Found!  #{ params['name'] }"
+  end
+end

data/examples/blog-to-staticify/paths-to-cache

@@ -0,0 +1,3 @@
+#! /bin/bash
+echo '/'
+ls posts/* | xargs -L 1 basename | sed 's|\(.*\)\.mkd|\/\1.html|g'

data/examples/blog-to-staticify/posts/first.mkd

@@ -0,0 +1,3 @@
+# First Post!
+
+hi!

data/examples/blog-to-staticify/posts/second.mkd

@@ -0,0 +1,5 @@
+# Totally
+
+## Awesome
+
+    post about nothing

data/examples/sinatra-blog-with-built-in-caching/my-sinatra-blog.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby
+# %w( rubygems sinatra rack/staticifier ).each {|lib| require lib }
+%w( rubygems sinatra ).each {|lib| require lib }
+require File.dirname(__FILE__) + '/../lib/rack-staticifier'
+
+use Rack::Staticifier
+
+set :public, 'cache'
+
+$posts = {
+  'hello-world' => '<html><body>Hello World!</body></html>',
+  'hi-there'    => 'Hi from my blog post text'
+}
+
+get '/' do
+  "Home Page rendered at #{ Time.now }"
+end
+
+get '/:post.html' do
+  name = params['post']
+  
+  if $posts.keys.include?(name)
+    $posts[name]
+
+  else
+    status 404
+    "Cannot find page: #{ name }" 
+  end
+end

data/lib/rack-staticifier.rb

@@ -0,0 +1,88 @@
+module Rack #:nodoc:
+
+  # Rack::Staticifier is Rack middleware for staticly caching responses.
+  #
+  # ==== Usage
+  #
+  #    # this will cache ALL responses in a 'cache' directory
+  #    use Rack::Staticifier
+  #  
+  #    # this will cache ALL responses in a 'public/my/cached/stuff' directory
+  #    use Rack::Staticifier, :root => 'public/my/cached/stuff'
+  #  
+  #    # this will only cache requests with 'foo' in the URL
+  #    use Rack::Staticifier do |env, response|
+  #      env['PATH_INFO'].include?('foo')
+  #    end
+  #  
+  #    # this will only cache requests with 'hi' in the response body
+  #    use Rack::Staticifier do |env, response|
+  #      # response is a regular Rack response, eg. [200, {}, ['hi there']]
+  #      body = ''
+  #      response.last.each {|string| body << string }
+  #      body.include?('hi')
+  #    end
+  #  
+  #    # this will only cache requests with 'foo' in the URL (incase you don't want to pass a block)
+  #    use Rack::Staticifier, :cache_if => lambda { |env, response| env['PATH_INFO'].include?('foo') }
+  #
+  class Staticifier
+
+    STATUS_CODES_NOT_TO_CACHE = [ 304 ]
+
+    # the Rack application
+    attr_reader :app
+
+    # configuration options
+    attr_reader :config
+
+    def initialize app, config_options = nil, &block
+      @app    = app
+      @config = default_config_options
+
+      config.merge!(config_options) if config_options
+      config[:cache_if] = block     if block
+    end
+
+    def call env
+      response = @app.call env
+      cache_response(env, response) if should_cache_response?(env, response)
+      response
+    end
+
+    private
+
+    def default_config_options
+      { :root => 'cache' }
+    end
+
+    def should_cache_response? env, response
+      return false if STATUS_CODES_NOT_TO_CACHE.include?(response.first) # there are certain HTTP Status Codes we should never cache
+      return false if response.last.respond_to?(:to_path) # we don't cache Rack::File's
+      return true unless config.keys.include?(:cache_if) and config[:cache_if].respond_to?(:call) # true if no cache_if / block
+
+      should_cache = config[:cache_if].call(env, response)
+      should_cache
+    end
+
+    def cache_response env, response
+      request_path = env['PATH_INFO']
+      request_path << 'index.html' if request_path.end_with?('/')
+
+      basename     = ::File.basename request_path
+      dirname      = ::File.join config[:root], ::File.dirname(request_path)
+      fullpath     = ::File.join dirname, basename
+
+      FileUtils.mkdir_p(dirname)
+      ::File.open(fullpath, 'w'){|f| f << response_body(response) }
+    end
+
+    def response_body response
+      body = ''
+      response.last.each {|string| body << string } # per the Rack spec, the last object should respond to #each
+      body
+    end
+
+  end
+
+end

data/lib/rack/staticifier.rb

@@ -0,0 +1,2 @@
+# require 'rack/staticifier'
+require 'rack-staticifier'

data/spec/rack-staticifier_spec.rb

@@ -0,0 +1,198 @@
+require 'rubygems'
+require 'rackbox'
+require 'fileutils'
+
+require File.dirname(__FILE__) + '/../lib/rack-staticifier'
+
+describe Rack::Staticifier do
+
+  before do
+    %w( public cache foo ).each {|dir| FileUtils.rm_rf dir }
+    @app = lambda {|env| [200, {}, ["hello from #{env['PATH_INFO']}"]] }
+  end
+
+  after :all do
+    %w( public cache foo ).each {|dir| FileUtils.rm_rf dir } # clean up!
+  end
+
+  it 'should render index.html for any requests ending in a slash' do
+    app = Rack::Staticifier.new @app
+
+    # for the '/' route
+    File.file?("cache/index.html").should be_false
+    RackBox.request app, "/"
+    File.file?("cache/index.html").should be_true
+    File.read("cache/index.html").should == "hello from /"
+
+    %w( foo/ bar/ ).each do |uri|
+      File.file?("cache/#{uri}index.html").should be_false
+      RackBox.request app, "/#{uri}"
+      File.file?("cache/#{uri}index.html").should be_true
+      File.read("cache/#{uri}index.html").should == "hello from /#{uri}"
+    end
+  end
+
+  it 'should cache all requests by default (in cache directory)' do
+    app = Rack::Staticifier.new @app
+
+    %w( foo bar ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_true
+      File.read("cache/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should cache all requests in a custom directory' do
+    app = Rack::Staticifier.new @app, :root => 'foo'
+
+    %w( foo bar ).each do |uri|
+      File.file?("foo/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("foo/#{uri}.html").should be_true
+      File.read("foo/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should cache all requests in a custom subdirectory' do
+    app = Rack::Staticifier.new @app, :root => 'foo/bar'
+
+    %w( foo bar ).each do |uri|
+      File.file?("foo/bar/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("foo/bar/#{uri}.html").should be_true
+      File.read("foo/bar/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should cache requests with slashes in them (create subdirectories)' do
+    app = Rack::Staticifier.new @app, :root => 'foo'
+
+    %w( hi/there a/b/c/1/2/3 totally/neato ).each do |uri|
+      File.file?("foo/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("foo/#{uri}.html").should be_true
+      File.read("foo/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should be able to only cache requests based on request environment' do
+    app = Rack::Staticifier.new @app, :cache_if => lambda {|env,resp| env['PATH_INFO'].include?('cache') }
+
+    %w( hi there crazy/person ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_false
+    end
+
+    %w( cache cache-me please/cache/me ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_true
+      File.read("cache/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should be able to only cache requests based on request environment (by passing a block)' do
+    app = Rack::Staticifier.new(@app){ |env,resp| env['PATH_INFO'].include?('cache') }
+
+    %w( hi there crazy/person ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_false
+    end
+
+    %w( cache cache-me please/cache/me ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_true
+      File.read("cache/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should be able to only cache requests based on generated response' do
+    app = Rack::Staticifier.new @app, :cache_if => lambda {|env,resp|
+      body = ''
+      resp[2].each {|s| body << s }
+      body.include?("hello from /foo")
+    }
+
+    %w( nope hi not/start/with/foo/x nor-me-foo ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_false
+    end
+
+    %w( foo fooooo foo/bar ).each do |uri|
+      File.file?("cache/#{uri}.html").should be_false
+      RackBox.request app, "/#{uri}.html"
+      File.file?("cache/#{uri}.html").should be_true
+      File.read("cache/#{uri}.html").should == "hello from /#{uri}.html"
+    end
+  end
+
+  it 'should not be cache a Rack::File (#to_path)' do
+    pending "either RackBox or Rack::MockRequest isn't happy about running this"
+
+=begin
+1)
+TypeError in 'Rack::Staticifier should not be cache a Rack::File (#to_path)'
+can't convert nil into String
+/usr/lib/ruby/gems/1.8/gems/rack-1.0.0/lib/rack/file.rb:81:in `initialize'
+/usr/lib/ruby/gems/1.8/gems/rack-1.0.0/lib/rack/file.rb:81:in `open'
+/usr/lib/ruby/gems/1.8/gems/rack-1.0.0/lib/rack/file.rb:81:in `each'
+/usr/lib/ruby/gems/1.8/gems/rack-1.0.0/lib/rack/mock.rb:126:in `initialize'
+/usr/lib/ruby/gems/1.8/gems/remi-rackbox-1.1.5/lib/rackbox/rack/sticky_sessions.rb:40:in `new'
+/usr/lib/ruby/gems/1.8/gems/remi-rackbox-1.1.5/lib/rackbox/rack/sticky_sessions.rb:40:in `request'
+/usr/lib/ruby/gems/1.8/gems/rack-1.0.0/lib/rack/mock.rb:55:in `get'
+/usr/lib/ruby/gems/1.8/gems/remi-rackbox-1.1.5/lib/rackbox/rackbox.rb:84:in `send'
+/usr/lib/ruby/gems/1.8/gems/remi-rackbox-1.1.5/lib/rackbox/rackbox.rb:84:in `request'
+./spec/rack-staticifier_spec.rb:137:
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_methods.rb:37:in `instance_eval'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_methods.rb:37:in `execute'
+/usr/lib/ruby/1.8/timeout.rb:53:in `timeout'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_methods.rb:34:in `execute'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_group_methods.rb:208:in `execute_examples'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_group_methods.rb:206:in `each'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_group_methods.rb:206:in `execute_examples'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/example/example_group_methods.rb:104:in `run'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/runner/example_group_runner.rb:23:in `run'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/runner/example_group_runner.rb:22:in `each'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/runner/example_group_runner.rb:22:in `run'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/runner/options.rb:117:in `run_examples'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/lib/spec/runner/command_line.rb:9:in `run'
+/usr/lib/ruby/gems/1.8/gems/rspec-1.2.2/bin/spec:4:
+/usr/bin/spec:19:in `load'
+/usr/bin/spec:19:
+=end
+
+    app = lambda {|env| [200, {}, Rack::File.new(__FILE__)] }
+    File.file?("cache/foo.html").should be_false
+    RackBox.request app, "/foo.html"
+    File.file?("cache/foo.html").should be_false # shouldn't be cached!
+
+    # just double check ...
+    app = lambda {|env| [200, {}, ["cache me!"]] }
+    File.file?("cache/foo.html").should be_false
+    RackBox.request app, "/foo.html"
+    File.file?("cache/foo.html").should be_true # normal #each should be cached
+  end
+
+  it 'should not cache responses with certain HTTP Status Codes' do
+    Rack::Staticifier::STATUS_CODES_NOT_TO_CACHE.each do |code|
+      app = lambda {|env| [code, {}, ["not cached"]] }
+      File.file?("foo.html").should be_false
+      RackBox.request app, "/foo.html"
+      File.file?("foo.html").should be_false # shouldn't be cached!
+    end
+
+    # this assumes that 304 will always be in STATUS_CODES_NOT_TO_CACHE ... want to double check!
+    app = lambda {|env| [304, {}, ["not cached"]] }
+    File.file?("foo.html").should be_false
+    RackBox.request app, "/foo.html"
+    File.file?("foo.html").should be_false # shouldn't be cached!
+  end
+
+  it 'should be able to customize the name of the cached file (?)'
+  
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: rack-staticifier
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 6
+  version: 0.1.6
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Staticly cache requests to any Rack application - perfect for creating static sites/blogs/etc!
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- examples/blog-to-staticify/config.ru
+- examples/blog-to-staticify/my-blog.rb
+- examples/blog-to-staticify/paths-to-cache
+- examples/blog-to-staticify/posts/first.mkd
+- examples/blog-to-staticify/posts/second.mkd
+- examples/sinatra-blog-with-built-in-caching/my-sinatra-blog.rb
+- lib/rack-staticifier.rb
+- lib/rack/staticifier.rb
+- spec/rack-staticifier_spec.rb
+has_rdoc: true
+homepage: http://github.com/remi/rack-staticifier
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Staticly cache requests to any Rack application
+test_files: 
+- spec/rack-staticifier_spec.rb
+- examples/blog-to-staticify/my-blog.rb
+- examples/sinatra-blog-with-built-in-caching/my-sinatra-blog.rb