delighted 1.0.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5713c3b8bbf569d4ea070698eb71615529769c64
+  data.tar.gz: 85fb1b406babe39d9560674a80562952f05e93b4
+SHA512:
+  metadata.gz: dcd088106f462f56a3bad2f6a339c3c0f1ad0d434ce65253d68e85c5194a70960f6a913cbf56ad83e378972ae34c14154330cd79c481c3cc791cda0739630399
+  data.tar.gz: dd86b0f081e36e4515a761a8e7b0cff16516ba498454b1c9b0891f2a5ed7bcff2617e163f02f21b35bd77eed4dc042609f81094fb4ffd5202507524b28afb9d6

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - ree

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Delighted Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,20 @@
+# Delighted API client for Ruby
+
+Official Ruby client for the [Delighted API](https://delightedapp.com).
+
+For installation and usage instructions, please [sign in to your Delighted account](https://delightedapp.com/signin) and follow the API documentation under Settings.
+
+## Supported Rubies
+
+- Ruby MRI (1.8.7+)
+- JRuby (1.8 + 1.9 modes)
+- RBX (1.8 + 1.9 modes)
+- REE (1.8.7-2012.02)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << 'test'
+  task.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/delighted.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'delighted/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "delighted"
+  spec.version       = Delighted::VERSION
+  spec.authors       = ["Mark Dodwell"]
+  spec.email         = ["mark@madeofcode.com"]
+  spec.description   = "Delighted API client for Ruby."
+  spec.summary       = "Delighted is the easiest and most beautiful way to measure customer happiness. Are your customers delighted?"
+  spec.homepage      = "https://github.com/delighted/delighted-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "multi_json"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "mocha"
+end

data/lib/delighted.rb

@@ -0,0 +1,25 @@
+require 'net/https'
+require 'uri'
+require 'cgi'
+require 'multi_json'
+require 'set'
+
+require 'delighted/utils'
+require 'delighted/json'
+
+require 'delighted/enumerable_resource_collection'
+require 'delighted/resource'
+require 'delighted/operations'
+require 'delighted/operations/all'
+require 'delighted/operations/create'
+require 'delighted/operations/retrieve'
+
+require 'delighted/resources/metrics'
+require 'delighted/resources/person'
+require 'delighted/resources/survey_responses'
+
+require 'delighted/errors'
+require 'delighted/resource_interface'
+require 'delighted/http_response'
+require 'delighted/http_adapter'
+require 'delighted/client'

data/lib/delighted/client.rb

@@ -0,0 +1,65 @@
+module Delighted
+  class Client
+    DEFAULT_API_BASE_URL = "https://api.delightedapp.com/v1"
+    DEFAULT_HTTP_ADAPTER = HTTPAdapter.new
+
+    def initialize(opts = {})
+      @api_key = opts[:api_key] or raise ArgumentError, "You must pass an :api_key."
+      @api_base_url = opts[:api_base_url] || DEFAULT_API_BASE_URL
+      @http_adapter = opts[:http_adapter] || DEFAULT_HTTP_ADAPTER
+    end
+
+    Resource.resources.each do |resource|
+      class_eval <<-END, __FILE__, __LINE__
+        def #{resource.interface_name}
+          @#{resource.interface_name} ||= ResourceInterface.new(self, #{resource.name})
+        end
+      END
+    end
+
+    def get_json(path, params = {})
+      headers = default_headers.dup.merge('Accept' => 'application/json')
+
+      uri = URI.parse(File.join(@api_base_url, path))
+      uri.query = Utils.to_query(params) unless params.empty?
+
+      response = @http_adapter.request(:get, uri, headers)
+      handle_json_response(response)
+    end
+
+    def post_json(path, params = {})
+      headers = default_headers.dup.merge('Accept' => 'application/json', 'Content-Type' => 'application/json')
+
+      uri = URI.parse(File.join(@api_base_url, path))
+      data = JSON.dump(params) unless params.empty?
+
+      response = @http_adapter.request(:post, uri, headers, data)
+      handle_json_response(response)
+    end
+
+    private
+
+    def handle_json_response(response)
+      case response.status_code
+      when 200, 201, 202
+        Utils.symbolize_keys(JSON.load(response.body))
+      when 401
+        raise AuthenticationError, response
+      when 406
+        raise UnsupportedFormatRequestedError, response
+      when 422
+        raise ResourceValidationError, response
+      when 503
+        raise ServiceUnavailableError, response
+      else
+        raise GeneralAPIError, response
+      end
+    end
+
+    def default_headers
+      @default_headers ||= {
+        'Authorization' => "Basic #{["#{@api_key}:"].pack('m0')}"
+      }.freeze
+    end
+  end
+end

data/lib/delighted/enumerable_resource_collection.rb

@@ -0,0 +1,4 @@
+module Delighted
+  class EnumerableResourceCollection < Array
+  end
+end

data/lib/delighted/errors.rb

@@ -0,0 +1,31 @@
+module Delighted
+  class Error < StandardError
+    def initialize(response)
+      @response = response
+    end
+
+    def to_s
+      "#{@response.status_code}: #{@response.body}"
+    end
+  end
+
+  class AuthenticationError < Error
+    # 401, api auth missing or incorrect
+  end
+
+  class UnsupportedFormatRequestedError < Error
+    # 406, invalid format in Accept header
+  end
+
+  class ResourceValidationError < Error
+    # 422, validation errors
+  end
+
+  class GeneralAPIError < Error
+    # 500, general/unknown error
+  end
+
+  class ServiceUnavailableError < Error
+    # 503, maintenance or overloaded
+  end
+end

data/lib/delighted/http_adapter.rb

@@ -0,0 +1,21 @@
+module Delighted
+  class HTTPAdapter
+    REQUEST_CLASSES = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+    }
+
+    def request(method, uri, headers = {}, data = nil)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      request = REQUEST_CLASSES[method].new(uri.request_uri)
+      headers.each { |k,v| request[k] = v }
+      request.body = data
+
+      response = http.request(request)
+      HTTPResponse.new(response.code, response.to_hash, response.body)
+    end
+  end
+end

data/lib/delighted/http_response.rb

@@ -0,0 +1,15 @@
+module Delighted
+  class HTTPResponse
+    attr_reader :status_code, :headers, :body
+
+    def initialize(raw_status_code, raw_headers, raw_body)
+      @status_code = raw_status_code.to_i
+      @headers = raw_headers
+      @body = raw_body
+    end
+
+    def content_type
+      @headers.values_at('content-type', 'Content-Type')[0]
+    end
+  end
+end

data/lib/delighted/json.rb

@@ -0,0 +1,23 @@
+module Delighted
+  class JSON
+    class << self
+      if MultiJson.respond_to?(:dump)
+        def dump(*args)
+          MultiJson.dump(*args)
+        end
+
+        def load(*args)
+          MultiJson.load(*args)
+        end
+      else
+        def dump(*args)
+          MultiJson.encode(*args)
+        end
+
+        def load(*args)
+          MultiJson.decode(*args)
+        end
+      end
+    end
+  end
+end

data/lib/delighted/operations.rb

@@ -0,0 +1,8 @@
+module Delighted
+  module Operations
+    def self.add_operations(klass, operation_module)
+      klass.extend(operation_module)
+      operation_module.instance_methods.each { |operation| klass.operations << operation }
+    end
+  end
+end

data/lib/delighted/operations/all.rb

@@ -0,0 +1,21 @@
+module Delighted
+  module Operations
+    module All
+      def self.included(klass)
+        klass.extend(AuxiliaryClassMethods)
+        Operations.add_operations(klass, OperationClassMethods)
+      end
+
+      module OperationClassMethods
+        def all(client, opts = {})
+          json = client.get_json(path, opts)
+          EnumerableResourceCollection.new(json.map { |attributes| new(attributes) })
+        end
+      end
+
+      module AuxiliaryClassMethods
+        # pagination, enumerable stuff etc.
+      end
+    end
+  end
+end

data/lib/delighted/operations/create.rb

@@ -0,0 +1,17 @@
+module Delighted
+  module Operations
+    module Create
+      def self.included(klass)
+        Operations.add_operations(klass, OperationClassMethods)
+      end
+
+      module OperationClassMethods
+        def create(client, attributes = {})
+          params = Utils.hash_removing_key(attributes, :id)
+          json = client.post_json(path, params)
+          new(json)
+        end
+      end
+    end
+  end
+end

data/lib/delighted/operations/retrieve.rb

@@ -0,0 +1,38 @@
+module Delighted
+  module Operations
+    module Retrieve
+      def self.included(klass)
+        if klass.singleton_resource?
+          Operations.add_operations(klass, Singleton::OperationClassMethods)
+        else
+          klass.extend(Pluralton::AuxiliaryClassMethods)
+          Operations.add_operations(klass, Pluralton::OperationClassMethods)
+        end
+      end
+
+      module Pluralton
+        module OperationClassMethods
+          def retrieve(client, id)
+            json = client.get_json(path(id))
+            new(json)
+          end
+        end
+
+        module AuxiliaryClassMethods
+          def path(id = nil)
+            id ? "#{@path}/#{id}" : @path
+          end
+        end
+      end
+
+      module Singleton
+        module OperationClassMethods
+          def retrieve(client, opts = {})
+            json = client.get_json(path, opts)
+            new(json)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delighted/resource.rb

@@ -0,0 +1,75 @@
+module Delighted
+  class Resource
+    class << self
+      def interface_name=(interface_name)
+        @interface_name = interface_name
+      end
+
+      def interface_name
+        @interface_name
+      end
+
+      def path=(path)
+        @path = path
+      end
+
+      def path
+        @path
+      end
+
+      def singleton_resource=(singleton_resource)
+        @singleton_resource = singleton_resource
+      end
+
+      def singleton_resource?
+        !!@singleton_resource
+      end
+
+      def operations
+        @operations ||= Set.new
+      end
+
+      def resources
+        @resources ||= Set.new
+      end
+
+      def inherited(klass)
+        resources << klass
+      end
+    end
+
+    undef :id if method_defined?(:id)
+    attr_reader :attributes
+    private :attributes
+
+    def initialize(attributes = {})
+      @id = attributes[:id]
+      define_id_reader if @id
+      @attributes = Utils.hash_removing_key(attributes, :id)
+      define_attribute_accessors(@attributes.keys)
+    end
+
+    def to_hash
+      attributes
+    end
+    alias_method :to_h, :to_hash
+
+    private
+
+    def define_id_reader
+      Utils.eigenclass(self).instance_eval do
+        attr_reader :id
+      end
+    end
+
+    def define_attribute_accessors(keys)
+      Utils.eigenclass(self).instance_eval do
+        keys.each do |key|
+          define_method(key) do
+            attributes[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delighted/resource_interface.rb

@@ -0,0 +1,19 @@
+module Delighted
+  class ResourceInterface
+    def initialize(client, resource)
+      @resource = resource # more helpful inspect
+
+      Utils.eigenclass(self).instance_eval do
+        resource.operations.each do |operation|
+          define_method(operation) do |*args, &block|
+            resource.send(operation, *args.unshift(client), &block)
+          end
+        end
+      end
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end

data/lib/delighted/resources/metrics.rb

@@ -0,0 +1,9 @@
+module Delighted
+  class Metrics < Resource
+    self.interface_name = "metrics"
+    self.path = "/metrics"
+    self.singleton_resource = true
+
+    include Operations::Retrieve
+  end
+end

data/lib/delighted/resources/person.rb

@@ -0,0 +1,8 @@
+module Delighted
+  class Person < Resource
+    self.interface_name = "people"
+    self.path = "/people"
+
+    include Operations::Create
+  end
+end

data/lib/delighted/resources/survey_responses.rb

@@ -0,0 +1,9 @@
+module Delighted
+  class SurveyResponse < Resource
+    self.interface_name = "survey_responses"
+    self.path = "/survey_responses"
+
+    include Operations::Create
+    include Operations::All
+  end
+end

data/lib/delighted/utils.rb

@@ -0,0 +1,45 @@
+module Delighted
+  module Utils
+    def self.eigenclass(object)
+      class << object; self; end
+    end
+
+    def self.hash_removing_key(hash, key)
+      hash.reject { |k,v| k == key }.inject({}) { |memo,(k,v)| memo[k] = v; memo }
+    end
+
+    def self.to_query(hash_or_array, namespace = nil)
+      hash_or_array.map { |object|
+        k, v = case hash_or_array
+        when Hash then object
+        when Array then [nil, object[0]]
+        else raise ArgumentError, "must pass Hash or Array"
+        end
+
+        namespaced_k = namespace ? "#{namespace}[#{k}]" : k
+
+        case v
+        when Hash, Array then to_query(v, namespaced_k)
+        else "#{CGI.escape(namespaced_k.to_s)}=#{CGI.escape(v.to_s)}"
+        end
+      }.join("&")
+    end
+
+    def self.symbolize_keys(object)
+      case object
+      when Hash
+        object.inject({}) { |memo,(k,v)|
+          memo[(k.to_sym rescue k)] = Hash === v ? symbolize_keys(v) : v
+          memo
+        }
+      when Array
+        object.map { |v| symbolize_keys(v) }
+      else
+        object
+      end
+    end
+  end
+end
+
+# Delighted::Utils.symbolize_keys([1, {'goo' => { 'bar' => 1, :gyp => ['x'] }, foo: Object.new }])
+# URI.unescape Delighted::Utils.to_query(foo: 1, gyp: { sum: 1, welp: ['a','b'] })

data/lib/delighted/version.rb

@@ -0,0 +1,3 @@
+module Delighted
+  VERSION = "1.0.0.alpha"
+end

data/test/delighted_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class Delighted::ClientTest < Delighted::TestCase
+  def test_instantiating_client_requires_api_key
+    assert_raises(ArgumentError) { Delighted::Client.new }
+    Delighted::Client.new(:api_key => '123abc')
+  end
+end
+
+class Delighted::MetricsTest < Delighted::TestCase
+  def test_retrieving_metrics
+    uri = URI.parse("https://api.delightedapp.com/v1/metrics")
+    headers = { 'Authorization' => "Basic #{["123abc:"].pack('m0')}", "Accept" => "application/json" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ :nps => 10 }))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    client = Delighted::Client.new(:api_key => '123abc', :http_adapter => mock_http_adapter)
+    metrics = client.metrics.retrieve
+    assert_kind_of Delighted::Metrics, metrics
+    assert_equal({ :nps => 10 }, metrics.to_hash)
+    assert_equal 10, metrics.nps
+    assert_raises(NoMethodError) { metrics.id }
+  end
+end
+
+class Delighted::PeopleTest < Delighted::TestCase
+  def test_creating_or_updating_a_person
+    uri = URI.parse("https://api.delightedapp.com/v1/people")
+    headers = { 'Authorization' => "Basic #{["123abc:"].pack('m0')}", "Accept" => "application/json", 'Content-Type' => 'application/json' }
+    data = Delighted::JSON.dump({ :email => 'foo@bar.com' })
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ :id => '123', :email => 'foo@bar.com' }))
+    mock_http_adapter.expects(:request).with(:post, uri, headers, data).once.returns(response)
+
+    client = Delighted::Client.new(:api_key => '123abc', :http_adapter => mock_http_adapter)
+    person = client.people.create(:email => 'foo@bar.com')
+    assert_kind_of Delighted::Person, person
+    assert_equal({ :email => 'foo@bar.com' }, person.to_hash)
+    assert_equal 'foo@bar.com', person.email
+    assert_equal '123', person.id
+  end
+end
+
+class Delighted::SurveyResponseTest < Delighted::TestCase
+  def test_creating_a_survey_response
+    uri = URI.parse("https://api.delightedapp.com/v1/survey_responses")
+    headers = { 'Authorization' => "Basic #{["123abc:"].pack('m0')}", "Accept" => "application/json", 'Content-Type' => 'application/json' }
+    data = Delighted::JSON.dump({ :person => '123', :score => 10 })
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump({ :id => '456', :person => '123', :score => 10 }))
+    mock_http_adapter.expects(:request).with(:post, uri, headers, data).once.returns(response)
+
+    client = Delighted::Client.new(:api_key => '123abc', :http_adapter => mock_http_adapter)
+    survey_response = client.survey_responses.create(:person => '123', :score => 10)
+    assert_kind_of Delighted::SurveyResponse, survey_response
+    assert_equal({ :person => '123', :score => 10 }, survey_response.to_hash)
+    assert_equal '123', survey_response.person
+    assert_equal 10, survey_response.score
+    assert_equal '456', survey_response.id
+  end
+
+  def test_listing_all_survey_responses
+    uri = URI.parse("https://api.delightedapp.com/v1/survey_responses")
+    headers = { 'Authorization' => "Basic #{["123abc:"].pack('m0')}", "Accept" => "application/json" }
+    response = Delighted::HTTPResponse.new(200, {}, Delighted::JSON.dump([{ :id => '123', :comment => 'One' }, { :id => '456', :comment => 'Two' }]))
+    mock_http_adapter.expects(:request).with(:get, uri, headers).once.returns(response)
+
+    client = Delighted::Client.new(:api_key => '123abc', :http_adapter => mock_http_adapter)
+    survey_responses = client.survey_responses.all
+    assert_kind_of Delighted::EnumerableResourceCollection, survey_responses
+    assert_kind_of Delighted::SurveyResponse, survey_responses[0]
+    assert_equal({ :comment => 'One' }, survey_responses[0].to_hash)
+    assert_equal 'One', survey_responses[0].comment
+    assert_equal '123', survey_responses[0].id
+    assert_kind_of Delighted::SurveyResponse, survey_responses[1]
+    assert_equal({ :comment => 'Two' }, survey_responses[1].to_hash)
+    assert_equal 'Two', survey_responses[1].comment
+    assert_equal '456', survey_responses[1].id
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'delighted'
+require 'minitest/autorun'
+require 'mocha/setup'
+
+class Delighted::TestCase < Minitest::Test
+  include Mocha
+
+  def mock_http_adapter
+    @mock ||= mock
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: delighted
+version: !ruby/object:Gem::Version
+  version: 1.0.0.alpha
+platform: ruby
+authors:
+- Mark Dodwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  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'
+- !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: minitest
+  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: mocha
+  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: Delighted API client for Ruby.
+email:
+- mark@madeofcode.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- delighted.gemspec
+- lib/delighted.rb
+- lib/delighted/client.rb
+- lib/delighted/enumerable_resource_collection.rb
+- lib/delighted/errors.rb
+- lib/delighted/http_adapter.rb
+- lib/delighted/http_response.rb
+- lib/delighted/json.rb
+- lib/delighted/operations.rb
+- lib/delighted/operations/all.rb
+- lib/delighted/operations/create.rb
+- lib/delighted/operations/retrieve.rb
+- lib/delighted/resource.rb
+- lib/delighted/resource_interface.rb
+- lib/delighted/resources/metrics.rb
+- lib/delighted/resources/person.rb
+- lib/delighted/resources/survey_responses.rb
+- lib/delighted/utils.rb
+- lib/delighted/version.rb
+- test/delighted_test.rb
+- test/test_helper.rb
+homepage: https://github.com/delighted/delighted-ruby
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Delighted is the easiest and most beautiful way to measure customer happiness.
+  Are your customers delighted?
+test_files:
+- test/delighted_test.rb
+- test/test_helper.rb