path-to 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-04-04
+
+* 1 major enhancement:
+  * Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+path-to, Copyright (c) 2009 Mike Burrows
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+LICENSE
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/path-to.rb
+lib/path-to/application.rb
+lib/path-to/path.rb
+lib/path-to/with_params.rb
+script/console
+script/destroy
+script/generate
+test/path-to/test_application.rb
+test/path-to/test_path.rb
+test/path-to/test_with_params.rb
+test/test_helper.rb

data/PostInstall.txt

@@ -0,0 +1,2 @@
+
+For more information on path-to, see http://path-to.rubyforge.org

data/README.rdoc

@@ -0,0 +1,52 @@
+= path-to README
+
+== Description
+
+path-to allows web applications to be modelled via URI templates and then accessed through an application-specific Ruby API.  It is
+designed to be extended easily to support discovery mechanisms; support for XRD may be added at some future date.
+
+== Synopsis
+
+Here's a simple example that illustrates access to a CMS: 
+
+   require "path-to"
+
+   class Users    < PathTo::Path ; end
+   class Articles < PathTo::Path ; end
+
+   app = Application.new(
+       :users    => "http://example.com/users/{user}",
+       :articles => "http://example.com/users/{user}/articles/{slug}") do |app|
+     def app.child_class_for(instance, method, params)
+       {
+         :users    => Users,
+         :articles => Articles
+       }[method]
+     end
+   end                                                         #=> Application
+
+Note that the Users and Articles classes and the overridden #child_class_for method above can be done away with (reducing the above
+code to just four lines) if there is no need to define any class-specific behaviour.
+
+Having defined URI template and class mappings for keys :users and :articles mapping to URI templates, calls to app.users and
+app.articles cause objects of the appropriate class to be generated.  These in turn support chaining and the collection of request
+params, like this:
+
+   app.users                                                   #=> http://example.com/users/ <Users>
+   app.users(:user => "dojo")                                  #=> http://example.com/users/dojo <Users>
+   app.users[:user => "dojo"]                                  #=> http://example.com/users/dojo <Users>
+   app.articles(:user => "dojo", :slug => "my-article")        #=> http://example.com/users/dojo/articles/my-article <Articles>
+   app.users[:user => "dojo"].articles[:slug => "my-article"]  #=> http://example.com/users/dojo/articles/my-article <Articles>
+
+With a little more work (overriding Users#[] and Articles#[] - as described in the documentation for the Path class), the last example
+becomes simply:
+
+  app.users["dojo"].articles["my-article"]                     #=> http://example.com/users/dojo/articles/my-article <Articles>
+
+HTTP support comes courtesy of HTTParty (the Path class includes it).  To GET an article in the above example, just invoke the get method on the path object:
+
+  app.users["dojo"].articles["my-article"].get                 #=> "<html>...</html>"
+
+== Installation, Dependencies, Testing
+
+TODO

data/Rakefile

@@ -0,0 +1,38 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+$:.push File.dirname(__FILE__) + '/lib'
+require 'path-to'
+
+# undefined method `empty?' for nil:NilClass
+# /Library/Ruby/Site/1.8/rubygems/specification.rb:886:in `validate'
+class NilClass
+  def empty?
+    true
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('path-to', PathTo::VERSION) do |p|
+  p.developer('Mike Burrows (asplake)', 'mjb@asplake.co.uk')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_deps         = [
+    ['httparty','>= 0.4.2'],
+    ['addressable','>= 2.0.2'],
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/path-to/application.rb

@@ -0,0 +1,121 @@
+require "path-to/path"
+require "path-to/http_client"
+require "addressable/uri"
+
+module PathTo
+  #
+  # Provides a Ruby client API interface to a web application.  Method calls on this Application object generate Path objects that
+  # map (via URI templates held here on the Application) to the web application's URIs.
+  #
+  # Example:
+  #
+  #   app = PathTo::Application.new(
+  #       :users    => "http://example.com/users/{user}",
+  #       :articles => "http://example.com/users/{user}/articles/{slug}") do |app|
+  #     def app.child_class_for(instance, method, params)
+  #       {
+  #         :users    => Users,
+  #         :articles => Articles
+  #       }[method]
+  #     end
+  #   end                                                         #=> PathTo::Application
+  #
+  #   app.users                                                   #=> http://example.com/users/ <Users>
+  #   app.users(:user => "dojo")                                  #=> http://example.com/users/dojo <Users>
+  #   app.articles(:user => "dojo", :slug => "my-article")        #=> http://example.com/users/dojo/articles/my-article <Articles>
+  #   app.users[:user => "dojo"].articles[:slug => "my-article"]  #=> http://example.com/users/dojo/articles/my-article <Articles>
+  #
+  class Application < WithParams    
+    # A Hash that maps method keys (Symbol) to URI templates (String)
+    attr_reader :templates
+    
+    # A Class (or at least something with a #new method) from which child objects will be created
+    attr_reader :default_type
+    
+    # An HTTParty or similar
+    attr_reader :http_client
+    
+    #
+    # Initializes an Application.  Parameters:
+    #
+    # [templates]     Initial value for the templates attribute, defaults to {}
+    # [default_type]  Initial value for the default_type attribute, defaults to Path
+    # [http_client]   An object through which http calls are invoked.  See HTTPClient and Path#http_client.
+    #
+    # Simple example:
+    #
+    #   # Model an application with just a "users" collection that generates Path objects
+    #   simple_app = PathTo::Application.new(:users => "http://example.com/users/{user}")
+    #
+    # The constructor yields self, utilised in this example:
+    #
+    #   # Model an application with "users" and "articles" collections, represented here on the client side by Users and Articles objects   
+    #   bigger_app = PathTo::Application.new(
+    #       :users    => "http://example.com/users/{user}",
+    #       :articles => "http://example.com/users/{user}/articles/{slug}") do |app|
+    #     def app.child_class_for(instance, method, params)
+    #       {
+    #         :users    => Users,
+    #         :articles => Articles
+    #       }[method]
+    #     end
+    #   end
+    #
+    def initialize(templates = {}, default_type = Path, http_client = HTTPClient)
+      super() # with default args
+      @templates, @default_type, @http_client = templates, default_type, http_client
+      yield self if block_given?
+    end
+    
+    #
+    # Determines whether this application &/or its child objects should respond to the given method, and if so returns a class from
+    # which a new child instance (typically Path or a subclass thereof) will be created.  This implementation (easily overridden)
+    # returns #default_type if there is a URI template defined for the method.
+    #
+    # Parameters:
+    #
+    # [instance] This application or (presumably) one of its child objects
+    # [method]   The method invoked on the instance that has (presumably) been intercepted by instance#method_missing
+    # [params]   The instance's params
+    # 
+    def child_class_for(instance, method, params)
+      default_type if uri_template_for(method, params)
+    end
+    
+    #
+    # Returns self.  See Path#application.
+    #
+    def application
+      self
+    end
+    
+    #
+    # Returns a URI template for the given method and params.  Parameters:
+    #
+    # [method]   The method invoked on the instance that has (presumably) been intercepted by instance#method_missing
+    # [params]   The instance's params
+    #
+    # This implementation returns a value from the #templates Hash, keyed by method (params is ignored).
+    #
+    #--
+    # TODO Consider taking an instance as the first parameter, as #child_class_for does
+    #
+    def uri_template_for(method, params = {})
+      templates[method]
+    end
+    
+    #
+    # Generates a URI, looking up a URI template (via #uri_template_for) and getting it formatted with the params.
+    #
+    #--
+    # TODO Consider taking an instance as the first parameter, as #child_class_for does
+    #
+    def uri_for(method, params = {})
+      # TODO it's a 1-line fix to Addressable to permit symbols (etc) as keys
+      if (t = uri_template_for(method, params))
+        string_keyed_params = params.keys.inject({}){|hash, key| hash[key.to_s] = params[key]; hash}
+        Addressable::URI.expand_template(t, string_keyed_params).to_s
+      end
+    end
+  end
+end

data/lib/path-to/path.rb

@@ -0,0 +1,71 @@
+require "path-to/with_params"
+
+module PathTo
+  #
+  # Builds on the chaining and param collection of WithParams to provide chainable references to URIs.  Delegates the modelling of the
+  # web application to a parent (or ancestor) application object, so that this configuration is in one place (and perhaps the result of a
+  # discovery process).
+  #
+  class Path < WithParams
+
+    #
+    # Finds (once) the application in the parent hierarchy.
+    #
+    def application
+      @application ||= parent.application if parent
+    end
+    
+    #
+    # Delegated to the application object (see Application#child_class_for for details).
+    #
+    def child_class_for(instance, service, args)
+      application.child_class_for(instance, service, args)
+    end
+    
+    #
+    # Generate a URI for this object, using application.uri_for (see Application#uri_for for details).
+    #
+    def uri
+      application.uri_for(service, params)
+    end
+    
+    #
+    # Returns the http_client of the application; override if necessary.  See also HTTPClient.
+    #
+    def http_client
+      @http_client ||= application.http_client
+    end
+    
+    #
+    # GET request on this object's URI
+    #
+    def get(*args)
+      http_client.get(uri, *args)
+    end
+    
+    #
+    # PUT request on this object's URI
+    #
+    def put(*args)
+      http_client.put(uri, *args)
+    end
+    
+    #
+    # POST request on this object's URI
+    #
+    def post(*args)
+      http_client.post(uri, *args)
+    end
+    
+    #
+    # DELETE request on this object's URI
+    #
+    def delete(*args)
+      http_client.delete(uri, *args)
+    end
+    
+    def inspect  #:nodoc:
+      "#{uri} #<#{self.class.name}:#{"0x%x" % object_id} service=#{service.inspect}, params=#{params.inspect}>"
+    end
+  end
+end

data/lib/path-to/with_params.rb

@@ -0,0 +1,91 @@
+module PathTo
+  #
+  # Chaining parameter collection.  Example:
+  #
+  #   p = WithParams.new.foo(:bar => "baz").fee[:fi => "fo"]  #=> <WithParams>
+  #   p.service                                               #=> :fee
+  #   p.params                                                #=> {:bar => "baz", :fi => "fo"}
+  #
+  class WithParams
+    # Parent object, presumably of type WithParams or descendant
+    attr_reader :parent
+    
+    # Service identifier, typically a method symbol intercepted in #method_missing
+    attr_reader :service
+    
+    # Parameter hash
+    attr_reader :params
+
+    #
+    # Initialize a new WithParams object. Parameters:
+    #
+    # [parent]  Value for the parent attribute
+    # [service] Value for the service attribute  
+    # [params]  Value for the params attribute
+    #
+    def initialize(parent = nil, service = nil, params = {})
+      @parent, @service, @params = parent, service, params
+    end
+
+    #
+    # Creates a child instance.  Parameters:
+    #
+    # [child_class] The class of the new instance, calls #child_class_for to determine this if none supplied
+    # [service]     Value for the new instance's service attribute, inherited from self (the parent) if none supplied
+    # [params]      The new instance's params, will be merged with self's (the parent's) params
+    #
+    def child(child_class = nil, service = nil, params = {})
+      child_class ||= child_class_for(instance, service, params)
+      service ||= self.service
+      params = self.params.merge(params)
+      child_class.new(self, service, params)
+    end
+
+    #
+    # Creates a child instance with new params.  Subclasses might override this to take values instead of hashes, as follows:
+    #
+    #   def [](value)
+    #     super(:key => value)
+    #   end
+    #
+    def [](params = {})
+      child(self.class, self.service, params)
+    end
+  
+    #
+    # Determines the class of a new child, given the parent instance, service and params
+    #
+    def child_class_for(instance, service, params)
+      self.class
+    end
+
+    #
+    # Determines whether we can respond to method (missing or otherwise).  We can respond to a missing method if #child_class_for
+    # returns a class for a new child.
+    #
+    def respond_to?(method)
+      child_class_for(self, method, params) || super
+    end
+    
+    #
+    # Tries to respond to a missing method.  We can do so if
+    #
+    # 1. any args are hashes (merged to make a params hash), and
+    # 2. #child_class_for returns a class or other factory object capable of creating a new child instance
+    #
+    # In all other cases and in the case of error we invoke super in the hope of avoiding any hard-to-debug behaviour!
+    #
+    def method_missing(method, *args)
+      begin
+        params = args.inject(Hash.new){|h, arg| h.merge(arg)}
+        if (child_class = child_class_for(self, method, params))
+          child(child_class, method, params)
+        else
+          super
+        end
+      rescue
+        super
+      end
+    end
+  end
+end

data/lib/path-to.rb

@@ -0,0 +1,6 @@
+module PathTo
+  VERSION = "0.0.1"
+end
+
+require "path-to/application"
+require "path-to/path"

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/path-to.rb'}"
+puts "Loading path-to gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/path-to/test_application.rb

@@ -0,0 +1,74 @@
+require "test/unit"
+require "path-to/application"
+
+module PathTo
+  class TestApplication < Test::Unit::TestCase
+    attr_reader :simple_app, :bigger_app
+    
+    class Users < Path
+      def [](user)
+        super(:user => user)
+      end
+    end
+    
+    class Articles < Path
+      def [](slug)
+        super(:slug => slug)
+      end
+    end
+    
+    def setup
+      @simple_app = Application.new(:users => "http://example.com/users/{user}")
+      
+      @bigger_app = Application.new(
+          :users    => "http://example.com/users/{user}",
+          :articles => "http://example.com/users/{user}/articles/{slug}") do |app|
+        def app.child_class_for(instance, method, params)
+          {
+            :users    => Users,
+            :articles => Articles
+          }[method]
+        end
+      end
+    end
+  
+    def test_uri_for
+      assert_equal("http://example.com/users/", simple_app.uri_for(:users))
+      assert_equal("http://example.com/users/", simple_app.uri_for(:users, :what => "ever"))
+      assert_equal("http://example.com/users/dojo", simple_app.uri_for(:users, :user => "dojo"))
+    end
+  
+    def test_child_uri
+      assert_equal("http://example.com/users/", simple_app.users.uri)
+      assert_equal("http://example.com/users/", simple_app.users(:what => "ever").uri)
+      assert_equal("http://example.com/users/", simple_app.users[:what => "ever"].uri)
+      assert_equal("http://example.com/users/dojo", simple_app.users(:user => "dojo").uri)
+      assert_equal("http://example.com/users/dojo", simple_app.users[:user => "dojo"].uri)
+    end
+    
+    def test_no_child
+      assert_raises(NoMethodError) {simple_app.flooby}
+    end
+
+    def test_bigger_app
+      assert_kind_of(Users, bigger_app.users)
+      assert_kind_of(Users, bigger_app.users["dojo"])
+      
+      assert_kind_of(Articles, bigger_app.articles)
+      assert_kind_of(Articles, bigger_app.articles["a-title"])
+      
+      assert_equal("http://example.com/users/", bigger_app.users.uri)
+      assert_equal("http://example.com/users/dojo", bigger_app.users["dojo"].uri)
+      
+      assert_equal("http://example.com/users//articles/", bigger_app.articles.uri)
+      assert_equal("http://example.com/users/dojo/articles/", bigger_app.articles(:user => "dojo").uri)
+      assert_equal("http://example.com/users//articles/a-title", bigger_app.articles["a-title"].uri)
+      
+      assert_equal("http://example.com/users/dojo/articles/a-title", bigger_app.articles(:user => "dojo", :slug => "a-title").uri)
+      assert_equal("http://example.com/users/dojo/articles/a-title", bigger_app.users["dojo"].articles["a-title"].uri)
+
+      assert_raises(NoMethodError) {bigger_app.flooby}
+    end
+
+  end
+end

data/test/path-to/test_path.rb

@@ -0,0 +1,48 @@
+require "test/unit"
+require "mocha"
+require "path-to/path"
+require "path-to/application"
+
+module PathTo
+  class TestPath < Test::Unit::TestCase
+    attr_reader :app, :users
+    
+    class TestPath < Path
+    end
+
+    def setup
+      @app = Application.new(
+          :users    => "http://example.com/users/{user}",
+          :articles => "http://example.com/users/{user}/articles/{slug}")
+      @users = @app.users
+    end
+    
+    def test_application
+      assert_equal(app, users.application)
+      assert_equal(app, users.articles.application)
+    end  
+
+    def test_nil_application
+      assert_nil(Path.new.application)
+      assert_nil(Path.new[].application)
+    end
+    
+    def test_child_class_for
+      params = {:slug => "a-title"}
+      app.expects(:child_class_for).with(users, :articles, params).returns(TestPath)
+      assert_equal(TestPath, users.child_class_for(users, :articles, params))
+    end
+    
+    def test_uri
+      assert_equal("http://example.com/users/dojo", users[:user => "dojo"].uri)
+    end
+    
+    def test_http_methods
+      request_options = {:body => {:bar => :baz}}
+      [:get, :put, :post, :delete].each do |method|
+        app.http_client.expects(method).with("http://example.com/users/", request_options)
+        users.send(method, request_options)
+      end
+    end
+  end
+end

data/test/path-to/test_with_params.rb

@@ -0,0 +1,60 @@
+require "test/unit"
+require "path-to/with_params"
+
+module PathTo
+  
+  class TestWithParams < Test::Unit::TestCase
+    attr_reader :root, :s1
+    
+    class WithParamsSubclass1 < WithParams
+      def child_class_for(instance, service, params)
+        WithParamsSubclass2
+      end
+    end
+
+    class WithParamsSubclass2 < WithParams
+    end
+    
+    def setup
+      @root = WithParams.new(nil, :root, :x => 1)
+      @s1 = WithParamsSubclass1.new
+    end
+    
+    def test_service
+      assert_nil(WithParams.new.service)
+      assert_equal(:root, root.service)
+      assert_equal(:root, root.child.service)
+      assert_equal(:child, root.child(nil, :child).service)
+      assert_equal(:child, root.child(nil, :child).child.service)
+    end
+    
+    def test_params
+      assert_equal({}, WithParams.new.params)
+      assert_equal({:x => 1}, root.params)
+      assert_equal({:x => 1}, root.child.params)
+      assert_equal({:x => 2}, root.child(nil, nil, {:x => 2}).params)
+      assert_equal({:x => 2}, root.child(nil, nil, {:x => 2}).child!.params)
+      assert_equal({:x => 1, :y => 2}, root.child(nil, nil, {:y => 2}).params)
+    end
+    
+    def test_child_type
+      assert_kind_of(WithParams, root.child)
+      assert_kind_of(WithParamsSubclass2, s1.child)
+      assert_kind_of(WithParamsSubclass2, s1.child.child)
+    end
+    
+    def test_ary_params
+      assert_equal(:root, root[].service)
+      assert_equal({:x => 1}, root[].params)
+      assert_equal({:x => 2}, root[:x => 2].params)
+      assert_equal({:x => 1, :y => 2}, root[:y => 2].params)
+    end
+    
+    def test_method_missing
+      assert_kind_of(WithParams, root.flooby)
+      assert_equal(:flooby, root.flooby.service)
+      assert_equal({:x => 1}, root.flooby.params)
+      assert_equal({:x => 1, :y => 2}, root.flooby[:y => 2].params)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/path-to'

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: path-to
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mike Burrows (asplake)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: |-
+  path-to allows web applications to be modelled via URI templates and then accessed through an application-specific Ruby API.  It is
+  designed to be extended easily to support discovery mechanisms; support for XRD may be added at some future date.
+email: 
+- mjb@asplake.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/path-to.rb
+- lib/path-to/application.rb
+- lib/path-to/path.rb
+- lib/path-to/with_params.rb
+- script/console
+- script/destroy
+- script/generate
+- test/path-to/test_application.rb
+- test/path-to/test_path.rb
+- test/path-to/test_with_params.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: path-to
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: path-to allows web applications to be modelled via URI templates and then accessed through an application-specific Ruby API
+test_files: 
+- test/path-to/test_application.rb
+- test/path-to/test_path.rb
+- test/path-to/test_with_params.rb
+- test/test_helper.rb