rack-mason 0.1.2

data/examples/railsapp/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/examples/railsapp/script/about

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+$LOAD_PATH.unshift "#{RAILTIES_PATH}/builtin/rails_info"
+require 'commands/about'

data/examples/railsapp/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/console'

data/examples/railsapp/script/dbconsole

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/dbconsole'

data/examples/railsapp/script/destroy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/destroy'

data/examples/railsapp/script/generate

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/generate'

data/examples/railsapp/script/performance/benchmarker

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../../config/boot',  __FILE__)
+require 'commands/performance/benchmarker'

data/examples/railsapp/script/performance/profiler

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../../config/boot',  __FILE__)
+require 'commands/performance/profiler'

data/examples/railsapp/script/plugin

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/plugin'

data/examples/railsapp/script/runner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/runner'

data/examples/railsapp/script/server

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/server'

data/examples/railsapp/test/functional/tommy_boy_controller_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class TommyBoyControllerTest < ActionController::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/examples/railsapp/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionController::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/examples/railsapp/test/test_helper.rb

@@ -0,0 +1,38 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+class ActiveSupport::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/examples/railsapp/test/unit/helpers/tommy_boy_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class TommyBoyHelperTest < ActionView::TestCase
+end

data/examples/sinatraapp/app.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'sinatra'
+require File.join(File.dirname(__FILE__), '..', 'middlewares', 'initial')
+require File.join(File.dirname(__FILE__), '..', 'middlewares', 'intro')
+require File.join(File.dirname(__FILE__), '..', 'middlewares', 'l337')
+require File.join(File.dirname(__FILE__), '..', 'middlewares', 'stylizer')
+
+# Note that these middlewares will seem to be applied in backwards order.
+# In other words, Rack::Stylizer parses the resulting HTML first, then
+# passes it to Rack::Initial, then to Rack::L337, and finally to Rack::Intro.
+
+1.times do
+  use Rack::Intro
+  use Rack::L337
+  use Rack::Initial
+  use Rack::Stylizer
+end
+
+get '/' do
+  %Q{
+    <!DOCTYPE html
+    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+      <head>
+        <title>The Greatest Movie of All Time</title>
+      </head>
+      <body>
+        <div id="container">
+          <p>
+            What my associate is trying to say is that our new brake pads are really cool.
+            You're not even gonna believe it.
+          </p>
+          <p>
+            Like, um, let's say you're driving along
+            the road, with your family.<br />
+            And you're driving along...la de da...woo...<br />
+            And then all of a sudden
+            there's a truck tire
+            in the middle of the road
+            and you hit the brakes.<br />
+            Screeeee!
+          </p>
+          <p>
+            Woah, that was close.
+          </p>
+          <p>
+            Now let's see what happens when you're
+            driving with "the other guy's brake pads".
+          </p>
+          <p>
+            You're driving along,<br />
+            you're driving along,<br />
+            and all of a sudden your kids are
+            yelling from the back seat:<br />
+            "I gotta go to the bathroom, daddy!"<br />
+            "Not now, dammit!"<br />
+            "Truck tire! I can't stop! Aaaaa! Help!"<br />
+            "There's a cliff! Aaaaa!"<br />
+            And your family screaming:<br />
+            "Oh my God, we're burning alive!"<br />
+            "No! I can't feel my legs!"<br />
+            Here comes the meat-wagon! Woo woo woo!<br />
+            And the medic gets out and says:<br />
+            "Oh! My! God!"<br />
+            New guy's in the corner puking his guts out:<br />
+            Blllleeeeeeeaaaaaaaaaaah!<br />
+            Blllleeeeeeeaaaaaaaaaaah!<br />
+          </p>
+          <p>
+            All because you wanna save a coupla extra pennies.
+          </p>
+          <a href="/more">&laquo; inflict me with more &raquo;</a>
+        </div>
+      </body>
+    </html>
+  }
+end
+
+get '/more' do
+  %Q{
+    <!DOCTYPE html
+    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+      <head>
+        <title>More of the Greatest Movie of All Time</title>
+      </head>
+      <body>
+        <div id="container">
+          <p>
+            D+? Oh my God! I passed! I passed! Oh, man i got a D+! I'm gonna graduate!
+            I'm gonna graduate! D+!
+          </p>
+          <p>
+            Hey guys, do i look different now that i'm a college grad?
+          </p>
+          <p>
+            Apparently they give a lot fewer D+'s than D-'s.
+            It's not a grade they like to give out, i'll tell ya that right now.
+          </p>
+          <a href="/">&laquo; take me back &raquo;</a>
+        </div>
+      </body>
+    </html>
+  }
+end

data/gem.yml

@@ -0,0 +1,17 @@
+name: "rack-mason"
+version: "0.1.2"
+summary: "Helps you write Rack middleware using Nokogiri."
+description: 
+  If you are creating Rack middleware that changes the HTML response, use
+  Rack::Mason to get a head start.  Rack::Mason takes care of the
+  boilerplate Rack glue so that you can focus on simply changing the HTML.
+  
+  Note: this is a fork from https://github.com/techiferous/rack-mason (c) techiferous@gmail.com
+homepage: http://github.com/radiospiel/rack-mason  
+author: radiospiel
+email: radiospiel@open-lab.org  
+dependencies:
+  - nokogiri
+  - rack
+  - diffy
+  - colored

data/lib/mason_helper.rb

@@ -0,0 +1,76 @@
+class NokogiriString
+  attr :nokogiri
+  
+  def initialize(nokogiri)
+    @nokogiri = nokogiri
+  end
+  
+  # A NokogiriString is not really a String, but is good enought 
+  # in the Rack context to act like one. 
+  def kind_of?(what)
+    return true if what == String
+    super
+  end
+  
+  def to_str
+    @to_str ||= @nokogiri.to_s
+  end
+  
+  def bytesize
+    to_str.bytesize
+  end
+  
+  def to_s
+    to_str
+  end
+end
+
+module Rack
+
+  # MasonHelper was created to separate Mason's implementation from Mason's
+  # interface.
+  #
+  # This class basically contains all of the Rack code that you'd have to write every
+  # time you wanted to write a new middleware that modifies the HTML response.
+  #
+  module MasonHelper #:nodoc:
+
+    # Rack::Mason provides a call method so that your middleware doesn't have to.
+    def call(env)
+      status, @headers, @body = @app.call(env)
+      if status == 200 && html?
+        @request = Rack::Request.new(env)
+        body_string = @body.length == 1 ? @body[0] : @body.join("")
+
+        doc = body_string.respond_to?(:nokogiri) ? body_string.nokogiri : Nokogiri::HTML(body_string)
+        
+        if doc && update_body(doc) != false
+          update_response_body(NokogiriString.new(doc))
+        end
+      end
+
+      [status, @headers, @body]
+    end
+
+    private
+
+    def html?
+      @headers["Content-Type"].to_s.include?("text/html")
+    end
+
+    def update_response_body(body)
+      # If we're dealing with a Rails response, we don't want to throw the
+      # response object away, we just want to update the response string.
+      if @body.class.name == "ActionController::Response"
+        @body.body = body
+      else
+        @body = [body]
+      end
+
+      #
+      # The content lenght might have changed... but there is Rack::ContentLength to add
+      # it later on again.
+      @headers.delete 'Content-Length'
+    end
+  end
+end

data/lib/mason_test_helper.rb

@@ -0,0 +1,99 @@
+require 'rack/mock'
+require 'diffy'
+require 'colored'
+
+# Mix this module into Test::Unit::TestCase to have access to these
+# test helpers when using Test::Unit.
+#
+# Here's an example of how you can use these helper methods:
+#
+#   def test_basic_document
+#     before_html = %Q{
+#       <!DOCTYPE html
+#       PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
+#       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+#       <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+#         <head>
+#           <title>Testing Rack::SexChange</title>
+#         </head>
+#         <body>
+#           Hi, Mom!
+#         </body>
+#       </html>
+#     }
+#     expected_html = %Q{
+#       <!DOCTYPE html
+#       PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
+#       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+#       <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+#         <head>
+#           <title>Testing Rack::SexChange</title>
+#         </head>
+#         <body>
+#           Hi, Dad!
+#         </body>
+#       </html>
+#     }
+#     after_html = process_html(before_html, Rack::SexChange)
+#     assert_html_equal expected_html, after_html
+#   end
+#
+# And here's an example of how you'd mix these helper methods into
+# Test::Unit::TestCase:
+#
+#   require 'test/unit'
+#   require 'rubygems'
+#   require 'plastic_test_helper'
+# 
+#   module Test
+#     module Unit
+#       class TestCase
+#     
+#         include MasonTestHelper
+# 
+#       end
+#     end
+#   end
+#
+module MasonTestHelper
+
+  # This takes care of the "plumbing" involved in testing your middleware.
+  # All you have to provide is an input HTML string, the class of
+  # your middleware (not the name of your class or an object, but
+  # the class itself), and finally some optional options to use when
+  # instantiating your middleware class.
+  #
+  # This method will run the input HTML string through the middleware
+  # and return the resulting HTML string (the body of the middleware's response).
+  #
+  # Examples:
+  #   resulting_html = process_html(input_html, Rack::Linkify)
+  #   resulting_html = process_html(input_html, Rack::Linkify, :twitter => true)
+  #
+  def process_html(html, middleware_class, options={})
+    app = lambda { |env| [200, {'Content-Type' => 'text/html'}, [html]] }
+    app2 = middleware_class.new(app, options)
+    Rack::MockRequest.new(app2).get('/', :lint => true).body
+  end
+
+  # this convenience method makes it easy to test changes to HTML strings
+  #
+  def assert_html_equal(expected_html_string, actual_html_string)
+    # Nokogiri does not preserve the same whitespace between tags when
+    # it processes HTML.  This means we can't do a simple string comparison.
+    # However, if we run both the expected HTML string and the actual HTML
+    # string through Nokogiri, then the whitespace will be changed in
+    # the same way and we can do a simple string comparison.
+    expected = Nokogiri::HTML(expected_html_string).to_html
+    actual = Nokogiri::HTML(actual_html_string).to_html
+    preamble = "\n"
+    preamble =  "*****************************************************\n"
+    preamble << "* The actual HTML does not match the expected HTML. *\n"
+    preamble << "* The differences are highlighted below.            *\n"
+    preamble << "*****************************************************\n"
+    message = preamble.magenta
+    message << Diffy::Diff.new(expected, actual).to_s(:color)
+    assert_block(message) { expected == actual }
+  end
+      
+end

data/lib/rack-mason.rb

@@ -0,0 +1,70 @@
+require 'nokogiri'
+require File.join(File.dirname(__FILE__), 'mason_helper')
+
+module Rack
+
+  # If you are creating Rack middleware that changes the HTML response, inherit
+  # from Rack::Mason to get a head start.  Rack::Mason takes care of the
+  # boilerplate Rack glue so that you can focus on simply changing the HTML.
+  #
+  # There are two ways you can change the HTML: as a Nokogiri document or as
+  # a string.  Simply define one of the following methods:
+  #
+  #   def update_body(doc)
+  #     ... insert code that changes the doc ...
+  #     doc
+  #   end
+  # 
+  # Rack::Mason also provides some convenience methods for interacting with
+  # Rack and Nokogiri.
+  #
+  class Mason
+    include MasonHelper
+
+    # Rack::Mason provides an initialize method so that your middleware
+    # doesn't have to.
+    #
+    def initialize(app, options = {}) #:nodoc:
+      @app = app
+      @options = options.freeze
+    end
+    
+    private
+
+    # returns the current request as a Rack::Request object
+    #
+    def request #:doc:
+      @request
+    end
+    
+    # returns the hash of options that were given to your middleware
+    #
+    def options #:doc:
+      @options
+    end
+
+    # a convenience method for adding a new HTML element as the first child
+    # of another HTML element
+    #
+    def add_first_child(parent, new_child) #:doc:
+      parent.children.first.add_previous_sibling(new_child)
+    end
+ 
+    # a convenience method for quickly creating a new HTML element
+    #
+    def create_node(doc, node_name, content=nil) #:doc:
+      node = Nokogiri::XML::Node.new(node_name, doc)
+      node.content = content if content
+      node
+    end
+    
+    # Nokogiri's node.content=(text) method automatically HTML escapes the given text.
+    # This can cause problems.  This method updates the text of an HTML element
+    # without escaping the text.
+    #
+    def update_text(node, new_text) #:doc:
+      node.send(:native_content=, new_text)
+    end
+
+  end
+end