gcal-unit 1.0.0

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "httparty", "~>0.8.0"
+
+group :test do
+  gem "rspec", "~> 2.10.0"
+  gem "vcr"
+  gem "fakeweb"
+  gem "dotenv"
+end

data/README.md

@@ -0,0 +1,134 @@
+G-G-G-GCal-Unit!
+==========================
+***
+
+![GCal Unit](https://s3.amazonaws.com/github-gcal-unit/gcal-unit.png)
+
+## GANGSTA SH*T
+
+GCal-Unit is a bullet proof vest for the Google Calendar API. It will pimp the hell out of your applications. This rapper is used only for Google Calendar API calls and not any other Google APIs (except for making those Google tokens fresh).
+
+## LOADING THE CLIP
+
+To start caping fools, you have to install this sh*t.
+
+```
+gem install gcal-unit
+```
+
+This will also load [httparty](http://github.com/jnunemaker/httparty) in your pimp cup.
+
+## CANDY SHOP
+
+I'll break it down for you, baby it's simple.
+
+```ruby
+#token is the user's Google API access token, yo
+
+# Get a list of a your Google calendars
+list = Google::CalendarList.new(token).list
+
+# Get the user's primary Google calendar
+primary = Google::Calendar.new(token).get("primary")
+
+# Get a list of events from a calendar
+events = Google::Event.new(token).nested_for('primary').list
+
+# Get a single event from a calendar
+event = Google::Event.new(token).nested_for('primary').get(event_id)
+
+# Insert an event for a calendar
+event = Google::Event.new(token).nested_for('primary').insert({
+  end: { date: { '1975-07-06' } },
+  start: { date: { '1975-07-06' } },
+  description: { string: { 'I was born.' } }
+})
+
+# Update an event for a calendar
+event = Google::Event.new(token).nested_for('primary').update(event_id, {
+  end: { date: { 'I was born with a pimp cup.' } }
+})
+
+# Delete an event
+Google::Event.new(token).nested_for('primary').delete(event_id)
+
+# Use the quick add feature
+event = Google::Event.new(token).nested_for('primary').quick_add('got shot 9 times yesterday at 2am')
+```
+
+The base URI for all of the API operations is: [http://www.googleapis.com/calendar/v3](http://www.googleapis.com/calendar/v3)
+
+If you have an interest in reading other things than c-notes, you can find the Google API Calendar documentation at [http://developers.google.com/google-apps/calendar/v3/reference](http://developers.google.com/google-apps/calendar/v3/reference)
+
+Each Google Calendar API model requires an API token. This token (as well as a refresh token) can be retrieved by using OAuth (we recommend [OmniAuth](https://github.com/intridea/omniauth)). If the token expires, you can use the authentication method in this library and your refresh token to refresh the API token for future calls.
+
+```ruby
+# refresh_token is your Google API refresh token for your registered application
+
+client = Google::Authorization.new(refresh_token)
+token = client.refresh()['access_token']  # use this token for all the api calls
+```
+
+## WANKSTA
+
+Configure the Google API wrapper with the sensitive data needed to make Google API calls.
+
+```ruby
+Google.configure do |config|
+  config.api_key = ENV['GOOGLE_API_KEY']
+  config.client_id = ENV['GOOGLE_CLIENT_ID']
+  config.client_secret = ENV['GOOGLE_CLIENT_SECRET']
+  # You can also set the refresh token here as well for later retreival but
+  # refresh tokens are not app specific but user specific, yo
+end
+```
+
+## KNOW YOUR HOOD
+
+When contributing use [dotenv](https://github.com/bkeepers/dotenv) to hold your sensitive data. The gem contains an example `.env` file. The `.env` file is in the .gitignore so your sensitive information will not be exposed.
+
+## IN DA CLUB
+
+To run the tests, there is some configuration that probably needs to occur. 
+The test suite uses VCR to make the initial calls to Google and then records the response.
+In order to make that initial call to Google work, we included a simple Sinatra application that you can
+run to record the correct refresh token for authentication.
+
+Here are the steps to make yo sh*t tight.
+
+1. visit https://developers.google.com/google-apps/calendar/
+1. sign in (upper right) with a Google account you want to use for testing
+1. visit https://code.google.com/apis/console
+1. create a project
+1. turn on calendar api
+1. visit api access
+1. create an oauth 2.0 client id
+1. choose web application
+1. choose http://localhost for hostname
+1. click on create client id
+1. edit settings and change redirect uri to http://localhost:3000/auth/google_oauth2/callback
+1. cp example.env .env
+1. change the GOOGLE_CLIENT_ID key to your client id in the .env file
+1. change the GOOGLE_CLIENT_SECRET key to your client secret in the .env file
+1. change the GOOGLE_API_KEY key to your API key in the .env file
+1. change the GOOGLE_TEST_USER key to who you are going to sign in as below when you run the Sinatra app
+1. bundle install --gemfile=bootstrapper/Gemfile
+1. rackup bootstrapper/config.ru -p 3000
+1. open your browser to http://localhost:3000 and authenticate with Google
+1. the GOOGLE_REFRESH_TOKEN will be added to your .env file
+1. add the user email that you signed in with to the .env file for the GOOGLE_TEST_USER key
+
+(Welcome to OAuth. So many steps, my grill is tarnishing)
+
+## GET RICH OR DIE TRYIN'
+
+To contribute, just take a hit and do the rest.
+
+* Fork the project
+* Create a test that indicates your behavior
+  * If you are using an http call, wrap your call with VCR
+* Code your feature or fix the bug
+* Commit (do not bump the version)
+* Send pull request
+
+Released under the [MIT license](http://www.opensource.org/licenses/mit-license.php).

data/Rakefile

@@ -0,0 +1,131 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def dir_name
+  name.gsub('-', '_')
+end
+
+def version
+  line = File.read("lib/#{dir_name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :validate
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{dir_name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push bf master"
+  sh "git push bf v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{dir_name}.rb", "lib/#{dir_name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{dir_name}.rb` file and `#{dir_name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/gcal-unit.gemspec

@@ -0,0 +1,57 @@
+
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  s.name              = 'gcal-unit'
+  s.version           = '1.0.0'
+  s.date              = '2012-08-30'
+  s.rubyforge_project = 'gcal-unit'
+
+  s.summary     = "Pimp ass API wrapper for the Google Calendar API."
+  s.description = "Wraps HTTP calls for the Google Calendar API."
+
+  s.authors  = ["Brilliant Fantastic"]
+  s.email    = 'support@brilliantfantastic.com'
+  s.homepage = 'http://github.com/brilliantfantastic/gcal-unit'
+
+  s.require_paths = %w[lib]
+  s.executables = []
+
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md]
+
+  s.add_dependency('httparty', "~> 0.7.8")
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    README.md
+    Rakefile
+    bootstrapper/Gemfile
+    bootstrapper/config.ru
+    example.env
+    gcal-unit.gemspec
+    lib/gcal_unit.rb
+    lib/gcal_unit/authorization.rb
+    lib/gcal_unit/calendar.rb
+    lib/gcal_unit/calendar_list.rb
+    lib/gcal_unit/client.rb
+    lib/gcal_unit/configuration.rb
+    lib/gcal_unit/errors.rb
+    lib/gcal_unit/event.rb
+    spec/lib/gcal_unit/authorization_spec.rb
+    spec/lib/gcal_unit/calendar_list_spec.rb
+    spec/lib/gcal_unit/calendar_spec.rb
+    spec/lib/gcal_unit/configuration_spec.rb
+    spec/lib/gcal_unit/event_spec.rb
+    spec/spec_helper.rb
+  ]
+  # = MANIFEST =
+
+  s.files.reject! { |f| f.include?("bootstrapper") || f.include?("example.env") }
+end

data/lib/gcal_unit/authorization.rb

@@ -0,0 +1,25 @@
+module Google
+  # Public: API methods to authorize a specific user for
+  # the API calls.
+  class Authorization < Client
+    base_uri 'https://accounts.google.com'
+
+    # Public: Returns a new access token for a specific refresh token.
+    #
+    # Returns a hash of metadata for refreshed user access.
+    def refresh
+      options = {
+        :body => {
+          :client_id => Google.configuration.client_id,
+          :client_secret => Google.configuration.client_secret,
+          :refresh_token => @token,
+          :grant_type => 'refresh_token'
+        },
+        :headers => {
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        }
+      }
+      http_post "/o/oauth2/token", options
+    end
+  end
+end

data/lib/gcal_unit/calendar.rb

@@ -0,0 +1,14 @@
+module Google
+  # Public: API methods for a singular calendar.
+  class Calendar < Client
+    # Public: Gets a single calendar.
+    #
+    # id - The id of the calendar to retrieve.
+    #
+    # Returns a hash of metadata for a calendar.
+    def get(id)
+      response = http_get "/calendars/#{id}"
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/gcal_unit/calendar_list.rb

@@ -0,0 +1,13 @@
+module Google
+  # Public: API methods for a list of calendars.
+  class CalendarList < Client
+    # Public: Gets a list of calendars for the user specified
+    # with the provided token.
+    #
+    # Returns a hash of metadata for a calendar list.
+    def list
+      response = http_get '/users/me/calendarList'
+      JSON.parse response.body
+    end
+  end
+end

data/lib/gcal_unit/client.rb

@@ -0,0 +1,135 @@
+module Google
+  # Public : Performs http calls to the Google APIs.
+  class Client
+    include HTTParty
+    base_uri 'https://www.googleapis.com/calendar/v3'
+
+    # Public: Initializes a new instance of a client.
+    #
+    # token - The user token to make the call.
+    def initialize(token)
+      @token = token
+    end
+
+    # Public: Performs a GET request for an http call with the correct queries
+    # and headers applied.
+    #
+    # path - the url for the GET request
+    # options - additional options for the GET request
+    # block - called after the GET request is complete
+    #
+    # Raises Google::AuthenticationRequiredError if the token is no longer valid
+    #
+    # Returns the response
+    def http_get(path, options={}, &block)
+      apply_api_key options # apply the API key if it is not there
+      apply_auth_header options # apply the authorization header if it is not there
+
+      response = self.class.get path, options, &block
+      raise AuthenticationRequiredError.new if response.code == 401
+      response
+    end
+
+    # Public: Performs a POST request for an http call with the correct queries
+    # and headers applied.
+    #
+    # path - the url for the POST request
+    # options - additional options for the POST request
+    # block - called after the POST request is complete
+    #
+    # Raises Google::AuthenticationRequiredError if the token is no longer valid
+    #
+    # Returns the response
+    def http_post(path, options={}, &block)
+      apply_api_key options # apply the API key if it is not there
+      apply_auth_header options # apply the authorization header if it is not there
+      apply_content_type_header options
+      apply_content_length_header options
+
+      response = self.class.post path, options, &block
+      raise AuthenticationRequiredError.new if response.code == 401
+      response
+    end
+
+    # Public: Performs a PUT request for an http call with the correct queries and
+    # headers applied.
+    #
+    # path - the url for the PUT request
+    # options - additional options for the PUT request
+    # block - called after the PUT request is complete
+    #
+    # Raises Google::AuthenticationRequiredError if the token is no longer valid
+    #
+    # Returns the response
+    def http_put(path, options={}, &block)
+      apply_api_key options # apply the API key if it is not there
+      apply_auth_header options # apply the authorization header if it is not there
+      apply_content_type_header options
+
+      response = self.class.put path, options, &block
+      raise AuthenticationRequiredError.new if response.code == 401
+      response
+    end
+
+    # Public: Performs a DELETE request for an http call with the correct queries and
+    # headers applied.
+    #
+    # path - the url for a DELETE request
+    # options - additional options for the DELETE request
+    # block - called after the DELETE request is complete
+    #
+    # Raises Google::AuthenticationRequiredError if the token is no longer valid
+    #
+    # Returns the response
+    def http_delete(path, options={}, &block)
+      apply_api_key options # apply the API key if it is not there
+      apply_auth_header options # apply the authorization header if it is not there
+
+      response = self.class.delete path, options, &block
+      raise AuthenticationRequiredError.new if response.code == 401
+      response
+    end
+
+    protected
+    # Protected: Adds the api key value to the query options
+    #
+    # Returns nothing
+    def apply_api_key(options)
+      options.merge! :query => {} unless options.has_key? :query
+      options[:query].merge!({ :key => Google.configuration.api_key })
+    end
+
+    # Protected: Adds the authorization token to the header
+    #
+    # Returns nothing
+    def apply_auth_header(options)
+      apply_header options, "Authorization", "Bearer #{@token}"
+    end
+
+    # Protected: Adds a default of application/json to the Content-Type unless
+    # one is already specified.
+    #
+    # Returns nothing
+    def apply_content_type_header(options)
+      if !options.has_key?(:headers) || !options[:headers].has_key?("Content-Type")
+        apply_header options, "Content-Type", "application/json"
+      end
+    end
+
+    # Protected: Applies the Content-Length of the body
+    #
+    # Returns nothing
+    def apply_content_length_header(options)
+      options[:body].nil? ? length = 0 : options[:body].length
+      apply_header options, "Content-Length", length.to_s
+    end
+
+    # Protected: Applies the specified key and value combination to the header
+    #
+    # Returns nothing
+    def apply_header(options, key, value)
+      options.merge! :headers => {} unless options.has_key? :headers
+      options[:headers].merge!({ key => value })
+    end
+  end
+end

data/lib/gcal_unit/configuration.rb

@@ -0,0 +1,10 @@
+module Google
+  # Public: Holds the configuration options for accessing
+  # a Google API.
+  class Configuration
+    attr_accessor :api_key,
+      :client_id,
+      :client_secret,
+      :refresh_token
+  end
+end

data/lib/gcal_unit/errors.rb

@@ -0,0 +1,7 @@
+module Google
+  # Public: Error that specifies the specified token is no longer valid.
+  class AuthenticationRequiredError < SecurityError; end
+
+  # Public: Error that specifies a calendar id was not provided.
+  class CalendarRequiredError < RuntimeError; end
+end

data/lib/gcal_unit/event.rb

@@ -0,0 +1,97 @@
+module Google
+  # Public: API methods for a calendar events.
+  class Event < Client
+    # Public: Saves a calendar id for methods that require a
+    # calendar for the API methods.
+    #
+    # calendar_id - Identifier for a specific calendar.
+    #
+    # Returns the event object for chaining
+    def nested_for(calendar_id)
+      @calendar_id = calendar_id
+      self
+    end
+
+    # Public: Gets a list of events for a specific calendar.
+    #
+    # Raises a Google::CalendarRequiredError if a calendar is not
+    # supplied (nested_for) was not called.
+    #
+    # Returns a hash of metadata for the calendars events.
+    def list
+      raise Google::CalendarRequiredError if @calendar_id.nil?
+      response = http_get "/calendars/#{@calendar_id}/events"
+      JSON.parse(response.body)
+    end
+
+    # Public: Gets a single event.
+    #
+    # id - The id of the event to retrieve.
+    #
+    # Raises a Google::CalendarRequiredError if a calendar is not
+    # supplied (nested_for) was not called.
+    #
+    # Returns a hash of metadata for an event.
+    def get(id)
+      raise Google::CalendarRequiredError if @calendar_id.nil?
+      response = http_get "/calendars/#{@calendar_id}/events/#{id}"
+      JSON.parse(response.body)
+    end
+
+    # Public: Inserts a new single event.
+    #
+    # event - A hash containing the data for an event to add.
+    #
+    # Raises a Google::CalendarRequiredError if a calendar is not
+    # supplied (nested_for) was not called.
+    #
+    # Returns a hash of metadata for the event that was added.
+    def insert(event)
+      raise Google::CalendarRequiredError if @calendar_id.nil?
+      response = http_post "/calendars/#{@calendar_id}/events", :body => JSON.dump(event)
+      JSON.parse(response.body)
+    end
+
+    # Public: Inserts a new single event that is parsed from a line of text.
+    #
+    # text - A sentence that is parsed into a single event.
+    #
+    # Raises a Google::CalendarRequiredError if a calendar is not
+    # supplied (nested_for) was not called.
+    #
+    # Returns a hash of metadata for the event that was added.
+    def quick_add(text)
+      raise Google::CalendarRequiredError if @calendar_id.nil?
+      response = http_post "/calendars/#{@calendar_id}/events/quickAdd", :query => { :text => text }
+      JSON.parse(response.body)
+    end
+
+    # Public: Updates a single event.
+    #
+    # id - The id of the event to update.
+    # event - A hash containing the data for the event to update.
+    #
+    # Raises a Google::CalendarRequiredError if a calendar is not
+    # supplied (nested_for) was not called.
+    #
+    # Returns a hash of metadata for the event that was updated.
+    def update(id, event)
+      raise Google::CalendarRequiredError if @calendar_id.nil?
+      response = http_put "/calendars/#{@calendar_id}/events/#{id}", :body => JSON.dump(event)
+      JSON.parse(response.body)
+    end
+
+    # Public: Deletes a single event.
+    #
+    # id - The id of the event to delete.
+    #
+    # Raises a Google::CalendarRequiredError if a calendar is not
+    # supplied (nested_for) was not called.
+    #
+    # Returns the response from the delete operation.
+    def delete(id)
+      raise Google::CalendarRequiredError if @calendar_id.nil?
+      http_delete "/calendars/#{@calendar_id}/events/#{id}"
+    end
+  end
+end

data/lib/gcal_unit.rb

@@ -0,0 +1,39 @@
+require 'httparty'
+require 'json'
+require 'open-uri'
+
+require 'gcal_unit/client'
+require 'gcal_unit/calendar_list'
+require 'gcal_unit/calendar'
+require 'gcal_unit/event'
+require 'gcal_unit/errors'
+require 'gcal_unit/authorization'
+require 'gcal_unit/configuration'
+
+# Public: Contains all the methods for wrapping the Google API.
+module Google
+  # Public: Holds the configuration for calling methods within
+  # the Google API.
+  #
+  # Returns a hash used for configuring the calls.
+  #   :api_key - Identifies the application requesting the call.
+  #              Sent with all the API calls.
+  #   :client_id - The OAuth client id that is used to generate
+  #                access tokens.
+  #   :client_secret - The OAuth client secret that is used to
+  #                    generate access tokens.
+  #   :refresh_token - A token that is used to retrieve an access
+  #                    token when the original token expires.
+  def self.configuration
+    @configuration ||= Google::Configuration.new
+  end
+
+  # Public: Allows configuration for the Google API.
+  #
+  # Yields the configuration for the Google API.
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  VERSION = "1.0.0"
+end

data/spec/lib/gcal_unit/authorization_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Google::Authorization do
+  let(:client) { Google::Authorization.new(Google.configuration.refresh_token) }
+
+  describe ".refresh" do
+    use_vcr_cassette "authorization_success"
+    it "should return a new access token" do
+      client.refresh()['access_token'].should_not be_nil
+    end
+  end
+end

data/spec/lib/gcal_unit/calendar_list_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Google::CalendarList do
+  let(:client) { Google::CalendarList.new(token) }
+
+  describe ".list" do
+    context "without a token" do
+      use_vcr_cassette "authentication_needed"
+      it "should raise an error if authentication is needed" do
+        expect { Google::CalendarList.new(nil).list }.to raise_error Google::AuthenticationRequiredError
+      end
+    end
+
+    context "with a token" do
+      use_vcr_cassette "calendar_list_success"
+      it "should return a list of calendars for the authorized user" do
+        client.list["items"].count.should > 0
+      end
+    end
+  end
+end

data/spec/lib/gcal_unit/calendar_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Google::Calendar do
+  let(:client) { Google::Calendar.new(token) }
+
+  describe ".get" do
+    context "without a token" do
+      use_vcr_cassette "authorization_success"
+      it "should raise an error if authentication is needed" do
+        expect { Google::Calendar.new(nil).get('any_string') }.to raise_error Google::AuthenticationRequiredError
+      end
+    end
+
+    context "with a token" do
+      use_vcr_cassette "calendar_success"
+      it "should return a primary google calendar" do
+        client.get("primary")["id"].should == ENV['GOOGLE_TEST_USER']
+      end
+    end
+  end
+end

data/spec/lib/gcal_unit/configuration_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Google do
+  after :all do
+    configure
+  end
+
+  describe ".configure" do
+    it "assigns a value to the api_key" do
+      Google.configure do |config|
+        config.api_key = '1234'
+      end
+      Google.configuration.api_key.should == '1234'
+    end
+
+    it "assigns a value to the client_id" do
+      Google.configure do |config|
+        config.client_id = '6789'
+      end
+      Google.configuration.client_id.should == '6789'
+    end
+
+    it "assigns a value to the client_secret" do
+      Google.configure do |config|
+        config.client_secret = '36748'
+      end
+      Google.configuration.client_secret.should == '36748'
+    end
+
+    it "assigns a value to the refresh_token" do
+      Google.configure do |config|
+        config.refresh_token = '1009'
+      end
+      Google.configuration.refresh_token = '1009'
+    end
+  end
+end

data/spec/lib/gcal_unit/event_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe Google::Event do
+  let(:client) { Google::Event.new(token) }
+  let(:event) do
+    {
+      end: { date: (Date.today + 1).strftime("%Y-%m-%d") },
+      start: { date: Date.today.strftime("%Y-%m-%d") }
+    }
+  end
+
+  describe ".update" do
+    it "should raise an error if the calendar id was not provided" do
+      expect { client.update(nil, nil) }.to raise_error Google::CalendarRequiredError
+    end
+
+    context "needs an existing event" do
+      before :all do
+        VCR.use_cassette "event_insert_success" do
+          @event = client.nested_for('primary').insert event
+        end
+      end
+
+      after :all do
+        VCR.use_cassette "event_delete_success" do
+          client.nested_for('primary').delete @event['id']
+        end
+      end
+
+      context "has a calendar" do
+        use_vcr_cassette "event_update_success"
+        
+        it "should change the event when the data is valid" do
+          @event['description'] = "This has changed"
+          response = client.nested_for('primary').update(@event['id'], @event)
+          response['description'].should == "This has changed"
+        end
+      end
+    end
+  end
+
+  describe ".list" do
+    it "should raise an error if the calendar id was not provided" do
+      expect { client.list }.to raise_error Google::CalendarRequiredError
+    end
+
+    context "without a token" do
+      use_vcr_cassette "authentication_needed"
+      it "should raise an error if authentication is needed" do
+        expect { Google::Event.new('').nested_for('primary').list }.to raise_error Google::AuthenticationRequiredError
+      end
+    end
+
+    context "with a token" do
+      use_vcr_cassette "event_list_success"
+      it "should return a list of events" do
+        client.nested_for('primary').list['kind'].should == 'calendar#events'
+      end
+    end
+  end
+
+  describe ".get" do
+    it "should raise an error if the calendar id was not provided" do
+      expect { client.get(nil) }.to raise_error Google::CalendarRequiredError
+    end
+
+    context "needs an existing event" do
+      before :all do
+        VCR.use_cassette "event_insert_success" do
+          @event = client.nested_for('primary').insert event
+        end
+      end
+
+      after :all do
+        VCR.use_cassette "event_delete_success" do
+          client.nested_for('primary').delete @event['id']
+        end
+      end
+
+      context "with a calendar" do
+        use_vcr_cassette "event_get_success"
+        it "should return a single event" do
+          client.nested_for('primary').get(@event['id'])['kind'].should == 'calendar#event'
+        end
+      end
+    end
+  end
+
+  describe ".delete" do
+    it "should raise an error if the calendar id was not provided" do
+      expect { client.delete(nil) }.to raise_error Google::CalendarRequiredError
+    end
+
+    context "needs an existing event" do
+      before :all do
+        VCR.use_cassette "event_insert_success" do
+          @event = client.nested_for('primary').insert event
+        end
+      end
+
+      context "has a calendar" do
+        use_vcr_cassette "event_delete_success"
+        it "should delete an event by id" do
+          client.nested_for('primary').delete(@event['id']).code.should == 204
+        end
+      end
+    end
+  end
+
+  describe ".insert" do
+    it "should raise an error if the calendar id was not provided" do
+      expect { client.insert(nil) }.to raise_error Google::CalendarRequiredError
+    end
+
+    context "with a calendar" do
+      use_vcr_cassette "event_insert_success"
+      it "should insert a new event when the data is valid" do
+        response = client.nested_for('primary').insert(event)
+        response['kind'].should == 'calendar#event'
+        client.nested_for('primary').delete response['id'] # clean up
+      end
+    end
+  end
+
+  describe ".quickAdd" do
+    use_vcr_cassette "event_quickadd_success"
+
+    it "should raise an error if the calendar id was not provided" do
+      expect { client.quick_add(nil) }.to raise_error Google::CalendarRequiredError
+    end
+
+    it "should insert a new event when the data is valid" do
+      response = client.nested_for('primary').quick_add("meet Jimmy today at 1pm")
+      response['kind'].should == 'calendar#event'
+      client.nested_for('primary').delete response['id'] # clean up
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require './lib/gcal_unit'
+require 'dotenv'
+require 'vcr'
+
+def token
+  @token
+end
+
+def configure
+  Google.configure do |config|
+    Dotenv.load
+    config.api_key = ENV['GOOGLE_API_KEY']
+    config.client_id = ENV['GOOGLE_CLIENT_ID']
+    config.client_secret = ENV['GOOGLE_CLIENT_SECRET']
+    config.refresh_token = ENV['GOOGLE_REFRESH_TOKEN']
+  end
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/cassettes'
+  c.hook_into :fakeweb
+  c.default_cassette_options = { :record => :new_episodes }
+end
+
+RSpec.configure do |config|
+  config.before(:all) do
+    configure
+    VCR.use_cassette "authorization_success" do
+      # Ensure a new access token before all the specs are run
+      client = Google::Authorization.new Google.configuration.refresh_token
+      @token = client.refresh()['access_token']
+    end
+  end
+  config.extend VCR::RSpec::Macros
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: gcal-unit
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Brilliant Fantastic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.8
+description: Wraps HTTP calls for the Google Calendar API.
+email: support@brilliantfantastic.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- README.md
+- Rakefile
+- gcal-unit.gemspec
+- lib/gcal_unit.rb
+- lib/gcal_unit/authorization.rb
+- lib/gcal_unit/calendar.rb
+- lib/gcal_unit/calendar_list.rb
+- lib/gcal_unit/client.rb
+- lib/gcal_unit/configuration.rb
+- lib/gcal_unit/errors.rb
+- lib/gcal_unit/event.rb
+- spec/lib/gcal_unit/authorization_spec.rb
+- spec/lib/gcal_unit/calendar_list_spec.rb
+- spec/lib/gcal_unit/calendar_spec.rb
+- spec/lib/gcal_unit/configuration_spec.rb
+- spec/lib/gcal_unit/event_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/brilliantfantastic/gcal-unit
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: gcal-unit
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 2
+summary: Pimp ass API wrapper for the Google Calendar API.
+test_files: []