tupplur 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2b8e48210120a1b238121391fc8552891670c81
+  data.tar.gz: 494017fd71c91f6fd6c936200df729a7adb201cd
+SHA512:
+  metadata.gz: bf38291747032151dc4cf271d31b2fc560f123dc71b3b494006fb02d9a7fb3ff663b7d447a926ef4dddd9d9129dbdfc7f4f18b03c9d2d8735f11fdfd52dbd191
+  data.tar.gz: ed1ca103911a472313dfb7725c1dd54dc6d55165006a9ba3c71385b0b94051a05362d7eaacd471207ad37174d40fbe9ae1b86f0f81850ed66a0badb0b90b5a5f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Robin Edman
+
+MIT License
+
+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.md

@@ -0,0 +1,115 @@
+# Tupplur
+
+Tupplur extends your Mongoid 3.x models, allowing you to expose fields as readable 
+or writable from outside of your application. It includes a Rack REST adapter, 
+so that any Rack app can expose some or all of its' models as JSON easily 
+through a standard REST CRUD api. 
+
+This library is especially useful if you're building APIs for mobile or 
+Single Page Applications (maybe using Backbone, Spine, AngularJS or whichever 
+framework you prefer).
+
+It's been designed to work well straight on top of Rack, or with lightweight 
+Rack-based frameworks such as Sinatra and Cuba. In fact, the REST adapter is 
+implemented as a Cuba application.
+
+If you're using Rails you're probably better off with another solution at the 
+moment, since it might make more sense to use something that's more 
+integrated into the framework.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tupplur'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tupplur
+
+If necessary in your application:
+    ```
+    require 'tupplur' # at the appropriate place.
+    ```
+
+## Usage
+
+Tupplur is divided into two parts: a model mixin and a Rack 
+application which acts like a REST endpoint.
+
+### REST endpoint Rack application
+  After Mongoid has been set up, mount the Rack app on a route of your choice. 
+  The details of how you do this will depend on which framework you're using.
+  Each model gets its' own endpoint. So repeat this for all 
+  models for which you want to provide a REST interface.
+
+  In Cuba:
+  ```ruby
+  on "/users" do 
+    run Tupplur::RESTEndpoint.new(User)
+  end
+  ```
+      
+  In Rack (in config.ru):
+  ```ruby
+  run Rack::URLMap.new("/" => YourApp.new, 
+                       "/users" => Tupplur::RESTEndpoint.new(User))
+  ```
+  
+  If you're using Sinatra you might prefer the Rack method to mounting it 
+  within Sinatra itself.
+
+### Model mixin
+In your model:
+  ```ruby
+  class User
+    include Mongoid::Document
+    include Tupplur::ModelExtensions
+   
+    # Define which operations you want to support.
+    rest_interface :create, 
+                   :read, 
+                   :update, 
+                   :delete
+    
+    # Fields that are to be both readable and writable.
+    externally_accessible :name,
+                          :email
+    
+    # Read-only fields.
+    externally_readable :active
+    
+    # Put your regular Mongoid model code here (or anywhere you want to as the ordering doesn't matter.)
+    field :name, type: String
+    field :email, type: String
+    field :password, type: String
+    field :active, type: Boolean, default: false
+  end
+  ```
+  This is where you define what parts of your model you want to 
+  expose outside of your backend application. This is configured 
+  in a similar manner to the way we choose to expose attributes on
+  objects in plain Ruby. There we use atr_reader and 
+  attr_accessor. Tupplur includes the corresponding methods 
+  externally_readable and externally_accessible.
+
+  You also define what REST operations a given model should 
+  support using the rest_interface method. Just like externally_readable and 
+  externally_writable it takes one or more symbols as arguments: :create, :read,
+  :update, :delete. The default is to not support any operation. You may 
+  see this as whitelisting operations.
+
+### Examples
+In the test directory you'll find an example app which uses the Cuba framework.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "bundler/gem_tasks"
+
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+end

data/lib/tupplur.rb

@@ -0,0 +1,8 @@
+require "tupplur/version"
+
+require "tupplur/errors"
+require "tupplur/model_extensions"
+require "tupplur/rest_endpoint"
+
+module Tupplur
+end

data/lib/tupplur/errors.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Tupplur
+  module Error
+    class RESTOperationNotAllowed < StandardError
+      def message
+        "The #{@operation} REST operation is not allowed."
+      end
+
+      def initialize(operation = 'unspecified')
+        @operation = operation
+      end
+    end
+
+    def self.log_exception(e)
+      puts "Exception: #{e}"
+      puts "Message: #{e.message}"
+      puts e.backtrace.join("\n")
+    end
+  end
+end

data/lib/tupplur/model_extensions.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require "active_support/all"
+
+module Tupplur
+  module ModelExtensions
+    def self.included(base)
+      base.const_set(:EXTERNALLY_READABLE_FIELDS, ['_id'])
+      base.const_set(:EXTERNALLY_ACCESSIBLE_FIELDS, [])
+      base.const_set(:REST_INTERFACE, [])
+
+      base.send(:include, InstanceMethods)
+      base.send(:extend, ClassMethods)
+    end
+
+    module InstanceMethods
+      def as_external_document
+       doc = self.as_document
+       
+       # note: id fix for client side libraries like Spine.js,
+       # who rely on an id attribute being present.
+       doc['id'] = doc['_id']
+
+       doc.slice(*readable_fields + ['id'])
+      end
+
+      def external_update!(document_as_hash)
+        allowed_fields = filter_accessible_fields(document_as_hash)
+        update_attributes!(allowed_fields)
+      end
+
+      # Does the model allow a certain REST operation?
+      # If no operation given: Does the model allow any REST operation at all?
+      def rest?(operation)
+        if operation
+          self.class.const_get(:REST_INTERFACE).include?(operation)
+        else
+          ! self.class.const_get(:REST_INTERFACE).empty?
+        end
+      end
+
+      private
+
+      def filter_accessible_fields(hsh)
+        hsh.slice(*self.class.const_get(:EXTERNALLY_ACCESSIBLE_FIELDS).map(&:to_s))
+      end
+
+      def readable_fields
+        (self.class.const_get(:EXTERNALLY_ACCESSIBLE_FIELDS) + self.class.const_get(:EXTERNALLY_READABLE_FIELDS)).map(&:to_s)
+      end
+    end
+
+    module ClassMethods
+      # Does the model allow a certain REST operation?
+      # If no operation given: Does the model allow any REST operation at all?
+      def rest?(operation = nil)
+        if operation
+          const_get(:REST_INTERFACE).include?(operation)
+        else
+          ! const_get(:REST_INTERFACE).empty?
+        end
+      end
+
+      def rest_read(document_id = nil)
+        if document_id
+          rest_read_document(document_id)
+        else
+          rest_read_all
+        end
+      end
+
+      def rest_update(document_id, client_model)
+        raise Tupplur::Error::RESTOperationNotAllowed.new('update') unless rest?(:update)
+
+        find(document_id).external_update!(client_model)
+      end
+
+      def rest_delete(document_id)
+        raise Tupplur::Error::RESTOperationNotAllowed.new('delete') unless rest?(:delete)
+
+        find(document_id).delete
+      end
+
+      def rest_create(client_fields)
+        raise Tupplur::Error::RESTOperationNotAllowed.new('create') unless rest?(:create)
+
+        external_create!(client_fields)
+      end
+
+      def rest_read_document(document_id)
+        raise Tupplur::Error::RESTOperationNotAllowed.new('read') unless rest?(:read)
+
+        find(document_id).as_external_document
+      end
+
+      def rest_read_all
+        raise Tupplur::Error::RESTOperationNotAllowed.new('read') unless rest?(:read)
+
+        all.map { |m| m.as_external_document }
+      end
+
+      def external_create!(fields)
+        allowed_fields = filter_accessible_fields(fields)
+        create!(allowed_fields)
+      end
+
+      private
+
+      # Externally accessible fields and embedded documents.
+      def externally_accessible(*fields)
+        const_get(:EXTERNALLY_ACCESSIBLE_FIELDS).push(*fields)
+      end
+
+      # Externally readable fields and embedded documents.
+      def externally_readable(*fields)
+        const_get(:EXTERNALLY_READABLE_FIELDS).push(*fields)
+      end
+
+      # Used to define allowed REST operations (e.g. :read, :create, :update, :delete).
+      # Example usage:
+      # class MyModel 
+      #   include Mongoid::Document
+      #   include Tupplur::ModelExtensions
+      #
+      #   rest_interface :read, :update, :delete
+      #
+      def rest_interface(*operations)
+        const_get(:REST_INTERFACE).push(*operations)
+      end
+
+
+      def filter_accessible_fields(hsh)
+        hsh.slice(*const_get(:EXTERNALLY_ACCESSIBLE_FIELDS).map(&:to_s))
+      end
+
+      def readable_fields
+        (const_get(:EXTERNALLY_ACCESSIBLE_FIELDS) + const_get(:EXTERNALLY_READABLE_FIELDS)).map(&:to_s)
+      end
+
+    end
+  end
+end

