sheetsu-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08990261ab0bd01d5d09dd026ece5ff594d28acc
+  data.tar.gz: 8025b4063f7f53881256b96df819e2e605ad1e32
+SHA512:
+  metadata.gz: 86efae15d670ef5e58f8815ac00a75946aa9ed4a699ac39323166b7882f929829c3cd7315c54158030067ab5b6e1de1a6608c2b38fddd76f99e656582c11a0cd
+  data.tar.gz: 4380e107a9e11912db44c1c35fbfdea924726eb79111b4870a38d1cd405cc83eea70afc7a19397b05d884c2cb2cb95d086d4d35e426fc5a3affe3d90d0ea0a1d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/sheetsu-ruby-*.gem
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--color

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_group "lib", "lib"
+end

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at jb41.mail@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

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

data/README.md

@@ -0,0 +1,245 @@
+# sheetsu-ruby
+Ruby bindings for the Sheetsu API (https://sheetsu.com/docs).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sheetsu-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sheetsu-ruby
+
+## Usage
+
+### Generating a Client
+
+You need to create a new Sheetsu::Client object, and populate it with your Sheetsu API URL. You can find this URL on [Sheetsu Dashboard](https://sheetsu.com/your-apis).
+
+```ruby
+# Create new client object
+client = Sheetsu::Client.new("https://sheetsu.com/apis/v1.0/020b2c0f")
+```
+or
+```ruby
+# Create new client object
+client = Sheetsu::Client.new("020b2c0f")
+```
+
+If you have HTTP Basic Authentication turned on for your API, you should pass `api_key` and `api_secret` here, like:
+```ruby
+# Create new client object with HTTP Basic Auth keys
+client = Sheetsu::Client.new("020b2c0f", api_key: "YOUR_API_KEY", api_secret: "YOUR_API_SECRET")
+```
+
+### CRUD
+
+Sheetsu gives you the ability to use full CRUD on your Google Spreadsheet. Remember to populate the first row of every sheet with column names. You can look at [example spreadsheet](https://docs.google.com/spreadsheets/d/1WTwXrh2ZDXmXATZlQIuapdv4ldyhJGZg7LX8GlzPdZw/edit?usp=sharing).
+
+### Create
+[Link to docs](https://sheetsu.com/docs#post)
+
+To add data to Google Spreadsheets, send a hash or an array of hashes.
+```ruby
+# Adds single row
+client.create({ id: 7, name: "Glenn", score: "69" })
+
+# Adds bunch of rows
+rows = [
+  { id: 7, name: "Glenn", score: "69" },
+  { id: 8, name: "Brian", score: "77" },
+  { id: 9, name: "Joe", score: "45" }
+]
+client.create(rows)
+```
+
+By default, all writes are performed on the first sheet (worksheet). Pass name of a sheet as a 2nd param to add data to other worksheet.
+```ruby
+# Adds single row to worksheet named "Sheet3"
+client.create({ "foo" => "bar", "baz" => "quux" }, "Sheet3")
+```
+
+On success returns a hash or an array of hashes with created values. On error check [errors](#errors).
+
+### Read
+[Link to docs](https://sheetsu.com/docs#get)
+
+Read the whole sheet
+```ruby
+client.read
+```
+
+You can pass hash with options
+  - `sheet` - get data from named worksheet
+  - `limit` - limit number of results
+  - `offset` - start from N first record
+  - `search` - hash with search params [(more below)](#search)
+
+```ruby
+# Get first two rows from worksheet named "Sheet2"
+client.read(sheet: "Sheet2", limit: 2)
+
+# Get 5th record from worksheet named "Sheet3"
+client.read(
+  offset: 4, # because rows are numbered from 0
+  limit: 1,  # because only one row
+  sheet: "Sheet3"
+)
+```
+
+#### search
+[Link to docs](https://sheetsu.com/docs#get_search)
+
+To get rows that match search criteria, pass a hash with search params
+
+```ruby
+# Get all rows where column 'id' is 'foo' and column 'value' is 'bar'
+client.read(search: { id: "foo", value: "bar" })
+
+# Get all rows where column 'First name' is 'Peter' and column 'Score' is '42'
+client.read(search: { "First name" => "Peter", "Score" => 42 })
+
+# Get first two row where column 'First name' is 'Peter',
+# column 'Score' is '42' from sheet named "Sheet3"
+client.read(
+  search: { "First name" => "Peter", "Score" => 42 } # search criteria
+  limit: 2        # first two rows
+  sheet: "Sheet3" # Sheet name
+)
+```
+
+On success returns an array of hashes. On error check [errors](#errors).
+
+### Update
+[Link to docs](https://sheetsu.com/docs#patch)
+
+To update row(s), pass column name and its value which is used to find row(s).
+
+```ruby
+# Update all columns where 'name' is 'Peter' to have 'score' = 99 and 'last name' = 'Griffin'
+client.update(
+  "name", # column name
+  "Peter", # value to search for
+  { "score": 99, "last name" => "Griffin" }, # hash with updates
+)
+```
+
+By default, [PATCH request](https://sheetsu.com/docs#patch) is sent, which is updating only values which are in the hash passed to the method. To send [PUT request](https://sheetsu.com/docs#put), pass 4th argument being `true`. [Read more about the difference between PUT and PATCH in our docs](https://sheetsu.com/docs#patch).
+
+
+```ruby
+# Update all columns where 'name' is 'Peter' to have 'score' = 99 and 'last name' = 'Griffin'
+# Empty all cells which matching, which are not 'score' or 'last name'
+client.update(
+  "name", # column name
+  "Peter", # value to search for
+  { "score": 99, "last name" => "Griffin" }, # hash with updates
+  true # nullify all fields not passed in the hash above
+)
+```
+
+To perform `#update` on different than the first sheet, pass sheet name as a 5th argument.
+```ruby
+# Update all columns where 'name' is 'Peter' to have 'score' = 99 and 'last name' = 'Griffin'
+# In sheet named 'Sheet3'
+# Empty all cells which matching, which are not 'score' or 'last name'
+client.update(
+  "name", # column name
+  "Peter", # value to search for
+  { "score": 99, "last name" => "Griffin" }, # hash with updates
+  true, # nullify all fields not passed in the hash above
+  "Sheet3"
+)
+```
+
+On success returns an array of hashes with updated values. On error check [errors](#errors).
+
+### Delete
+[Link to docs](https://sheetsu.com/docs#delete)
+
+To delete row(s), pass column name and its value which is used to find row(s).
+
+```ruby
+# Delete all rows where 'name' equals 'Peter'
+client.delete(
+  "name", # column name
+  "Peter" # value to search for
+)
+```
+
+You can pass sheet name as a 3rd argument. All operations are performed on the first sheet, by default.
+```ruby
+# Delete all rows where 'foo' equals 'bar' in sheet 'Sheet3'
+client.delete(
+  "foo",   # column name
+  "bar",   # value to search for
+  "Sheet3" # sheet name
+)
+```
+
+If success returns `:ok` symbol. If error check [errors](#errors).
+
+### Errors
+There are different styles of error handling. We choose to throw exceptions and signal failure loudly. You do not need to deal with any HTTP responses from the API calls directly. All exceptions are matching particular response code from Sheetsu API. You can [read more about it here](https://sheetsu.com/docs#statuses).
+
+All exceptions are a subclass of `Sheetsu::SheetsuError`. The list of different error subclasses is listed below. You can choose to rescue each of them or rescue just the parent class (`Sheetsu::SheetsuError`).
+
+
+```ruby
+Sheetsu::NotFoundError
+Sheetsu::ForbiddenError
+Sheetsu::LimitExceedError
+Sheetsu::UnauthorizedError
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Run all tests:
+```
+rspec
+```
+
+Run a single test:
+```
+rspec spec/read_spec.rb
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sheetsu/sheetsu-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+### Pull Requests
+
+- **Add tests!** Your patch won't be accepted if it doesn't have tests.
+
+- **Create topic branches**. Please, always create a branch with meaningful name. Don't ask us to pull from your master branch.
+
+- **One pull request per feature**. If you want to do more than one thing, please send
+  multiple pull requests.
+
+- **Send coherent history**. Make sure each individual commit in your pull
+  request is meaningful. If you had to make multiple intermediate commits while
+  developing, please squash them before sending them to us.
+
+### Docs
+
+[Sheetsu documentation sits on GitHub](https://github.com/sheetsu/docs). We would love your contributions! We want to make these docs accessible and easy to understand for everyone. Please send us Pull Requests or open issues on GitHub.
+
+# To do 
+1. Allow passing whole API URLs as well as just slugs to the client, like:
+```ruby
+client = Sheetsu::Client.new("https://sheetsu.com/apis/v1.0/020b2c0f")
+# should be the same as
+client = Sheetsu::Client.new("020b2c0f")
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sheetsu"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sheetsu.rb

@@ -0,0 +1,44 @@
+require 'sheetsu/create'
+require 'sheetsu/read'
+require 'sheetsu/update'
+require 'sheetsu/delete'
+require 'sheetsu/util'
+
+module Sheetsu
+  class Client
+
+    def initialize(api_url, auth_credentials={})
+      @api_url = Sheetsu::Util.parse_api_url(api_url)
+      @http_basic_auth = auth_credentials
+    end
+
+    def create(data, sheet=nil)
+      if data.is_a?(Hash)
+        Sheetsu::Create.new(@api_url, @http_basic_auth).row(data, { sheet: sheet })
+      elsif data.is_a?(Array)
+        Sheetsu::Create.new(@api_url, @http_basic_auth).rows(data, { sheet: sheet })
+      end 
+    end
+
+    def read(options={})
+      Sheetsu::Read.new(@api_url, @http_basic_auth).rows(options)
+    end
+
+    def update(column, value, data, update_whole=false, sheet=nil)
+      options = { column: column, value: value, data: data, update_whole: update_whole, sheet: sheet }
+
+      if update_whole
+        Sheetsu::Update.new(@api_url, @http_basic_auth).put(options)
+      else
+        Sheetsu::Update.new(@api_url, @http_basic_auth).patch(options)
+      end
+    end
+
+    def delete(column, value, sheet=nil)
+      options = { column: column, value: value, sheet: sheet }
+
+      Sheetsu::Delete.new(@api_url, @http_basic_auth).rows(options)
+    end
+
+  end
+end

data/lib/sheetsu/create.rb

@@ -0,0 +1,24 @@
+require 'sheetsu/util'
+require 'sheetsu/errors'
+require 'sheetsu/request'
+
+require 'json'
+
+module Sheetsu
+  class Create < Sheetsu::Request
+
+    def row(row, options={})
+      add_options_to_url(options)
+
+      response = call(:post, row)
+      parse_response(response)
+    end
+
+    def rows(rows, options={})
+      add_options_to_url(options)
+
+      response = call(:post, { rows: rows })
+      parse_response(response)
+    end
+  end
+end

data/lib/sheetsu/delete.rb

@@ -0,0 +1,18 @@
+require 'sheetsu/util'
+require 'sheetsu/errors'
+require 'sheetsu/request'
+
+require 'json'
+
+module Sheetsu
+  class Delete < Sheetsu::Request
+
+    def rows(options)
+      add_options_to_url(options)
+
+      response = call(:delete)
+      parse_response(response)
+    end
+
+  end
+end

data/lib/sheetsu/errors.rb

@@ -0,0 +1,25 @@
+module Sheetsu
+  class SheetsuError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+
+    def initialize(message = nil, http_status = nil, http_body = nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+    end
+  end
+
+  class NotFoundError < SheetsuError
+  end
+
+  class ForbiddenError < SheetsuError
+  end
+
+  class LimitExceedError < SheetsuError
+  end
+
+  class UnauthorizedError < SheetsuError
+  end
+end

data/lib/sheetsu/read.rb

@@ -0,0 +1,18 @@
+require 'sheetsu/util'
+require 'sheetsu/errors'
+require 'sheetsu/request'
+
+require 'json'
+
+module Sheetsu
+  class Read < Sheetsu::Request
+
+    def rows(options={})
+      add_options_to_url(options)
+
+      response = call(:get)
+      parse_response(response)
+    end
+
+  end
+end

data/lib/sheetsu/request.rb

@@ -0,0 +1,109 @@
+require 'net/http'
+
+module Sheetsu
+  class Request
+    
+    def initialize(url, basic_auth)
+      @url = url
+      @basic_auth = basic_auth
+    end
+
+    def call(method, body=nil)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request = request(method)
+      request = add_headers(request)
+      request = add_basic_auth(request)
+      request = add_body(request, body)
+
+      http.request(request)
+    end
+
+    private
+
+      def uri
+        @uri ||= URI.parse(@url)
+      end
+
+      def request(method)
+        request = http_klass(method).new(uri.request_uri)
+        add_headers(request)
+
+        request
+      end
+
+      def add_headers(request)
+        Sheetsu::Util.default_headers.each_pair { |k,v| request[k] = v }
+        request
+      end
+
+      def add_basic_auth(request)
+        if @basic_auth.keys.any?
+          request.basic_auth(CGI.unescape(@basic_auth[:api_key]), CGI.unescape(@basic_auth[:api_secret]))
+        end
+        request
+      end
+
+      def add_body(request, body)
+        if body
+          request.body = body.to_json
+        end
+        request
+      end
+
+      def http_klass(method)
+        case method
+        when :get    then Net::HTTP::Get
+        when :post   then Net::HTTP::Post
+        when :put    then Net::HTTP::Put
+        when :patch  then Net::HTTP::Patch
+        when :delete then Net::HTTP::Delete
+        end
+      end
+
+      def parse_response(response)
+        Sheetsu::Util.parse_response(response)
+      end
+
+      def add_options_to_url(options)
+        add_sheet_to_url(options)
+        add_column_value_to_url(options)
+        add_query_params_to_url(options)
+      end
+
+      def add_column_value_to_url(options)
+        if options[:column] && options[:value]
+          @url += Sheetsu::Util.encoded_column(options)
+          
+          options.delete(:column)
+          options.delete(:value)
+        end
+      end
+
+      def add_sheet_to_url(options)
+        if options[:sheet]
+          @url += ['/sheets/', CGI::escape(options[:sheet]).to_s].join('')
+
+          options.delete(:sheet)
+        end
+      end
+
+      def add_query_params_to_url(options)
+        h = Hash.new.tap do |hash|
+          hash[:limit] = options[:limit] if options[:limit]
+          hash[:offset] = options[:offset] if options[:offset]
+
+          if options[:search]
+            hash.merge!(options[:search])
+            @url += '/search'
+          end
+        end
+
+        if h.keys.any?
+          @url = Sheetsu::Util.append_query_string_to_url(@url, h)
+        end
+      end
+
+  end
+end

data/lib/sheetsu/update.rb

@@ -0,0 +1,25 @@
+require 'sheetsu/util'
+require 'sheetsu/errors'
+require 'sheetsu/request'
+
+require 'json'
+
+module Sheetsu
+  class Update < Sheetsu::Request
+
+    def put(options)
+      add_options_to_url(options)
+
+      response = call(:put, options[:data])
+      parse_response(response)
+    end
+
+    def patch(options)
+      add_options_to_url(options)
+
+      response = call(:patch, options[:data])
+      parse_response(response)
+    end
+
+  end
+end

data/lib/sheetsu/util.rb

@@ -0,0 +1,53 @@
+require 'cgi'
+
+require 'sheetsu/version'
+
+module Sheetsu
+  module Util
+
+    @sheetsu_api_url = "https://sheetsu.com/apis/v1.0/"
+
+    def self.default_headers
+      {
+        'Accept-Encoding' => 'gzip, deflate',
+        'Accept' => 'application/vnd.sheetsu.3+json',
+        'Content-Type' => 'application/json',
+        'User-Agent' => "Sheetsu-Ruby/#{Sheetsu::VERSION}"
+      }
+    end
+
+    def self.parse_api_url(url)
+      [@sheetsu_api_url, url].join('')
+    end
+
+    def self.append_query_string_to_url(url, options)
+      url + "?#{query_string(options)}"
+    end
+
+    def self.encoded_column(options)
+      ['/', CGI::escape(options[:column].to_s), '/', CGI::escape(options[:value].to_s)].join('')
+    end
+
+    def self.parse_response(response)
+      case response.code.to_i
+      when 200 then JSON.parse(response.body)
+      when 201 then JSON.parse(response.body)
+      when 204 then :ok
+      when 401 then raise Sheetsu::UnauthorizedError
+      when 403 then raise Sheetsu::ForbiddenError
+      when 404 then raise Sheetsu::NotFoundError
+      when 429 then raise Sheetsu::LimitExceedError
+      else
+        raise Sheetsu::SheetsuError.new(nil, response.code, response.body)
+      end
+    end
+
+    private
+      def self.query_string(options)
+        options.map do |k,v|
+          "#{k.to_s}=#{CGI::escape(v.to_s)}"
+        end.join('&')
+      end
+
+  end
+end

data/lib/sheetsu/version.rb

@@ -0,0 +1,3 @@
+module Sheetsu
+  VERSION = "0.1.0"
+end

data/sheetsu-ruby.gemspec

@@ -0,0 +1,29 @@
+ # coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sheetsu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sheetsu-ruby"
+  spec.version       = Sheetsu::VERSION
+  spec.authors       = ["Michael Oblak"]
+  spec.email         = ["m@sheetsu.com"]
+
+  spec.summary       = %q{Turn Google Spreadsheets into REST APIs}
+  spec.description   = %q{Sheetsu (https://sheetsu.com) allows you to automate Google Spreadsheets and use them as a resource in a REST API. It's easier than using standard Google Spreadsheets API, because Sheetsu handles all the 'dirty' work for you.}
+  spec.homepage      = "https://sheetsu.com"
+
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "webmock", "~> 2.3"
+  spec.add_development_dependency "pry", "~> 0"
+  spec.add_development_dependency "simplecov", "~> 0"
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: sheetsu-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Oblak
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: simplecov
+  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'
+description: Sheetsu (https://sheetsu.com) allows you to automate Google Spreadsheets
+  and use them as a resource in a REST API. It's easier than using standard Google
+  Spreadsheets API, because Sheetsu handles all the 'dirty' work for you.
+email:
+- m@sheetsu.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".simplecov"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sheetsu.rb
+- lib/sheetsu/create.rb
+- lib/sheetsu/delete.rb
+- lib/sheetsu/errors.rb
+- lib/sheetsu/read.rb
+- lib/sheetsu/request.rb
+- lib/sheetsu/update.rb
+- lib/sheetsu/util.rb
+- lib/sheetsu/version.rb
+- sheetsu-ruby.gemspec
+homepage: https://sheetsu.com
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Turn Google Spreadsheets into REST APIs
+test_files: []
+has_rdoc: