gossamer 0.1

data/History.txt

@@ -0,0 +1,5 @@
+= Gossamer CHANGELOG
+
+=== 0.1 (2008-07-23)
+
+* Initial release.

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/colors
+examples/skype
+examples/text
+examples/world_clock
+lib/gossamer.rb
+lib/gossamer/broker.rb
+lib/gossamer/params_processor.rb
+lib/gossamer/resource.rb
+lib/gossamer/typed_string.rb
+test/test_gossamer.rb

data/README.txt

@@ -0,0 +1,168 @@
+= gossamer
+
+A microframework to spin websites out of distributed, lightweight, ephemeral resources.
+
+Home page: http://gossamer.rubyforge.com
+
+
+== Description
+
+Gossamer is a web framework that emphasizes the use of distributed, independent resources. With Gossamer, you construct websites out of a network of lightweight objects that manage particular resources. Resources can utilize other resources through fault-tolerant, loosely coupled RESTful[http://en.wikipedia.org/wiki/Representational_State_Transfer] communications. Resource brokers manage the resource objects, storing them in a distributed cache (eg, <tt>memcache</tt>). Resources can easily serve their content in multiple formats, such as HTML, Atom, and RDF.
+
+Gossamer is intended to be a useful platform for aggregators, mashups, web services, implementing the semantic web, and other applications that depend on external network resources rather than internal databases.
+
+
+== Features
+
+* Object-oriented "resource" view of data encourages encapsulation, and maps nicely to the semantic/programmable web.
+
+* Loosely-coupled connections between resources encourages both cooperation and error correction.
+
+* Resources can be updated automatically.
+
+* Resources are stored (frozen) in a distributed cache, accessible by multiple processes on the same machine or multiple machines.
+
+
+== Overview
+
+Instead of implementing models, controllers, views, and server scripts, you implement <em>resources, brokers</em>, and <em>servers.</em>
+
+A server creates a broker, and a broker manages one or more resources.  Each resource is fully responsible for creating, updating, and rendering its data.
+
+A small site may have only one server and a few resources; a large site may have many servers, each responsible for a set of resources.
+
+
+=== Resources
+
+<em>Resources</em> are independent entities that encapsulate the initialization, updating, and rendering of some kind of information.  The implementation of a resource depends on its complexity and the data it represents.
+
+Some examples of resources:
+
+* The copyright terms for a site.  This would be static text, perhaps with some links to contacts at an organization.
+
+* A report based on a query of a local database.
+
+* The presence information for a particular user, using several APIs to fetch that information from various services.
+
+* The aggregation of several blogs.
+  
+Each resource has three parts, or phases:
+
+initialize:: The resource configures itself, and any data that is static and quickly generated is stored in instance variables.
+
+update:: The resource performs any long-running tasks, like complex queries or accessing remote data.  If the resource has set its <tt>update_frequency</tt> and implemented an <tt>#update</tt> method, this updating phase will be performed again at that frequency.
+
+render:: The resource renders itself in the requested format.  Often this is HTML, but it could be Atom, XML, or other formats.  A resource "publishes" its formats simply by implementing the appropriate method: <tt>#to_html</tt> for HTML, <tt>#to_atom</tt> for Atom, and so on.  If a resource doesn't implement any rendering methods, it is only visible to other resources, not to web servers.
+
+A resource may use other resources.  For example, a resource that represents the presence info of a person may depend on other resources that represent particular presence services, such as AIM, Skype, and Twitter.  The general presence resource will make requests of the individual presence services, combining that data into a single resource.
+
+A website may implement all its "pages" as Gossamer resources, each of which may depend on other resources to gather and render the final HTML.
+
+Here is a small example resource that simply creates and renders a static string:
+
+  class MyResource < Gossamer::Resource
+
+    def update
+      @text = "Some information about something."
+    end
+  
+    def to_html
+      @text
+    end
+  
+  end
+
+
+=== Brokers
+
+A <em>broker</em> is the go-between for resources.  A broker can be asked to store a resource at a particular path (a local URI) for later access by that broker or another broker who is configured similarly.  Once the resource is stored in the distributed cache, it is "frozen" and inactive.  When a broker is asked for a resource, the resource is thawed out, and either returned to the caller as an object or rendered in a particular format (eg, HTML, Atom, XML).
+
+There can be multiple brokers, and even brokers on different machines.  Any broker using the same cache configuration can access any resource saved into the cache by any broker.
+
+If a broker is asked to store a resource that wants to be updated, the resource is scheduled for updates according to its configured frequency.  When the update time comes, the resource is pulled out of the cache, its update method is called, and the resource is put back into the cache.  (There is currently no notification mechanism, so a resource that depends on another updating resource will have to update itself slightly after the first resource has updated.)
+
+Here is a simple broker:
+
+  class MyBroker < Gossamer::Broker
+  
+    def initialize
+      super(:cache_address => "localhost:11211", :cache_namespace => "text")
+    end
+  
+  end
+
+
+=== Servers
+
+A server isn't an actual object class in Gossamer, but just a convention of how to create a broker and resources, and, optionally, hook in a Rack application.  Here's a simple server that uses the resource and broker examples above, and connects a Mongrel web server into the broker.
+
+  broker = MyBroker.new
+  broker["/info"] = MyResource.new
+  app = Rack::Builder.new { run broker }.to_app
+  Rack::Handler::Mongrel.run(app, :Port => 3000)
+  
+When this example is run, a HTTP request for "http://localhost:3000/info" will show the sample text.
+
+
+== Limitations & problems
+
+* Data flows only one way: from a resource to the user or into another resource.  There is currently no facility for submitting forms or modifying data inside resources.  Nor are there any sort of notifications.  This means most resources will work on a polling model, which is suboptimal.
+
+* Performance is undetermined.  It might be fast enough for you.  It might be really slow.
+
+* Because Gossamer was built as a research experiment and not a specified, production system, there are no unit or functional tests.
+
+* Gossamer is not a full-stack framework.  It knows nothing of databases, configuration, or templating systems.
+
+
+== Synopsis
+
+See the <tt>examples/</tt> directory for some sample servers and resources.
+
+
+== Requirements
+
+* ruby 1.8.6 or higher
+* Rack[http://rack.rubyforge.org]
+* a Rack-compatible web server
+* memcached[http://blog.evanweaver.com/files/doc/fauna/memcached/] (which requires libmemcached[http://tangent.org/552/libmemcached.html] and memcached[http://danga.com/memcached])
+* Scheduler (<tt>sudo gem install scheduler</tt>)
+
+If you install from the Gossamer gem, you'll get all these for free, except for <tt>libmemcached</tt>.
+
+
+== Installation
+
+  sudo gem install gossamer
+
+
+== Author
+
+John Labovitz
+
+johnl@johnlabovitz.com
+
+
+== License
+
+(The BSD License)
+
+Copyright (c) 2008, John Labovitz. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY JOHN LABOVITZ "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL JOHN LABOVITZ BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,22 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
+
+require 'gossamer'
+
+Hoe.new('gossamer', Gossamer::VERSION) do |p|
+  p.developer('John Labovitz', 'johnl@johnlabovitz.com')
+  p.url = 'http://gossamer.rubyforge.org'
+  p.remote_rdoc_dir = '' # Release to root
+  p.summary = 'A microframework to spin websites out of distributed, lightweight, ephemeral resources'
+  # p.description = p.paragraphs_of('README.txt', 2..6).join("\n\n")
+  # p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps << ['memcached', '>= 0.11']
+  p.extra_deps << ['rack', '>= 0.3.0']
+  p.extra_deps << ['scheduler', '>= 0.3']
+end
+
+# vim: syntax=Ruby

data/examples/colors

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'gossamer'
+require 'builder'
+
+module Colors
+  
+  COLORS = %w{red blue green}
+  
+  class Color < Gossamer::Resource
+    
+    attr_accessor :name
+        
+    def to_html
+      html = Builder::XmlMarkup.new
+      html.div(name, :style => "background-color: #{name}; color: white; height: 200; width: 200")
+      html.target!
+    end
+    
+  end
+  
+  class HomePage < Gossamer::Resource
+        
+    def to_html
+      html = Builder::XmlMarkup.new
+      html.html do
+        html.body do
+          html.h1("Colors")
+          COLORS.each do |name|
+            path = "/color/#{name}"
+            html.a(:href => path) do
+              html << @broker.get(path)
+            end
+          end
+        end
+      end
+      html.target!
+    end
+
+  end
+  
+  class Broker < Gossamer::Broker
+    
+    def initialize(params={})
+      super(params.merge(:cache_address => "localhost:11211", :cache_namespace => "colors"))
+    end
+    
+  end
+  
+  class ColorServer
+
+    def self.run(name)
+      color = Color.new(:name => name)
+      broker = Broker.new
+      broker["/color/#{name}"] = color
+    end
+    
+  end
+  
+  class WebServer
+
+    def self.run
+      broker = Broker.new
+      broker['/'] = HomePage.new
+      app = Rack::Builder.new { run broker }.to_app
+      Rack::Handler::Mongrel.run(app, :Port => 3000)
+    end
+  
+  end
+  
+  class SingleServer
+
+    def self.run
+      COLORS.each do |name|
+        ColorServer.run(name)
+      end
+      WebServer.run
+    end
+    
+  end
+    
+  class MultiServer
+    
+    def self.run
+      COLORS.each do |name|
+        fork { ColorServer.run(name) }
+      end
+      sleep 1
+      WebServer.run
+    end
+    
+  end
+  
+end
+
+case ARGV.shift
+when '-m'
+  Colors::MultiServer.run
+else
+  Colors::SingleServer.run
+end

data/examples/skype

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'gossamer'
+require 'builder'
+require 'open-uri'
+require 'hpricot'
+require 'units/standard'
+
+module Skype
+    
+  class SkypeStatus < Gossamer::Resource
+    
+    STATUS_CODES = {
+      1 => "offline",     # offline or invisible
+      2 => "online",
+      3 => "away",
+      4 => "not available",
+      5 => "do not disturb",
+      7 => "skype me",
+    }
+
+    attr_accessor :user_id
+    attr_accessor :state
+    attr_accessor :call_link
+  
+    def initialize(params)
+      super(params.merge(:REQUIRED => [:user_id], :DEFAULTS => {:update_frequency => 5.seconds}))
+    end
+    
+    def update
+      status = Hpricot(open("http://mystatus.skype.com/#{@user_id}.xml"))
+      status_code = status.at('//statuscode').inner_text.to_i
+      @state = STATUS_CODES[status_code]
+      @call_link = "skype:#{@user_id}?call"
+    end
+  
+    def to_html
+      html = Builder::XmlMarkup.new
+      html.a(@user_id, :href => @call_link)
+      html.text! " (#{@state})" if @state
+      html.target!
+    end
+  
+  end
+  
+  class HomePage < Gossamer::Resource
+    
+    attr_accessor :users
+          
+    def to_html
+      html = Builder::XmlMarkup.new
+      html.html do
+        html.head do
+          html.title("Skype status")
+          html.script(:type => 'text/javascript', :src => "http://ajax.googleapis.com/ajax/libs/prototype/1.6.0.2/prototype.js")
+        end
+        html.body do
+          html.h1("Skype status")
+          html.ul do
+            @users.each do |user|
+              html.li(:id => user) do
+                status = @broker["/#{user}"]
+                html << status.to_html
+                html.script(%Q{new Ajax.PeriodicalUpdater('#{user}', '#{status.path}', { method: 'post', frequency: #{status.update_frequency} });})
+              end
+            end
+          end
+        end
+      end
+      html.target!
+    end
+            
+  end
+  
+  class Broker < Gossamer::Broker
+    
+    def initialize(params={})
+      super(params.merge(:cache_address => "localhost:11211", :cache_namespace => "skype"))
+    end
+    
+  end
+  
+  class Server
+    
+    def self.run
+      users = %w{jslabovitz echo123}
+      broker = Broker.new
+      broker['/'] = HomePage.new(:users => users)
+      users.each do |user|
+        broker["/#{user}"] = SkypeStatus.new(:user_id => user)
+      end
+      app = Rack::Builder.new { run broker }.to_app
+      Rack::Handler::Mongrel.run(app, :Port => 3000)
+    end
+    
+  end
+  
+end
+
+Skype::Server.run

data/examples/text

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'gossamer'
+  
+class MyResource < Gossamer::Resource
+
+  def update
+    @text = "Some information about something."
+  end
+  
+  def to_html
+    @text
+  end
+  
+end
+
+class MyBroker < Gossamer::Broker
+  
+  def initialize
+    super(:cache_address => "localhost:11211", :cache_namespace => "text")
+  end
+  
+end
+
+broker = MyBroker.new
+broker["/info"] = MyResource.new
+app = Rack::Builder.new { run broker }.to_app
+Rack::Handler::Mongrel.run(app, :Port => 3000)

data/examples/world_clock

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'gossamer'
+require 'builder'
+require 'date'
+
+module WorldClock
+  
+  class Clock < Gossamer::Resource
+    
+    attr_accessor :name
+    attr_accessor :offset
+    attr_accessor :time
+    
+    def initialize(params={})
+      super(params.merge(:REQUIRED => [:name, :offset], :DEFAULTS => { :update_frequency => 1 }))
+    end
+    
+    def update
+      @time = DateTime.now.new_offset(@offset / 24.0)
+    end
+    
+    def to_html
+      html = Builder::XmlMarkup.new
+      html.div(:style => 'border: 1px black solid; text-align: center') do
+        html.h2(@name.to_s)
+        html.h1(@time.to_s)
+      end
+      html.target!
+    end
+    
+  end
+  
+  class HomePage < Gossamer::Resource
+    
+    attr_accessor :cities
+    
+    def to_html
+      html = Builder::XmlMarkup.new
+      html.html do
+        html.head do
+          html.title("World Clock")
+          html.script(:type => 'text/javascript', :src => "http://ajax.googleapis.com/ajax/libs/prototype/1.6.0.2/prototype.js")
+        end
+        html.body do
+          html.h1("World Clock")
+          cities.each do |name, offset|
+            html_id = name.downcase
+            html.span(:id => html_id) do
+              clock = @broker["/clock/#{name}"]
+              html << clock.to_html
+              html.script(%Q{new Ajax.PeriodicalUpdater('#{html_id}', '#{clock.path}', { method: 'post', frequency: #{clock.update_frequency} });})
+            end
+          end
+        end
+      end
+      html.target!
+    end
+
+  end
+  
+  class Broker < Gossamer::Broker
+    
+    def initialize(params={})
+      super(params.merge(:cache_address => "localhost:11211", :cache_namespace => "world_clock"))
+    end
+    
+  end
+  
+  class Server
+
+    def self.run
+      
+      cities = {
+        'Portland' => -8,
+        'Denver' => -7,
+        'NewYork' => -5,
+      }
+
+      broker = Broker.new
+      
+      cities.each do |name, offset|
+        broker["/clock/#{name}"] = Clock.new(:name => name, :offset => offset)
+      end
+      
+      broker['/'] = HomePage.new(:cities => cities)
+      
+      app = Rack::Builder.new { run broker }.to_app
+      Rack::Handler::Mongrel.run(app, :Port => 3000)
+    end
+    
+  end
+    
+end
+
+WorldClock::Server.run

data/lib/gossamer.rb

@@ -0,0 +1,8 @@
+require 'gossamer/broker'
+require 'gossamer/resource'
+
+module Gossamer
+  
+  VERSION = '0.1'
+  
+end

data/lib/gossamer/broker.rb

@@ -0,0 +1,120 @@
+require 'memcached'
+require 'rack'
+require 'scheduler'
+require 'gossamer/typed_string'
+require 'gossamer/params_processor'
+
+module Gossamer
+  
+  class Broker
+    
+    class UnknownPath < Exception; end
+    class UnknownFormat < Exception; end
+    
+    attr_accessor :cache_address
+    attr_accessor :cache_namespace
+    attr_accessor :cache
+    attr_accessor :default_format
+    
+    include ParamsProcessor
+    
+    def initialize(params={})
+      process_params(params.merge(:REQUIRED => [:cache_address, :cache_namespace], :DEFAULTS => { :default_format => 'html' }))
+      @cache = Memcached.new(@cache_address, :namespace => @cache_namespace)
+      @resources = {} # key is resource path, value is Scheduler::Event if scheduled for update
+    end
+    
+    def clone
+      clone = dup
+      clone.cache = @cache.clone
+      clone
+    end
+        
+    def [](path)
+      begin
+        resource = @cache.get(path)
+        resource.broker = self
+        resource
+      rescue Memcached::NotFound
+        nil
+      end
+    end
+
+    def []=(path, resource)
+      put(path, resource)
+    end
+    
+    def put(path, resource)
+      resource.path = path
+      post(path, resource)
+      if resource.respond_to?(:update) && @resources[path].nil?
+        @resources[path] = Scheduler.after_delay(0) { update(resource.path) }
+      end
+    end
+    
+    def post(path, resource)
+      resource.broker = nil
+      begin
+        @cache.set(path, resource)
+      rescue TypeError => e
+        raise e, "Couldn't save #{resource.class} to path #{path.inspect}: #{e.inspect}"
+      end
+      resource.broker = self
+    end
+    
+    def update(path)
+      if (event = @resources[path])
+        Scheduler.cancel(event)
+        @resources[path] = nil
+      end
+      broker = clone
+      resource = broker[path]
+      resource.update
+      broker.post(path, resource)
+      @resources[path] = Scheduler.after_delay(resource.update_frequency) { update(resource.path) }
+    end
+    
+    def call(env)
+      request = Rack::Request.new(env)
+      response = Rack::Response.new
+      begin
+        response.body = get(request.path_info, request.params['format'])
+        response['Content-Type'] = response.body.type
+      rescue UnknownPath, UnknownFormat => e
+        ;;warn "Error while handling request for #{request.path_info.inspect}: #{e.inspect}"
+        response.status, response.body = 404, "Resource does not exist"
+      rescue => e
+        ;;warn "Error while handling request for #{request.path_info.inspect}: #{e.inspect}"
+        e.backtrace.each { |t| ;;warn "\t" + t }
+        response.status, response.body = 500, "Internal error"
+      end
+      response.finish
+    end
+    
+    def get(path, format=nil)
+      format = (format.to_s.empty? ? @default_format : format.to_s.downcase)
+      raise UnknownFormat, "Unknown format #{format.inspect} for path #{path.inspect}" if format =~ /[^\w]/
+      resource = self[path] or raise UnknownPath, "Unknown path #{path.inspect}"
+      begin
+        method = resource.method("to_#{format}")
+      rescue NameError => e
+        raise UnknownFormat, "Unknown format #{format.inspect} for path #{path.inspect}"
+      end
+      ;;warn "#{path} [#{format}] => #{resource.class}#{(method && method.name) ? '.' + method.name : ''}"
+      case format
+      when 'html'
+        TypedString.new(method.call, "text/html")
+      when 'xml'
+        TypedString.new(method.call, "application/xml")
+      when 'atom'
+        TypedString.new(method.call, "application/atom+xml")
+      when 'text'
+        TypedString.new(method.call, "text/plain")
+      else
+        TypedString.new(method.call, "application/octet-stream")
+      end
+    end
+        
+  end
+  
+end

data/lib/gossamer/params_processor.rb

@@ -0,0 +1,16 @@
+module ParamsProcessor
+  
+  def process_params(params={})
+    if (required = params.delete(:REQUIRED))
+      required.each { |name| raise "#{name.inspect} required" unless params[name] }
+    end
+
+    if (defaults = params.delete(:DEFAULTS))
+      defaults.each { |name, value| params[name] ||= value }
+    end
+
+    config = params.delete(:CONFIG) || []
+    params.each { |name, value| method("#{name}=").call(value) unless config.include?(name) }
+  end
+  
+end

data/lib/gossamer/resource.rb

@@ -0,0 +1,19 @@
+require 'gossamer/params_processor'
+
+module Gossamer
+  
+  class Resource
+    
+    include ParamsProcessor
+    
+    attr_accessor :path
+    attr_accessor :broker
+    attr_accessor :update_frequency
+    
+    def initialize(params={})
+      process_params(params)
+    end
+    
+  end
+  
+end

data/lib/gossamer/typed_string.rb

@@ -0,0 +1,13 @@
+class TypedString < String
+        
+  def initialize(string, type)
+    super(string.to_s)
+    @type = type
+    @encoding = "utf8"
+  end
+  
+  def type
+    "#{@type}; charset=#{@encoding}"
+  end
+  
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: gossamer
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- John Labovitz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: memcached
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.11"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: scheduler
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: Gossamer is a web framework that emphasizes the use of distributed, independent resources. With Gossamer, you construct websites out of a network of lightweight objects that manage particular resources. Resources can utilize other resources through fault-tolerant, loosely coupled RESTful[http://en.wikipedia.org/wiki/Representational_State_Transfer] communications. Resource brokers manage the resource objects, storing them in a distributed cache (eg, <tt>memcache</tt>). Resources can easily serve their content in multiple formats, such as HTML, Atom, and RDF.  Gossamer is intended to be a useful platform for aggregators, mashups, web services, implementing the semantic web, and other applications that depend on external network resources rather than internal databases.
+email: 
+- johnl@johnlabovitz.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- examples/colors
+- examples/skype
+- examples/text
+- examples/world_clock
+- lib/gossamer.rb
+- lib/gossamer/broker.rb
+- lib/gossamer/params_processor.rb
+- lib/gossamer/resource.rb
+- lib/gossamer/typed_string.rb
+- test/test_gossamer.rb
+has_rdoc: true
+homepage: http://gossamer.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: gossamer
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A microframework to spin websites out of distributed, lightweight, ephemeral resources
+test_files: 
+- test/test_gossamer.rb