herbert 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+nbproject

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in herbert.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/herbert.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "herbert/version"
+
+Gem::Specification.new do |s|
+  s.name        = "herbert"
+  s.version     = Herbert::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Pavel Kalvoda"]
+  s.email       = ["me@pavelkalvoda.com","pavel@drinkwithabraham.com"]
+  #s.homepage    = ""
+  s.summary     = %q{Sinatra-based toolset for creating JSON API servers backed by Mongo & Memcached}
+  s.description = <<-desc
+Herbert makes development of JSON REST API servers ridiculously simple.
+It provides a bunch of useful helpers and conventions to speed up development.
+Input validation, logs and advanced AJAX support are baked in.
+Herbert is very lightweight and transparent, making it easy to use & modify.
+desc
+
+	s.add_dependency("sinatra","= 1.2.6")
+	s.add_dependency("memcache-client")
+	s.add_dependency("mongo")
+	s.add_dependency("syslogger")
+	s.add_dependency("kwalify","= 0.7.2")
+	s.add_dependency("activesupport")
+	s.add_dependency("bson_ext",">= 1.3.1")
+	
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/file.rb

@@ -0,0 +1,2 @@
+puts "file got loaded"
+

data/lib/herbert.rb

@@ -0,0 +1,3 @@
+require 'herbert/loader'
+
+

data/lib/herbert/Ajaxify.rb

@@ -0,0 +1,50 @@
+module Herbert
+  module Ajaxify
+    Headers = {
+      'Access-Control-Allow-Methods' => %w{POST GET PUT DELETE OPTIONS},
+      'Access-Control-Allow-Headers' => %w{Content-Type X-Requested-With},
+      'Access-Control-Allow-Origin' => %w{*},
+      'Access-Control-Expose-Header' => %w{Content-Type Content-Length X-Build},
+      'X-Build' => [Herbert::Utils.version]
+    }
+
+    def self.registered(app)
+      # Heeeaderzz!!! Gimme heaaaderzzz!!!
+      path = File.join(app.settings.root, 'config','headers.rb')
+      if File.exists?(path) then
+        log.h_debug("Loading additional headers from #{path}")
+        custom = eval(File.open(path).read)
+        custom.each {|name, value|
+          value = [value] unless value.is_a?(Array)
+          Headers[name] = (Headers[name] || []) | value
+        }
+      else
+        log.h_info("File #{path} doesn't exists; no addition headers loaded")
+      end
+
+      app.before do
+      # Add the headers to the response
+        Headers.each {|name, value|
+          value = [value] unless value.is_a?(Array)
+          value.map! {|val|
+            (val.is_a?(Proc) ? val.call : val).to_s
+          }
+          response[name] = value.join(', ')
+        }
+      end
+
+      # Proxy for not CORS enables services such as 
+      # Google Maps
+      # /proxy/<url to fetch>
+      if app.get '/proxy/:url' do
+        url = URI.parse(URI.decode(params[:url]))
+        res = Net::HTTP.start(url.host, 80) {|http|
+          http.get(url.path + (url.query ? '?' + url.query : ''))
+        }
+        response['content-type'] = res['content-type']
+        res.body
+      end
+    end
+   end
+  end
+end

data/lib/herbert/AppLogger.rb

@@ -0,0 +1,90 @@
+module Herbert
+  # Full-fledged request & response logger with
+  # several storage providers (console, mongo, cache)
+  class AppLogger
+    def self.provider
+      @@provider
+    end
+
+    def self.provider=(prov)
+      @@provider = prov
+    end
+
+    def self.log(request, response)
+      log = {
+        "request"=> {
+          "path"=> request.path,
+          "method"=> request.request_method,
+          "xhr" => request.xhr?,
+          "postData"=> request.POST,
+          "query"=> request.GET,
+          "headers"=> {},
+          "body"=> {
+            "isJson"=> request.json?,
+            "value"=> request.json? ? request.body : request.body_raw
+          },
+          "client"=> {
+            "ip"=> request.ip,
+            "hostname"=> request.host,
+            "referer"=> request.referer
+          }
+        },
+        "response"=> {
+          "code"=> response.status,
+          "headers"=> response.headers,
+          "body"=> {
+            "isJson"=> response.json?,
+            "value"=> response.body
+          },
+        },
+        "meta"=> {
+          "dateTime"=> Time.new,
+          "processingTime"=> response.app.timer_elapsed.round(3),
+          "port" => request.port
+        }
+      }
+
+      # Extract tha headerz
+      request.env.keys.each do |key|
+        if key =~ /^HTTP_/ then
+          log['request']['headers'][key.gsub(/^HTTP_/,'')] = request.env[key]
+        end
+      end
+      # do not log bodies from GET/DELETE/HEAD
+      log["request"].delete("body") if %{GET DELETE HEAD}.include?(log["request"]["method"])
+      # If an error occured, add it
+      log["response"]["error"] = request.env['sinatra.error'].to_hash if request.env['sinatra.error']
+      id = @@provider.save(log)
+      response['X-RequestId'] = id.to_s if @@provider.respond_to?(:id) && response.app.settings.append_log_id
+    end
+  end
+	
+	module LoggingProviders
+		class StdoutProvider
+			def initialize
+				require 'pp'
+			end
+
+			def save(log)
+				pp log
+			end
+		end
+
+		class MongoProvider
+
+			Collection = 'logs'
+    
+			def initialize(db)
+				@db = db
+			end
+
+			def save(log)
+				@db[Collection].save(log)
+			end
+    
+			def id
+				true
+			end
+		end
+  end
+end

data/lib/herbert/ApplicationError.rb

@@ -0,0 +1,61 @@
+module Herbert
+
+  # Provides centralized handling of exceptions in an
+  # application context
+  module Error
+    # Error relevant in application context
+    class ApplicationError < StandardError
+      attr_reader :code, :message, :http_code, :errors
+
+      # Code to text translation
+      Translation = {
+        "1000" => ["Malformated JSON", 400],
+        "1001" => ["Non-unicode encoding",400],
+        "1002" => ["Non-acceptable Accept header", 406],
+        "1003" => ["Not found", 404],
+        "1010" => ["Missing request body", 400],
+        "1011" => ["Missign required parameter", 400],
+        "1012" => ["Invalid request body", 400],
+        "1020" => ["Unspecified error occured", 500]
+      }
+
+      def initialize(errno, http_code = nil, errors = [])
+        raise ArgumentError, "Unknown error code: #{errno}" unless Translation.has_key?(errno.to_s)
+        @code = errno
+        @message = Translation[@code.to_s][0]
+        @http_code = (http_code || Translation[@code.to_s][1])
+        @errors = errors.to_a
+      end
+
+      def to_hash
+        { :code => @code, :stackTrace => backtrace, :validationTrace => @errors}
+      end
+
+      # Add an error
+      def self.push(code, error)
+        Translation[code.to_s] = error.to_a
+      end
+
+      # Add a hash of errors
+      def self.merge(errors)
+        if errors.is_a? Hash then
+          Translation.merge!(errors)
+        else
+          raise ArgumentError("Expected a hash of codes and descriptions")
+        end
+      end
+
+    end
+  end
+end
+
+module Sinatra
+  class NotFound
+    def to_hash
+      {
+        :code => 1003,
+        :message => "Not found"
+      }
+    end
+  end
+end

data/lib/herbert/Configurator.rb

@@ -0,0 +1,49 @@
+module Herbert
+  module Configurator
+    module Prepatch
+      def self.registered(app)
+        # Enable envs such as development;debug, where debug is herberts debug flag
+        env = ENV['RACK_ENV'].split(';')
+        ENV['RACK_ENV'], ENV['HERBERT_DEBUG'] = (env[0].empty? ? 'development' :  env[0]), (env[1] == 'debug' ? 1:0).to_s
+        app.set :environment, ENV['RACK_ENV'].downcase.to_sym
+      end
+    end
+    
+    module Helpers
+      def staging?
+        ENV['RACK_ENV'] == 'staging'
+      end
+
+      def development?
+        ENV['RACK_ENV'] == 'development' || (ENV['RACK_ENV'].empty?)
+      end
+
+      def debug?
+        ENV['HERBERT_DEBUG'] == '1'
+      end
+    end
+
+    def self.registered(app)
+      app.enable :logging if app.development?
+      #Assume loading by rackup...
+      app.settings.root ||= File.join(Dir.getwd, 'lib')
+      path = File.join(app.settings.root, 'config')
+      # Load and evaluate common.rb and appropriate settings
+      ['common.rb', app.environment.to_s + '.rb'].each do |file|
+        cpath = File.join(path, file)
+        if File.exists?(cpath) then
+          # Ummm, I'm sorry?
+          app.instance_eval(IO.read(cpath))
+          log.h_debug("Applying #{cpath} onto the application")
+        else
+          log.h_warn("Configuration file #{cpath} not found")
+        end
+      end
+    # So, we have all our settings... Please note that configure
+    # block inside an App can overwrite our settings, but Herbert's
+    # services are being created right now, so they only take in account
+    # previous declarations
+    end
+
+  end
+end

