cartowrap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aec8b6861e9df5308c3a92d3837eb2a2f1327726
+  data.tar.gz: c1393f7b197d66c13f0ea7d6082368032f1f1491
+SHA512:
+  metadata.gz: cae94667afb8b4893d9bfc2f0cad8e8acb56c40121c3e7eaaa1b429f816d9acbecf3a8493ec4acad6011f58f11a4b14721215adbd2ed6d304831af4be3b61912
+  data.tar.gz: a414751fa85250d00a249f93ee724447a2e34e4df521489dd552762443088daf79ddcf81122a77098b86460653de1e7cc46a0499e8e3fd189af0581802afa925

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Miguel Mendoza
+
+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,28 @@
+# Cartowrap
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cartowrap'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install cartowrap
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Cartowrap'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/cartowrap/api.rb

@@ -0,0 +1,116 @@
+module Cartowrap
+  class API
+    def initialize(api_key = nil, account = nil)
+      @api_key = api_key || Cartowrap.config.api_key
+      @account = account || Cartowrap.config.account
+      @credentials = {}
+      @credentials['api_key'] = @api_key
+      @credentials['account'] = @account
+      @options = OpenStruct.new
+    end
+
+    attr_reader :api_key, :account, :credentials, :options, :response
+
+    def send_query(query)
+      options.endpoint = "sql"
+      options.query_string = true
+      options.q = query
+      result = make_call(options)
+      result
+    end
+
+    def get_synchronizations
+      options.endpoint = "import"
+      options.query_string = false
+      result = make_call(options)
+      result
+    end
+
+    def get_synchronization(import_id)
+      options.endpoint = "import"
+      options.import_id = import_id
+      options.query_string = false
+      options.http_method = 'get'
+      result = make_call(options)
+      result
+    end
+
+    def check_synchronization(import_id)
+      options.endpoint = "import"
+      options.query_string = false
+      options.http_method = 'get'
+      options.resource_id = "#{import_id}/sync_now"
+      result = make_call(options)
+      result
+    end
+
+    def force_synchronization(import_id)
+      options.endpoint = "import"
+      options.query_string = false
+      options.http_method = 'put'
+      options.resource_id = "#{import_id}/sync_now"
+      result = make_call(options)
+      result
+    end
+
+    def create_synchronization(url, interval, sync_options={})
+      validate_sync_options(sync_options) if sync_options
+      options.endpoint = "import"
+      options.type_guessing = sync_options[:type_guessing]
+      options.quoted_fields_guessing = sync_options[:quoted_fields_guessing]
+      options.content_guessing = sync_options[:content_guessing]
+      options.query_string = false
+      options.url = url
+      options.interval = interval
+      options.http_method = 'post'
+      result = make_call(options)
+      result
+    end
+
+    def delete_synchronization(import_id)
+      options.endpoint = "import"
+      options.resource_id = import_id
+      options.query_string = false
+      options.http_method = 'delete'
+      result = make_call(options)
+      result
+    end
+
+    def initialize_options
+      @options = OpenStruct.new
+    end
+
+    private
+
+    def validate_sync_options(sync_options)
+      valid_options = [:type_guessing, :quoted_fields_guessing, :content_guessing]
+      sync_options = sync_options.map{|o| ((valid_options.include? o[0]) && !!o[1] == o[1]) ? o : nil}.compact.to_h
+      sync_options
+    end
+
+    def make_call(options)
+      result = Cartowrap.make_request(options, credentials)
+      unless check_errors(result.status.to_i, result.body)
+        MultiJson.load("[#{result.body.to_s}]")[0]
+      end
+      initialize_options
+      @response = result.body
+    end
+
+    def check_errors(status, body)
+      case status
+      when 500
+        initialize_options
+        raise Cartowrap::ServerError.new(status, '')
+      when 401
+        initialize_options
+        raise Cartowrap::NoTokenError.new(status, body)
+      when 404
+        initialize_options
+        raise Cartowrap::NotFoundError.new(status, '')
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/cartowrap/config/spring.rb

@@ -0,0 +1 @@
+Spring.applicaiton_root = 'spec/test_app'

data/lib/cartowrap/errors.rb

@@ -0,0 +1,78 @@
+module Cartowrap
+
+  class CartowrapError < StandardError; end
+
+    class AppSecretNotDefinedError < ::Cartowrap::CartowrapError; end
+
+
+    class APIError < ::Cartowrap::CartowrapError
+      attr_accessor :cdb_error_type, :cdb_error_code, :cdb_error_subcode, :cdb_error_message,
+                    :cdb_error_user_msg, :cdb_error_user_title, :http_status, :response_body
+
+
+      def initialize(http_status, response_body, error_info = nil)
+        if response_body
+          self.response_body = response_body.strip
+        else
+          self.response_body = ''
+        end
+        self.http_status = http_status
+
+        if error_info && error_info.is_a?(String)
+          message = error_info
+        else
+          unless error_info
+            begin
+              error_info = MultiJson.load(response_body)['error'] if response_body
+            rescue
+            end
+            error_info ||= {}
+          end
+
+          self.cdb_error_type = error_info["type"]
+          self.cdb_error_code = error_info["code"]
+          self.cdb_error_subcode = error_info["error_subcode"]
+          self.cdb_error_message = error_info["message"]
+          self.cdb_error_user_msg = error_info["error_user_msg"]
+          self.cdb_error_user_title = error_info["error_user_title"]
+
+          error_array = []
+          %w(type code error_subcode message error_user_title error_user_msg).each do |key|
+            error_array << "#{key}: #{error_info[key]}" if error_info[key]
+          end
+
+          if error_array.empty?
+            message = self.response_body
+          else
+            message = error_array.join(', ')
+          end
+        end
+        message += " [HTTP #{http_status}]" if http_status
+
+        super(message)
+      end
+    end
+
+    # Cartodb returned an invalid response body
+    class BadCartodbResponse < APIError; end
+
+    # Cartodb responded with an error while attempting to request an access token
+    class OAuthTokenRequestError < APIError; end
+
+    # Any error with a 5xx HTTP status code
+    class ServerError < APIError; end
+
+    # Any error with a 4xx HTTP status code
+    class ClientError < APIError; end
+
+    # All API authentication failures.
+    class AuthenticationError < ClientError; end
+
+    # not found
+    class NotFoundError < APIError; end
+
+    # not found
+    class NoTokenError < APIError; end
+
+
+end

data/lib/cartowrap/http_service/endpoint.rb

@@ -0,0 +1,52 @@
+module Cartowrap
+  module HTTPService
+    class Endpoint
+
+      attr_reader :options, :credentials
+
+      def initialize(options, credentials = {})
+        @options = options
+        @credentials  = credentials
+      end
+
+      def get
+        p options.to_json
+        endpoint = "#{endpoint_uri}#{endpoint_querystring}"
+      end
+
+      private
+
+      def endpoint_uri
+        query = options.q if options.q
+        resource = options.resource_id if options.resource_id
+        string = ""
+        api = options.endpoint
+        case api
+        when "sql"
+          string += "/api/v2/sql/?q=#{query}"
+        when "import"
+          string += "/api/v1/synchronizations/"
+          string += "?#{options.query}" if options.query_string && options.query
+        else
+        end
+        string += resource if resource
+        string
+      end
+
+      def endpoint_querystring
+        p options.query_string
+        api_key = credentials["api_key"]
+        string = ''
+        if options.query_string == false
+          string += "?api_key=#{api_key}"
+        else
+          string += "&api_key=#{api_key}"
+        end
+        string
+      end
+
+    end
+  end
+  Endpoint = HTTPService::Endpoint
+end
+

data/lib/cartowrap/http_service/response.rb

@@ -0,0 +1,15 @@
+module Cartowrap
+  module HTTPService
+    class Response
+      attr_reader :status, :body, :headers
+
+      # Creates a new Response object, which standardizes the response received by Facebook for use within Koala.
+      def initialize(status, body, headers)
+        @status = status
+        @body = body
+        @headers = headers
+      end
+    end
+  end
+  Response = HTTPService::Response
+end

data/lib/cartowrap/http_service.rb

@@ -0,0 +1,25 @@
+require 'faraday'
+require 'cartowrap/http_service/response'
+require 'cartowrap/http_service/endpoint'
+module Cartowrap
+  module HTTPService
+    class << self
+    end
+    def self.make_request(options, credentials={})
+      http_method = options.http_method&.to_sym || :get
+      account = credentials["account"]
+      endpoint = Endpoint.new(options, credentials).get
+      con = Faraday.new(:url => "https://#{account}.cartodb.com") do |faraday|
+        faraday.request  :multipart
+        faraday.response :logger
+        faraday.adapter  Faraday.default_adapter
+      end
+      response = con.send(http_method) do |req|
+        req.url "#{endpoint}"
+        req.headers['Content-Type'] = 'application/json' if options.http_method == 'post' || options.http_method == 'put'
+        req.body = options.marshal_dump.to_json if options.http_method == 'post' || options.http_method == 'put'
+      end
+      Cartowrap::HTTPService::Response.new(response.status.to_i, response.body, response.headers)
+    end
+  end
+end

data/lib/cartowrap/version.rb

@@ -0,0 +1,3 @@
+module Cartowrap
+  VERSION = '0.1.0'
+end

data/lib/cartowrap.rb

@@ -0,0 +1,23 @@
+require 'multi_json'
+require 'cartowrap/api'
+require 'cartowrap/http_service'
+require 'cartowrap/errors'
+require 'ostruct'
+module Cartowrap
+  class << self
+    attr_accessor :http_service, :config
+    def configure
+      yield config
+    end
+    def config
+      @config ||= OpenStruct.new
+    end
+  end
+  def self.http_service=(service)
+    @http_service = service
+  end
+  def self.make_request(options, credentials = {})
+    http_service.make_request(options, credentials)
+  end
+  self.http_service = HTTPService
+end

data/lib/tasks/cartowrap_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :cartowrap do
+#   # Task goes here
+# end

data/spec/cases/api_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+describe "Cartowrap::API" do
+  before(:each) do
+    @service = Cartowrap::API.new()
+  end
+  it "makes query requests" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.send_query('anything')
+  end
+  it "gets synchronizations index" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.get_synchronizations
+  end
+  it "gets one synchronization" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.get_synchronization("import_id")
+  end
+  it "checks for synchronization status" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.check_synchronization("import_id")
+  end
+  it "forces a synchronization" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.force_synchronization("import_id")
+  end
+  it "creates a synchronization" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.create_synchronization("url", 900)
+  end
+  it "deletes a synchronization" do
+    expect(Cartowrap).to receive(:make_request).and_return(Cartowrap::HTTPService::Response.new(200, "", ""))
+    @service.delete_synchronization("import_id")
+  end
+end

