mocrata 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ea5004761040d9a269f778003915705495aeb80
+  data.tar.gz: 29f11a520caf96642656e6e0268b643f3d284cae
+SHA512:
+  metadata.gz: d887cafd67ad5669aa6560c169eba34464db314df0763ebbc5dd697b22bf2b32d5f0312dc192d8323e9630cea1d1b03c420f33934fa08a855dab19792639820f
+  data.tar.gz: 6ac06af00a4d45b148edd57adabf239f2d26e653f1ded892f9b36acd82ad99d94631858f3d7a6d6d20e6593880ff83120b1f27d2a917dcac8e5322b4169b1bc3

data/.gitignore

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

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Heather Rivers
+
+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,61 @@
+# Mocrata
+
+Mocrata is a [SODA](http://dev.socrata.com/) (Socrata Open Data API) client
+developed by [Mode Analytics](https://modeanalytics.com).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mocrata'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mocrata
+
+## Usage
+
+### Setup
+
+```
+Mocrata.configure do |config|
+  config.app_token = 'yourtoken' # optional Socrata application token
+end
+```
+
+### Accessing data
+
+```
+dataset = Mocrata::Dataset.new('http://soda.demo.socrata.com/resource/6xzm-fzcu')
+
+dataset.csv
+=> [["Sally", 10], ["Earl", 2]]
+
+dataset.json
+=> [{"name"=>"Sally", "age"=>10}, {"name"=>"Earl", "age"=>2}]
+
+dataset.fields
+=> {"name"=>"text", "age"=>"number"}
+```
+
+### Iterating through rows
+
+```
+dataset.each_row(:csv) do |row|
+  # do something with the row
+end
+
+dataset.each_row(:json) { |row| ... }
+```
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/mocrata/configuration.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+#
+module Mocrata
+  # @attr [String] app_token A Socrata application token
+  #
+  class Configuration
+    # The maximum number of rows allowed per request by Socrata
+    MAX_PER_PAGE = 1000
+
+    attr_accessor :app_token
+
+    # @return [Integer] the value of the `per_page` configuration option
+    #
+    def per_page
+      @per_page ||= MAX_PER_PAGE
+    end
+
+    # Sets the value of the `per_page` configuration option
+    #
+    # @param value [Integer] the number of results per page {http://dev.socrata.com SODA} resource url
+    #
+    # @return [Integer] the value
+    #
+    # @raise [Mocrata::Configuration::ConfigurationError] if the value is invalid
+    #
+    def per_page=(value)
+      if value > MAX_PER_PAGE
+        message = "Per page #{value} exceeds maximum value of #{MAX_PER_PAGE}"
+        raise ConfigurationError.new(message)
+      end
+
+      @per_page = value
+    end
+
+    class ConfigurationError < StandardError; end
+  end
+end

data/lib/mocrata/dataset.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+#
+module Mocrata
+  # A Mocrata::Dataset instance represents a SODA dataset and provides
+  # interfaces for reading its metadata and contents in supported formats.
+  #
+  class Dataset
+    # Construct a new Dataset instance
+    #
+    # @param url [String] valid {http://dev.socrata.com SODA} resource url
+    #
+    # @return [Mocrata::Dataset] the instance
+    #
+    # @example
+    #   dataset = Mocrata::Dataset.new('http://data.sfgov.org/resource/funx-qxxn')
+    #
+    def initialize(url)
+      @url = url
+    end
+
+    # Iterate through each row of the dataset
+    #
+    # @param format [Symbol, String] the format, `:json` or `:csv`
+    #
+    # @yield [Array<Array>] row of values
+    #
+    # @example
+    #   dataset.each_row(:json) do |row|
+    #     # do something with the row
+    #   end
+    #
+    def each_row(format, &block)
+      each_page(format) do |page|
+        page.each(&block)
+      end
+    end
+
+    # Iterate through each page of the dataset
+    #
+    # @param format [Symbol, String] the format, `:json` or `:csv`
+    # @param per_page [optional, Integer] the number of rows to return for each page
+    #
+    # @yield [Array<Array>] page of rows
+    #
+    # @example
+    #   dataset.each_page(:csv) do |page|
+    #     # do something with the page
+    #   end
+    #
+    def each_page(format, per_page = nil, &block)
+      page       = 1
+      per_page ||= Mocrata.config.per_page
+
+      while true
+        rows = send(format, :page => page, :per_page => per_page)
+        yield rows
+        break if rows.size < per_page
+        page += 1
+      end
+    end
+
+    # The contents of the dataset in CSV format
+    #
+    # @param params [optional, Hash] hash of options to pass along to the HTTP request
+    #
+    # @option params [Integer] :page the page to request
+    # @option params [Integer] :per_page the number of rows to return for each page
+    #
+    # @return [Array<Array>] the array of rows
+    #
+    # @example
+    #   dataset.csv(:page => 2, :per_page => 10)
+    #
+    def csv(params = {})
+      get(:csv, params).body
+    end
+
+    # The contents of the dataset in JSON format
+    #
+    # @param params [optional, Hash] hash of options to pass along to the HTTP request
+    #
+    # @option params [Integer] :page the page to request
+    # @option params [Integer] :per_page the number of rows to return for each page
+    #
+    # @return [Array<Hash>] the array of rows
+    #
+    # @example
+    #   dataset.json(:page => 2, :per_page => 10)
+    #
+    def json(params = {})
+      get(:json, params).body
+    end
+
+    # Get the headers associated with the dataset
+    #
+    # @return [Hash] a hash of headers
+    #
+    def headers
+      # SODA doesn't support HEAD requests, unfortunately
+      @headers ||= get(:json, :per_page => 0).headers
+    end
+
+    # A hash of field names and types from headers
+    #
+    # @return [Hash] a hash of field names and types
+    #
+    def fields
+      Hash[field_names.zip(field_types)]
+    end
+
+    private
+
+    attr_reader :url
+
+    def get(format, params = {})
+      Mocrata::Request.new(base_url, format, params).response
+    end
+
+    def base_url
+      @base_url ||= Mocrata::DatasetUrl.new(url).normalize
+    end
+
+    def field_names
+      headers.fetch('x-soda2-fields', [])
+    end
+
+    def field_types
+      headers.fetch('x-soda2-types', [])
+    end
+  end
+end

data/lib/mocrata/dataset_url.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+#
+module Mocrata
+  # @attr_reader [String] original the original Socrata dataset URL
+  #
+  class DatasetUrl
+    attr_reader :original
+
+    # Construct a new DatasetUrl instance
+    #
+    # @param original [String] the original Socrata dataset URL
+    #
+    # @return [Mocrata::DatasetUrl] the instance
+    #
+    # @example
+    #   url = Mocrata::DatasetUrl.new('http://data.sfgov.org/resource/funx-qxxn')
+    #
+    def initialize(original)
+      @original = original
+    end
+
+    # Normalize a Socrata dataset URL. Ensures https protocol. Removes query
+    # string and fragment, if any.
+    #
+    # @return [String] the normalized URL
+    #
+    def normalize
+      uri = URI(self.class.ensure_protocol(original))
+
+      uri.scheme   = 'https'
+      uri.fragment = nil
+      uri.query    = nil
+
+      self.class.strip_format(uri.to_s)
+    end
+
+    # Validate the original URL against the expected Socrata dataset URL
+    # pattern
+    #
+    # @raise [Mocrata::DatasetUrl::InvalidError] if the URL is invalid
+    #
+    def validate!
+      unless original =~ VALID_PATTERN
+        raise InvalidError.new("Invalid URL: #{original.inspect}")
+      end
+
+      true
+    end
+
+    class << self
+      # Ensure that a URL has a valid protocol
+      #
+      # @param url [String] the url with or without protocol
+      #
+      # @return [String] the url with protocol
+      #
+      def ensure_protocol(url)
+        if url =~ /\A\/\//
+          url = "https:#{url}"
+        elsif url !~ /\Ahttps?:\/\//
+          url = "https://#{url}"
+        end
+
+        url
+      end
+
+      # Strip explicit format from a given URL if present
+      #
+      # @param url [String] the url with or without format
+      #
+      # @return [String] the url without format
+      #
+      def strip_format(url)
+        url.gsub(/\.[a-zA-Z]+\Z/, '')
+      end
+    end
+
+    private
+
+    VALID_PATTERN = /\/resource\//
+
+    class InvalidError < StandardError; end
+  end
+end

data/lib/mocrata/request.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+#
+require 'cgi'
+require 'csv'
+require 'json'
+require 'net/https'
+
+module Mocrata
+  # @attr_reader [String] url the request URL
+  # @attr_reader [Symbol] format the request format, `:json` or `:csv`
+  # @attr_reader [Hash] params the requst params
+  #
+  class Request
+    attr_reader :url, :format, :params
+
+    # Construct a new Request instance
+    #
+    # @param url [String] the request URL
+    # @param format [Symbol] the request format, `:json` or `:csv`
+    # @param params [Hash] the requst params
+    #
+    # @return [Mocrata::Request] the instance
+    #
+    def initialize(url, format, params = {})
+      @url    = url
+      @format = format
+      @params = params
+    end
+
+    # Perform the HTTP GET request
+    #
+    # @return [Mocrata::Response] the validated response
+    #
+    def response
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      request.add_field('Accept', content_type)
+      request.add_field('X-App-Token', Mocrata.config.app_token)
+
+      response = http.request(request)
+
+      Mocrata::Response.new(response).tap(&:validate!)
+    end
+
+    # @return [String] the content type for the specified format
+    #
+    # @raise [Mocrata::Request::RequestError] if the format is not supported
+    #
+    def content_type
+      Mocrata::CONTENT_TYPES.fetch(format, nil).tap do |type|
+        raise RequestError.new("Invalid format: #{format}") unless type
+      end
+    end
+
+    private
+
+    def http
+      @http ||= Net::HTTP.new(uri.host, uri.port).tap do |http|
+        http.use_ssl     = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    def soda_params
+      @soda_params ||= {}.tap do |soda|
+        limit = params.fetch(:per_page, Mocrata.config.per_page)
+        page  = params.fetch(:page, 1)
+
+        soda[:$limit]  = limit
+        soda[:$offset] = (page - 1) * limit
+      end
+    end
+
+    def uri
+      @uri ||= URI(url).dup.tap do |uri|
+        uri.query = self.class.query_string(soda_params)
+      end
+    end
+
+    class << self
+      # Construct a query string from a hash
+      #
+      # @param hash [Hash] the hash of parmas
+      #
+      # @return [String] the query string
+      #
+      def query_string(hash)
+        hash.map { |k, v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&')
+      end
+    end
+
+    class RequestError < StandardError; end
+  end
+end

data/lib/mocrata/response.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+#
+require 'json'
+require 'csv'
+
+module Mocrata
+  class Response
+    # Construct a new Response instance
+    #
+    # @param http_response [Net::HTTPResponse] the http response
+    #
+    # @return [Mocrata::Response] the instance
+    #
+    def initialize(http_response)
+      @http_response = http_response
+    end
+
+    # Perform certain checks against the HTTP response and raise an exception
+    # if necessary
+    #
+    # @return [true]
+    #
+    # @raise [Mocrata::Response::ResponseError] if the response is invalid
+    #
+    def validate!
+      if content_type == :json
+        if body.respond_to?(:has_key?) && body.has_key?('error')
+          raise ResponseError.new("API error: #{body['message']}")
+        end
+      end
+
+      true
+    end
+
+    # HTTP headers with certain values parsed as JSON
+    #
+    # @return [Hash] the header keys and values
+    #
+    def headers
+      @headers ||= {}.tap do |result|
+        http_response.each_header do |key, value|
+          value = JSON.parse(value) if JSON_HEADERS.include?(key)
+
+          result[key] = value
+        end
+      end
+    end
+
+    # The HTTP response body, processed according to content type
+    #
+    # @return [Array] the parsed body
+    #
+    def body
+      send(content_type)
+    end
+
+    private
+
+    # SODA headers that are always encoded as JSON
+    JSON_HEADERS = %w(x-soda2-fields x-soda2-types)
+
+    attr_reader :http_response
+
+    def content_type
+      type = headers['content-type']
+
+      CONTENT_TYPES.each do |key, value|
+        return key if type && type.start_with?(value)
+      end
+
+      raise ResponseError.new("Unexpected content type: #{type}")
+    end
+
+    def csv
+      CSV.parse(http_response.body)[1..-1] # exclude header
+    end
+
+    def json
+      JSON.parse(http_response.body)
+    end
+
+    class ResponseError < StandardError; end
+  end
+end

data/lib/mocrata/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+#
+module Mocrata
+  VERSION = "0.0.1"
+end

data/lib/mocrata.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+#
+# Mocrata is a [SODA](http://dev.socrata.com/) (Socrata Open Data API) client
+# developed by [Mode Analytics](https://modeanalytics.com).
+#
+module Mocrata
+  # Supported Socrata content types
+  #
+  # @see http://dev.socrata.com/docs/formats/ Socrata format documentation
+  #
+  # @todo Add support for application/rdf+xml
+  #
+  CONTENT_TYPES = {
+    :json => 'application/json',
+    :csv  => 'text/csv'
+  }
+
+  class << self
+    # Set Mocrata configuration values
+    #
+    # @yield [Mocrata::Configuration] the configuration instance
+    #
+    # @example
+    #   Mocrata.configure do |config|
+    #     config.app_token = 'yourtoken'
+    #     config.per_page  = 1000
+    #   end
+    #
+    def configure(&block)
+      yield config
+    end
+
+    # The Mocrata configuration instance
+    #
+    # @return [Mocrata::Configuration] the configuration instance
+    #
+    def config
+      @config ||= Mocrata::Configuration.new
+    end
+
+    # Remove Mocrata configuration instance variable
+    #
+    def reset
+      if instance_variable_defined?(:@config)
+        remove_instance_variable(:@config)
+      end
+    end
+  end
+end
+
+require 'mocrata/configuration'
+require 'mocrata/dataset'
+require 'mocrata/dataset_url'
+require 'mocrata/request'
+require 'mocrata/response'
+require 'mocrata/version'

data/mocrata.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mocrata/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mocrata"
+  spec.version       = Mocrata::VERSION
+  spec.authors       = ["Heather Rivers"]
+  spec.email         = ["heather@modeanalytics.com"]
+  spec.description   = %q{Mode's SODA client}
+  spec.summary       = %q{Mocrata is a SODA (Socrata Open Data API) client developed by Mode Analytics}
+  spec.homepage      = "https://github.com/mode/mocrata"
+  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|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "rdoc"
+
+  spec.required_ruby_version = "~> 2.0"
+end

data/spec/lib/mocrata/configuration_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mocrata::Configuration do
+  let :config do
+    Mocrata::Configuration.new
+  end
+
+  describe '#per_page' do
+    it 'has default value' do
+      expect(config.per_page).to eq(1000)
+    end
+  end
+
+  describe '#per_page=' do
+    it 'overrides default value' do
+      expect(config.per_page).to eq(1000)
+      config.per_page = 50
+      expect(config.per_page).to eq(50)
+    end
+
+    it 'raises exception if max value is exceeded' do
+      expect { config.per_page = 1001 }.to raise_error(
+        Mocrata::Configuration::ConfigurationError)
+    end
+  end
+end

data/spec/lib/mocrata/dataset_spec.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mocrata::Dataset do
+  let :dataset do
+    Mocrata::Dataset.new('')
+  end
+
+  let :rows do
+    (0..5).map do |i|
+      { "key_#{i}" => "value_#{i}" }
+    end
+  end
+
+  let :pages do
+    [rows[0..3], rows[4..5]]
+  end
+
+  describe '#each_row' do
+    it 'yields rows' do
+      expect(dataset).to receive(:each_page)
+        .and_yield(pages[0])
+        .and_yield(pages[1])
+
+      expect { |b|
+        dataset.each_row(:json, &b)
+      }.to yield_successive_args(*rows)
+    end
+  end
+
+  describe '#each_page' do
+    it 'yields pages' do
+      expect(dataset).to receive(:json).and_return(*pages)
+
+      expect { |b|
+        dataset.each_page(:json, 4, &b)
+      }.to yield_successive_args(*pages)
+    end
+  end
+
+  describe '#get' do
+    it 'returns response' do
+      dataset = Mocrata::Dataset.new(
+        'https://data.sfgov.org/resource/funx-qxxn')
+
+      response = Mocrata::Response.new(true)
+
+      expect_any_instance_of(Mocrata::Request).to receive(
+        :response).and_return(response)
+
+      expect(dataset.send(:get, :csv)).to eq(response)
+    end
+  end
+
+  describe '#csv' do
+    it 'returns csv body' do
+      response = Mocrata::Response.new(true)
+
+      expect(response).to receive(:body).and_return([])
+      expect(dataset).to receive(:get).and_return(response)
+
+      expect(dataset.csv).to eq([])
+    end
+  end
+
+  describe '#json' do
+    it 'returns json body' do
+      response = Mocrata::Response.new(true)
+
+      expect(response).to receive(:body).and_return([])
+      expect(dataset).to receive(:get).and_return(response)
+
+      expect(dataset.json).to eq([])
+    end
+  end
+
+  describe '#headers' do
+    it 'builds headers' do
+      response = Mocrata::Response.new(true)
+
+      expect(response).to receive(:headers).and_return('foo' => 'bar')
+      expect(dataset).to receive(:get).and_return(response)
+
+      expect(dataset.headers).to eq('foo' => 'bar')
+    end
+  end
+
+  describe '#fields' do
+    it 'builds empty map' do
+      expect(dataset).to receive(:field_names).and_return([])
+      expect(dataset).to receive(:field_types).and_return([])
+
+      expect(dataset.fields).to eq({})
+    end
+
+    it 'builds map' do
+      expect(dataset).to receive(:field_names).and_return(['key1', 'key2'])
+      expect(dataset).to receive(:field_types).and_return(['val1', 'val2'])
+
+      expect(dataset.fields).to eq('key1' => 'val1', 'key2' => 'val2')
+    end
+  end
+
+  describe '#field_names' do
+    it 'handles missing header' do
+      expect(dataset).to receive(:headers).and_return({})
+
+      expect(dataset.send(:field_names)).to eq([])
+    end
+
+    it 'returns header if present' do
+      expect(dataset).to receive(:headers).and_return(
+        'x-soda2-fields' => ['name1', 'name2'])
+
+      expect(dataset.send(:field_names)).to eq(['name1', 'name2'])
+    end
+  end
+
+  describe '#field_types' do
+    it 'handles missing header' do
+      expect(dataset).to receive(:headers).and_return({})
+
+      expect(dataset.send(:field_types)).to eq([])
+    end
+
+    it 'returns header if present' do
+      expect(dataset).to receive(:headers).and_return(
+        'x-soda2-types' => ['type1', 'type2'])
+
+      expect(dataset.send(:field_types)).to eq(['type1', 'type2'])
+    end
+  end
+end

data/spec/lib/mocrata/dataset_url_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mocrata::DatasetUrl do
+  describe '#validate!' do
+    it 'returns true for valid url' do
+      url = Mocrata::DatasetUrl.new(
+        'data.sfgov.org/resource/funx-qxxn.csv?limit=100#foo')
+
+      expect(url.validate!).to eq(true)
+    end
+
+    it 'raises exception for invalid url' do
+      url = Mocrata::DatasetUrl.new('data.sfgov.org/nope/funx-qxxn.csv')
+
+      expect {
+        url.validate!
+      }.to raise_error(Mocrata::DatasetUrl::InvalidError)
+    end
+  end
+
+  describe '#normalize' do
+    it 'normalizes original url' do
+      url = Mocrata::DatasetUrl.new(
+        'data.sfgov.org/resource/funx-qxxn.csv?limit=100#foo')
+
+      expect(url.normalize).to eq('https://data.sfgov.org/resource/funx-qxxn')
+    end
+  end
+
+  describe '.ensure_protocol' do
+    it 'adds missing protocol' do
+      url = Mocrata::DatasetUrl.ensure_protocol('data.sfgov.org/')
+
+      expect(url).to eq('https://data.sfgov.org/')
+    end
+
+    it 'adds protocol to schemeless url' do
+      url = Mocrata::DatasetUrl.ensure_protocol('//data.sfgov.org/')
+
+      expect(url).to eq('https://data.sfgov.org/')
+    end
+
+    it 'preserves http protocol' do
+      url = Mocrata::DatasetUrl.ensure_protocol('http://data.sfgov.org/')
+
+      expect(url).to eq('http://data.sfgov.org/')
+    end
+
+    it 'preserves https protocol' do
+      url = Mocrata::DatasetUrl.ensure_protocol('https://data.sfgov.org/')
+
+      expect(url).to eq('https://data.sfgov.org/')
+    end
+  end
+
+  describe '.strip_format' do
+    it 'preserves url without format' do
+      url = Mocrata::DatasetUrl.strip_format('data.sfgov.org/resource/foo')
+
+      expect(url).to eq('data.sfgov.org/resource/foo')
+    end
+
+    it 'strips format at end of url' do
+      url = Mocrata::DatasetUrl.strip_format('data.sfgov.org/resource/foo.bar')
+
+      expect(url).to eq('data.sfgov.org/resource/foo')
+    end
+
+    it 'preserves format if not at end of url' do
+      url = Mocrata::DatasetUrl.strip_format('data.sfgov.org/resource/foo.bar/baz')
+
+      expect(url).to eq('data.sfgov.org/resource/foo.bar/baz')
+    end
+  end
+end

data/spec/lib/mocrata/request_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mocrata::Request do
+  describe '#response' do
+    it 'forms response' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', :json)
+
+      expect_any_instance_of(Mocrata::Response).to receive(
+        :validate!).and_return(true)
+
+      expect(request.send(:http)).to receive(:request).and_return(true)
+
+      expect(request.response).to be_an_instance_of(Mocrata::Response)
+    end
+  end
+
+  describe '#content_type' do
+    it 'raises exception with null format' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', nil)
+
+      expect {
+        request.content_type
+      }.to raise_error(Mocrata::Request::RequestError)
+    end
+
+    it 'raises exception with invalid format' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', :nope)
+
+      expect {
+        request.content_type
+      }.to raise_error(Mocrata::Request::RequestError)
+    end
+
+    it 'returns valid content type' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', :csv)
+
+      expect(request.content_type).to eq('text/csv')
+    end
+  end
+
+  describe '#http' do
+    it 'uses ssl' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', nil)
+
+      expect(request.send(:http).use_ssl?).to be true
+    end
+  end
+
+  describe '#soda_params' do
+    it 'is formed with default params' do
+      request = Mocrata::Request.new('', nil)
+
+      expect(request.send(:soda_params)).to eq(:$limit => 1000, :$offset => 0)
+    end
+
+    it 'is formed with custom params' do
+      request = Mocrata::Request.new('', nil, :page => 5, :per_page => 100)
+
+      expect(request.send(:soda_params)).to eq(:$limit => 100, :$offset => 400)
+    end
+
+    it 'ignores custom params' do
+      request = Mocrata::Request.new('', nil, :wat => 'nope')
+
+      expect(request.send(:soda_params)).to eq(:$limit => 1000, :$offset => 0)
+    end
+  end
+
+  describe '#uri' do
+    before :each do
+      expect(Mocrata.config).to receive(:per_page).and_return(10)
+    end
+
+    it 'is formed with default parameters' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', nil)
+
+      result = request.send(:uri).to_s
+
+      expect(result).to eq(
+        'https://data.sfgov.org/resource/funx-qxxn?$limit=10&$offset=0')
+    end
+
+    it 'is formed with custom parameters' do
+      request = Mocrata::Request.new(
+        'https://data.sfgov.org/resource/funx-qxxn', nil,
+        :per_page => 5,
+        :page     => 3)
+
+      result = request.send(:uri).to_s
+
+      expect(result).to eq(
+        'https://data.sfgov.org/resource/funx-qxxn?$limit=5&$offset=10')
+    end
+  end
+
+  describe '.query_string' do
+    it 'forms empty query string' do
+      expect(Mocrata::Request.query_string({})).to eq('')
+    end
+
+    it 'forms simple query string' do
+      result = Mocrata::Request.query_string(:foo => 'bar')
+      expect(result).to eq('foo=bar')
+    end
+
+    it 'forms complex string' do
+      result = Mocrata::Request.query_string(:foo => 'bar', :bar => 'baz')
+      expect(result).to eq('foo=bar&bar=baz')
+    end
+
+    it 'escapes values' do
+      result = Mocrata::Request.query_string(:foo => '"\'Stop!\' said Fred"')
+
+      expect(result).to eq('foo=%22%27Stop%21%27+said+Fred%22')
+    end
+  end
+end

data/spec/lib/mocrata/response_spec.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mocrata::Response do
+  let :response do
+    Mocrata::Response.new(true)
+  end
+
+  describe '#validate!' do
+    it 'returns true without content type' do
+      expect(response).to receive(:content_type).and_return(nil)
+      expect(response.validate!).to be true
+    end
+
+    it 'returns true with csv content' do
+      expect(response).to receive(:content_type).and_return(:csv)
+      expect(response.validate!).to be true
+    end
+
+    it 'returns true with json array' do
+      expect(response).to receive(:content_type).and_return(:json)
+      expect(response).to receive(:body).and_return([])
+      expect(response.validate!).to be true
+    end
+
+    it 'returns true with json array' do
+      expect(response).to receive(:content_type).and_return(:json)
+      expect(response).to receive(:body).at_least(:once).and_return({})
+      expect(response.validate!).to be true
+    end
+
+    it 'raises exception with json error' do
+      expect(response).to receive(:content_type).and_return(:json)
+      expect(response).to receive(:body).at_least(:once).and_return(
+        'error'   => true,
+        'message' => 'something went wrong')
+
+      expect { response.validate! }.to raise_error(
+        Mocrata::Response::ResponseError)
+    end
+  end
+
+  describe '#content_type' do
+    it 'detects csv' do
+      expect(response).to receive(:headers).and_return(
+        'content-type' => 'text/csv')
+
+      expect(response.send(:content_type)).to eq(:csv)
+    end
+
+    it 'detects csv with junk at the end' do
+      expect(response).to receive(:headers).and_return(
+        'content-type' => 'text/csv; charset=utf-8')
+
+      expect(response.send(:content_type)).to eq(:csv)
+    end
+
+    it 'detects json' do
+      expect(response).to receive(:headers).and_return(
+        'content-type' => 'application/json')
+
+      expect(response.send(:content_type)).to eq(:json)
+    end
+
+    it 'raises exception for unrecognized content type' do
+      expect(response).to receive(:headers).and_return(
+        'content-type' => 'text/html')
+
+      expect { response.send(:content_type) }.to raise_error(
+        Mocrata::Response::ResponseError)
+    end
+
+    it 'raises exception for absent content type' do
+      expect(response).to receive(:headers).and_return({})
+      expect { response.send(:content_type) }.to raise_error(
+        Mocrata::Response::ResponseError)
+    end
+  end
+
+  describe '#csv' do
+    it 'parses body and excludes header' do
+      csv = "\"header1\"\n\"row1\"\n\"row2\""
+      expect(response.send(:http_response)).to receive(:body).and_return(csv)
+      expect(response.send(:csv)).to eq([['row1'], ['row2']])
+    end
+  end
+
+  describe '#json' do
+    it 'parses body' do
+      json = '[{"key1":"val1"}]'
+      expect(response.send(:http_response)).to receive(:body).and_return(json)
+      expect(response.send(:json)).to eq([{'key1' => 'val1'}])
+    end
+  end
+
+  describe '#body' do
+    it 'returns json' do
+      expect(response).to receive(:content_type).and_return(:json)
+      expect(response).to receive(:json).and_return([])
+      expect(response.body).to eq([])
+    end
+
+    it 'returns csv' do
+      expect(response).to receive(:content_type).and_return(:csv)
+      expect(response).to receive(:csv).and_return([])
+      expect(response.body).to eq([])
+    end
+  end
+
+  describe '#headers' do
+    it 'preserves non json headers' do
+      expect(response.send(:http_response)).to receive(:each_header)
+        .and_yield('x-foo-header', 'foo')
+        .and_yield('x-bar-header', 'bar')
+
+      expect(response.headers).to eq(
+        'x-foo-header' => 'foo',
+        'x-bar-header' => 'bar')
+    end
+
+    it 'parses json headers' do
+      expect(response.send(:http_response)).to receive(:each_header)
+        .and_yield('x-foo-header', 'foo')
+        .and_yield('x-soda2-fields', '{"name":"value"}')
+
+      expect(response.headers).to eq(
+        'x-foo-header'   => 'foo',
+        'x-soda2-fields' => { 'name' => 'value' })
+    end
+  end
+end

data/spec/lib/mocrata_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mocrata do
+  after :each do
+    Mocrata.reset
+  end
+
+  describe '.configure' do
+    it 'sets configuration variables' do
+      expect_any_instance_of(Mocrata::Configuration).to receive(:setting=).once
+
+      Mocrata.configure do |config|
+        config.setting = 'value'
+      end
+    end
+  end
+
+  describe '.config' do
+    it 'instantiates and memoizes configuration instance' do
+      expect(Mocrata.instance_variable_get(:@config)).to be_nil
+
+      expect(Mocrata.config).to be_an_instance_of(Mocrata::Configuration)
+
+      config = Mocrata.instance_variable_get(:@config)
+
+      expect(config).to be_an_instance_of(Mocrata::Configuration)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+#
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'mocrata'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: mocrata
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Heather Rivers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: rspec
+  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: rdoc
+  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: Mode's SODA client
+email:
+- heather@modeanalytics.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mocrata.rb
+- lib/mocrata/configuration.rb
+- lib/mocrata/dataset.rb
+- lib/mocrata/dataset_url.rb
+- lib/mocrata/request.rb
+- lib/mocrata/response.rb
+- lib/mocrata/version.rb
+- mocrata.gemspec
+- spec/lib/mocrata/configuration_spec.rb
+- spec/lib/mocrata/dataset_spec.rb
+- spec/lib/mocrata/dataset_url_spec.rb
+- spec/lib/mocrata/request_spec.rb
+- spec/lib/mocrata/response_spec.rb
+- spec/lib/mocrata_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mode/mocrata
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Mocrata is a SODA (Socrata Open Data API) client developed by Mode Analytics
+test_files:
+- spec/lib/mocrata/configuration_spec.rb
+- spec/lib/mocrata/dataset_spec.rb
+- spec/lib/mocrata/dataset_url_spec.rb
+- spec/lib/mocrata/request_spec.rb
+- spec/lib/mocrata/response_spec.rb
+- spec/lib/mocrata_spec.rb
+- spec/spec_helper.rb
+has_rdoc: