url_mount 0.1.0 → 0.2.0

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gem 'rack'
+
+group :development do
+  gem 'rake'
+end
+
+group :test do
+  gem 'shoulda'
+end

data/Gemfile.lock

@@ -0,0 +1,25 @@
+--- 
+dependencies: 
+  rake: 
+    group: 
+    - :development
+    version: ">= 0"
+  shoulda: 
+    group: 
+    - :test
+    version: ">= 0"
+  rack: 
+    group: 
+    - :default
+    version: ">= 0"
+specs: 
+- rake: 
+    version: 0.8.7
+- rack: 
+    version: 1.1.0
+- shoulda: 
+    version: 2.10.3
+hash: 20813f28addb840e72440df2793e52ace4717691
+sources: 
+- Rubygems: 
+    uri: http://gemcutter.org

data/README.textile

@@ -0,0 +1,131 @@
+h1. UrlMount
+
+UrlMount is a universal mount point designed for use in rack applications.
+
+It provides a simple way to pass a url mounting point to the mounted application.
+
+This means that when you mount an application in the url space, it's a simple call to url to get the mount point of where the application is.
+
+h2. Example
+
+Say you mount an application at "/foo/bar"
+
+<pre><code>router.mount("/foo/bar").to(my_app)
+
+# behind the scenes, the routers mount method should do this:
+
+  if my_app.respond_to?(:url_mount=)
+    mount_point = UrlMount.new("/foo/bar")
+    my_app.url_mount = mount_point
+  end
+</code></pre>
+
+This means that if an application can handle a url_mount, you give it one.
+
+This then allows the +my_app+ applciation, to know where it's mounted.  Generating a url is now as simple as
+<pre><code>File.join(url_mount.url, "/local/url/path")</code></pre>
+
+The benefit of this is that all routers or applciations can make use of this.  If used, it can act as a universal glue between rack applications where parent apps can let the child applications know where they're mounted so the child applciations can have a chance of generating full routes, even when they're not in the request path.
+
+h3. Show me the code
+
+url_mount is made to be used with many routers that are currently available.
+
+<pre><code>
+# simple string mounting point
+mount = UrlMount.new("/foo/bar")
+mount.url == "/foo/bar"
+
+# Mount Point including variables
+mount = UrlMount.new("/foo/:bar", :bar => "bar")
+mount.url(:bar => "something") == "/foo/something"
+mount.url #=> Raises UrlMount::Ungeneratable because a required variable was not found
+mount.required_variables == [:bar]
+
+# UrlMount::Ungeneratable raised when a route cannot be generated without options
+no_mount = UrlMount.new("/foo/:bar") # fails because the mount point cannot be generated with no options
+
+# Mount Point including optional variables
+mount = UrlMount.new("/foo/:bar(/:baz)", :bar => "bar")
+mount.url(:bar => "doh") == "/foo/doh"
+mount.url(:bar => "doh", :baz => "hah") == "/foo/doh/hah"
+mount.required_variables == [:bar]
+mount.optional_variables == [:baz]
+
+# Mount Point with defaults
+mount = UrlMount.new("/foo/:bar(/:baz)", :bar => "default_bar")
+mount.url == "/foo/default_bar"
+mount.url(:baz => "baz_value") == "/foo/default_bar/baz_value"
+mount.url(:bar => "other_bar") == "/foo/other_bar"
+
+# Using procs for mount point defaults
+mount = UrlMount.new("/foo/:bar", :bar => proc{"some_bar"})
+mount.url == "/foo/some_bar"
+
+# Nested mounting point
+mount_parent = UrlMount.new("/foo/bar")
+mount_child  = UrlMount.new("/baz/:barry)
+
+mount_child.url_mount = mount_parent
+
+mount_parent.url == "/foo/bar"
+mount_child.url(:barry =>"barry_value") == "/foo/bar/baz/barry_value"
+</code></pre>
+
+Considering that UrlMounts can be nested, when you mount an application you should do it something like this.
+
+<pre><code>
+if mounted_app.respond_to?(:url_mount=)
+  mount = UrlMount.new(path, deafult_options)
+
+  # If this app is mounted, add this apps mount point to
+  # the mount point for the child app
+  mount.url_mount = self.url_mount if self.url_mount
+
+  mounted_app.url_mount = mount
+end
+</code></pre>
+
+h2. Generating routes
+
+When you generate routes, you can see which variables will be used by the mount point, so that you can remove these options from the options hash.  otherwise, depending on the generating application, you may get query string options.
+
+<pre><code>
+  url = UrlMount.new(/"foo/:bar(/:baz)", :bar => "some_bar")
+
+  generation_options = {:baz => "baz", :bar => "bar"}
+  mount_point = url.url(generation_options)
+
+  # We can now at this point ask the mount point what variables it will use if present.
+  url.variables.each{|v| generation_options.delete(v)}
+
+  # use the generation_options now without the mount_point variables to interfere with a query string
+</code></pre>
+
+h2. Callbacks
+
+When generating the routes, you can provide one or more callbacks to the mount point.  Inside the callbacks you can set options for the routes based on the Rack request.
+
+<pre><code>mount = UrlMount.new("/foo/:bar") do |env, opts|
+  opts[:bar] ||= "my_bar"
+end
+
+mount.url(env) # Rack::Request === env
+#=> /foo/my_bar
+</code></pre>
+
+NOTE: callbacks are only run when a rack environment is given to the url method
+
+h2. Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+h2. Copyright
+
+Copyright (c) 2010 Daniel Neighman. See LICENSE for details.

data/Rakefile

@@ -1,23 +1,6 @@
 require 'rubygems'
 require 'rake'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "url_mount"
-    gem.summary = %Q{Universal mounting points for rack applications}
-    gem.description = %Q{Glue to allow mounted rack applications to know where they're mounted}
-    gem.email = "has.sox@gmail.com"
-    gem.homepage = "http://github.com/hassox/url_mount"
-    gem.authors = ["Daniel Neighman"]
-    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
@@ -38,8 +21,6 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
-
 task :default => :test
 
 require 'rake/rdoctask'

data/lib/url_mount.rb

@@ -3,18 +3,30 @@ class UrlMount
   # Inspiration for this is taken straight from Usher.  http://github.com/joshbuddy/usher
   DELIMETERS = ['/', '(', ')']
 
-  attr_accessor :raw_path, :options, :url_mount
+  attr_accessor :raw_path, :options, :url_mount, :host, :scheme
   alias_method :defaults, :options
 
-  def initialize(path, opts = {})
+  def initialize(path, opts = {}, &blk)
     @raw_path, @options = path, opts
     @url_split_regex = Regexp.new("[^#{DELIMETERS.collect{|d| Regexp.quote(d)}.join}]+|[#{DELIMETERS.collect{|d| Regexp.quote(d)}.join}]")
+    @host, @scheme = opts[:host], opts[:scheme]
+    @callbacks = []
+    @callbacks << blk if blk
+  end
+
+  def callback(&blk)
+    @callbacks << blk if blk
+    @callbacks
   end
 
   def local_segments
     @local_segments || parse_local_segments
   end
 
+  def variables
+    required_variables + local_variables
+  end
+
   def required_variables
     @required_variables ||= begin
       required_variable_segments.map{|s| s.name}
@@ -48,17 +60,49 @@ class UrlMount
     end
   end
 
-  def to_s(opts = {})
-    opts = options.merge(opts)
-    requirements_met =  (required_variables - (opts.keys & required_variables)).empty?
+  def url(env = {}, opts = {})
+    unless env.key?('rack.version')
+      opts = env
+      env  = nil
+    end
 
-    raise Ungeneratable, "Missing required variables" unless requirements_met
-    File.join(local_segments.inject([]){|url, segment| str = segment.to_s(opts); url << str if str; url}) =~ /(.*?)\/?$/
-    result = $1
-    url_mount.nil? ? result : File.join(url_mount.to_s(opts), result)
+    @callbacks.each{|blk| blk.call(env,opts)} if env
+
+    requirements_met =  (local_required_variables - (opts.keys + options.keys)).empty?
+
+    if !required_to_generate? && !requirements_met
+      nil
+    else
+      raise Ungeneratable, "Missing required variables" if !requirements_met
+      File.join(local_segments.inject([]){|url, segment| str = segment.to_s(opts); url << str if str; url}) =~ /(.*?)\/?$/
+      path = local_segments.inject([]){|url, segment| str = segment.to_s(opts); url << str if str; url}.join
+      match = /(.*?)\/?$/.match(path)
+      result = match[1]
+      path = url_mount.nil? ? result : File.join(url_mount.to_s(opts), result)
+      if opts[:host] || host || opts[:scheme] || scheme
+        _host   = opts[:host]   || host
+        _scheme = opts[:scheme] || scheme || "http"
+        raise Ungeneratable, "Missing host when generating absolute url" if _scheme && !_host
+        uri = URI.parse(path)
+        uri.host    = _host
+        uri.scheme  = _scheme || "http"
+        uri.to_s
+      else
+        path
+      end
+    end
   end
+  alias_method :to_s, :url
 
   private
+  def local_required_variables
+    local_segments.select{|s| s.instance_of?(Segment::Variable)}.map{|s| s.name}
+  end
+
+  def required_to_generate?
+    true
+  end
+
   def parse_local_segments
     stack = []
     @local_segments = []
@@ -84,7 +128,7 @@ class UrlMount
         end
       when /^\:(.*)/
         if stack.empty?
-          @local_segments << Segment::Variable.new($1, true, options)
+          @local_segments << Segment::Variable.new($1, options)
         else
           buffer << segment
         end
@@ -104,9 +148,6 @@ class UrlMount
     class Base
       attr_accessor :name
 
-      def required!; @required = true; end
-      def required?; !!@required; end
-
       def optional_variable_segments; []; end
       def required_variable_segments; []; end
     end
@@ -121,12 +162,8 @@ class UrlMount
     end
 
     class Variable < Base
-      def initialize(name, required, options)
-        @name, @required = name.to_sym, true
-      end
-
-      def optional_variable_segments
-        []
+      def initialize(name, options)
+        @name, @options = name.to_sym, (options || {})
       end
 
       def required_variable_segments
@@ -134,26 +171,32 @@ class UrlMount
       end
 
       def to_s(opts = {})
-        opts[name]
+        item = opts[name] || @options[name]
+        item.respond_to?(:call) ? item.call : item
       end
     end
 
     class Conditional < Base
-      attr_reader :segments
-      def initialize(path, options)
-        @url_mount = UrlMount.new(path, options)
+      class UnrequiredUrlMount < UrlMount
+        private
+        def required_to_generate?; false; end
+      end
+
+      def initialize(*args)
+        @url_mount = UnrequiredUrlMount.new(*args)
       end
 
       def optional_variable_segments
-        (@url_mount.required_variable_segments + @url_mount.optional_variable_segments).map{|s| s.name}
+        (@url_mount.required_variable_segments + @url_mount.optional_variable_segments)
       end
 
-      def required_variable_segments; []; end
+      def required_variables; []; end
+      def optional_variables
+        (@url_mount.required_variables + @url_mount.optional_variables)
+      end
 
       def to_s(opts = {})
-        if (opts.keys & @url_mount.required_variables) == @url_mount.required_variables
-          @url_mount.to_s(opts)
-        end
+        @url_mount.to_s(opts)
       end
     end
   end

data/test/helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'rack'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))

data/test/test_url_mount.rb

@@ -8,7 +8,6 @@ class TestUrlMount < Test::Unit::TestCase
     assert_equal({:some => "options"}, u.defaults)
   end
 
-
   context "required variables" do
     should "calculate the required variables of the mount as an emtpy array when there are none" do
       u = UrlMount.new("/foo")
@@ -21,27 +20,44 @@ class TestUrlMount < Test::Unit::TestCase
     end
 
     should "calculate the required variables when there are some" do
-      u = UrlMount.new("/foo/:bar/baz/:homer")
+      u = UrlMount.new("/foo/:bar/baz/:homer", :bar => "bar", :homer => "homer")
       assert_equal [:bar, :homer], u.required_variables
       assert_equal( {:required => [:bar, :homer], :optional => []}, u.variables )
     end
 
+    should "calculate required variables from procs" do
+      u = UrlMount.new("/foo/:bar/:baz", :bar => "a_bar", :baz => proc{"baz_in_proc"})
+      assert_equal "/foo/a_bar/baz_in_proc", u.url
+    end
+
     should "generate a static url mount" do
       u = UrlMount.new("/foo/bar")
-      assert_equal "/foo/bar", u.to_s
+      assert_equal "/foo/bar", u.url
     end
 
     should "generate a dynamic url with static and variable segments" do
-      u = UrlMount.new("/foo/:bar/baz/:barry")
-      assert_equal "/foo/bar/baz/sue", u.to_s(:bar => "bar", :barry => "sue")
+      u = UrlMount.new("/foo/:bar/baz/:barry", :bar => "bar", :barry => "sue")
+      assert_equal "/foo/bar/baz/sue", u.url
     end
 
     should "raise an exception when a required variable is missing" do
-      u = UrlMount.new("/foo/:bar/:baz")
       assert_raises UrlMount::Ungeneratable do
-        u.to_s(:bar => "baz")
+        UrlMount.new("/foo/:bar/:baz").url
       end
     end
+
+    should "consume the options so the router does not use them" do
+      opts = {:bar => "bar", :other => "other"}
+      u = UrlMount.new("/foo/:bar", :bar => "some_default_bar")
+      u.url(opts)
+      assert_equal( {:bar => "bar", :other => "other"}, opts )
+    end
+
+    should "alias to_s to url" do
+      u = UrlMount.new "/foo/bar"
+      assert_equal u.to_s, u.url
+    end
+
   end
 
   context "optional variables" do
@@ -57,60 +73,63 @@ class TestUrlMount < Test::Unit::TestCase
 
     should "calculate optional variables when there are some" do
       u = UrlMount.new("/foo(/:bar(/:baz))")
-      assert_equal "/foo/gary", u.to_s(:bar => "gary")
+      assert_equal "/foo/gary", u.url(:bar => "gary")
     end
 
     should "skip nested optional variables when the optional parent is not present" do
       u = UrlMount.new("/foo(/:bar(/:baz))")
-      assert_equal "/foo", u.to_s(:baz => "sue")
+      assert_equal "/foo", u.url(:baz => "sue")
     end
   end
 
   context "default variables" do
     should "generate a simple url with a variable with a default" do
       u = UrlMount.new("/foo/:bar", :bar => "default")
-      assert_equal "/foo/default", u.to_s
+      assert_equal "/foo/default", u.url
     end
 
     should "generate urls with multiple varilables using defaults" do
       u = UrlMount.new("/foo/:bar/:baz", :bar => "bar", :baz => "baz")
-      assert_equal "/foo/bar/baz", u.to_s
+      assert_equal "/foo/bar/baz", u.url
     end
 
     should "generate urls with optional variables" do
       u = UrlMount.new("/foo(/:bar)", :bar => "bar")
-      assert_equal "/foo/bar", u.to_s
+      assert_equal "/foo/bar", u.url
     end
 
     should "generate urls with mixed variables" do
       u = UrlMount.new("/foo/:bar(/:baz(/:barry))", :barry => "bazz", :bar => "clue")
-      assert_equal "/foo/clue", u.to_s
-      assert_equal "/foo/clue/sue/bazz", u.to_s(:baz => "sue")
+      assert_equal "/foo/clue", u.url
+      assert_equal "/foo/clue/sue/bazz", u.url(:baz => "sue")
     end
 
     should "generate urls with overwritten defaults" do
       u = UrlMount.new("/foo/:bar(/:baz)", :bar => "barr", :baz => "bazz")
-      assert_equal "/foo/sue/larry",  u.to_s(:bar => "sue", :baz => "larry")
-      assert_equal "/foo/barr/gary",  u.to_s(:baz => "gary")
-      assert_equal "/foo/harry/bazz", u.to_s(:bar => "harry")
+      assert_equal "/foo/sue/larry",  u.url(:bar => "sue", :baz => "larry")
+      assert_equal "/foo/barr/gary",  u.url(:baz => "gary")
+      assert_equal "/foo/harry/bazz", u.url(:bar => "harry")
+    end
+
+    should "generate optional and fixed paths with procs" do
+      u = UrlMount.new("/foo/:bar(/:baz)",  :bar => proc{"the_bar"}, :baz => proc{"the_baz"})
+      assert_equal "/foo/the_bar/the_baz",  u.url
+      assert_equal "/foo/bar/other_baz",    u.url(:bar => "bar", :baz => proc{"other_baz"})
     end
   end
 
   context "complex compound urls" do
     should "generate complex urls containing multiple nested conditionals and multiple required variables" do
-      u = UrlMount.new("/foo(/:bar(/:baz))/:gary")
-      assert_equal "/foo/gary",           u.to_s(:gary => "gary")
-      assert_equal "/foo/bar/gary",       u.to_s(:gary => "gary", :bar => "bar")
-      assert_equal "/foo/bar/baz/gary",   u.to_s(:gary => "gary", :bar => "bar", :baz => "baz")
-      assert_raises UrlMount::Ungeneratable do
-        u.to_s(:bar => "bar")
-      end
+      u = UrlMount.new("/foo(/:bar(/:baz))/:gary", :gary => "gary")
+      assert_equal "/foo/gary",           u.url
+      assert_equal "/foo/bar/gary",       u.url(:bar => "bar")
+      assert_equal "/foo/bar/baz/gary",   u.url(:bar => "bar", :baz => "baz")
     end
   end
 
   context "nested url mounts" do
     should "allow a mount to accept a mount" do
-      u1 = UrlMount.new("/root/:bar")
+      u1 = UrlMount.new("/root/:bar", :bar => "bar")
       u2 = UrlMount.new("/baz/barry")
       u1.url_mount = u2
     end
@@ -118,9 +137,104 @@ class TestUrlMount < Test::Unit::TestCase
     should "generate the mount" do
       u1 = UrlMount.new("/root/bar")
       u2 = UrlMount.new("/baz/barry")
-      u1.url_mount = u2
-      assert "/root/bar", u1.to_s
-      assert "/root/bar/baz/barry", u2.to_s
+      u2.url_mount = u1
+      assert_equal "/root/bar", u1.url
+      assert_equal "/root/bar/baz/barry", u2.url
+    end
+
+    should "overwrite a parents options" do
+      u1 = UrlMount.new("/root/:bar", :bar => "bar")
+      u2 = UrlMount.new("/baz/barry")
+      u2.url_mount = u1
+      assert_equal "/root/different/baz/barry", u2.url(:bar => "different")
+    end
+
+    should "not consume params to nested routes" do
+      u1 = UrlMount.new("/root/:bar",   :bar => "bar")
+      u2 = UrlMount.new("/baz/:barry",  :barry => "barry")
+      u2.url_mount = u1
+      opts = {:bar => "sue", :barry => "wendy"}
+      assert_equal "/root/sue/baz/wendy", u2.url(opts)
+      assert_equal({:bar => "sue", :barry => "wendy"}, opts)
+    end
+  end
+
+  context "host options" do
+    should "generate an absolute url when given the host option" do
+      u = UrlMount.new("/foo/bar")
+      assert_equal "http://example.com/foo/bar", u.url(:host => "example.com")
+    end
+
+    should "generate an absolute url when the host option is set in the route" do
+      u = UrlMount.new("/foo/bar", :host => "example.com")
+      assert_equal "http://example.com/foo/bar", u.url
+    end
+
+    should "overwrite the host" do
+      u = UrlMount.new("/foo/bar", :host => "example.com")
+      assert_equal "http://foo.com/foo/bar", u.url(:host => "foo.com")
+    end
+
+    should "allow me to set the scheme" do
+      u = UrlMount.new("/foo/bar", :host => "example.com", :scheme => "https")
+      assert_equal "https://example.com/foo/bar", u.url
+    end
+
+    should "raise an exception if the scheme is set and not the host" do
+      u = UrlMount.new("/foo/bar")
+      assert_raises(UrlMount::Ungeneratable) do
+        u.url(:scheme => "https")
+      end
+    end
+  end
+
+  context "callbacks" do
+    should "let me add a callback" do
+      captures = []
+      u = UrlMount.new("/foo/bar") do |env, opts|
+        captures << :block
+        req = Rack::Request.new(env)
+        assert_equal "example.com", req.host
+        opts[:host] = req.host
+        opts[:scheme] = req.scheme
+      end
+      env = Rack::MockRequest.env_for("/", 'HTTP_HOST' => "example.com")
+      assert_equal "http://example.com/foo/bar", u.url(env)
+      assert_equal :block, captures.first
+    end
+
+    should "let me add many callbacks" do
+      captures = []
+      u = UrlMount.new("/foo/bar")
+      u.callback do |env, opts|
+        captures << :one
+        opts[:one] = :one
+      end
+      u.callback do |env, opts|
+        captures << :two
+        captures << opts[:one]
+      end
+      env = Rack::MockRequest.env_for("/", :host => "example.com")
+      assert_equal "/foo/bar", u.url(env)
+      assert_equal [:one, :two, :one], captures
+    end
+
+    should "not run the callbacks if the env is not available" do
+      captures = []
+      u = UrlMount.new("/foo/bar")
+      u.callback do |env, opts|
+        captures << :here
+      end
+      assert_equal "/foo/bar", u.url
+      assert_equal [], captures
+    end
+
+    should "let me generate a required option url via callbacks" do
+      env = Rack::MockRequest.env_for "/"
+      u = UrlMount.new("/foo/:bar") do |env, opts|
+        opts[:bar] ||= "here_is_my_bar"
+      end
+      assert_equal "/foo/here_is_my_bar", u.url(env)
     end
   end
 end

data/url_mount.gemspec

@@ -1,54 +1,22 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+require 'bundler'
 
 Gem::Specification.new do |s|
   s.name = %q{url_mount}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Daniel Neighman"]
-  s.date = %q{2010-02-18}
+  s.date = %q{2010-06-07}
   s.description = %q{Glue to allow mounted rack applications to know where they're mounted}
   s.email = %q{has.sox@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/url_mount.rb",
-     "test/helper.rb",
-     "test/test_url_mount.rb",
-     "url_mount.gemspec"
-  ]
+  s.files = Dir["**/*"]
   s.homepage = %q{http://github.com/hassox/url_mount}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Universal mounting points for rack applications}
-  s.test_files = [
-    "test/helper.rb",
-     "test/test_url_mount.rb"
-  ]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    else
-      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-  end
+  s.add_bundler_dependencies
 end
 

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: url_mount
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -9,38 +15,56 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-18 00:00:00 +11:00
+date: 2010-06-07 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: thoughtbot-shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  requirement: *id001
+  prerelease: false
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  name: rack
+  requirement: *id002
+  prerelease: false
+  type: :runtime
 description: Glue to allow mounted rack applications to know where they're mounted
 email: has.sox@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
-- .document
-- .gitignore
+- Gemfile
+- Gemfile.lock
+- lib/url_mount.rb
 - LICENSE
-- README.rdoc
+- pkg/url_mount-0.1.0.gem
 - Rakefile
-- VERSION
-- lib/url_mount.rb
+- README.textile
 - test/helper.rb
 - test/test_url_mount.rb
+- url_mount-0.2.0.gem
 - url_mount.gemspec
 has_rdoc: true
 homepage: http://github.com/hassox/url_mount
@@ -52,24 +76,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Universal mounting points for rack applications
-test_files: 
-- test/helper.rb
-- test/test_url_mount.rb
+test_files: []
+

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,22 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC
-*.gem

data/README.rdoc

@@ -1,94 +0,0 @@
-= UrlMount
-
-UrlMount is a universal mount point designed for use in rack applications.
-
-It provides a simple way to pass a url mounting point to the mounted application.
-
-This means that when you mount an application in the url space, it's a simple to_s to get the mount point of where the application is.
-
-== Example
-
-Say you mount an application at "/foo/bar"
-
-<pre><code>router.mount("/foo/bar").to(my_app)
-
-# behind the scenes, the routers mount method should do this:
-
-  if my_app.respond_to?(:url_mount=)
-    mount_point = UrlMount.new("/foo/bar")
-    my_app.url_mount = mount_point
-  end
-</code></pre>
-
-This means that if an application can handle a url_mount, you give it one.
-
-This then allows the +my_app+ applciation, to know where it's mounted.  Generating a url is now as simple as
-<pre><code>File.join(url_mount.to_s, "/local/url/path")</code></pre>
-
-The benefit of this is that all routers or applciations can make use of this.  If used, it can act as a universal glue between rack applications where parent apps can let the child applications know where they're mounted.
-
-=== Show me the code
-
-urlmount is made to be used with many routers that are currently available.
-
-<pre><code>
-# simple string mounting point
-mount = urlmount.new("/foo/bar")
-mount.to_s == "/foo/bar"
-
-# Mount Point including variables
-mount = UrlMount.new("/foo/:bar")
-mount.to_s(:bar => "something") == "/foo/something"
-mount.to_s #=> Raises UrlMount::Ungeneratable because a required variable was not found
-mount.required_variables == [:bar]
-
-# Mount Point including optional variables
-mount = UrlMount.new("/foo/:bar(/:baz)")
-mount.to_s(:bar => "doh") == "/foo/doh"
-mount.to_s(:bar => "doh", :baz => "hah") == "/foo/doh/hah"
-mount.required_variables == [:bar]
-mount.optional_variables == [:baz]
-
-# Mount Point with defaults
-mount = UrlMount.new("/foo/:bar(/:baz)", :bar => "default_bar")
-mount.to_s == "/foo/default_bar"
-mount.to_s(:baz => "baz_value") == "/foo/default_bar/baz_value"
-mount.to_s(:bar => "other_bar") == "/foo/other_bar"
-
-# Nested mounting point
-mount_parent = UrlMount.new("/foo/bar")
-mount_child  = UrlMount.new("/baz/:barry)
-
-mount_child.url_mount = mount_parent
-
-mount_parent.to_s == "/foo/bar"
-mount_child.to_s(:barry =>"barry_value") == "/foo/bar/baz/barry_value"
-</code></pre>
-
-Considering that UrlMounts can be nested, when you mount an application you should do it something like this.
-
-<pre><code>
-if mounted_app.respond_to?(:url_mount=)
-  mount = UrlMount.new(path, deafult_options)
-
-  # If this app is mounted, add this apps mount point to
-  # the mount point for the child app
-  mount.url_mount = self.url_mount if self.url_mount
-
-  mounted_app.url_mount = mount
-end
-</code></pre>
-
-== Note on Patches/Pull Requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 Daniel Neighman. See LICENSE for details.

data/VERSION

@@ -1 +0,0 @@
-0.1.0