bls_api 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f4938be36f9e555cb7ba3e8c68114143c5d06ae
+  data.tar.gz: cdf087da4ddc16b5c5d66d7fb380ea6739ab69a7
+SHA512:
+  metadata.gz: fd0c6a16df4d39cd383cd722a698dd8e25e1310cff4756c84f457a6e59b848cc726dfac422c1b7b28b7568b470ab2bcf7143acfc4770a0818cef078055264158
+  data.tar.gz: 07613e657478815be83623498283d6d5ac87a50161fb59e618e42f294509cbe3cee563d62241cbc40bb039d5d08bd65e481bd0e1aaf02acff4f8df7a7cae4f46

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.3.0
+  - 2.2.3
+  - 1.9.3-p448
+before_install: gem install bundler -v 1.10.6

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 The Associated Press
+
+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,108 @@
+# Bureau of Labor Statistics API wrapper #
+
+This is a Ruby wrapper for [v2][v2] of the [BLS Public Data API][bls-dev].
+
+[bls-dev]: http://www.bls.gov/developers/home.htm
+[v2]: http://www.bls.gov/developers/api_signature_v2.htm
+
+## Installation ##
+
+    $ gem install bls_api
+
+## Usage ##
+
+    >> require "bls_api"
+    >> client = BLS_API::Client.new
+    >> data = client.get(:series_ids => ["LNS14000000"], :start_year => 2015, :end_year => 2015)
+
+You'll get back a Hash, with the series IDs you provided as keys. The values
+are `BLS_API::Series` instances, which expose the data for each series along
+with some BLS-provided metadata:
+
+    >> unemployment_rate = data["LNS14000000"]
+
+    >> unemployment_rate.catalog.series_title
+    => "(Seas) Unemployment Rate"
+    >> unemployment_rate.catalog.seasonality
+    => "Seasonally Adjusted"
+
+    >> june = unemployment_rate.get_month(2015, 6)
+    >> june.value.to_f
+    => 5.3
+
+### Series metadata ###
+
+`Series#catalog` just returns an [OpenStruct][openstruct] with whatever
+metadata the BLS API returned for that series:
+
+    >> unemployment_rate.catalog
+    => #<OpenStruct series_title="(Seas) Unemployment Rate",
+    series_id="LNS14000000", seasonality="Seasonally Adjusted",
+    survey_name="Labor Force Statistics from the Current Population Survey",
+    measure_data_type="Percent or rate", commerce_industry="All Industries",
+    occupation="All Occupations", cps_labor_force_status="Unemployment rate",
+    demographic_age="16 years and over",
+    demographic_ethnic_origin="All Origins", demographic_race="All Races",
+    demographic_gender="Both Sexes",
+    demographic_marital_status="All marital statuses",
+    demographic_education="All educational levels">
+
+This is great if you already know what fields to expect; otherwise the more
+familiar way to explore it might be as a Hash:
+
+    >> unemployment_rate.catalog.to_h.keys
+    => [:series_title, :series_id, :seasonality, :survey_name,
+    :measure_data_type, :commerce_industry, :occupation,
+    :cps_labor_force_status, :demographic_age, :demographic_ethnic_origin,
+    :demographic_race, :demographic_gender, :demographic_marital_status,
+    :demographic_education]
+
+[openstruct]: http://ruby-doc.org/stdlib-2.3.0/libdoc/ostruct/rdoc/OpenStruct.html
+
+### Data by month ###
+
+You've already seen `Series#get_month`, which takes a year and month
+(1 = January) and returns a `BLS_API::Month`, and you've seen `Month#value`:
+
+    >> june = unemployment_rate.get_month(2015, 6)
+    >> june.value.to_f
+    => 5.3
+
+You also can get one-, three-, six- or 12-month changes (net changes _or_
+percent changes):
+
+    >> june.net_change(1).to_f
+    => -0.2
+    >> june.percent_change(1).to_f
+    => -3.6
+
+These examples use `#to_f` for display purposes because this client uses
+[BigDecimal][bigdecimal] instances by default to preserve precision:
+
+    >> june.value
+    => #<BigDecimal:7ff5493f5390,'0.53E1',18(18)>
+
+If you'd prefer Floats, you can set `client.use_floats = true` before making
+your request:
+
+    >> client.use_floats = true
+    >> data = client.get(:series_ids => ["LNS14000000"], :start_year => 2015, :end_year => 2015)
+    >> unemployment_rate = data["LNS14000000"]
+    >> unemployment_rate.get_month(2015, 6).value
+    => 5.3
+
+Also, BLS sometimes provides footnotes for certain data points, which you can
+access via `Month#footnotes`:
+
+    >> last_month.footnotes
+    => {"P"=>"Preliminary"}
+
+[bigdecimal]: http://ruby-doc.org/stdlib-2.3.0/libdoc/bigdecimal/rdoc/BigDecimal.html
+
+## Configuration ##
+
+You'll need an [API key][api-key], which you can provide as an argument to
+`BLS_API::Client.new` or as a `BLS_API_KEY` environment variable. (If you
+provide both, the argument to `Client.new` takes precedence.)
+
+[api-key]: http://data.bls.gov/registrationEngine/

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bls_api"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bls_api.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "bls_api/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "bls_api"
+  spec.version       = BLS_API::VERSION
+  spec.authors       = ["Justin Myers"]
+  spec.email         = ["jmyers@ap.org"]
+  spec.license       = "MIT"
+
+  spec.summary       = %q{API wrapper for data from the U.S. Bureau of Labor Statistics.}
+  spec.description   = %q{API wrapper for data from the U.S. Bureau of Labor Statistics.}
+  spec.homepage      = "https://github.com/associatedpress/bls_api"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "climate_control", "~> 0.0.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock", "~> 1.21"
+end

data/lib/bls_api/client.rb

@@ -0,0 +1,80 @@
+require "bls_api/constants"
+require "bls_api/destringify"
+require "bls_api/errors"
+require "bls_api/raw_request"
+
+module BLS_API
+  class Client
+    include BLS_API::Destringify
+    include BLS_API::RawRequest
+
+    attr_accessor :api_key
+    attr_accessor :request_annual_averages
+    attr_accessor :request_catalog
+    attr_accessor :request_calculations
+    attr_accessor :use_floats
+
+    def initialize(api_key = nil)
+      @api_key = ENV.fetch("BLS_API_KEY", nil)
+      @api_key = api_key unless api_key.nil?
+      @api_key = nil if @api_key.is_a?(String) && @api_key.empty?
+      if @api_key.nil?
+        missing_key_message = <<-EOF.gsub(/^ */, "").gsub(/\r?\n/, " ").strip
+          You must provide an API key as an argument to BLS_API::Client.new or
+          as the BLS_API_KEY environment variable. If you do not have an API
+          key, register for one at http://data.bls.gov/registrationEngine/.
+        EOF
+        raise BLS_API::Errors::ConfigurationError, missing_key_message
+      end
+
+      @request_annual_averages = true
+      @request_catalog = true
+      @request_calculations = true
+      @use_floats = false
+    end
+
+    # Public: Request a batch of data from the BLS API.
+    #
+    # By default, raises BLS_API::Errors::APIError if the request is
+    # unsuccessful. (You can catch this with an IOError, if that's more your
+    # thing.)
+    #
+    # options - A Hash with three required arguments and four optional
+    #           arguments.
+    #           Required arguments include:
+    #           :series_ids - An Array of String series IDs for which to
+    #                         request data. If a String is provided instead, it
+    #                         is assumed to be a single series ID.
+    #           :start_year - An Integer representing the earliest year for
+    #                         which to request data.
+    #           :end_year   - An Integer representing the latest year for which
+    #                         to request data. Note that the BLS API will
+    #                         return an error if you specify a year for which
+    #                         no data exists; for example, an :end_year of 2016
+    #                         will raise an error during January of 2016 when
+    #                         no 2016 data has yet been released.
+    #           Optional arguments include:
+    #           :catch_errors     - A Boolean specifying whether to raise an
+    #                               APIError if the request is unsuccessful
+    #                               (default: true).
+    #           :catalog          - A Boolean specifying whether to include
+    #                               catalog data in the response
+    #                               (default: true).
+    #           :calculations     - A Boolean specifying whether to include
+    #                               net-change and percent-change calculations
+    #                               in the response (default: true).
+    #           :annual_averages  - A Boolean specifying whether to include
+    #                               annual averages in the response
+    #                               (default: true).
+    #
+    # Returns a Hash with the given String series IDs as keys and
+    #   BLS_API::Series instances as values.
+    def get(options = {})
+      raw_response = self.make_api_request(options)
+      destringified = self.destringify(raw_response, @use_floats)
+      series = Hash[destringified["Results"]["series"].map do |raw_series|
+        [raw_series["seriesID"], BLS_API::Series.new(raw_series)]
+      end]
+    end
+  end
+end

data/lib/bls_api/constants.rb

@@ -0,0 +1,11 @@
+module BLS_API
+  module Constants
+    ENDPOINT_URL = "http://api.bls.gov/publicAPI/v2/timeseries/data/"
+
+    MAX_SERIES_PER_REQUEST = 50
+    MAX_YEARS_PER_REQUEST = 20
+
+    MAX_RETRIES = 3
+    TIME_BETWEEN_RETRIES = 5  # In seconds
+  end
+end

data/lib/bls_api/destringify.rb

@@ -0,0 +1,124 @@
+require "bigdecimal"
+
+module BLS_API
+  module Destringify
+    # Public: Convert numeric data in a BLS API response from Strings to
+    # instances of more useful Numeric subclasses for the user's convenience.
+    #
+    # (My guess is BLS sends data as strings in order to maintain precision and
+    # simplify the JSON conversion on their end.)
+    #
+    # raw_response  - A Hash of parsed JSON data from an API response, such as
+    #                 that returned by BLS_API::RawRequest#make_api_request.
+    # use_floats    - An optional Boolean specifying whether to express values
+    #                 as Floats (for simplicity) instead of as BigDecimals
+    #                 (for precision) (default: false).
+    #
+    # Returns a Hash similar to raw_response but with some keys and values
+    #   converted to Numerics.
+    def destringify(raw_response, use_floats = false)
+      output = {}
+
+      raw_response.keys.reject { |key| key == "Results" }.each do |key|
+        output[key] = raw_response[key]
+      end
+
+      output_results = {}
+      output["Results"] = output_results
+      raw_results = raw_response["Results"]
+      raw_results.keys.reject { |key| key == "series" }.each do |key|
+        output_results[key] = raw_results[key]
+      end
+
+      output_results["series"] = raw_results["series"].map do |raw_series|
+        self.destringify_series(raw_series, use_floats)
+      end
+
+      output
+    end
+
+    # Internal: Convert the keys and values in a calculations object (change in
+    # an indicator over the past {1,3,6,12} months) from Strings to Numerics.
+    #
+    # raw_calcs   - A Hash with String keys (specifying the number of months
+    #               over which a given change was calculated) and String values
+    #               (specifying the change over that period of time).
+    # use_floats  - An optional Boolean specifying whether to express values
+    #               as Floats (for simplicity) instead of as BigDecimals
+    #               (for precision) (default: false).
+    #
+    # Returns a Hash with Integer keys and BigDecimal values (to preserve
+    #   precision).
+    def destringify_calculations(raw_calcs, use_floats = false)
+      Hash[raw_calcs.each_pair.map do |key, value|
+        [
+          key.to_i,
+
+          case use_floats
+          when true then value.to_f
+          else BigDecimal.new(value)
+          end
+        ]
+      end]
+    end
+
+    # Internal: Convert all quantitative keys and values in a month object
+    # (statistics and optional changes corresponding to a particular
+    # series/month combination) from Strings to Numerics.
+    #
+    # raw_month   - A Hash for a given month's data point. Should contain
+    #               "year", "period" and "value" properties, at least.
+    # use_floats  - An optional Boolean specifying whether to express values
+    #               as Floats (for simplicity) instead of as BigDecimals
+    #               (for precision) (default: false).
+    #
+    # Returns a Hash with all of the same keys as `raw_month`.
+    def destringify_month(raw_month, use_floats = false)
+      output = {}
+
+      output["year"] = raw_month["year"].to_i
+      output["value"] = case use_floats
+                        when true then raw_month["value"].to_f
+                        else BigDecimal.new(raw_month["value"])
+                        end
+
+      if raw_month.include?("calculations")
+        output["calculations"] = Hash[
+          raw_month["calculations"].each_pair.map do |name, calcs|
+            [name, self.destringify_calculations(calcs, use_floats)]
+          end
+        ]
+      end
+
+      keys_to_pass_through = raw_month.keys.reject do |key|
+        ["year", "value", "calculations"].include?(key)
+      end
+      keys_to_pass_through.each { |key| output[key] = raw_month[key] }
+
+      output
+    end
+
+    # Internal: Convert numeric data in a BLS API series from Strings to
+    # Numerics.
+    #
+    # raw_series  - An Array of month Hashes from a BLS API response.
+    # use_floats  - An optional Boolean specifying whether to express values
+    #               as Floats (for simplicity) instead of as BigDecimals
+    #               (for precision) (default: false).
+    #
+    # Returns an Array of month Hashes after conversion by #destringify_month.
+    def destringify_series(raw_series, use_floats = false)
+      output = {}
+
+      raw_series.keys.reject { |key| key == "data" }.each do |key|
+        output[key] = raw_series[key]
+      end
+
+      output["data"] = raw_series["data"].map do |raw_month|
+        self.destringify_month(raw_month, use_floats)
+      end
+
+      output
+    end
+  end
+end

data/lib/bls_api/errors.rb

@@ -0,0 +1,8 @@
+module BLS_API
+  module Errors
+    class APIError < IOError; end
+    class ConfigurationError < ArgumentError; end
+    class NotRetrievedError < KeyError; end
+    class OptionsError < ArgumentError; end
+  end
+end

data/lib/bls_api/month.rb

@@ -0,0 +1,63 @@
+require "bls_api/errors"
+
+module BLS_API
+  class Month
+    def initialize(raw_month)
+      @raw_month = raw_month
+    end
+
+    def year
+      @raw_month["year"]
+    end
+
+    def month
+      @raw_month["period"].slice(/^M(\d+)$/, 1).to_i
+    end
+
+    def value
+      @raw_month["value"]
+    end
+
+    def footnotes
+      non_empty_footnotes = @raw_month["footnotes"].reject { |x| x.empty? }
+      Hash[non_empty_footnotes.map do |footnote|
+        [footnote["code"], footnote["text"]]
+      end]
+    end
+
+    def net_change(timeframe)
+      unless @raw_month.include?("calculations")
+        raise BLS_API::NotRetrievedError, "Calculations not retrieved"
+      end
+      net_changes = @raw_month["calculations"].fetch("net_changes") do
+        raise BLS_API::NotRetrievedError, (
+          "Net-change calculations not available from BLS")
+      end
+      net_changes.fetch(timeframe) do
+        raise BLS_API::NotRetrievedError, (
+          "#{timeframe}-month net changes not available from BLS")
+      end
+    end
+
+    def percent_change(timeframe)
+      unless @raw_month.include?("calculations")
+        raise BLS_API::NotRetrievedError, "Calculations not retrieved"
+      end
+      percent_changes = @raw_month["calculations"].fetch("pct_changes") do
+        raise BLS_API::NotRetrievedError, (
+          "Percent-change calculations not available from BLS")
+      end
+      percent_changes.fetch(timeframe) do
+        raise BLS_API::NotRetrievedError, (
+          "#{timeframe}-month percent changes not available from BLS")
+      end
+    end
+
+    def <=>(other)
+      year_comparison = self.year <=> other.year
+      return year_comparison unless year_comparison == 0
+
+      month_comparison = self.month <=> other.month
+    end
+  end
+end

data/lib/bls_api/raw_request.rb

@@ -0,0 +1,89 @@
+require "json"
+
+require "bls_api/constants"
+require "bls_api/errors"
+
+module BLS_API
+  module RawRequest
+    # Internal: Request a batch of data from the BLS API.
+    #
+    # By default, raises BLS_API::Errors::APIError if the request is
+    # unsuccessful. (You can catch this with an IOError, if that's more your
+    # thing.)
+    #
+    # options - A Hash with three required arguments and four optional
+    #           arguments.
+    #           Required arguments include:
+    #           :series_ids - An Array of String series IDs for which to
+    #                         request data. If a String is provided instead, it
+    #                         is assumed to be a single series ID.
+    #           :start_year - An Integer representing the earliest year for
+    #                         which to request data.
+    #           :end_year   - An Integer representing the latest year for which
+    #                         to request data. Note that the BLS API will
+    #                         return an error if you specify a year for which
+    #                         no data exists; for example, an :end_year of 2016
+    #                         will raise an error during January of 2016 when
+    #                         no 2016 data has yet been released.
+    #           Optional arguments include:
+    #           :catch_errors     - A Boolean specifying whether to raise an
+    #                               APIError if the request is unsuccessful
+    #                               (default: true).
+    #           :catalog          - A Boolean specifying whether to include
+    #                               catalog data in the response
+    #                               (default: true).
+    #           :calculations     - A Boolean specifying whether to include
+    #                               net-change and percent-change calculations
+    #                               in the response (default: true).
+    #           :annual_averages  - A Boolean specifying whether to include
+    #                               annual averages in the response
+    #                               (default: true).
+    #
+    # Returns a Hash of the parsed JSON response from the API.
+    def make_api_request(options = {})
+      # Ensure required arguments are provided.
+      series_ids = options.fetch(:series_ids) do
+        raise BLS_API::Errors::OptionsError, "Missing series IDs"
+      end
+      series_ids = [series_ids] if series_ids.is_a?(String)
+      start_year = options.fetch(:start_year) do
+        raise BLS_API::Errors::OptionsError, "Missing start year"
+      end
+      end_year = options.fetch(:end_year) do
+        raise BLS_API::Errors::OptionsError, "Missing end year"
+      end
+
+      # Build and make the API request.
+      endpoint_uri = URI.parse(BLS_API::Constants::ENDPOINT_URL)
+      req = Net::HTTP::Post.new(endpoint_uri.path)
+      req.body = {
+        "seriesid" => series_ids,
+        "startyear" => start_year.to_s,
+        "endyear" => end_year.to_s,
+        "annualaverage" => options.fetch(:annual_averages, true),
+        "calculations" => options.fetch(:calculations, true),
+        "catalog" => options.fetch(:catalog, true),
+        "registrationKey" => self.api_key
+      }.to_json
+      req.content_type = "application/json"
+      res = Net::HTTP.start(endpoint_uri.host, endpoint_uri.port) do |http|
+        http.request(req)
+      end
+
+      # Let the user know if the API request failed.
+      parsed = JSON.parse(res.body)
+      catch_errors = options.fetch(:catch_errors, true)
+      if catch_errors && parsed["status"] != "REQUEST_SUCCEEDED"
+        error_messages = %Q{"#{parsed["message"].join(%Q{", "})}"}
+        error_message = <<-EOF.gsub(/^ */, "").gsub(/\r?\n/, " ").strip
+          BLS API returned an error: #{parsed["status"]}
+          Additional messages were: #{error_messages}
+        EOF
+        raise BLS_API::Errors::APIError, error_message
+      end
+
+      # Return the whole API response.
+      parsed
+    end
+  end
+end

data/lib/bls_api/series.rb

@@ -0,0 +1,56 @@
+require "ostruct"
+
+require "bls_api/month"
+
+module BLS_API
+  class Series
+    include BLS_API::Destringify
+
+    attr_reader :id
+
+    def initialize(raw_series)
+      @id = raw_series["seriesID"]
+      begin
+        @raw_series = self.destringify_series(raw_series)
+      rescue ArgumentError
+        # Series was already destringified _and_ it was using Floats.
+        @raw_series = raw_series
+      end
+    end
+
+    # Public: Return catalog information for this series if available.
+    #
+    # Returns an OpenStruct if possible; returns nil if no catalog information
+    #   was received.
+    def catalog
+      return nil unless @raw_series.include?("catalog")
+      return @catalog unless @catalog.nil?
+      @catalog = OpenStruct.new(@raw_series["catalog"])
+    end
+
+    # Public: Return information for the given month.
+    #
+    # year  - An Integer representing the year for which to retrieve data.
+    # month - An Integer representing the month (1 = January) for which to
+    #         retrieve data.
+    #
+    # Returns a BLS_API::Month.
+    def get_month(year, month)
+      self.monthly  # Ensure we've converted all months.
+      @months.detect do |parsed_month|
+        parsed_month.year == year && parsed_month.month == month
+      end
+    end
+
+    # Public: Return information for all months.
+    #
+    # Returns an Array of BLS_API::Months.
+    def monthly
+      return @months unless @months.nil?
+      @months = @raw_series["data"].map do |month_data|
+        BLS_API::Month.new(month_data)
+      end
+      @months.sort!.reverse!
+    end
+  end
+end

data/lib/bls_api/version.rb

@@ -0,0 +1,3 @@
+module BLS_API
+  VERSION = "1.0.1"
+end

data/lib/bls_api.rb

@@ -0,0 +1,8 @@
+require "bls_api/client"
+require "bls_api/constants"
+require "bls_api/destringify"
+require "bls_api/errors"
+require "bls_api/month"
+require "bls_api/raw_request"
+require "bls_api/series"
+require "bls_api/version"

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: bls_api
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Justin Myers
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: API wrapper for data from the U.S. Bureau of Labor Statistics.
+email:
+- jmyers@ap.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bls_api.gemspec
+- lib/bls_api.rb
+- lib/bls_api/client.rb
+- lib/bls_api/constants.rb
+- lib/bls_api/destringify.rb
+- lib/bls_api/errors.rb
+- lib/bls_api/month.rb
+- lib/bls_api/raw_request.rb
+- lib/bls_api/series.rb
+- lib/bls_api/version.rb
+homepage: https://github.com/associatedpress/bls_api
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: API wrapper for data from the U.S. Bureau of Labor Statistics.
+test_files: []