glass-api 0.1.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDhlNGI0MDllYjdjYjAxYjBiODlmYjdhNGM4YTdlZTkwYzllNGU5Mg==
+  data.tar.gz: !binary |-
+    OGFlYjRkODcyZDY3YWUwZDc5OGZjOTU2ZTRjMGQxYzA2ZTU5YjM5OQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YWI4N2IwYjA4ZTY2ZDg5NWQ4ODIzZjdiZGFkNjk2NjM0NzM0NWI4ZmU5NzU0
+    M2U0YjZjYWU0NjUxMjJhNjM2M2M5NWQwNmU0ZjI1Yzg0MTViM2NlNDRmYzUw
+    ZDM5YWM3NjhkMzI4OGIzNjVkOTkzMThjMmM1NjcxZjk1OWNhMDA=
+  data.tar.gz: !binary |-
+    ZDAwNzQ1ZjZkNTFjZDM1ZmU3ZDhmMTEzOWQyZjQ5YmM3YmJlMmVlY2Y2ZDA5
+    NDBkMTFmYmFhYmNjNjcxNDBmMDkzN2Q5ODgyODg0NzM4NGNhMzJjNzg2ZjM1
+    NjFhNGZmYzI3Y2Q3NjUyZDVlZjdkNGZlZTMwMzZmZTg3NTk5MzY=

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in glass.gemspec
+gemspec
+
+group :test do
+  gem 'simplecov'
+  gem 'coveralls'
+end

data/README.md

