rackjson 0.1.0

data/.document

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

data/.gitignore

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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Oliver Nightingale
+
+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/README.markdown

@@ -0,0 +1,144 @@
+# RackJSON
+
+Simple Rack middleware for persisting JSON documents.
+
+## Installation
+
+`gem install rackjson`
+
+RackJSON uses MongoDB for persistence so you also need to install MongoDB.
+
+## Usage
+
+In your rackup file:
+
+`require mongo
+require rackjson`
+
+`use Rack::JSON::Resource, :collections => [:notes], :db => Mongo::Connection.new.db("mydb")`
+
+`run lambda { |env| 
+  [404, {'Content-Length' => '9', 'Content-Type' => 'text/plain'}, "Not Found"]
+}`
+
+This will set up a RESTful resource called 'notes' at /notes which will store any JSON document.
+
+### REST API
+
+To see what actions are available on the notes resource:
+
+`curl -i -XOPTIONS http://localhost:9292/notes`
+
+`HTTP/1.1 200 OK`
+`Connection: close`
+`Date: Sun, 11 Apr 2010 11:09:40 GMT`
+`Content-Type: text/plain`
+`Content-Length: 0`
+`Allow: GET, POST`
+
+Listing the existing notes:
+
+`curl -i http://localhost:9292/notes`
+
+`HTTP/1.1 200 OK
+Connection: close
+Date: Sun, 11 Apr 2010 11:12:04 GMT
+Content-Type: application/json
+Content-Length: 2`
+
+`[]`
+
+Currently there are no notes, create one with a post request:
+
+`curl -i -XPOST -d'{"title":"hello world!"}' http://localhost:9292/notes`
+
+`HTTP/1.1 201 Created
+Connection: close
+Date: Sun, 11 Apr 2010 11:14:17 GMT
+Content-Type: application/json
+Content-Length: 149`
+
+`{"updated_at":"Sun Apr 11 12:14:17 +0100 2010","title":"hello world!","_id":"4bc1af0934701204fd000001","created_at":"Sun Apr 11 12:14:17 +0100 2010"}`
+
+RackJSON will assign an id to this resource as _id.  This can be used to access this resource directly
+
+`curl -i http://localhost:9292/notes/4bc1af0934701204fd000001`
+
+`HTTP/1.1 200 OK
+Connection: close
+Date: Sun, 11 Apr 2010 11:16:30 GMT
+Content-Type: application/json
+Content-Length: 147`
+
+`[{"updated_at":"Sun Apr 11 11:14:17 UTC 2010","title":"hello world!","_id":"4bc1af0934701204fd000001","created_at":"Sun Apr 11 11:14:17 UTC 2010"}]`
+
+This resource will also appear in the index of notes resources
+
+`curl -i http://localhost:9292/notes`
+
+`HTTP/1.1 200 OK
+Connection: close
+Date: Sun, 11 Apr 2010 11:17:27 GMT
+Content-Type: application/json
+Content-Length: 147`
+
+`[{"updated_at":"Sun Apr 11 11:14:17 UTC 2010","title":"hello world!","_id":"4bc1af0934701204fd000001","created_at":"Sun Apr 11 11:14:17 UTC 2010"}]`
+
+Update a resource using a PUT request
+
+`curl -i -XPUT -d'{"title":"updated"}' http://localhost:9292/notes/4bc1af0934701204fd000001`
+
+`HTTP/1.1 200 OK
+Connection: close
+Date: Sun, 11 Apr 2010 11:25:04 GMT
+Content-Type: application/json
+Content-Length: 144`
+
+`{"updated_at":"Sun Apr 11 12:25:04 +0100 2010","title":"updated","_id":"4bc1af0934701204fd000001","created_at":"Sun Apr 11 12:25:04 +0100 2010"}`
+
+A PUT request can also be used to create a resource at the given location:
+
+`curl -i -XPUT -d'{"foo":"bar"}' http://localhost:9292/notes/1`
+
+`HTTP/1.1 200 OK
+Connection: close
+Date: Sun, 11 Apr 2010 11:27:13 GMT
+Content-Type: application/json
+Content-Length: 113`
+
+`{"updated_at":"Sun Apr 11 12:27:13 +0100 2010","_id":1,"foo":"bar","created_at":"Sun Apr 11 12:27:13 +0100 2010"}`
+
+Finally a resource can be deleted using a DELETE request
+
+`curl -i -XDELETE http://localhost:9292/notes/1`
+
+`HTTP/1.1 200 OK
+Connection: close
+Date: Sun, 11 Apr 2010 11:29:14 GMT
+Content-Type: application/json
+Content-Length: 12
+`
+
+`{"ok": "true"}`
+
+### JSON Query
+
+RackJSON supports querying of the resources using JSONQuery style syntax.  Pass the JSONQuery as query string parameters when making a get request.
+
+`curl http://localhost:9292/notes?[?title=foo]`
+
+This will get all resources which have a title attribute = 'foo'.  Greater than and less than are also supported:
+
+`curl http://localhost:9292/notes?[?rating>5][?position=<10]`
+
+The resources can be ordered using the query syntax also, to get the notes ordered by rating:
+
+`curl http://localhost:9292/notes?[\rating]`
+
+You can limit the number of resources that are returned, to get the first 10 resources:
+
+`curl http://localhost:9292/notes?[0:10]`
+
+To only select certain properties of a document you can specify the fields you want, to get just the titles
+
+`curl http://localhost:9292/notes?[=title]`

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rackjson"
+    gem.summary = %Q{A rack end point for storing json documents.}
+    gem.description = %Q{A rack end point for storing json documents.}
+    gem.email = "oliver.n@new-bamboo.co.uk"
+    gem.homepage = "http://github.com/olivernn/rackjson"
+    gem.authors = ["Oliver Nightingale"]
+    gem.add_dependency('mongo', '>=0.19.1')
+    gem.add_dependency('mongo_ext', '>=0.19.1')
+    gem.add_dependency('json', '>=1.2.3')
+    gem.add_dependency('rack', '>=1.0.1')
+    # 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'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rackjson #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/lib/rackjson.rb

@@ -0,0 +1,57 @@
+module Rack #:nodoc:
+  class Builder
+
+    # Setup resource collections hosted behind OAuth and OpenID auth filters.
+    #
+    # ===Example
+    #   contain :notes, :projects
+    #
+    # def contain(*args)
+    #   @ins << lambda do |app|
+    #     Rack::Session::Pool.new(
+    #       CloudKit::OAuthFilter.new(
+    #         CloudKit::OpenIDFilter.new(
+    #           CloudKit::Service.new(app, :collections => args.to_a))))
+    #   end
+    #   @last_cloudkit_id = @ins.last.object_id
+    # end
+
+    def private_resource
+      @ins << lambda do |app|
+        Rack::JSON::UserFilter.new(
+          Rack::JSON::Resource.new(app, args.first),
+          args.first
+        )
+      end
+    end
+
+    # Setup resource collections without authentication.
+    #
+    # ===Example
+    #   expose_resources :collections => [:notes, :projects], :db => Mongo::Connection.new.db("my_mongodb")
+    #
+    def expose_resource(*args)
+      @ins << lambda do |app|
+        Rack::JSON::Resource.new(app, args.first)
+      end
+    end
+  end
+end
+
+require 'rubygems'
+require 'json'
+require 'rack'
+require 'mongo'
+require 'time'
+
+module Rack::JSON
+
+  autoload :Document, 'rackjson/document'
+  autoload :JSONDocument, 'rackjson/json_document'
+  autoload :JSONQuery, 'rackjson/json_query'
+  autoload :MongoDocument, 'rackjson/mongo_document'
+  autoload :Request, 'rackjson/request'
+  autoload :Resource, 'rackjson/resource'
+  autoload :Response, 'rackjson/response'
+
+end

data/lib/rackjson/document.rb

@@ -0,0 +1,29 @@
+module Rack::JSON
+  class Document
+
+    def initialize(doc)
+      if doc.is_a? String
+        @document = Rack::JSON::JSONDocument.new(doc)
+      else doc.is_a? OrderedHash
+        @document = Rack::JSON::MongoDocument.new(doc)
+      end
+    end
+
+    def method_missing(name, *args)
+      @document.send(name, *args)
+    end
+
+    def to_json
+      unless @json
+        gen_attrs = @document.attributes
+        gen_attrs.each_pair do |key, value|
+
+          if value.is_a? Mongo::ObjectID
+            gen_attrs[key] = gen_attrs[key].to_s
+          end
+        end
+      end
+      @json ||= JSON.generate gen_attrs
+    end
+  end
+end

data/lib/rackjson/json_document.rb

@@ -0,0 +1,47 @@
+module Rack::JSON
+  class JSONDocument
+
+    attr_reader :attributes
+
+    def initialize(doc)
+      @attributes = JSON.parse(doc)
+      set_attributes
+    end
+
+    def add_id(id)
+      @attributes["_id"] = id unless @attributes["_id"]
+    end
+
+    private
+
+    def set_attribute_created_at
+      @attributes["created_at"] = Time.now unless @attributes["created_at"]
+    end
+
+    def set_attribute_dates
+      @attributes.each_pair do |key, value|
+        if value.class == String && value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/)
+          @attributes[key] = Time.parse(value)
+        end
+      end
+    end
+
+    def set_attribute_ids
+      @attributes["_id"] = Mongo::ObjectID.from_string(@attributes["_id"].to_s)
+    rescue Mongo::InvalidObjectID
+      return false
+    end
+
+    def set_attribute_updated_at
+      @attributes["updated_at"] = Time.now
+    end
+
+    def set_attributes
+      private_methods.each do |method|
+        if method.match /^set_attribute_\w*$/
+          send method
+        end
+      end
+    end
+  end
+end

data/lib/rackjson/json_query.rb

@@ -0,0 +1,73 @@
+module Rack::JSON
+  class JSONQuery
+
+    attr_accessor :options, :selector
+
+    def initialize(query_string)
+      @query_string = query_string
+      @conditions = @query_string.split(/\[|\]/).compact.reject {|s| s.empty? }
+      @options = {}
+      @selector = {}
+      build
+    end
+
+    private
+
+    def build
+      @conditions.each do |condition|
+        private_methods.each do |method|
+          if method.match /^set_query_\w*$/
+            send method, condition
+          end
+        end
+      end
+    end
+
+    def comparison(symbol)
+      { 
+        '>'  => '$gt',
+        '<'  => '$lt',
+        '=<' => '$lte',
+        '>=' => '$gte'
+      }[symbol]
+    end
+
+    def set_query_fields(condition)
+      if condition.match /^=\w+$/
+        @options[:fields] = condition.sub('=', '').split(',')
+      end
+    end
+
+    def set_query_selector_equality(condition)
+      if condition.match /^\?\w+=.+$/
+        field = condition.sub('?', '').split('=').first.to_sym
+        value = (condition.sub('?', '').split('=').last.match(/^\d+$/) ? condition.sub('?', '').split('=').last.to_f : condition.sub('?', '').split('=').last.to_s)
+        @selector[field] = value
+      end
+    end
+
+    def set_query_selector(condition)
+      if condition.match /^\?\w+>=|=<|<|>\d+$/
+        field = condition.sub('?', '').split(/>=|=<|<|>/).first.to_sym
+        value = condition.sub('?', '').split(/>=|=<|<|>/).last.to_f
+        @selector[field] = { comparison(condition.slice(/>=|=<|<|>/)) => value }
+      end
+    end
+
+    def set_query_skip_limit(condition)
+      if condition.match /^\d+:\d+$/
+        @options[:skip] = condition.split(':').first.to_i
+        @options[:limit] = condition.split(':').last.to_i
+      end
+    end
+
+    def set_query_sort(condition)
+      condition.split(/,\s?/).each do |part|
+        if part.match /^[\/|\\]\w*$/
+          @options[:sort] ||= []
+          @options[:sort] << [part.sub(/[\/|\\]/, '').to_sym, (part.match(/\//) ? :asc : :desc)]
+        end
+      end
+    end
+  end
+end

data/lib/rackjson/mongo_document.rb

@@ -0,0 +1,32 @@
+module Rack::JSON
+  class MongoDocument
+
+    attr_accessor :attributes
+
+    def initialize(row)
+      @attributes = row
+      set_created_at
+      set_attributes
+    end
+
+    private
+
+    def set_attribute_ids
+      @attributes["_id"] = @attributes["_id"].to_s if (@attributes["_id"].is_a? Mongo::ObjectID)
+    end
+
+    def set_created_at
+      if @attributes["_id"].is_a? Mongo::ObjectID
+        @attributes["created_at"] = @attributes["_id"].generation_time unless @attributes["created_at"]
+      end
+    end
+
+    def set_attributes
+      private_methods.each do |method|
+        if method.match /^set_attribute_\w*$/
+          send method
+        end
+      end
+    end
+  end
+end

data/lib/rackjson/request.rb

@@ -0,0 +1,38 @@
+module Rack::JSON
+  class Request < Rack::Request
+    include Rack::Utils
+    def initialize(env)
+      super(env)
+    end
+
+    def collection
+      self.path_info.split('/')[1] || ""
+    end
+
+    def collection_path?
+      self.path_info.match /^\/\w+$/
+    end
+
+    def member_path?
+      self.path_info.match /^\/\w+\/\w+$/
+    end
+
+    def json
+      self.body.rewind
+      self.body.read
+    end
+
+    def query
+      @query ||= Rack::JSON::JSONQuery.new(unescape(query_string))
+    end
+
+    def resource_id
+      id_string = self.path_info.split('/').last.to_s
+      begin
+        Mongo::ObjectID.from_string(id_string)
+      rescue Mongo::InvalidObjectID
+        id_string.match(/^\d+$/) ? id_string.to_i : id_string
+      end
+    end
+  end
+end

data/lib/rackjson/resource.rb

@@ -0,0 +1,87 @@
+module Rack::JSON
+  class Resource
+    METHODS_NOT_ALLOWED = [:trace, :connect]
+
+    def initialize(app, options)
+      @app = app
+      @collections = options[:collections]
+      @db = options[:db]
+    end
+
+    def call(env)
+      request = Rack::JSON::Request.new(env)
+      if bypass? request
+        @app.call(env)
+      else
+        @collection = @db[request.collection]
+        send(request.request_method.downcase, request)
+      end
+    end
+
+    private
+
+    def bypass?(request)
+      !(@collections.include? request.collection.to_sym)
+    end
+
+    def delete(request)
+      if request.member_path?
+        if @collection.remove({:_id => request.resource_id})
+          render "{'ok': true}"
+        end
+      else
+        render "", :status => 405
+      end
+    end
+
+    [:get, :head].each do |method|
+      define_method method do |request|
+        request.query.selector.merge!({:_id => request.resource_id}) if request.member_path?
+        rows = []
+        @collection.find(request.query.selector, request.query.options).each { |row| rows << Rack::JSON::Document.new(row).attributes }
+        if rows.empty? && request.member_path?
+          render "document not found", :status => 404, :head => (method == :head)
+        else
+          render JSON.generate(rows), :head => (method == :head)
+        end
+      end
+    end
+
+    def options(request)
+      if request.collection_path?
+        headers = { "Allow" => "GET, POST" }
+      elsif request.member_path?
+        headers = { "Allow" => "GET, PUT, DELETE" }
+      end
+      render "", :headers => headers
+    end
+
+    def post(request)
+      document = Rack::JSON::Document.new(request.json)
+      @collection.insert(document.attributes)
+      render document.to_json, :status => 201
+    rescue JSON::ParserError => error
+      render (error.class.to_s + " :" + error.message), :status => 422
+    end
+
+    def put(request)
+      @collection.find_one(:_id => request.resource_id) ? status = 200 : status = 201
+      document = Rack::JSON::Document.new(request.json)
+      document.add_id(request.resource_id)
+      @collection.save(document.attributes)
+      render document.to_json, :status => status
+    rescue JSON::ParserError => error
+      render (error.class.to_s + " :" + error.message), :status => 422
+    end
+
+    def render(body, options={})
+      Rack::JSON::Response.new(body, options).to_a
+    end
+
+    METHODS_NOT_ALLOWED.each do |method|
+      define_method method do
+        render "", :status => 405
+      end
+    end
+  end
+end

data/lib/rackjson/response.rb

@@ -0,0 +1,33 @@
+module Rack::JSON
+  class Response
+    def initialize(body, options={})
+      @status = options[:status] || 200
+      @body = body
+      @head = options[:head] || false
+      @headers = options[:headers] || {}
+      set_headers
+      head_response if @head
+    end
+
+    def to_a
+      [@status, @headers, @body]
+    end
+
+    private
+
+    def head_response
+      @body = ""
+    end
+
+    def set_headers
+      @headers["Content-Length"] = @body.length.to_s
+      begin
+        JSON.parse(@body)
+        @headers["Content-Type"] = "application/json"
+      rescue JSON::ParserError => error
+        # the response will only ever be either json or plain text
+        @headers["Content-Type"] = "text/plain"
+      end
+    end
+  end
+end

data/rackjson.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rackjson}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Oliver Nightingale"]
+  s.date = %q{2010-04-25}
+  s.description = %q{A rack end point for storing json documents.}
+  s.email = %q{oliver.n@new-bamboo.co.uk}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/rackjson.rb",
+     "lib/rackjson/document.rb",
+     "lib/rackjson/json_document.rb",
+     "lib/rackjson/json_query.rb",
+     "lib/rackjson/mongo_document.rb",
+     "lib/rackjson/request.rb",
+     "lib/rackjson/resource.rb",
+     "lib/rackjson/response.rb",
+     "rackjson.gemspec",
+     "test/helper.rb",
+     "test/suite.rb",
+     "test/test_document.rb",
+     "test/test_json_document.rb",
+     "test/test_json_query.rb",
+     "test/test_mongo_document.rb",
+     "test/test_resource.rb",
+     "test/test_response.rb"
+  ]
+  s.homepage = %q{http://github.com/olivernn/rackjson}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A rack end point for storing json documents.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/suite.rb",
+     "test/test_builder.rb",
+     "test/test_document.rb",
+     "test/test_json_document.rb",
+     "test/test_json_query.rb",
+     "test/test_mongo_document.rb",
+     "test/test_resource.rb",
+     "test/test_response.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_runtime_dependency(%q<mongo>, [">= 0.19.1"])
+      s.add_runtime_dependency(%q<mongo_ext>, [">= 0.19.1"])
+      s.add_runtime_dependency(%q<json>, [">= 1.2.3"])
+      s.add_runtime_dependency(%q<rack>, [">= 1.0.1"])
+    else
+      s.add_dependency(%q<mongo>, [">= 0.19.1"])
+      s.add_dependency(%q<mongo_ext>, [">= 0.19.1"])
+      s.add_dependency(%q<json>, [">= 1.2.3"])
+      s.add_dependency(%q<rack>, [">= 1.0.1"])
+    end
+  else
+    s.add_dependency(%q<mongo>, [">= 0.19.1"])
+    s.add_dependency(%q<mongo_ext>, [">= 0.19.1"])
+    s.add_dependency(%q<json>, [">= 1.2.3"])
+    s.add_dependency(%q<rack>, [">= 1.0.1"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'rack'
+require 'rack/test'
+require 'timecop'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rackjson'
+
+class Test::Unit::TestCase
+end

data/test/suite.rb

@@ -0,0 +1,5 @@
+require 'test_document'
+require 'test_json_document'
+require 'test_json_query'
+require 'test_mongo_document'
+require 'test_resource'

data/test/test_builder.rb

@@ -0,0 +1,17 @@
+require 'helper'
+require 'rack/builder'
+
+class BuilderTest < Test::Unit::TestCase
+
+  def test_expose_resource_shortcut
+    app = Rack::Builder.new do
+      expose_resource :collections => [:testing], :db => Mongo::Connection.new.db("test")
+      run lambda { |env| 
+        [404, {'Content-Length' => '9', 'Content-Type' => 'text/plain'}, "Not Found"]
+      }      
+    end
+
+    response = Rack::MockRequest.new(app).get('/testing')
+    assert response.ok?
+  end
+end

data/test/test_document.rb

@@ -0,0 +1,63 @@
+require 'helper'
+
+class DocumentTest < Test::Unit::TestCase
+
+  def setup
+    @db = Mongo::Connection.new.db("test")
+    @collection = @db['resource_test']
+  end
+
+  def teardown
+    @collection.drop
+  end
+
+  def test_creating_from_json
+    json = '{"test":"hello"}'
+    document = Rack::JSON::Document.new(json)
+    assert_equal("hello", document.attributes["test"])
+    assert_equal(Time.now.to_s, document.attributes["created_at"].to_s)
+    assert_equal(Time.now.to_s, document.attributes["updated_at"].to_s)
+  end
+
+  def test_creating_from_json_with_id
+    json = '{"_id": "4b9f783ba040140525000001", "test":"hello"}'
+    document = Rack::JSON::Document.new(json)
+    assert_equal(Mongo::ObjectID.from_string('4b9f783ba040140525000001'), document.attributes["_id"])
+    assert_equal("hello", document.attributes["test"])
+    assert_equal(Time.now.to_s, document.attributes["created_at"].to_s)
+    assert_equal(Time.now.to_s, document.attributes["updated_at"].to_s)
+  end
+
+  def test_creating_from_json_with_non_object_id
+    json = '{"_id": 1, "test":"hello"}'
+    document = Rack::JSON::Document.new(json)
+    assert_equal(1, document.attributes["_id"])
+    assert_equal("hello", document.attributes["test"])
+    assert_equal(Time.now.to_s, document.attributes["created_at"].to_s)
+    assert_equal(Time.now.to_s, document.attributes["updated_at"].to_s)
+  end
+
+  def test_adding_id
+    json = '{"test":"hello"}'
+    document = Rack::JSON::Document.new(json)
+    id = @collection.insert(document.attributes)
+    document.add_id(id)
+    assert_equal(id.to_s, document.attributes[:_id].to_s)
+  end
+
+  def test_creating_from_row
+    @collection.insert({"test"=>"hello"})
+    rows = []
+    @collection.find.each { |r| rows << r }
+    document = Rack::JSON::Document.new(rows.first)
+    assert_equal("hello", document.attributes["test"])
+  end
+
+  def test_document_created_at
+    json = '{"test":"hello", "created_at": "01/01/2010"}'
+    document = Rack::JSON::Document.new(json)
+    assert_equal("hello", document.attributes["test"])
+    assert_equal("01/01/2010", document.attributes["created_at"])
+    assert_equal(Time.now.to_s, document.attributes["updated_at"].to_s)
+  end
+end

data/test/test_json_document.rb

@@ -0,0 +1,73 @@
+require 'helper'
+
+class JSONDocumentTest < Test::Unit::TestCase
+
+  def test_parsing_simple_json_structure
+    hash = { "title" => "testing" }
+    doc  = JSON.generate hash
+    assert_equal hash["title"], Rack::JSON::JSONDocument.new(doc).attributes["title"]
+  end
+  
+  def test_parsing_nested_json_structure
+    hash = { "title" => "nested", "nest" => { "note" => "im nested" } }
+    doc = JSON.generate hash
+    assert_equal hash["nest"], Rack::JSON::JSONDocument.new(doc).attributes["nest"]
+    assert_equal hash["title"], Rack::JSON::JSONDocument.new(doc).attributes["title"]
+  end
+  
+  def test_parsing_dates_from_json
+    hash = { "date" => "2010-04-10T14:20:12Z" }
+    doc = JSON.generate hash
+    assert_equal( Time.parse("2010-04-10T14:20:12Z") , Rack::JSON::JSONDocument.new(doc).attributes["date"])
+  end
+  
+  def test_parsing_mongo_object_id
+    hash = { "_id" => "4ba7e82ca04014011c000001" }
+    doc = JSON.generate hash
+    assert_equal(Mongo::ObjectID.from_string("4ba7e82ca04014011c000001"), Rack::JSON::JSONDocument.new(doc).attributes["_id"])
+  end
+  
+  def test_parsing_non_mongo_object_ids
+    hash = { "_id" => 1 }
+    doc = JSON.generate hash
+    assert_equal(hash["_id"], Rack::JSON::JSONDocument.new(doc).attributes["_id"])
+  end
+  
+  def test_adding_an_id
+    hash = { "test" => "I don't have an ID" }
+    doc = JSON.generate hash
+    json_doc = Rack::JSON::JSONDocument.new(doc)
+    json_doc.add_id(1)
+    assert_equal(1, json_doc.attributes["_id"])
+  end
+  
+  def test_not_overriding_an_id
+    hash = { "test" => "I do have an ID", "_id" => 2 }
+    doc = JSON.generate hash
+    json_doc = Rack::JSON::JSONDocument.new(doc)
+    json_doc.add_id(1)
+    assert_equal(2 , json_doc.attributes["_id"])
+  end
+  
+  def test_adding_timestamps
+    hash = { "_id" => 1 }
+    doc = JSON.generate hash
+    t = Time.now
+    assert_equal(t.to_s, Rack::JSON::JSONDocument.new(doc).attributes["created_at"].to_s)
+    assert_equal(t.to_s, Rack::JSON::JSONDocument.new(doc).attributes["updated_at"].to_s)
+  end
+
+  def test_not_always_updating_created_at
+    hash = { "_id" => 1 }
+    doc = JSON.generate hash
+    t1 = Time.now
+    assert_equal(t1.to_s, Rack::JSON::JSONDocument.new(doc).attributes["created_at"].to_s)
+    assert_equal(t1.to_s, Rack::JSON::JSONDocument.new(doc).attributes["updated_at"].to_s)
+    sleep 1
+    hash2 = { "_id" => 1, "created_at" => t1.to_s }
+    doc = JSON.generate hash2
+    t2 = Time.now
+    assert_equal(t1.to_s, Rack::JSON::JSONDocument.new(doc).attributes["created_at"].to_s)
+    assert_equal(t2.to_s, Rack::JSON::JSONDocument.new(doc).attributes["updated_at"].to_s)
+  end
+end

data/test/test_json_query.rb

@@ -0,0 +1,69 @@
+require 'helper'
+
+class QueryTest < Test::Unit::TestCase
+  def test_ascending_sort
+    json_query = "[/price]"
+    query  = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:sort => [[:price, :asc]]}, query.options)
+  end
+
+  def test_descending_sort
+    json_query = '[\price]'
+    query  = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:sort => [[:price, :desc]]}, query.options)
+  end
+
+  def test_multiple_sort_fields
+    json_query = '[/price, \rating]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:sort => [[:price, :asc], [:rating, :desc]]}, query.options)
+  end
+
+  def test_skips_and_limits
+    json_query = '[0:10]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:skip => 0, :limit => 10}, query.options)
+  end
+
+  def test_map_query
+    json_query = '[=name]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:fields => ['name']}, query.options)
+  end
+
+  def test_single_equality_condition_with_number
+    json_query = '[?price=10]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:price => 10}, query.selector)
+  end
+
+  def test_single_equality_condition_with_string
+    json_query = '[?name=bob!]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:name => 'bob!'}, query.selector)
+  end
+
+  def test_single_greater_than_condition
+    json_query = '[?price>10]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:price => {'$gt' => 10}}, query.selector)
+  end
+
+  def test_single_greater_than_or_equal_condition
+    json_query = '[?price>=10]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:price => { '$gte' => 10}}, query.selector)
+  end
+
+  def test_single_less_than_condition
+    json_query = '[?price<10]'
+    query = Rack::JSON::JSONQuery.new(json_query)
+    assert_equal({:price => {'$lt' => 10}}, query.selector)
+  end
+
+  # def test_single_greater_than_or_equal_condition
+  #   json_query = '[?price=<10]'
+  #   query = Rack::JSON::JSONQuery.new(json_query)
+  #   assert_equal({:price => { '$lte' => 10}}, query.selector)
+  # end
+end

data/test/test_mongo_document.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+class MongoDocumentTest < Test::Unit::TestCase
+
+  def test_stringifying_mongo_object_ids
+    hash = { "_id" => Mongo::ObjectID.from_string("4ba7e82ca04014011c000001") }
+    doc = Rack::JSON::MongoDocument.new(hash).attributes
+    assert_equal("4ba7e82ca04014011c000001", doc["_id"])
+  end
+
+  def test_not_stringifying_non_mongo_object_ids
+    hash = { "_id" => 1 }
+    doc = Rack::JSON::MongoDocument.new(hash).attributes
+    assert_equal({ "_id" => 1 }, doc)
+  end
+
+  def test_setting_the_created_at_stamp
+    hash = { "_id" => Mongo::ObjectID.from_string("4ba7e82ca04014011c000001") }
+    doc = Rack::JSON::MongoDocument.new(hash).attributes
+    assert_equal({ "_id" => "4ba7e82ca04014011c000001", 
+                   "created_at" => Mongo::ObjectID.from_string("4ba7e82ca04014011c000001").generation_time
+                 }, doc)
+  end
+end

data/test/test_resource.rb

@@ -0,0 +1,108 @@
+require 'helper'
+
+class ResourceTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+  include Rack::Utils
+  def setup
+    @db = Mongo::Connection.new.db("test")
+    @collection = @db['testing']
+  end
+
+  def teardown
+    @collection.drop
+  end
+
+  def app
+    Rack::JSON::Resource.new lambda { |env| 
+      [404, {'Content-Length' => '9', 'Content-Type' => 'text/plain'}, "Not Found"]
+    },  :collections => [:testing], :db => @db 
+  end
+
+  def test_non_existing_resource
+    get '/blah'
+    assert_equal 404, last_response.status
+  end
+
+  def test_index_method
+    @collection.save({:testing => true})
+    get '/testing'
+    assert last_response.ok?
+    assert_match /"testing":true/, last_response.body
+  end
+
+  def test_creating_a_document
+    put '/testing/1', '{"title": "testing"}'
+    assert_equal 201, last_response.status
+    assert_match /"_id":1/, last_response.body
+    assert_match /"title":"testing"/, last_response.body
+  end
+
+  def test_show_a_single_document
+    put '/testing/1', '{"title": "testing first"}'
+    put '/testing/2', '{"title": "testing second"}'
+    get '/testing/1'
+    assert last_response.ok?
+    assert_match /"title":"testing first"/, last_response.body
+    assert_no_match /"title":"testing second"/, last_response.body
+  end
+
+  def test_not_finding_a_specific_document
+    get '/testing/1'
+    assert_equal 404, last_response.status
+    assert_equal "document not found", last_response.body
+  end
+
+  def test_index_method_with_query_parameters
+    @collection.save({:testing => true, :rating => 5, :title => 'testing'})
+    get '/testing?[?title=testing]'
+    assert last_response.ok?
+    assert_match /"title":"testing"/, last_response.body
+    get '/testing?[?rating=5]'
+    assert last_response.ok?
+    assert_match /"title":"testing"/, last_response.body
+  end
+
+  def test_index_method_with_sort
+    @collection.save({:testing => true, :rating => 5, :title => 'testing'})
+    get '/testing?[/title]'
+    assert last_response.ok?
+    assert_match /"title":"testing"/, last_response.body
+    get '/testing?[?rating=5]'
+    assert last_response.ok?
+    assert_match /"title":"testing"/, last_response.body
+  end
+
+  def test_putting_a_new_document
+    put '/testing/1', '{"title": "testing update"}'
+    assert_equal 201, last_response.status
+    assert_match /"_id":1/, last_response.body
+    assert_match /"title":"testing update"/, last_response.body
+  end
+
+  def test_updating_a_document
+    @collection.save({:title => 'testing', :_id => 1})
+    put '/testing/1', '{"title": "testing update"}'
+    assert last_response.ok?
+    assert_match /"_id":1/, last_response.body
+    assert_match /"title":"testing update"/, last_response.body
+  end
+
+  def test_deleting_a_document
+    @collection.save({:title => 'testing', :_id => 1})
+    assert @collection.find_one({:_id => 1})
+    delete '/testing/1'
+    assert last_response.ok?
+    assert_nil @collection.find_one({:_id => 1})
+  end
+
+  def test_deleting_only_with_member_path
+    delete '/testing'
+    assert_equal 405, last_response.status
+  end
+
+  def test_posting_a_document
+    post '/testing', '{"title": "testing"}'
+    assert last_response.status == 201
+    assert_match /"title":"testing"/, last_response.body
+  end
+end

data/test/test_response.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+class ResponseTest < Test::Unit::TestCase
+  def test_setting_the_content
+    response = Rack::JSON::Response.new("test")
+    assert_equal(3, response.to_a.length)
+  end
+
+  def test_default_http_status_to_200
+    response = Rack::JSON::Response.new("test")
+    assert_equal(200, response.to_a[0])
+  end
+
+  def test_setting_http_status_code
+    response = Rack::JSON::Response.new("test", :status => 422)
+    assert_equal(422, response.to_a[0])
+  end
+
+  def test_response_body
+    response = Rack::JSON::Response.new("test")
+    assert_equal("test", response.to_a[2])
+  end
+
+  def test_setting_the_content_length
+    response = Rack::JSON::Response.new("test")
+    assert_equal("4", response.to_a[1]["Content-Length"])
+  end
+
+  def test_setting_the_content_type
+    response = Rack::JSON::Response.new("test")
+    assert_equal("text/plain", response.to_a[1]["Content-Type"])
+  end
+
+  def test_sending_json
+    response = Rack::JSON::Response.new("{'title': 'hello'}")
+    assert_equal("{'title': 'hello'}", response.to_a[2])
+  end
+
+  def test_head_response
+    response = Rack::JSON::Response.new("test", :head => true)
+    assert_equal("", response.to_a[2])
+    assert_equal("4", response.to_a[1]["Content-Length"])
+    assert_equal("text/plain", response.to_a[1]["Content-Type"])
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: rackjson
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Oliver Nightingale
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.19.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mongo_ext
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.19.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+    version: 
+description: A rack end point for storing json documents.
+email: oliver.n@new-bamboo.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/rackjson.rb
+- lib/rackjson/document.rb
+- lib/rackjson/json_document.rb
+- lib/rackjson/json_query.rb
+- lib/rackjson/mongo_document.rb
+- lib/rackjson/request.rb
+- lib/rackjson/resource.rb
+- lib/rackjson/response.rb
+- rackjson.gemspec
+- test/helper.rb
+- test/suite.rb
+- test/test_document.rb
+- test/test_json_document.rb
+- test/test_json_query.rb
+- test/test_mongo_document.rb
+- test/test_resource.rb
+- test/test_response.rb
+has_rdoc: true
+homepage: http://github.com/olivernn/rackjson
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A rack end point for storing json documents.
+test_files: 
+- test/helper.rb
+- test/suite.rb
+- test/test_builder.rb
+- test/test_document.rb
+- test/test_json_document.rb
+- test/test_json_query.rb
+- test/test_mongo_document.rb
+- test/test_resource.rb
+- test/test_response.rb