lapse 0.0.1

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode

data/Contributing.markdown

@@ -0,0 +1,19 @@
+## Submitting a Pull Request
+
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add tests for your unimplemented feature or bug fix.
+4. Run `bundle exec rake`. If your tests pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake`. If your tests fail, return to step 5.
+7. Run `open coverage/index.html`. If your changes are not completely covered
+   by your tests, return to step 3.
+8. Add documentation for your feature or bug fix.
+9. Run `bundle exec rake doc`. If your changes are not 100% documented, go
+   back to step 8.
+10. Add, commit, and push your changes.
+11. [Submit a pull request.][pr]
+
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+# Gem dependencies
+puts gemspec
+
+gem 'rake', :group => [:development, :test]
+
+# Development dependencies
+group :development do
+  gem 'yard'
+  gem 'redcarpet', :platform => 'ruby'
+end
+
+# Testing dependencies
+group :test do
+  gem 'minitest'
+  gem 'minitest-wscolor' if RUBY_VERSION >= '1.9.3'
+  gem 'webmock', :require => 'webmock/minitest'
+  gem 'mocha', :require => 'mocha/setup'
+  gem 'simplecov', :require => false
+  gem 'hashie' #unknown why this is required for certain dev envs to work (ahem, adam)
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Seesaw Decisions Corporation
+
+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/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new(:doc) do |task|
+    task.files   = ['Readme.markdown', 'LICENSE', 'lib/**/*.rb']
+    task.options = [
+      '--output-dir', 'doc',
+      '--markup', 'markdown',
+    ]
+  end
+rescue LoadError
+end

data/Readme.markdown

@@ -0,0 +1,64 @@
+# Lapse
+
+Lapse, as in teeter-Lapse, let's you work with the Seesaw API in Ruby.
+
+All networking is done with Net::HTTP so you don't have to worry about version conflicts with whatever networking library you may be using.
+
+Read the [documentation](http://rubydoc.info/github/seesawco/Lapse-rb/master/frames) online.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+``` ruby
+gem 'Lapse'
+```
+
+And then execute:
+
+``` shell
+$ bundle
+```
+
+Or install it yourself as:
+
+``` shell
+$ gem install Lapse
+```
+
+## Configuration
+
+Should you wish to configure the client in an initializer, you can do the following:
+
+``` ruby
+Lapse::Client.configure do |client|
+  client.api_host = "some.api-host.com"
+  client.api_scheme = "http"
+end
+```
+
+## Usage
+
+A client takes an optional access token when you initialize it. If you don't provide one, you can still use it to make unauthenticated requests. If you do provide one, it will set the authorization header for all requests.
+
+``` ruby
+> client = Lapse::Client.new(access_token: 'your_access_token')
+> current_user = client.me
+> current_user.username
+#=> "soffes"
+> decision = client.decision(5, 3276)
+#=> "Which lamp for the new apartment?"
+> slug = client.slug('d/3I0n0g')
+> slug.decision.user.username
+#=> "soffes"
+```
+
+## Supported Ruby Versions
+
+Lapse is tested under 1.8.7, 1.9.2, 1.9.3, 2.0.0, JRuby 1.7.2 (1.9 mode), and Rubinius 2.0.0 (1.9 mode).
+
+[![Build Status](https://travis-ci.org/seesawco/Lapse-rb.png?branch=master)](https://travis-ci.org/seesawco/Lapse-rb)
+
+## Contributing
+
+See the [contributing guide](Contributing.markdown).

data/lapse.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lapse/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'lapse'
+  gem.version       = Lapse::VERSION
+  gem.authors       = ['Sam Soffes', 'Aaron Gotwalt', 'Adam Ryan']
+  gem.email         = ['sam@soff.es', 'gotwalt@gmail.com', 'adam.g.ryan@gmail.com']
+  gem.description   = 'Ruby gem for working with the Everlapse API.'
+  gem.summary       = gem.description
+  gem.homepage      = 'https://github.com/seesawco/lapse-rb'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = '>= 1.8.7'
+  gem.add_dependency 'multi_json', '~> 1.6'
+  gem.add_dependency 'hashie', '~> 1.2.0'
+end

data/lib/lapse/client/configuration.rb

@@ -0,0 +1,24 @@
+module Lapse
+  class Client
+    # Client methods for working with configuration.
+    module Configuration
+      # Get the configuration from the API.
+      #
+      # @return [Hashie::Mash] A hash of configuration data.
+      # @example
+      #   Totter.configuration
+      def configuration
+        get('configuration').body
+      end
+
+      # Get the featured timelines and users for Explore.
+      #
+      # @return [Hashie::Mash] A hash of timelines and users data.
+      # @example
+      #   Totter.explore
+      def explore
+        get('explore').body
+      end
+    end
+  end
+end

data/lib/lapse/client.rb

@@ -0,0 +1,96 @@
+require 'Lapse/transport'
+require 'uri'
+
+module Lapse
+  # API client for interacting with the Seesaw API
+  class Client
+    Dir[File.expand_path('../client/*.rb', __FILE__)].each { |f| require f }
+
+    include Configuration
+
+    attr_reader :access_token
+    attr_reader :api_scheme
+    attr_reader :api_host
+    attr_reader :api_version
+    attr_reader :transport
+    attr_reader :result_format
+
+    # Default parameters for the client
+    DEFAULTS = {
+      :api_scheme => 'https',
+      :api_host => 'everlapse.com',
+      :api_version => '1',
+      :result_format => :mashie,
+      :transport => :http
+    }
+
+    # The current configuration parameters for all clients
+    def self.options
+      @options ||= Hashie::Mash.new(DEFAULTS.dup)
+    end
+
+    # Sets the current configuration parameters for all clients
+    def self.options=(val)
+      @options = val
+    end
+
+    # Allows the setting of configuration parameters in a configure block.
+    def self.configure
+      yield options
+    end
+
+    # Initialize a new client.
+    #
+    # @param options [Hash] optionally specify `:access_token`, `:api_scheme`, `:api_host`, ':api_url', `:api_version`, `:client_token`, or `:transport`.
+    def initialize(options = {})
+      options = { :access_token => options } if options.is_a? String
+      options = self.class.options.merge(options)
+
+      # Parse `api_url` option
+      if url = options.delete(:api_url)
+        uri = URI.parse(url)
+        options[:api_scheme] = uri.scheme
+        options[:api_host] = uri.host + (uri.port != 80 && uri.port != 443 ? ":#{uri.port}" : '')
+      end
+
+      @access_token = options[:access_token] if options[:access_token]
+      @api_scheme = options[:api_scheme]
+      @api_host = options[:api_host]
+      @api_version = options[:api_version]
+      @client_token = options[:client_token] if options[:client_token]
+      @transport = options[:transport]
+      @result_format = options[:result_format]
+
+      # Include transport
+      transport_module = Lapse::Transport::TRANSPORT_MAP[@transport]
+      raise 'Invalid transport' unless transport_module
+      self.extend transport_module
+    end
+
+    # API base URL.
+    #
+    # @return [String] API base URL
+    def base_url
+      "#{@api_scheme}://#{@api_host}/v#{@api_version}/"
+    end
+
+    # Is the client has an access token.
+    #
+    # @return [Boolean] true if it is using one and false if it is not
+    def authenticated?
+      @access_token != nil and @access_token.length > 0
+    end
+
+    # Is the client using SSL.
+    #
+    # @return [Boolean] true if it is using SSL and false if it is not
+    def ssl?
+      @api_scheme == 'https'
+    end
+
+    # Returns the current status of HTTP stubbing
+    def self.stubbed?
+      @@stubbed
+    end
+  end
+end

data/lib/lapse/error.rb

@@ -0,0 +1,51 @@
+module Lapse
+  # Standard Lapse error
+  class Error < StandardError; end
+
+  # Raised when Lapse returns a 400 HTTP status code
+  class BadRequest < Error; end
+
+  # Raised when Lapse returns a 401 HTTP status code
+  class Unauthorized < Error; end
+
+  # Raised when Lapse returns a 403 HTTP status code
+  class Forbidden < Error; end
+
+  # Raised when Lapse returns a 404 HTTP status code
+  class NotFound < Error; end
+
+  # Raised when Lapse returns a 406 HTTP status code
+  class NotAcceptable < Error; end
+
+  # Raised when Lapse returns a 422 HTTP status code
+  class UnprocessableEntity < Error; end
+
+  # Raised when Lapse returns a 500 HTTP status code
+  class InternalServerError < Error; end
+
+  # Raised when Lapse returns a 501 HTTP status code
+  class NotImplemented < Error; end
+
+  # Raised when Lapse returns a 502 HTTP status code
+  class BadGateway < Error; end
+
+  # Raised when Lapse returns a 503 HTTP status code
+  class ServiceUnavailable < Error; end
+
+  # Raised when a unique ID is required but not provided
+  class UniqueIDRequired < Error; end
+
+  # Status code to exception map
+  ERROR_MAP = {
+    400 => Lapse::BadRequest,
+    401 => Lapse::Unauthorized,
+    403 => Lapse::Forbidden,
+    404 => Lapse::NotFound,
+    406 => Lapse::NotAcceptable,
+    422 => Lapse::UnprocessableEntity,
+    500 => Lapse::InternalServerError,
+    501 => Lapse::NotImplemented,
+    502 => Lapse::BadGateway,
+    503 => Lapse::ServiceUnavailable
+  }
+end

data/lib/lapse/response.rb

@@ -0,0 +1,3 @@
+module Lapse
+
+end

data/lib/lapse/transport/http.rb

@@ -0,0 +1,171 @@
+
+module Lapse
+  module Transport
+    # Default HTTP API transport adapter
+    module HTTP
+      require 'net/http'
+      require 'net/https'
+      require 'uri'
+      require 'multi_json'
+      require 'hashie'
+
+    private
+
+      def http
+        return @http if @http
+
+        uri = URI.parse(self.base_url)
+        @http = Net::HTTP.new(uri.host, uri.port)
+        @http.use_ssl = self.ssl?
+        @http
+      end
+
+      def request(method, path, params = nil)
+        uri = URI.parse("#{self.base_url}#{path}")
+
+        # if the request requires parameters in the query string, merge them in
+        if params and !can_post_data?(method)
+          query_values = uri.query ? URI.decode_www_form(uri.query).inject({}) {|h,(k,v)| h[k]=v; h} : {}
+          uri.query = to_url_params((query_values || {}).merge(params))
+        end
+
+        # Build request
+        request = build_request(method, uri)
+
+        # Add headers
+        request['Authorization'] = "Bearer #{self.access_token}" if authenticated?
+        request['X-Seesaw-Client-Token'] = @client_token if @client_token
+        request['Content-Type'] = 'application/json'
+
+        # Add params as JSON if they exist
+        request.body = MultiJson.dump(params) if can_post_data?(method) and params
+
+        # Request
+        response = http.request(request)
+
+        # Check for errors
+        handle_error(response)
+
+        # Return the raw response object
+        response
+      end
+
+      def build_request(method, uri)
+        case method
+          when :get
+            Net::HTTP::Get.new(uri.request_uri)
+          when :post
+            Net::HTTP::Post.new(uri.request_uri)
+          when :put
+            Net::HTTP::Put.new(uri.request_uri)
+          when :delete
+            Net::HTTP::Delete.new(uri.request_uri)
+        end
+      end
+
+      def to_url_params(hash)
+        params = []
+        hash.each_pair do |key, value|
+          params << param_for(key, value).flatten
+        end
+        params.sort.join('&')
+      end
+
+      def param_for(key, value, parent = nil)
+        if value.is_a?(Hash)
+          params = []
+          value.each_pair do |value_key, value_value|
+            value_parent = parent ? parent + "[#{key}]" : key.to_s
+            params << param_for(value_key, value_value, value_parent)
+          end
+          params
+        else
+          ["#{parent ? parent + "[#{key}]" : key.to_s}=#{CGI::escape(value.to_s)}"]
+        end
+      end
+
+      def handle_error(response)
+        # Find error or return
+        return unless error = Lapse::ERROR_MAP[response.code.to_i]
+
+        # Try to add a useful message
+        message = nil
+        begin
+          message = MultiJson.load(response.body)['error_description']
+        rescue MultiJson::DecodeError => e
+        end
+
+        # Raise error
+        raise error.new(message)
+      end
+
+      def json_request(*args)
+        # Perform request, pass result format
+        Response.new(request(*args), result_format)
+      end
+
+      def boolean_from_response(*args)
+        response = request(*args)
+        (200..299).include? response.code.to_i
+      end
+
+      def can_post_data?(method)
+        [:post, :put].include?(method)
+      end
+
+      [:get, :post, :put, :delete].each do |method|
+        define_method method do |*args|
+          json_request(method, *args)
+        end
+      end
+
+      # Response class responsible for deserializing API calls
+      # @attr [Object] body The parsed response
+      # @attr [Hash] headers HTTP headers returned as part of the response
+      class Response
+        attr_accessor :body, :headers
+
+        # Initializes a new result
+        #
+        # @param http_response [Net::HTTPResponse] the raw response to parse
+        def initialize(http_response, result_format = :mashie)
+          @result_format = result_format
+          @headers = parse_headers(http_response.to_hash)
+          @body = parse_body(http_response.body)
+        end
+
+        private
+
+        # Parses raw headers in to a reasonable hash
+        def parse_headers(raw_headers)
+          # raw headers from net_http have an array for each result. Flatten them out.
+          raw_headers.inject({}) do |remainder, (k, v)|
+            remainder[k] = [v].flatten.first
+            remainder
+          end
+        end
+
+        # Parses the raw body in to a Hashie::Mash object, an array of Hashie::Mashes, or, if all else fails, returns a hash.
+        def parse_body(body)
+          # Parse JSON
+          object = MultiJson.load(body)
+
+          case @result_format
+          when :mashie
+            # Hash
+            return Hashie::Mash.new(object) if object.is_a? Hash
+            # Array
+            begin
+              return object.map { |h| Hashie::Mash.new(h) } if object.is_a? Array
+            rescue
+              # sometimes, for things like string arrays, we'll end up with an error. Fall through.
+            end
+          end
+
+          object
+        end
+      end
+
+    end
+  end
+end

data/lib/lapse/transport.rb

@@ -0,0 +1,11 @@
+module Lapse
+  # Transports are a way for the client to communicate with the API.
+  module Transport
+    Dir[File.expand_path('../transport/*.rb', __FILE__)].each { |f| require f }
+
+    # Transport adapter map
+    TRANSPORT_MAP = {
+      :http => Lapse::Transport::HTTP
+    }
+  end
+end

data/lib/lapse/version.rb

@@ -0,0 +1,4 @@
+module Lapse
+  # Verion of the Lapse gem
+  VERSION = '0.0.1'
+end

data/lib/lapse.rb

@@ -0,0 +1,26 @@
+require 'Lapse/version'
+require 'Lapse/client'
+require 'Lapse/error'
+
+# Lapse, as in teeter-Lapse, let's you work with the Seesaw API in Ruby.
+module Lapse
+  class << self
+    # Alias for Lapse::Client.new
+    #
+    # @return [Lapse::Client]
+    def new(options = {})
+      Client.new(options)
+    end
+
+    # Delegate to Lapse::Client.new
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    # Forward respond_to? to Lapse::Client.new
+    def respond_to?(method, include_private = false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+  end
+end

data/test/lapse/client_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class ClientTest < Lapse::TestCase
+  def test_initialization
+    client = Lapse::Client.new(:access_token => 'asdf1234')
+    assert_equal 'asdf1234', client.access_token
+    assert client.authenticated?
+
+    client = Lapse::Client.new('asdf1234')
+    assert_equal 'asdf1234', client.access_token
+
+    client = Lapse::Client.new
+    refute client.authenticated?
+  end
+
+  def test_base_url
+    client = Lapse::Client.new
+    assert_equal 'https://everlapse.com/v1/', client.base_url
+
+    client = Lapse::Client.new(:api_scheme => 'http', :api_host => 'example.com', :api_version => 42)
+    assert_equal 'http://example.com/v42/', client.base_url
+
+    client = Lapse::Client.new(:api_url => 'http://example.com')
+    assert_equal 'http://example.com/v1/', client.base_url
+
+    client = Lapse::Client.new(:api_url => 'http://localhost:3000')
+    assert_equal 'http://localhost:3000/v1/', client.base_url
+  end
+
+  def test_ssl?
+    client = Lapse::Client.new
+    assert client.ssl?
+
+    client = Lapse::Client.new(:api_scheme => 'http')
+    refute client.ssl?
+  end
+
+  def test_configuration
+    Lapse::Client.configure do |client|
+      client.api_host = 'blah'
+      client.api_scheme = 'gopher'
+      client.result_format = :hash
+    end
+
+    assert_equal 'blah', Lapse::Client.new.api_host
+    assert_equal 'gopher', Lapse::Client.new.api_scheme
+    Lapse::Client.new.result_format
+
+    # forcibly reset the configuration
+    Lapse::Client.options = nil
+  end
+
+end

data/test/lapse/transport/http_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class HttpTest < Lapse::TestCase
+  def test_default_mashie_format
+    stub_request(:get, 'https://everlapse.com/v1/configuration').to_return(status: 200, body: "{}")
+    assert_equal Hashie::Mash, Lapse.configuration.class
+  end
+end

data/test/lapse_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class LapseTest < Lapse::TestCase
+  def test_respond_to
+    assert Lapse.respond_to?(:new, true)
+  end
+
+  def test_new
+    assert_equal Lapse.new.class, Lapse::Client
+  end
+end

data/test/support/client_macros.rb

@@ -0,0 +1,9 @@
+module ClientMacros
+  def local_client
+    client = Lapse::Client.new(:access_token => '9774e653f7b3c1de5f21b61adc08ba24', :api_host => 'localhost:5000', :api_scheme => 'http')
+  end
+
+  def unauthenticated_monkeybars_production_client
+    Lapse::Client.new(:client_token => '29756b7591819c57e01ac2c6d9ae5311')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require :test
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
+end
+
+require 'minitest/autorun'
+require 'Lapse'
+
+# Support files
+Dir["#{File.expand_path(File.dirname(__FILE__))}/support/*.rb"].each do |file|
+  require file
+end
+
+class Lapse::TestCase < MiniTest::Unit::TestCase
+  include ::ClientMacros
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: lapse
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sam Soffes
+- Aaron Gotwalt
+- Adam Ryan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Ruby gem for working with the Everlapse API.
+email:
+- sam@soff.es
+- gotwalt@gmail.com
+- adam.g.ryan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Contributing.markdown
+- Gemfile
+- LICENSE
+- Rakefile
+- Readme.markdown
+- lapse.gemspec
+- lib/lapse.rb
+- lib/lapse/client.rb
+- lib/lapse/client/configuration.rb
+- lib/lapse/error.rb
+- lib/lapse/response.rb
+- lib/lapse/transport.rb
+- lib/lapse/transport/http.rb
+- lib/lapse/version.rb
+- test/lapse/client_test.rb
+- test/lapse/transport/http_test.rb
+- test/lapse_test.rb
+- test/support/client_macros.rb
+- test/test_helper.rb
+homepage: https://github.com/seesawco/lapse-rb
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3688395446889741402
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby gem for working with the Everlapse API.
+test_files:
+- test/lapse/client_test.rb
+- test/lapse/transport/http_test.rb
+- test/lapse_test.rb
+- test/support/client_macros.rb
+- test/test_helper.rb
+has_rdoc: