pretty_proxy 3.0.1 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f0b7cd40975e96c78486559c56a14332c80c480
-  data.tar.gz: 36e64c2a281cf96d487b4258a096204f4f1bc9da
+  metadata.gz: 3d98ec7a74142c72c40fbc20de2aa4553829196e
+  data.tar.gz: 671e81774cfc968511a1b9350538411cf935b50e
 SHA512:
-  metadata.gz: dd0cd6022492f5b31122b58b52f8f907674b8c55c37f5d38dbc510d19f59904bdcab62714b35884670a0047f54169bce43c4c24ab7fc31646fd434a29079c650
-  data.tar.gz: 164ea3a9431730971635076a2173799fa87e555f35f0f5fc2aeba73220e903154c4ac122da8b670c8cafdc7f7d7449938afdeb0300e8684211e13f780d46ab30
+  metadata.gz: 38e3c0e99b16af783e0f34c488d94a161cb8a034eb9a5aef609c3a8117c0c8a6e051f0d8fb66cb4dc040cebc980da0a00edfeb718b186a34f1fc5a0b367ca843
+  data.tar.gz: b204811390ada1dadf6b127d377dea989f9c475a577bc99ff9050ca0d79b074aab10afdb7e75c0e0dd46c759c813c9c7e471d2430477a3656af7b2702af8c760

data/example/example.ru

@@ -11,9 +11,10 @@ proxy_path = pretty_proxy_new_args['proxy_path']
 original_domain = pretty_proxy_new_args['original_domain']
 original_paths = pretty_proxy_new_args['original_paths']
 
+# replace the constants with the paths without trailing slashs
 original_html = config['xhtml_template'].join("\n")
-                  .gsub('PROXY_PATH', proxy_path)
-                  .gsub('ORIGINAL_DOMAIN', original_domain)
+                  .gsub('PROXY_PATH', proxy_path[1..-2])
+                  .gsub('ORIGINAL_DOMAIN', original_domain[0..-2])
 
 pp = PrettyProxy.new(proxy_path, original_domain, original_paths)
 

data/example/example_spec.rb

@@ -17,6 +17,8 @@ proxy_url = original_domain + Pathname.new(proxy_path).join('.' + config['conten
 
 describe 'PrettyProxy example' do
   let (:pp) { PrettyProxy.new(proxy_path, original_domain, original_paths) }
-  it { expect(open(proxy_url)).to be_equivalent_to(pp.proxify_html(open(original_url), proxy_url)) }
+  let (:original_page) { open(original_url) }
+  let (:proxy_page) { open(proxy_url) }
+  it { expect(proxy_page.read).to be_equivalent_to(pp.proxify_html(original_page.read, proxy_url, original_page.content_type)) }
 end
 

data/lib/pretty_proxy.rb

@@ -51,6 +51,19 @@ require 'addressable/uri'
 # same of the original_domain.
 #
 # CHANGELOG:
+#   4.0.0
+#     * proxify_hyperlink don't take relative paths or urls anymore, only
+#       absolute urls. This is because the proxy url was used for a double
+#       purpose (know the proxy scheme+host+port and resolve relative
+#       hyperlinks). This can lead to the mistake of believing that the
+#       base url to resolve relative links in the page is the page url
+#       (what's false if the page has a base tag). See more in:
+#       http://www.w3.org/TR/html5/infrastructure.html#base-urls
+#     * proxify_html (and other methods who use it, as #call) use the base
+#       tag from the page to determine the base url, and add the the base
+#       tag (if the page don't have one) to simplify the assets proxification.
+#       All a[href] are changed to absolute urls.
+#     * rspec-html-matchers added as development dependency
 #   3.0.0
 #     * return a String for unproxify_url (and not more a URI)
 #        because this is a change in the API (and can break code) the major
@@ -147,84 +160,81 @@ class PrettyProxy < Rack::Proxy
     raise ArgumentError, "the url argument isn't a valid uri"
   end
 
-  # Take a hyperlink and the url of the proxy page (not the original page)
-  # where it come from and return the rewritten hyperlink. If the page
-  # pointed vy the hyperlink is in the proxy control the rewritten hyperlink
-  # gonna point to the proxyfied version, otherwise gonna point to the original
-  # version.
-  # @param hyperlink [String, URI::HTTP, URI::HTTPS] A string with a relative
-  #   path or an url (string or URI).
-  # @param proxy_page_url [String, URI::HTTP, URI::HTTPS] The url from the
-  #   proxy page where the hyperlink come from.
-  # @return [String] A relative path or an url.
+  # Take a absolute URL and the scheme://host[:port] of the proxy page
+  # (can have path/?query#fragment, but they are ignored) and return the
+  # rewritten hyperlink.
+  # The url only is rewritten to point the proxyfied version if it's under
+  # proxy control.
+  # If the url is under proxy control, but it's also a url to the proxy, the
+  # url isn't changed (to not double proxyfy, /proxy/ ~> /proxy/proxy/).
+  # @param hyperlink [String, URI::HTTP, URI::HTTPS] A string or URI object
+  #   with a absolute url.
+  # @param proxy_site [String, URI::HTTP, URI::HTTPS] A URL with
+  #   scheme://host[:port] to use in the hyperlink proxification.
+  # @return [String] A absolute URL.
   # @raise PrettyProxy::ProxyError
-  def proxify_hyperlink(hyperlink, proxy_page_url)
-    hyperlink = Addressable::URI.parse(hyperlink.clone)
-    proxy_page_url = Addressable::URI.parse(proxy_page_url)
-
-    # this is URI relative ('//duckduckgo.com', '/path', '../path')
-    if hyperlink.relative?
-      absolute_hyperlink = Addressable::URI.parse(unproxify_url(proxy_page_url))
-                                           .join(hyperlink)
-      if inside_proxy_control? absolute_hyperlink
-        # this is path relative ('../path', 'path', but not '//duckduckgo.com' or '/path')
-        if Pathname.new(hyperlink.path).relative?
-          if point_to_a_proxy_page?(absolute_hyperlink, proxy_page_url)
-            # in the case of a relative path in the original page who points
-            # to a proxy page, and the proxy page is inside the proxy control
-            # we have to use the absolute_hyperlink or the page will be double
-            # proxified. Example: ../proxy/content in http://example.com/proxy/content,
-            # with original_path as '/' is http://example.com/proxy/proxy/content
-            hyperlink = absolute_hyperlink
-          end
-        else
-          hyperlink.path = @proxy_path[0..-2] + absolute_hyperlink.path
-          hyperlink.host = proxy_page_url.host if hyperlink.host
-          hyperlink.port = proxy_page_url.port if hyperlink.port
-        end
-      else
-        hyperlink = absolute_hyperlink
-      end
-    else # the hyperlink is absolute
-      if inside_proxy_control? hyperlink
-        # if points to the proxy itself we don't double-proxify
-        unless point_to_a_proxy_page?(hyperlink, proxy_page_url)
-          hyperlink = proxify_uri(hyperlink, proxy_page_url)
-        end
-      end
-    end
+  def proxify_hyperlink(hyperlink, proxy_site)
+    hyperlink = Addressable::URI.parse(hyperlink)
+    proxy_site = Addressable::URI.parse(proxy_site)
 
-    hyperlink.to_s
+    if inside_proxy_control?(hyperlink) &&
+          ! point_to_a_proxy_page?(hyperlink, proxy_site)
+      proxify_uri(hyperlink, proxy_site).to_s
+    else
+      hyperlink.to_s
+    end
   end
 
-  # Take a (X)HTML Document and apply proxify_hyperlink to the 'href'
-  # attribute of each 'a' element.
+  # Take a (X)HTML Document add a base tag (if none) and apply
+  # proxify_hyperlink to the 'href' attribute of each 'a' element.
+  # If the page has a base tag leave it unchanged.
+  # If a valid mime_type is passed as argument, but the html argument
+  # can't be parsed by this mime-type it simple returns the first argument
+  # unchanged.
   # @param html [String] A (X)HTML document.
   # @param proxy_url [String, URI::HTTP, URI::HTTPS] The url where the
   #   the proxified version of the page will be displayed.
-  # @return [String] A copy of the document with the changes applied.
+  # @param mime_type [String] A string containing 'text/html' or
+  #   'application/xhtml+xml' (insensitive to case and any characters
+  #   before or after the type). Define if the content will be parsed as xml or
+  #   html. See this link for more info: http://www.w3.org/TR/xhtml-media-types/.
+  #   Raise an exception if an invalid value is provided.
+  # @return [String] A copy of the document with the changes applied,
+  #   or the original string, if the document can't be parsed.
   # @raise PrettyProxy::ProxyError
-  def proxify_html(html, proxy_url)
-    parsed_html = nil
-
-    # If you parse XHTML as HTML with Nokogiri and use to_s after the markup can be messed up
-		# 
-    # Example:     <meta name="description" content="not important" />
-    #   becomes    <meta name="description" content="not important" >
-    # To avoid this we parse a document who is XML valid as XML, and, otherwise as HTML
-    begin
-      # this also isn't a great way to do this
-      # the Nokogiri don't have exception classes, this way any StandardError will be silenced
-      options = Nokogiri::XML::ParseOptions::DEFAULT_XML &
-                  Nokogiri::XML::ParseOptions::STRICT &
-                  Nokogiri::XML::ParseOptions::DTDVALID
-      parsed_html = Nokogiri::XML::Document.parse(html, nil, nil, options)
-    rescue
-      parsed_html = Nokogiri::HTML(html)
+  def proxify_html(html, proxy_url, mime_type)
+    parsed_html = Utils.parse_html_or_xhtml(html, mime_type)
+
+    if parsed_html.nil?
+      return html
     end
 
-    parsed_html.css('a').each do | hyperlink |
-      hyperlink['href'] = proxify_hyperlink(hyperlink['href'], proxy_url)
+    # This isn't in conformance with the following document
+    # http://www.w3.org/TR/html5/infrastructure.html#base-urls
+    # but support to frames is not a priority
+    document_original_url = unproxify_url(proxy_url)
+    # in theory base must have a href... but to avoid an exception by bad html
+    base_tag = parsed_html.at_css('base[href]')
+    base_url = nil
+    if base_tag
+      base_url = Addressable::URI.parse(document_original_url)
+                                 .join(base_tag['href']).to_s
+    else
+      base_url = document_original_url
+    end
+
+    # the href isn't a obrigatory attribute of an anchor element
+    parsed_html.css('a[href]').each do | hyperlink |
+      absolute_hyperlink = Addressable::URI.parse(base_url)
+                                           .join(hyperlink['href']).to_s
+      hyperlink['href'] = proxify_hyperlink(absolute_hyperlink, proxy_url)
+    end
+
+    unless base_tag
+      is_XML = %r{application/xhtml\+xml}.match(mime_type)
+      base_tag = "<base href='#{document_original_url}' #{is_XML ? '/' : ''}>"
+      parsed_html.at_css('head').first_element_child
+                 .add_previous_sibling(base_tag)
     end
 
     parsed_html.to_s
@@ -312,7 +322,8 @@ class PrettyProxy < Rack::Proxy
       fail ProxyError, 'unknown content-encoding, only encodings known are gzip, deflate and identity'
     end
 
-    page = proxify_html(page, Rack::Request.new(requested_to_proxy_env).url)
+    request_to_proxy = Rack::Request.new(requested_to_proxy_env)
+    page = proxify_html(page, request_to_proxy.url, content_type)
     status, headers, page = sugared_rewrite_response([status, headers, page],
                                                       requested_to_proxy_env,
                                                       rewritten_env)
@@ -338,6 +349,8 @@ class PrettyProxy < Rack::Proxy
     [status, headers, [page]]
   end
 
+  # The simplest way to make use of this class is subclass this class and
+  # redefine this method.
   # @abstract This method is called only over (X)HTML responses, after they are
   #   decompressed and the hyperlinks proxified, before they are compressed
   #   again and the new content-length calculated.
@@ -412,7 +425,7 @@ class PrettyProxy < Rack::Proxy
     uri = absolute_uri.clone
 
     uri.site = proxy_site.site
-    uri.path = @proxy_path + uri.path[1..-1]
+    uri.path = @proxy_path[0..-2] + uri.path
 
     uri
   end
@@ -424,9 +437,45 @@ class PrettyProxy < Rack::Proxy
     def self.same_domain?(u1, u2)
       u1.normalized_scheme == u2.normalized_scheme &&
         u1.normalized_host == u2.normalized_host &&
-        u1.normalized_port == u2.normalized_port
+        u1.inferred_port == u2.inferred_port
     end
 
+    def self.parse_html_or_xhtml(doc, mime_type)
+      # If you parse XHTML as HTML with Nokogiri, and use to_s after, the markup
+      # can be messed up, breaking the structural integrity of the xml
+      # 
+      # Example:     <meta name="description" content="not important" />
+      #   becomes    <meta name="description" content="not important" >
+      #
+      # In the other side if you parse HTML as a XML, and use to_s after, the
+      # Nokogiri make empty content tags self-close
+      #
+      # Example:    <script type="text/javascript" src="/ballonizer.js"></script>
+      #   becomes:  <script type="text/javascript" src="/ballonizer.js" />
+      #
+      # What's even worse than the contrary (xml as html)
+      parsed_doc = nil
+
+      case mime_type
+      when /text\/html/i
+        parsed_doc = Nokogiri::HTML(doc)
+      when /application\/xhtml\+xml/i
+        options = Nokogiri::XML::ParseOptions::DEFAULT_XML &
+                    Nokogiri::XML::ParseOptions::STRICT &
+                    Nokogiri::XML::ParseOptions::NONET
+        begin
+          parsed_doc = Nokogiri::XML::Document.parse(doc, nil, nil, options)
+        rescue
+          return nil
+        end
+      else
+        fail ProxyError, "the only mime-types accepted are text/html and" +
+                         " application/xhtml+xml, the passed argument was " +
+                         "'#{mime_type}'"
+      end
+
+      parsed_doc
+    end
     def self.validate_proxy_path(proxy_path)
       fail ConfigError, "proxy_path argument don't start with a '/'" unless proxy_path.start_with? '/'
       fail ConfigError, "proxy_path argument don't end with a '/'" unless proxy_path.end_with? '/'

data/spec/pretty_proxy_spec.rb

@@ -1,5 +1,6 @@
 require 'pretty_proxy'
-require 'equivalent-xml' # needed for be_equivalent_to xml rspec matcher
+require 'equivalent-xml'
+require 'rspec-html-matchers'
 require 'zlib'
 require 'uri'
 
@@ -22,12 +23,13 @@ end
 
 describe PrettyProxy do
 
-  def generate_html_for_test(hyperlinks)
+  def generate_html_for_test(base_url, hyperlinks)
     doc = <<-END
 <!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">
 	<head>
+    #{base_url ? "<base href='#{base_url}' />" : ''}
 		<title>A title</title>
 		<meta http-equiv="content-type" content="application/xhtml+xml; charset=UTF-8" />
 	</head>
@@ -51,18 +53,43 @@ describe PrettyProxy do
     doc
   end
 
-  let(:original_html) { generate_html_for_test(['http://site.net/p2/p2_2/',
-                                                'http://othersite.net',
-                                                '../p3', '../p2/p2_2/',
-                                                'http://site.net/proxy/p1',
-                                                '../proxy/p1', '/p1']) }
+  let(:original_html_url) { 'http://site.net/p1' }
+  let(:requested_to_proxy_url) do
+    pp.proxify_hyperlink(original_html_url, 'http://site.net')
+  end
 
-  let(:proxified_html) { generate_html_for_test(['http://site.net/proxy/p2/p2_2/',
-                                                  'http://othersite.net',
-                                                  'http://site.net/p3', '../p2/p2_2/',
-                                                  'http://site.net/proxy/p1',
-                                                  'http://site.net/proxy/p1',
-                                                  '/proxy/p1']) }
+  let (:link_examples) do
+    [ 'http://site.net/p2/p2_2/', 'http://othersite.net', '../p3',
+      '../p2/p2_2/', 'http://site.net/proxy/p1', '../proxy/p1', '/p1'
+    ]
+  end
+
+  let(:html_base_href) { 'http://othersite.net/p1' }
+  let(:original_html_with_base) do
+    generate_html_for_test(html_base_href, link_examples)
+  end
+  let(:proxified_html_with_base) do
+    # in this case only the first link is proxified because all others are
+    # pointing for a site outside proxy control (or for the proxy itself)
+    generate_html_for_test(html_base_href, [
+      'http://site.net/proxy/p2/p2_2/', 'http://othersite.net',
+      'http://othersite.net/p3', 'http://othersite.net/p2/p2_2/',
+      'http://site.net/proxy/p1', 'http://othersite.net/proxy/p1',
+      'http://othersite.net/p1'
+    ])
+  end
+
+  let(:original_html) do
+    generate_html_for_test(nil, link_examples)
+  end
+  let(:proxified_html) do
+    generate_html_for_test(original_html_url, [
+      'http://site.net/proxy/p2/p2_2/', 'http://othersite.net',
+      'http://site.net/p3', 'http://site.net/proxy/p2/p2_2/',
+      'http://site.net/proxy/p1', 'http://site.net/proxy/p1',
+      'http://site.net/proxy/p1'
+    ])
+  end
 
   let (:correct_new_args_example) { ['/proxy/', 'http://myoriginalsite.com', '/content'] }
   let (:pp) { described_class.new(*correct_new_args_example) }
@@ -84,7 +111,6 @@ describe PrettyProxy do
       end
     end
 
-    # TODO: Add specs for '/' in the start of the proxy_path
     let (:right_args) { correct_new_args_example }
     context "when proxy_path doesn't start with a '/'" do
       it { expect {new.call('proxy/', right_args[1], right_args[2])}.to raise_error(PrettyProxy::ConfigError) }
@@ -169,7 +195,7 @@ describe PrettyProxy do
       expect(pp.unproxify_url('http://myproxy.net/proxys/sitez/p1/#id')).to eq 'http://site.net/p1/#id'
     end
     it 'change the port to the original' do
-      expect(URI(pp.unproxify_url('http://myproxy.net:9292/proxys/sitez/p1/#id')).port).to eq 80
+      expect(URI.parse(pp.unproxify_url('http://myproxy.net:9292/proxys/sitez/p1/#id')).port).to eq 80
     end
 
     context 'when the url redirect to the own proxy' do
@@ -188,36 +214,26 @@ describe PrettyProxy do
   describe '#proxify_hyperlink' do
     let (:pp) { described_class.new('/proxy/', 'http://site.net', ['/p1', '/p2/p2_2/']) }
 
-    it "proxify absolute paths to inside the proxy control" do
-      expect(pp.proxify_hyperlink('/p2/p2_2/', 'http://theproxy.net/proxy/p1')).to eq '/proxy/p2/p2_2/'
-    end
-    it "proxify hyperlinks with scheme to inside the proxy control" do
-      expect(pp.proxify_hyperlink('http://site.net/p2/p2_2/', 'http://theproxy.net/proxy/p1')).to eq 'http://theproxy.net/proxy/p2/p2_2/'
-    end
-    it "proxify hyperlinks without scheme to inside the proxy control" do
-      expect(pp.proxify_hyperlink('//site.net/p2/p2_2/', 'http://theproxy.net/proxy/p1')).to eq '//theproxy.net/proxy/p2/p2_2/'
+    it 'proxify urls that are inside the proxy control' do
+      original_link = 'http://site.net/p2/p2_2/'
+      url_proxy_page_with_the_link = 'http://theproxy.net/proxy/p1'
+      proxified_link = 'http://theproxy.net/proxy/p2/p2_2/'
+      expect(pp.proxify_hyperlink(original_link, url_proxy_page_with_the_link)).to eq proxified_link
     end
-    it "don't change hyperlinks with scheme to ouside the proxy control" do
-      expect(pp.proxify_hyperlink('http://othersite.net', 'http://theproxy.net/proxy/p1')).to eq 'http://othersite.net'
-    end
-    it 'change to urls the relative paths to outside the proxy control' do
-      expect(pp.proxify_hyperlink('../p3', 'http://theproxy.net/proxy/p1')).to eq 'http://site.net/p3'
-      expect(pp.proxify_hyperlink('../p2/p2_2', 'http://theproxy.net/proxy/p1')).to eq 'http://site.net/p2/p2_2' # without the trailing '/'
-    end
-    it "don't change relative paths to inside the proxy control" do
-      expect(pp.proxify_hyperlink('../p2/p2_2/', 'http://theproxy.net/proxy/p1')).to eq '../p2/p2_2/'
+    it "don't proxify urls that are outside proxy control" do
+      outside_site = 'http://othersite.net'
+      proxy_url = 'http://theproxy.net/proxy/p1'
+      expect(pp.proxify_hyperlink(outside_site, proxy_url)).to eq outside_site
     end
 
     context 'when the proxy itself is inside the proxy control' do
       let (:pp) { described_class.new('/proxy/', 'http://site.net', '/') }
       
-      it "dont't change urls to the proxy itself" do
-        expect(pp.proxify_hyperlink('http://site.net/proxy/p1', 'http://site.net/proxy/p1')).to eq 'http://site.net/proxy/p1'
-        expect(pp.proxify_hyperlink('http://site.net/proxy/p1', 'http://site.net/proxy/p2/p2_2/')).to eq 'http://site.net/proxy/p1'
-      end
-      it 'change to urls the relative paths to the proxy itself' do
-        expect(pp.proxify_hyperlink('../proxy/p1', 'http://site.net/proxy/p1')).to eq 'http://site.net/proxy/p1'
-        expect(pp.proxify_hyperlink('../../proxy/p1', 'http://site.net/proxy/p2/p2_2/')).to eq 'http://site.net/proxy/p1'
+      it "preserve urls to the proxy itself (don't double proxify)" do
+        proxy_url = 'http://site.net/proxy/p1'
+        another_proxy_url = 'http://site.net/proxy/p2/p2_2/'
+        expect(pp.proxify_hyperlink(proxy_url, proxy_url)).to eq proxy_url
+        expect(pp.proxify_hyperlink(proxy_url, another_proxy_url)).to eq proxy_url
       end
     end
   end
@@ -225,13 +241,44 @@ describe PrettyProxy do
   describe '#proxify_html' do
     let (:pp) { described_class.new('/proxy/', 'http://site.net', ['/p1', '/p2/p2_2/']) }
 
-    it 'apply #proxify_hyperlink in all hyperlinks in the page' do
+    # valid mime_types are 'text/html' and 'application/xhtml+xml' (with any
+    # others characters before or after)
+    context 'when the mime_type is invalid' do
+      it { expect {pp.proxify_html(original_html, 'http://site.net/proxy/p1', 'not a valid mime-type')}.to raise_error(described_class::ProxyError) }
+    end
+
+    context "when the content can't be parsed" do
+      it 'return the original string' do
+        # without the </b> to make this xml invalid the test fail
+        # (the href is changed)
+        page = '<a href="http://site.net/p2/p2_2/">test</a></b>'
+        expect(pp.proxify_html(page, 'http://proxy.net/proxy/p1', 'application/xhtml+xml')).to equal(page)
+      end
+    end
+
+    it 'apply #proxify_hyperlink in all anchors in the page' do
       # We aren't really testing with HTML, but with XHTML, what is a XML
       # This is because we dont have a matcher to test HTML equivalence, only XML equivalence
       # This test is not guaranteed to pass if the input is a HTML non-XHTML
       # The parse and unparse of the HTML can output a value who is not XML equivalent to the input
       # Maybe the way is use regex instead of Nokogiri to this work
-      expect(pp.proxify_html(original_html, 'http://site.net/proxy/p1')).to be_equivalent_to(proxified_html)
+      expect(pp.proxify_html(original_html, requested_to_proxy_url, 'application/xhtml+xml')).to be_equivalent_to(proxified_html)
+    end
+
+    context 'when the page has a base tag' do
+      subject do
+        pp.proxify_html(
+          original_html_with_base,
+          requested_to_proxy_url,
+          'application/xhtml+xml'
+        )
+      end
+      it 'do not alter the base tag' do
+        should have_tag("base[href='#{html_base_href}']")
+      end
+      it 'use the base tag href as base url for relative links' do
+        should be_equivalent_to(proxified_html_with_base)
+      end
     end
   end
 
@@ -299,19 +346,25 @@ describe PrettyProxy do
   describe '#rewrite_response' do
     let (:pp) { described_class.new('/proxy/', 'http://site.net', ['/p1', '/p2/p2_2/']) }
     # See http://rack.rubyforge.org/doc/SPEC.html for the rack env hash fields spec
-    let (:original_env) {{'HTTP_HOST' => 'site.net',
-                          'SCRIPT_NAME' => '',
-                          'PATH_INFO' => '/proxy/p1',
-                          'QUERY_STRING' => '',
-                          'SERVER_NAME' => 'site.net',
-                          'SERVER_PORT' => '80',
-                          'rack.url_scheme' => 'http'}}
+    let (:original_env) do
+      url = URI.parse(original_html_url)
+      { 'HTTP_HOST' => url.host,
+        'SCRIPT_NAME' => '',
+        'PATH_INFO' => pp.proxy_path[0..-2] + url.path,
+        'QUERY_STRING' => '',
+        'SERVER_NAME' => url.host,
+        'SERVER_PORT' => url.port,
+        'rack.url_scheme' => url.scheme
+      }
+    end
     let (:rewritten_env) { pp.rewrite_env(original_env) }
-    let (:response_example) { original_content =  [200,
-                                                  {'content-type' => 'application/xhtml+xml',
-                                                   'content-encoding' => 'identity',
-                                                   'content-length' => original_html.bytesize.to_s },
-                                                  [original_html]] }
+    let (:response_example) do
+      original_content = [200, {
+        'content-type' => 'application/xhtml+xml',
+        'content-encoding' => 'identity',
+        'content-length' => original_html.bytesize.to_s
+      }, [original_html]]
+    end
 
     context 'when the content-type is html or xhtml' do
       let (:original_response) { response_example }
@@ -319,11 +372,11 @@ describe PrettyProxy do
 
       let (:rewritten_headers) { subject[1] }
       let (:rewritten_body) { subject[2].join }
-      let (:original_url) { Rack::Request.new(original_env).url }
+      let (:requested_to_proxy_url) { Rack::Request.new(original_env).url }
 
       # NOTE: TESTING ONLY WITH XHTML, BY THE SAME MOTIVE EXPLAINED IN THE #proxify_html SPEC
       it 'apply #proxify_html to the body' do
-        expect(rewritten_body).to be_equivalent_to pp.proxify_html(original_html, original_url)
+        expect(rewritten_body).to be_equivalent_to pp.proxify_html(original_html, requested_to_proxy_url, 'application/xhtml+xml')
       end
 
       it 'change the content-length header to the new size of the body' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pretty_proxy
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.1
 platform: ruby
 authors:
 - Henrique Becker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-30 00:00:00.000000000 Z
+date: 2013-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -150,6 +150,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-html-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
 description: If you want to replicate a site section with some change (like translation)
   and mantain the url pretty maybe this is the right library.
 email: henriquebecker91@gmail.com
@@ -184,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A Rack::Proxy child pretty url oriented