data/lib/herbert/Error.rb

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+require File.dirname(__FILE__) + '/ApplicationError.rb'
+
+module Herbert
+  module Error
+    # Inclusion hook
+    def self.registered(app)
+      # Disable HTML errors and preliminary reporting
+      log.h_warn("Herbert is running in debugging mode - exceptions will be visualized") if app.debug?
+      app.set :raise_errors, false
+      app.set :show_exceptions, false
+      app.set :dump_errors, app.debug?
+      # Add a new error state handler which produces
+      # compact JSON error reports (handled by #Sinatra::Jsonify)
+      app.error do
+        err = request.env['sinatra.error']
+        if err.class == ApplicationError then
+          log.h_debug("Caught manageable error")
+          response.status = err.http_code
+          body = {
+            :error => {
+              :code => err.code,
+              :message => err.message
+            }
+          }
+          # Add backtrace, Kwalify validation report and other info if
+          # running in development mode
+          if settings.development? then
+            log.h_debug("Adding stacktrace and report to the error")
+            body[:error][:stacktrace] = err.backtrace.join("\n")
+            body[:error][:info] = (err.errors || [])
+          end
+          response.body = body
+        else
+        # If the exception is not manageable, bust it
+          log.h_error("A non-managed error occured! Backtrace: #{err.backtrace.join("\n")}")
+          response.status = 500
+          response.body = settings.development? ? err.to_s : nil
+        end
+      end
+
+      #Ummm, nasty.... FIXME
+      app.not_found do
+        content_type 'application/json', :charset => 'utf-8'
+        {:error => {
+          :code => 1003,
+          :message => "Not found"
+        }}
+      end
+    end
+
+    module Helpers
+      # Request-context helper of error states
+      def error(code = 1020, http_code = nil, errors = nil)
+        raise Herbert::Error::ApplicationError.new(code, http_code, errors)
+      end
+    end
+  end
+end

data/lib/herbert/Jsonify.rb

@@ -0,0 +1,79 @@
+
+class True
+  def to_json
+    return 1
+  end
+end
+
+module Sinatra
+
+  # Makes JSON the default DDL of HTTP communication
+  module Jsonify
+    # Sinatra inclusion hook
+    def self.registered(app)
+      app.before do
+        log.h_debug("Adding proper content-type and charset")
+        content_type 'application/json', :charset => 'utf-8'
+      end
+    end
+
+    class Sinatra::Request
+
+      @is_json = false
+      # Encapsulates #Rack::Request.body in order to remove #IO.String
+      # and therefore to enable repeated reads
+      def body_raw
+        @body_raw ||= body(true).read
+        @body_raw
+      end
+
+      def ensure_encoded(strict = true)
+        if !@is_json then
+          begin
+            @body_decoded ||= ActiveSupport::JSON.decode(body_raw)
+            @is_json = true;
+          rescue StandardError
+            @is_json = false;
+            raise ::Herbert::Error::ApplicationError.new(1000) if strict
+          end
+        end
+      end
+
+      # Overrides #Rack::Request.body, returns native #Hash
+      # Preserves access to underlying @env['rack.input'] #IO.String
+      def body(rack = false)
+        if rack then
+        super()
+        else
+          ensure_encoded
+        @body_decoded
+        end
+      end
+
+      def json?
+        ensure_encoded(false)
+        @is_json
+      end
+    end
+
+    class Sinatra::Response
+      # Reference to application instance that created this response
+      attr_accessor :app
+      
+      # Automatically encode body to JSON, but only as long as
+      # the content-type remained set to app/json
+      def finish
+        @app.log_request
+        if json?
+          log.h_debug("Serializing response into JSON")
+          @body = [ActiveSupport::JSON.encode(@body)]
+        end
+        super
+      end
+      
+      def json?
+        @header['Content-type'] === 'application/json;charset=utf-8'
+      end
+    end
+  end
+end

data/lib/herbert/Log.rb

@@ -0,0 +1,30 @@
+module Sinatra
+  module Log
+    def log_request
+      ::Herbert::AppLogger.log(request, response) if settings.log_requests
+    end
+
+    def timer_elapsed
+      return (@timer_stop.to_f - @timer_start.to_f)*100
+    end
+
+    module Extension
+      def self.registered(app)
+        case app.log_requests
+        when :db
+          provider = Herbert::LoggingProviders::MongoProvider.new(app.db)
+        when :stdout
+          provider = Herbert::LoggingProviders::StdoutProvider.new
+        else
+					app.log_requests.respond_to?(:save) ? provider = app.log_requests : log.h_fatal("Unknown logs storage provider.")
+        end
+        Herbert::AppLogger.provider = provider
+        # Make the app automatically inject refernce to iteself into the response,
+        # so Sinatra::Response::finish can manipulate it
+        app.before { response.app = self; @timer_start = Time.new }
+        app.after { @timer_stop = Time.new}
+      #app.before { log_request }
+      end
+    end
+  end
+end

data/lib/herbert/Resource.rb

@@ -0,0 +1,49 @@
+module Herbert
+  # This class allows you to organize code by REST resources.
+	# Any class that subclasses Herbert::Resource is automatically "merged" 
+	# into the application. Resource name will be derived from the class name.
+	# 
+	# For instance,
+	#   class Messages < Herbert::Resource
+  #     get '/' do
+  #    	  "here's a message for you!"
+  #     end
+	#   end
+	# will respond to 
+	#   GET /messages/
+	# 
+	
+  class Resource
+    def self.new
+      raise StandardError.new('You are not allowed to instantize this class directly')
+    end
+		
+		# Translates Sintra DSL calls
+    def self.inherited(subclass)
+      %w{get post put delete}.each do |verb|
+        subclass.define_singleton_method verb.to_sym  do |route, &block|
+          app.send verb.to_sym, "/#{subclass.to_s.downcase}#{route}", &block
+        end
+      end
+    end
+  end
+
+	# Loads all Herbert resources
+  module ResourceLoader
+    def self.registered(app)
+			# Inject refence to the app into Resource
+      Resource.class_eval do
+				define_singleton_method :app do
+					app
+				end
+			end
+			
+			# And load all resource definitions
+      path = File.join(app.settings.root, 'Resources')
+      Dir.new(path).each do |file|
+        next if %{. ..}.include? file
+        require File.join(path,file)
+      end
+    end
+  end
+end

data/lib/herbert/Services.rb

@@ -0,0 +1,90 @@
+module Sinatra
+  module Database
+    def self.registered(app)
+      app.set :mongo_connection, Mongo::Connection.new(app.settings.db_settings[:host],
+      app.settings.db_settings[:porty],
+      app.settings.db_settings[:options])
+      log.h_debug("Connected to MongoDB #{app.settings.mongo_connection}")
+      app.set :mongo_db, app.settings.mongo_connection.db(app.settings.db_settings[:db_name])
+    end
+
+    def db
+      settings.mongo_db
+    end
+
+  end
+
+  module Cache
+    def self.registered(app)
+      servers = []
+      app.settings.cache[:servers].each {|c|
+        servers << (c[:host] + ':' + (c[:port] || 11211).to_s)
+      }
+      app.set :cache, MemCache.new(app.settings.cache[:options])
+      app.settings.cache.servers = servers
+      log.h_debug("Connected to Memcached #{app.settings.cache.inspect}")
+    end
+
+    def mc
+      settings.cache
+    end
+  end
+
+  
+  module Validation    
+    module Extension
+      # Um, dragons... Fucking swarm... But I'll try to explain this anyway.
+      # We'll scan the defined settings.validation[:path] dir for dirs. Those found dirs
+      # will denote <resource>s. Then, we will scan the "resource" dirs for files.
+      # These files will represent one http <verb>.yaml each. And then, we create hierchy of 
+      # validation schemas following this pattern: 
+      # ::setting.validation[:module]::<resource>::<verb_schema>
+      # where the <verb_schema> equals <verb>.capitalize and contains parsed contents of <verb>.yaml file. 
+      # Please note that I haven't used a single (.*_)eval even though I was terribly tempted.
+      # And I also documented this method. I'm so awesome, considerate and drunk, am I not?
+      # Uh, yea, and notice the nice cascade of 'end's on the end
+      def self.registered(app)
+        # Define the ::<schema_root> module
+        validation_module = Kernel.const_set(app.settings.validation[:module], Module.new)
+        schema_root = Dir.new(File.join(app.settings.root, app.settings.validation[:path]))
+        log.h_debug("Loading validation schemas from #{schema_root.path}");
+        # For each resource
+        schema_root.each do |resource_dir|
+          next if %w{.. .}.include? resource_dir
+          resource_name = resource_dir
+          resource_dir = File.join(schema_root, resource_dir)
+          # Create <schema_root>::<resource> module
+          validation_module.const_set(resource_name, Module.new {})
+          if File.directory?(resource_dir) then
+            Dir.new(resource_dir).each do |verb|
+              next if %w{.. .}.include? verb
+              # And create the <schema_root>::<resource>::<verb_schema> constant
+              validation_module.const_get(resource_name).const_set(/(\w+).yaml/.match(verb)[1].capitalize, YAML.load_file(File.join(resource_dir, verb)))
+            end
+          end
+        end
+      end
+    end
+    
+    module Helpers
+      # Only a few dragons here. This method validates body of the request
+      # against a schema. If no schema was passed to the method, it will
+      # try to find it automagically
+      def validate!(schema = nil)
+        schema ||= Kernel.const_get(
+          settings.validation[:module]
+        ).const_get(
+          /^\/(.*)\//.match(request.path)[1].capitalize
+        ).const_get(
+          request.env['REQUEST_METHOD'].downcase.capitalize
+        )
+        res = Kwalify::Validator.new(schema).validate(request.body)
+        res.map! { |error|
+          error.to_s
+        }
+        error(1012, nil, res) unless res == []
+      end
+    end
+  end
+
+end

data/lib/herbert/Utils.rb

@@ -0,0 +1,10 @@
+module Herbert
+  module Utils
+    # Assert v<major>.<minor>.<etc> tags
+    def self.version
+      version = `git describe --long`.strip
+      version[0] = '' if version[0] == 'v'
+      version
+    end
+  end
+end

data/lib/herbert/loader.rb

@@ -0,0 +1,63 @@
+require 'logger'
+require 'mongo'
+require 'memcache'
+require 'sinatra/base'
+require 'kwalify'
+require 'active_support'
+
+module Herbert
+  ::Logger.class_eval do
+		# prefix all Herbert's log with [Herbert]
+    [:fatal, :error, :warn, :info, :debug].each do |type|
+      name = "h_" + type.to_s
+      define_method name do |message|
+        send(type, "[Herbert] " + message)
+      end
+    end
+  end
+
+  # Plug it in, the monkey style :]
+  module ::Kernel
+    @@logger = Logger.new(STDOUT)
+    def log
+      @@logger
+    end
+  end
+	
+  module Loader
+    $HERBERT_PATH = File.dirname(__FILE__)
+    log.h_info("Here comes Herbert. He's a berserker!")
+    # because order matters
+    %w{Utils Jsonify Configurator Error Services Ajaxify AppLogger Log Resource}.each {|file|
+      require $HERBERT_PATH + "/#{file}.rb"
+    }
+
+    def self.registered(app)
+      # Set some default
+      # TODO to external file?
+      app.set :log_requests, :db
+      app.enable :append_log_id # If logs go to Mongo, IDs will be appended to responses
+      ## register the ;debug flag patch first to enable proper logging
+      app.register Herbert::Configurator::Prepatch
+      # the logger
+      log.level = app.development? ? Logger::DEBUG : Logger::INFO
+      # the extensions
+      app.register Herbert::Configurator
+      app.register Herbert::Configurator::Helpers
+      app.helpers Herbert::Configurator::Helpers
+      app.register Herbert::Error
+      app.helpers Herbert::Error::Helpers
+      app.register Sinatra::Jsonify
+      app.register Sinatra::Database
+      app.helpers Sinatra::Database
+      app.register Sinatra::Cache
+      app.helpers Sinatra::Cache
+      app.register Sinatra::Validation::Extension
+      app.helpers Sinatra::Validation::Helpers
+      app.register Herbert::Ajaxify
+      app.helpers Sinatra::Log
+      app.register Sinatra::Log::Extension
+			app.register Herbert::ResourceLoader
+    end
+  end
+end

data/lib/herbert/version.rb

@@ -0,0 +1,3 @@
+module Herbert
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification 
+name: herbert
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Pavel Kalvoda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-18 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 6
+        version: 1.2.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: memcache-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: syslogger
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: kwalify
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 2
+        version: 0.7.2
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 1
+        version: 1.3.1
+  type: :runtime
+  version_requirements: *id007
+description: |
+  Herbert makes development of JSON REST API servers ridiculously simple.
+  It provides a bunch of useful helpers and conventions to speed up development.
+  Input validation, logs and advanced AJAX support are baked in.
+  Herbert is very lightweight and transparent, making it easy to use & modify.
+
+email: 
+- me@pavelkalvoda.com
+- pavel@drinkwithabraham.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- herbert.gemspec
+- lib/file.rb
+- lib/herbert.rb
+- lib/herbert/Ajaxify.rb
+- lib/herbert/AppLogger.rb
+- lib/herbert/ApplicationError.rb
+- lib/herbert/Configurator.rb
+- lib/herbert/Error.rb
+- lib/herbert/Jsonify.rb
+- lib/herbert/Log.rb
+- lib/herbert/Resource.rb
+- lib/herbert/Services.rb
+- lib/herbert/Utils.rb
+- lib/herbert/loader.rb
+- lib/herbert/version.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Sinatra-based toolset for creating JSON API servers backed by Mongo & Memcached
+test_files: []
+