@@ -0,0 +1,166 @@
+# Glass
+
+[![Gem Version](https://badge.fury.io/rb/glass-api.png)](http://badge.fury.io/rb/glass-api)
+[![Build
+Status](https://travis-ci.org/TeamSBK/Glass.png?branch=master)](https://travis-ci.org/TeamSBK/Glass)
+[![Coverage
+Status](https://coveralls.io/repos/TeamSBK/Glass/badge.png?branch=master)](https://coveralls.io/r/TeamSBK/Glass?branch=master)
+
+Glass is a lightweight Rails Engine that is built to do all the heavy lifting from serving an API in your Rails Application.
+
+
+## Features
+
+* CRUD for your models without a Controller
+* Integrates quickly for all client-side Javascript frameworks (Ember, Backbone, Angular)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'glass-api', require: 'glass'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install glass-api
+
+And then run:
+
+    rails generate glass:install
+
+This generator will install Glass. It will also add an initializer in `config/initializer/glass.rb`
+
+    Glass.configure do |config|
+      config.models = ['User']
+      config.app_name = 'Test App'
+      config.format = :json
+    end
+
+It will modify your `app/assets/javascripts/application.js`, adding:
+
+    //= require glass
+
+It will modify your `config/routes.rb`, adding:
+
+    mount Glass::Engine => '/api', as: 'glass'
+
+## Mongoid
+
+    class Model
+      include Mongoid::Document
+      def self.column_names
+        self.fields.collect { |field| field[0] }
+      end
+    end
+    
+## Usage
+
+#### Ruby
+
+Start the server:
+
+    rails server
+
+#### Javascript
+
+The following usage examples makes use of the Glass API given that you have a
+`User` model in your Rails app and you have configured the Glass gem to expose it.
+
+###### Find
+
+Finds a list of records in a model with 'Foo' as name.
+
+```javascript
+glass.User.find({
+  name: 'Foo'
+}, function (res, error) {
+  if (!error) {
+    // Do something with res
+  }
+});
+```
+
+
+###### Find All
+
+The following usage example finds all users.
+
+```javascript
+glass.User.findAll(function (res, error) {
+  if (!error) {
+    // Do something with res
+  }
+});
+```
+
+
+###### Create
+
+Create a new user record.
+
+```javascript
+var user = {
+  name: 'Jaune Sarmiento',
+  email: 'hello@jaunesarmiento.me'
+};
+
+glass.User.create(user, function (res, error) {
+  if (!error) {
+    // Do something with res
+  }
+});
+```
+
+###### Update
+
+Update the user with `id == 1` and update its name to `Joko`.
+
+```javascript
+// Given our create() function returns the user object with 1 as id
+var user = {
+  id: 1,
+  name: 'Joko'
+};
+
+glass.User.update(user, function (res, error) {
+  if (!error) {
+    // Do something with res
+  }
+});
+```
+
+
+###### Delete
+
+Delete a user record with `id == 1`.
+
+```javascript
+glass.User.delete(1, function (res, error) {
+  if (!error) {
+    // Do something with res
+  }
+});
+```
+
+## 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
+
+## License
+
+MIT. See [License] for more details.
+Copyright (c) 2013 TeamSBK. Powered by [Proudcloud] Inc.
+
+
+  [License]: http://github.com/TeamSBK/Glass/blob/master/LICENSE.txt
+  [Proudcloud]: http://www.proudcloud.net
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/assets/javascripts/glass.js

@@ -0,0 +1,283 @@
+(function () {
+
+  // Glass core module
+  var Glass = Glass = function () {
+    this.init();
+  };
+
+  // Configuration settings
+  Glass.prototype.config = {};
+
+  // CSRF token
+  Glass.prototype.token = null;
+
+  // Model names
+  Glass.prototype.models = [];
+
+  // Initialization
+  Glass.prototype.init = function () {
+    // Get the CSRF token that will be used for all requests
+    this.token = this.getCsrfToken();
+
+    this.getConfig((function (config) {
+      if (config === undefined) throw new Error('Failed to get configuration data from the server.');
+
+      this.config = config;
+
+      var i = config.models.length;
+      while (i--) {
+        m = config.models[i];
+        Glass.prototype[m] = new this.Model(m, config.routes[m.toLowerCase()]);
+        Glass.prototype[m].token = this.token;
+      }
+    }).bind(this));
+  };
+
+  // Gets the CSRF token from the DOM
+  Glass.prototype.getCsrfToken = function () {
+    var token = document.querySelector('meta[name="csrf-token"]');
+    if (!token) throw new Error('Could not find CSRF token.');
+    else token = token.getAttribute('content');
+
+    return token;
+  };
+
+  // Fires an XHR to get the config data from the server
+  Glass.prototype.getConfig = function (callback) {
+    // Get the config from the server
+    this.get('/api', function (res, error) {
+      if (!error) {
+        var config = JSON.parse(res.response);
+        callback(config, error);
+      }
+      else {
+        callback(null, error);
+      }
+    }, false);
+  };
+
+  Glass.prototype.get = function (url, callback, async) {
+    this.doXHR('GET', url, callback, async);
+  };
+
+  Glass.prototype.post = function (url, callback, async) {
+    this.doXHR('POST', url, callback, async);
+  }
+
+  Glass.prototype.put = function (url, callback, async) {
+    this.doXHR('PUT', url, callback, async);
+  }
+
+  Glass.prototype.delete = function (url, callback, async) {
+    this.doXHR('DELETE', url, callback, async);
+  }
+
+  Glass.prototype.doXHR = function (type, url, callback, async) {
+    if (arguments.length < 3) throw new Error('Glass#doXHR is missing ' + (3 - arguments.length) + ' parameters.');
+    if (async === undefined) async = true;
+
+    // Append our CSRF token
+    url += ((url.indexOf('?') != -1) ? '&' : '?') + "authenticity_token=" + this.token;
+
+    var xhr = new XMLHttpRequest();
+    xhr.open(type, url, async);
+    xhr.setRequestHeader('Content-Type', 'application/json');
+
+    xhr.onreadystatechange = (function () {
+      if (xhr.readyState == 4) {
+        if (xhr.status == 200 || xhr.status === 0) callback(xhr, null);
+        else callback(null, 'Could not complete XMLHttpRequest to ' + url);
+      }
+    }).bind(this);
+
+    xhr.send();
+  }
+
+
+  // Glass.Model module
+  var Model = Glass.prototype.Model = function (name, routes) {
+    this.init(name, routes);
+
+    // Let's add the XHR functions to our model as well
+    this.get = Glass.prototype.get;
+    this.post = Glass.prototype.post;
+    this.put = Glass.prototype.put;
+    this.delete = Glass.prototype.delete;
+    this.doXHR = Glass.prototype.doXHR;
+  };
+
+  Model.prototype.routes = null;
+
+  Model.prototype.name = null;
+
+  // Returns the total rows
+  Model.prototype.count = function () {};
+
+  // Model initialization
+  Model.prototype.init = function (name, routes) {
+    if (arguments.length < 2) throw new Error('Model#init() is missing ' + (2 - arguments.length) + ' parameters.');
+
+    // Build the model's routes
+    this.routes = routes;
+
+    // Set this model's name
+    this.name = name;
+  };
+
+  Model.prototype.findAll = function(callback) {
+    this.find({}, callback); // Just call Model#find() with a blank options
+  };
+
+  Model.prototype.find = function(options, callback) {
+    options || (options = {}); // providing no options means find all
+
+    var queryParams = this.serialize(options),
+        path = '/api' + this.routes['index'].path,
+        url = (queryParams.length > 0) ? path + '?' + queryParams : path;
+
+    this.get(url, function (res, error) {
+      if (!error) {
+        var result = JSON.parse(res.response);
+        if (callback) callback(result, null);
+      }
+      else {
+        if (callback) callback(null, error);
+      }
+    });
+  };
+
+  Model.prototype.findOne = function(options, callback) {
+    // TODO: Find one record here; return first?
+  }
+
+  Model.prototype.findById = function(id, callback) {
+    if (typeof id == 'function' || id === undefined) throw new Error("Model#findbyId() is missing 'id' parameter.");
+
+    var route = this.routes['show'].path.replace(/:id/, id),
+        url = '/api' + route;
+
+    this.get(url, function (res, error) {
+      if (!error) {
+        var result = JSON.parse(res, error);
+        if (callback) callback(res.body, null);
+      }
+      else {
+        if (callback) callback(null, error);
+      }
+    });
+  }
+
+  Model.prototype.create = function(options, callback) {
+    if (typeof options == 'function' || options === undefined) throw new Error("Model#create() is missing 'options' parameter.");
+
+    var queryParams = this.serialize(options),
+        path = '/api' + this.routes['create'].path,
+        url = (queryParams.length > 0) ? path + '?' + queryParams : path;
+
+    this.post(url, function (res, error) {
+      if (!error) {
+        var result = JSON.parse(res.response);
+        if (callback) callback(result, null);
+      }
+      else {
+        if (callback) callback(null, error);
+      }
+    });
+  };
+
+  Model.prototype.update = function(options, callback) {
+    if (typeof options == 'function' || options === undefined) throw new Error("Model#update() is missing 'options' parameter.");
+
+    if (options.hasOwnProperty('id')) {
+      // Replace :id in our route with the value of id
+      var route = this.routes['update'].path.replace(/:id/, options.id);
+      delete options.id;
+    }
+    else {
+      throw new Error("Model#update() is missing 'options.id' parameter.");
+    }
+
+    var queryParams = this.serialize(options),
+        path = '/api' + route,
+        url = (queryParams.length > 0) ? path + '?' + queryParams : path;
+
+    this.put(url, function (res, error) {
+      if (!error) {
+        var result = JSON.parse(res.response);
+        if (callback) callback(result, null);
+      }
+      else {
+        if (callback) callback(null, error);
+      }
+    });
+  };
+
+  Model.prototype.delete = function(options, callback) {
+    if (typeof options == 'function' || options === undefined) throw new Error("Model#delete() is missing 'options' parameter.");
+
+    if (options.hasOwnProperty('id')) {
+      // Replace :id in our route with the value of id
+      var route = this.routes['destroy'].path.replace(/:id/, options.id);
+      delete options.id;
+    }
+    else {
+      throw new Error("Model#update() is missing 'options.id' parameter.");
+    }
+
+    var queryParams = this.serialize(options),
+        path = '/api' + route,
+        url = (queryParams.length > 0) ? path + '?' + queryParams : path;
+
+    this.delete(url, function (res, error) {
+      if (!error) {
+        var result = JSON.parse(res.response);
+        if (callback) callback(result, null);
+      }
+      else {
+        if (callback) callback(null, error);
+      }
+    });
+  };
+
+  Model.prototype.serialize = function (obj) {
+    var values = [],
+        prefix = '';
+    return this.recursiveSerialize(obj, values, prefix).join('&');
+  };
+
+  Model.prototype.recursiveSerialize = function(obj, values, prefix) {
+    for (var key in obj) {
+      if (typeof obj[key] == 'object') {
+        if (prefix.length == 0) prefix += '[' + key + ']';
+        else prefix += key;
+
+        values = this.recursiveSerialize(obj[key], values, prefix);
+
+        var prefixes = values.split('[');
+
+        if (prefixes.length > 1) prefix = prefixes.slice(0, prefixes.length - 1).join('[');
+        else prefix = prefixes[0];
+      }
+      else {
+        value = encodeURIComponent(obj[key]);
+        if (prefix.length > 0) var prefixedKey = prefix + '[' + key + ']';
+        else prefixedKey = key;
+
+        prefixedKey = encodeURIComponent(prefixedKey);
+
+        if (value) values.push(prefixedKey + '=' + value);
+      }
+    }
+
+    return values;
+  };
+
+
+  // Add Glass.js to window
+  //window.addEventListener('load', function () {
+    //var g = new Glass();
+    //window['glass'] = g;
+  //}, false);
+  window.glass = new Glass();
+
+}());

data/app/controllers/glass/api_controller.rb

@@ -0,0 +1,99 @@
+module Glass
+  class ApiController < Glass::ApplicationController
+    before_filter :sanitize_model
+    before_filter :sanitize_params, only: [:create, :update, :index]
+    before_filter :validate_model
+
+    respond_to :json
+
+    def index
+      begin
+        render json: all_or_where(@model) # See Private Method Below
+      rescue
+
+        @unknown_params = [].tap do |keys|
+          @new_hash.each do |key, val|
+            unless @model.column_names.include? key.to_s
+              keys << [key => val]
+            end
+          end
+        end
+
+        render json: { unknown_parameters: @unknown_params.flatten }, status: :unprocessable_entity
+      end
+    end
+
+    def show
+      begin
+        render json: @model.find(params[:id]).to_json
+      rescue Exception => exception
+        render json: "#{exception}", status: :unprocessable_entity
+      end
+    end
+
+    def create
+      object = @model.new(@new_hash)
+
+      if object.save
+        render json: object.to_json
+      else
+        render json: object.errors, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      begin
+        object = @model.find(params[:id])
+      rescue Exception => exception
+        render json: "#{exception}", status: :unprocessable_entity
+      end
+
+      if object.update_attributes(@new_hash)
+        render json: object.to_json
+      else
+        render json: object.errors, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      begin
+        object = @model.find(params[:id])
+      rescue Exception => exception
+        render json: "#{exception}", status: :unprocessable_entity
+      end
+
+      if object.delete
+        render json: 'Successfully deleted'
+      else
+        render json: 'Unable to delete entity', status: :unprocessable_entity
+      end
+    end
+
+  private
+    def sanitize_model
+      @model = params[:model_scope].capitalize.singularize.constantize
+    end
+
+    def sanitize_params
+      @new_hash = {}
+
+      params.each do |key, value|
+        @new_hash[key.to_sym] = value unless ignored_keys.include? key
+      end
+    end
+
+    def validate_model
+      render json: "uninitialized constant #{@model}", status: :unprocessable_entity unless defined?(@model)
+    end
+
+    def ignored_keys
+      ['utf', 'authenticity_token', 'id', 'controller', 'action', 'model_scope', 'api']
+    end
+
+    def all_or_where(model)
+      @new_hash.present? ? model.where(@new_hash).to_json : model.all.to_json
+    end
+
+  end
+
+end

data/app/controllers/glass/application_controller.rb

@@ -0,0 +1,12 @@
+module Glass
+
+ class ModelNotFound < ::StandardError
+  end
+
+  class ObjectNotFound < ::StandardError
+  end
+
+  class ApplicationController < ActionController::Base
+
+  end
+end

data/app/controllers/glass/main_controller.rb

@@ -0,0 +1,15 @@
+module Glass
+  class MainController < Glass::ApplicationController
+    before_filter :setup_config
+
+    def index
+      render json: Glass::Config.to_json
+    end
+
+  private
+    def setup_config
+      Glass::Config.setup
+    end
+
+  end
+end

data/config/routes.rb

@@ -0,0 +1,12 @@
+Glass::Engine.routes.draw do
+
+  root to: 'main#index'
+
+  controller "api" do
+    get     '/:model_scope',      to: :index,     as: 'index',    via: 'get'
+    get     '/:model_scope/:id',  to: :show,      as: 'show',     via: 'get'
+    post    '/:model_scope',      to: :create,    as: 'create',   via: 'post'
+    put     '/:model_scope/:id',  to: :update,    as: 'update',   via: 'put'
+    delete  '/:model_scope/:id',  to: :delete,    as: 'destroy',  via: 'delete'
+  end
+end

data/lib/generators/glass/install_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators'
+
+module Glass
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "Glass Installation"
+
+    def install
+      routes = File.open(Rails.root.join('config/routes.rb')).try :read
+      initializer = (File.open(Rails.root.join('config/initializers/glass.rb')) rescue nil).try :read
+
+      gsub_file "config/routes.rb", /mount Glass::Engine => \'api'\, as: :\'rails_admin\'/, ''
+      route("mount Glass::Engine => '/api', as: :glass")
+
+      template "initializer.erb", 'config/initializers/glass.rb' unless initializer
+    end
+  end
+end

data/lib/generators/glass/templates/initializer.erb

@@ -0,0 +1,16 @@
+Glass.configure do |config|
+
+  # Set the application name here
+  config.app_name = "<%= Rails.application.engine_name.titleize.chomp(' Application').gsub(' ','') %>"
+
+  # Set the models that would be included
+  # config.models = ['User']
+
+  # Set the format that would be used for this application. Default is json
+  config.format = :json
+
+  # Set the mountable path for Glass.js to recognize the URL
+  # Default is '/api'
+  config.mounted_at = '/api'
+
+end

data/lib/generators/glass/uninstall_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module Glass
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "Glass Uninstalltion"
+
+    def uninstall
+      remove_file 'config/initializers/glass.rb'
+      gsub_file "config/routes.rb", /mount Glass::Engine => \'api'\, as: :\'rails_admin\'/, ''
+    end
+  end
+end

data/lib/glass.rb

@@ -0,0 +1,9 @@
+require 'glass/config'
+require 'glass/engine'
+require "glass/version"
+
+module Glass
+  def self.configure(&block)
+    block.call(Glass::Config)
+  end
+end

data/lib/glass/config.rb

@@ -0,0 +1,57 @@
+module Glass
+  module Config
+    class << self
+      attr_accessor :app_name
+      attr_accessor :models
+      attr_accessor :format
+      attr_accessor :mounted_at
+      attr_accessor :routes
+      attr_accessor :registry
+
+      def reset
+        @app_name = ''
+        @mounted_at = '/api'
+        @models = []
+        @format = :json
+        @routes = {}
+      end
+
+      def models_with_routes
+        @models.each do |model|
+          @routes[model.downcase.to_sym] = create_routes(model)
+        end
+      end
+
+      def pluralize_downcase(model)
+        model.pluralize.downcase
+      end
+
+      def capitalize_singularize(model)
+        model.capitalize.singularize
+      end
+
+      def create_routes(model)
+        model_scope = pluralize_downcase(model)
+        model_name = capitalize_singularize(model)
+
+        return_routes(model_name, model_scope)
+      end
+
+      def return_routes(model_name, model_scope)
+        return {
+            "index"   => { "type" => "get",   "path" => "/#{model_scope}"      },
+            "show"    => { "type" => "get",   "path" => "/#{model_scope}/:id"  },
+            "create"  => { "type" => "post",  "path" => "/#{model_scope}"      },
+            "update"  => { "type" => "put",   "path" => "/#{model_scope}/:id"  },
+            "destroy" => { "type" => "delete","path" => "/#{model_scope}/:id"  } }
+      end
+
+      def setup
+        models_with_routes
+      end
+
+    end
+
+    self.reset
+  end
+end

data/lib/glass/engine.rb

@@ -0,0 +1,8 @@
+require 'rails'
+require 'glass'
+
+module Glass
+  class Engine < Rails::Engine
+    isolate_namespace Glass
+  end
+end

data/lib/glass/version.rb

@@ -0,0 +1,3 @@
+module Glass
+  VERSION = "0.1.2"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: glass-api
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Adrian Peterson Co, Jaune Sarmiento, Robbie Marcelo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-18 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: rspec
+  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: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Glass - A lightweight Rails Engine for an open RESTful API for models
+email:
+- adrianpco@gmail.com, hawnecarlo@gmail.com, rbmrclo@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- app/assets/javascripts/glass.js
+- app/controllers/glass/api_controller.rb
+- app/controllers/glass/application_controller.rb
+- app/controllers/glass/main_controller.rb
+- config/routes.rb
+- lib/generators/glass/install_generator.rb
+- lib/generators/glass/templates/initializer.erb
+- lib/generators/glass/uninstall_generator.rb
+- lib/glass/config.rb
+- lib/glass/engine.rb
+- lib/glass/version.rb
+- lib/glass.rb
+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.6
+signing_key: 
+specification_version: 4
+summary: Glass is a your one-stop solution for a RESTFUL API. It is a lightweight
+  Rails Engine that is built to do all the heavy lifting from serving an API in your
+  Rails Application.
+test_files: []