data/lib/tupplur/rest_endpoint.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'cuba'
+
+module Tupplur
+  class RESTEndpoint < Cuba
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+      super() do
+        on ":id" do |document_id|
+          # REST read document
+          on get do
+            begin
+              send_json(@model.rest_read(document_id))
+            rescue Tupplur::Error::RESTOperationNotAllowed => e
+              res.status = 401
+            end
+          end
+
+          # REST update document
+          on put, param('data') do |client_model|
+            begin
+              send_json(@model.rest_update(document_id, client_model))
+            rescue Tupplur::Error::RESTOperationNotAllowed => e
+              res.status = 401
+            end
+          end
+          
+          # REST delete document
+          on delete do
+            begin
+              send_json(@model.rest_delete(document_id))
+            rescue Tupplur::Error::RESTOperationNotAllowed => e
+              res.status = 401
+            end
+          end
+        end
+
+        # REST read whole collection
+        on get do
+          begin
+            send_json(@model.rest_read)
+          rescue Tupplur::Error::RESTOperationNotAllowed => e
+            res.status = 401
+          end
+        end
+
+        # REST create document
+        on post, param('data') do |client_fields|
+          begin
+            @model.rest_create(client_fields)
+          rescue Tupplur::Error::RESTOperationNotAllowed => e
+            res.status = 401
+          end
+        end
+      end
+    end
+
+    def self.define
+      raise NotImplementedError, "Use .new and run the app instead."
+    end
+
+    private
+
+    def send_json(document)
+      res['Content-Type'] = 'application/json; charset=utf-8'
+      res.write(document.to_json)
+    end
+
+  end
+end

data/lib/tupplur/version.rb

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

data/test/rest_endpoint_test.rb

@@ -0,0 +1,126 @@
+require_relative "test_helper"
+require_relative "../lib/tupplur"
+
+module RESTEndPointTest
+  class Base < TupplurTestCase
+    def tabula_rasa
+      User.delete_all
+      Secret.delete_all
+    end
+
+    def setup
+      tabula_rasa
+
+      User.create!(name: "Adam", 
+                   email: "adam@example.com",
+                   password: "verysecurepassword")
+      User.create!(name: "Brenda",
+                   email: "brenda@example.com",
+                   password: "verysecurepassword")
+
+      Secret.create!(message: "Super secret info.")
+    end
+
+    def teardown
+      tabula_rasa
+    end
+  end
+
+  class GetTest < Base 
+    test "get all documents returns only readable and accessible attributes" do
+      get "/users"
+    
+      expected_response = [{name: "Adam", email: "adam@example.com", active: false},
+                           {name: "Brenda", email: "brenda@example.com", active: false}]
+      response = ActiveSupport::JSON.decode(last_response.body).map(&:symbolize_keys!)
+
+      assert_equal(expected_response, response.map { |m| m.except(:_id, :id) })
+    end
+
+    test "get document with id returns only readable and accessible attributes" do
+      brenda_id = User.find_by(name: "Brenda")._id
+      get "/users/#{brenda_id}"
+
+      expected_response = {name: "Brenda", email: "brenda@example.com", active: false}
+      response = ActiveSupport::JSON.decode(last_response.body).symbolize_keys!
+
+      assert_equal(expected_response, response.except(:_id, :id))
+    end
+
+    test "cannot get resource that does not allow it" do
+      get "/secrets"
+
+      assert_equal(401, last_response.status)
+    end
+  end
+
+  class UpdateTest < Base
+    test "update accessible attribute" do
+      user = User.find_by(name: "Brenda")
+      put "/users/#{user._id}", {data: {name: "Brian"}}
+      user.reload
+
+      assert_equal("Brian", user.name)
+    end
+
+    test "cannot update readonly attribute" do
+      user = User.last
+      put "/users/#{user._id}", {data: {active: true}}
+      user.reload
+
+      refute(user.active)
+    end
+
+    test "cannot update internal attribute" do
+      user = User.last
+      put "users/#{user._id}", {data: {password: "anotherpassword"}}
+      user.reload
+
+      assert_equal("verysecurepassword", user.password)
+    end
+
+    test "cannot update resource that does not allow it" do
+      secret = Secret.first
+      put "secrets/#{secret._id}", {data: {message: "I say"}}
+      secret.reload
+
+      assert_equal("Super secret info.", secret.message)
+    end
+  end
+
+  class DeleteTest < Base
+    test "delete resource" do
+      user_id = User.first._id
+      delete "/users/#{user_id}"
+
+      refute(User.find(user_id))
+    end
+
+    test "cannot delete resource that does not allow it" do
+      secret_id = Secret.first._id
+      delete "/secrets/#{secret_id}"
+
+      assert(Secret.find(secret_id))
+    end
+  end
+
+  class CreateTest < Base
+    test "create resource" do
+      post "/users", {data: {name: "Charles", email: "charles@example.com"}}
+
+      assert(User.find_by(name: "Charles"))
+    end
+
+    test "cannot set readable attributes" do
+      post "/users", {data: {name: "Roger", active: true}}
+
+      refute(User.find_by(name: "Roger").active)
+    end
+
+    test "cannot create resource that does not allow it" do
+      post "/secrets", {data: {message: "Hey"}}
+
+      refute(Secret.find_by(message: "Hey"))
+    end
+  end
+end

data/test/test_app/app.rb

@@ -0,0 +1,20 @@
+require "mongoid"
+require_relative "helpers"
+
+cd_to_here
+Mongoid.load!("./mongoid.yml")
+
+require_relative "../../lib/tupplur"
+require_relative "models/user"
+require_relative "models/secret"
+
+Cuba.define do
+  on "users" do
+    run Tupplur::RESTEndpoint.new(User)
+  end
+
+  on "secrets" do
+    run Tupplur::RESTEndpoint.new(Secret)
+  end
+end
+

data/test/test_app/config.ru

@@ -0,0 +1,4 @@
+#encoding: utf-8
+require './app'
+
+run Cuba

data/test/test_app/helpers.rb

@@ -0,0 +1,4 @@
+def cd_to_here
+  root_directory = File.expand_path(File.dirname(__FILE__))
+  Dir.chdir(root_directory)
+end

data/test/test_app/models/secret.rb

@@ -0,0 +1,7 @@
+class Secret
+  include Mongoid::Document
+  include Tupplur::ModelExtensions
+
+  field :message, type: String
+end
+

data/test/test_app/models/user.rb

@@ -0,0 +1,20 @@
+class User
+  include Mongoid::Document
+  include Tupplur::ModelExtensions
+
+  rest_interface :create, 
+                 :read, 
+                 :update, 
+                 :delete
+
+  externally_accessible :name,
+                        :email
+
+  externally_readable :active
+
+  field :name, type: String
+  field :email, type: String
+  field :password, type: String
+  field :active, type: Boolean, default: false
+end
+

data/test/test_app/mongoid.yml

@@ -0,0 +1,20 @@
+# Tell Mongoid which environment this configuration is for.
+development:
+  # This starts the session configuration settings. You may have as
+  # many sessions as you like, but you must have at least 1 named
+  # 'default'.
+  sessions:
+    # Define the default session.
+    default:
+      # A session can have any number of hosts. Usually 1 for a single
+      # server setup, and at least 3 for a replica set. Hosts must be
+      # an array of host:port pairs. This session is single server.
+      hosts:
+        - 127.0.0.1:27017
+      # Define the default database name.
+      database: tupplurtest
+      # Set username and password if you need to.
+      # username: user
+      # password: password
+  options:
+    raise_not_found_error: false

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require "turn/autorun"
+require "active_support/all"
+require "rack/test"
+require_relative "test_app/app"
+
+Turn.config.natural = true
+
+class TupplurTestCase < ActiveSupport::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Cuba
+  end
+end

data/tupplur.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+#lib = File.expand_path('../lib', __FILE__)
+#$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# require 'tupplur/version'
+require File.expand_path('../lib/tupplur/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "tupplur"
+  spec.version       = Tupplur::VERSION
+  spec.authors       = ["Robin Edman"]
+  spec.email         = ["robin.edman@gmail.com"]
+  spec.description   = %q{Tupplur extends Mongoid, allowing fields to be exposed as readable or writable from outside of your application.}
+  spec.summary       = spec.description
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "turn", "~> 0.9"
+  spec.add_development_dependency "activesupport", "~> 3.0"
+  spec.add_development_dependency "rack-test", "~> 0.6.2"
+  spec.add_development_dependency "virtus", "~> 1.0"
+  spec.add_development_dependency "mongoid", "~> 3.0"
+
+  spec.add_runtime_dependency "cuba", "~>3.1.0"
+  # Mongoid is an implicitly assumed dependency. So is ActiveSupport.
+  # We don't specify those versions since we don't want to risk conflicts with
+  # Mongoid.
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: tupplur
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robin Edman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: cuba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: Tupplur extends Mongoid, allowing fields to be exposed as readable or
+  writable from outside of your application.
+email:
+- robin.edman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tupplur.rb
+- lib/tupplur/errors.rb
+- lib/tupplur/model_extensions.rb
+- lib/tupplur/rest_endpoint.rb
+- lib/tupplur/version.rb
+- test/rest_endpoint_test.rb
+- test/test_app/app.rb
+- test/test_app/config.ru
+- test/test_app/helpers.rb
+- test/test_app/models/secret.rb
+- test/test_app/models/user.rb
+- test/test_app/mongoid.yml
+- test/test_helper.rb
+- tupplur.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Tupplur extends Mongoid, allowing fields to be exposed as readable or writable
+  from outside of your application.
+test_files:
+- test/rest_endpoint_test.rb
+- test/test_app/app.rb
+- test/test_app/config.ru
+- test/test_app/helpers.rb
+- test/test_app/models/secret.rb
+- test/test_app/models/user.rb
+- test/test_app/mongoid.yml
+- test/test_helper.rb