data/spec/cases/error_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'cartowrap'
+describe Cartowrap::APIError do
+  it "is a Cartowrap::CartowrapError" do
+    expect(Cartowrap::APIError.new(nil, nil)).to be_a(Cartowrap::CartowrapError)
+  end
+
+  [:cdb_error_type, :cdb_error_code, :cdb_error_subcode, :cdb_error_message, :cdb_error_user_msg, :cdb_error_user_title, :http_status, :response_body].each do |accessor|
+    it "has an accessor for #{accessor}" do
+      expect(Cartowrap::APIError.instance_methods.map(&:to_sym)).to include(accessor)
+      expect(Cartowrap::APIError.instance_methods.map(&:to_sym)).to include(:"#{accessor}=")
+    end
+  end
+
+  it "sets http_status to the provided status" do
+    error_response = '{ "error": {"type": "foo", "other_details": "bar"} }'
+    expect(Cartowrap::APIError.new(400, error_response).response_body).to eq(error_response)
+  end
+
+  it "sets response_body to the provided response body" do
+    expect(Cartowrap::APIError.new(400, '').http_status).to eq(400)
+  end
+
+  context "with an error_info hash" do
+    let(:error) {
+      error_info = {
+        'type' => 'type',
+        'message' => 'message',
+        'code' => 1,
+        'error_subcode' => 'subcode',
+        'error_user_msg' => 'error user message',
+        'error_user_title' => 'error user title'
+      }
+      Cartowrap::APIError.new(400, '', error_info)
+    }
+
+    {
+      :cdb_error_type => 'type',
+      :cdb_error_message => 'message',
+      :cdb_error_code => 1,
+      :cdb_error_subcode => 'subcode',
+      :cdb_error_user_msg => 'error user message',
+      :cdb_error_user_title => 'error user title'
+    }.each_pair do |accessor, value|
+      it "sets #{accessor} to #{value}" do
+        expect(error.send(accessor)).to eq(value)
+      end
+    end
+
+    it "sets the error message appropriately" do
+      expect(error.message).to eq("type: type, code: 1, error_subcode: subcode, message: message, error_user_title: error user title, error_user_msg: error user message [HTTP 400]")
+    end
+  end
+
+  context "with an error_info string" do
+    it "sets the error message \"error_info [HTTP http_status]\"" do
+      error_info = "Cartodb is down."
+      error = Cartowrap::APIError.new(400, '', error_info)
+      expect(error.message).to eq("Cartodb is down. [HTTP 400]")
+    end
+  end
+
+  context "with no error_info and a response_body containing error JSON" do
+    it "should extract the error info from the response body" do
+      response_body = '{ "error": { "type": "type", "message": "message", "code": 1, "error_subcode": "subcode", "error_user_msg": "error user message", "error_user_title": "error user title" } }'
+      error = Cartowrap::APIError.new(400, response_body)
+      {
+        :cdb_error_type => 'type',
+        :cdb_error_message => 'message',
+        :cdb_error_code => 1,
+        :cdb_error_subcode => 'subcode',
+        :cdb_error_user_msg => 'error user message',
+        :cdb_error_user_title => 'error user title'
+      }.each_pair do |accessor, value|
+        expect(error.send(accessor)).to eq(value)
+      end
+    end
+  end
+
+end
+
+describe Cartowrap::CartowrapError do
+  it "is a StandardError" do
+     expect(Cartowrap::CartowrapError.new).to be_a(StandardError)
+  end
+end
+
+describe Cartowrap::BadCartodbResponse do
+  it "is a Cartowrap::APIError" do
+     expect(Cartowrap::BadCartodbResponse.new(nil, nil)).to be_a(Cartowrap::APIError)
+  end
+end
+
+describe Cartowrap::OAuthTokenRequestError do
+  it "is a Cartowrap::APIError" do
+     expect(Cartowrap::OAuthTokenRequestError.new(nil, nil)).to be_a(Cartowrap::APIError)
+  end
+end
+
+describe Cartowrap::ServerError do
+  it "is a Cartowrap::APIError" do
+     expect(Cartowrap::ServerError.new(nil, nil)).to be_a(Cartowrap::APIError)
+  end
+end
+
+describe Cartowrap::ClientError do
+  it "is a Cartowrap::APIError" do
+     expect(Cartowrap::ClientError.new(nil, nil)).to be_a(Cartowrap::APIError)
+  end
+end
+
+describe Cartowrap::AuthenticationError do
+  it "is a Cartowrap::ClientError" do
+     expect(Cartowrap::AuthenticationError.new(nil, nil)).to be_a(Cartowrap::ClientError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'simplecov'
+SimpleCov.start
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: cartowrap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vizzuality
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  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'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  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: 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'
+description: Provides a common interface for some CartoDB functions.
+email:
+- info@vizzuality.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/cartowrap.rb
+- lib/cartowrap/api.rb
+- lib/cartowrap/config/spring.rb
+- lib/cartowrap/errors.rb
+- lib/cartowrap/http_service.rb
+- lib/cartowrap/http_service/endpoint.rb
+- lib/cartowrap/http_service/response.rb
+- lib/cartowrap/version.rb
+- lib/tasks/cartowrap_tasks.rake
+- spec/cases/api_spec.rb
+- spec/cases/error_spec.rb
+- spec/spec_helper.rb
+- spec/test_app/log/development.log
+homepage: http://vizzuality.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.5.1
+signing_key: 
+specification_version: 4
+summary: A simple CartoDB wrapper.
+test_files:
+- spec/test_app/log/development.log
+- spec/cases/api_spec.rb
+- spec/cases/error_spec.rb
+- spec/spec_helper.rb