open_fda_api 0.0.3 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10a12a605aa07fbd3dfa75f7fdb9e909fc9eaa7b18f2add3449db666110c7d3f
-  data.tar.gz: 79207bf839e4a82f2a6a1f374645cc4e2a25cfa2923d4726aaf856d779b667dd
+  metadata.gz: adc99f4c0266329d56ee1cbc6592789908b09a98580136813e3d8033e33c2328
+  data.tar.gz: 6fc8dc376b266e216e5f263248cbae5342c655a50ba3aa1c9d37245a6b521bdf
 SHA512:
-  metadata.gz: 1a172a5bd14024af9dff624f3bf0c5cd22d09cb43cd7b5901b43d7b328e88d6cfbbabc8097be14ec456fe64b4e6ff661334687c24cb7141f217be52b4808ccfd
-  data.tar.gz: 375be0de9fbf21279fd5b0d00ebd16375455d99a3d1e672bfc6cdf3373aa04c3cc2c824b7deddb6104c8b39856365b2a54c8ef5ae04243682d830a72782f04f3
+  metadata.gz: 95da4769cc677e55b92f682bc4b7f05d98543cfcfa05f2d4786c8254e52a6399235e3850a11c7d70ba63dd61ea28e42fda25fc336e8ac1fb3710e9e9a4dc29ca
+  data.tar.gz: f93d3fa2ffc26fad6f9460333326d32f97f51f99dcd567b85ddd62b5ed4e5f868d4aff4bcc8183b37214927e7a03ff4e64fee534c8a98a1c2f5ffc3fe7ee619c

data/.rubocop.yml

@@ -12,3 +12,7 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*

data/CHANGELOG.md

@@ -1,6 +1,31 @@
 ## [Unreleased]
 
-## [0.0.2] - 2022-01-19
+## [0.0.9] - 2022-01-24
+- Filled out the following Drug endpoints:
+  - product_labeling
+  - ndc_directory
+  - recall_enforcement_reports
+  - drugs_at_fda
+
+## [0.0.8] - 2022-01-24
+- Delete the `OpenFdaApi.client` method since its only function was to forward messages
+
+## [0.0.7] - 2022-01-23
+- Use Faraday instead of using Net::HTTP directly
+- Introduce `QueryInputs` to group query params passed in together
+
+## [0.0.6] - 2022-01-21
+- Support for more query fields
+
+## [0.0.5] - 2022-01-20
+- Validate, against search fields given to us from openFDA API, when building queries.
+
+## [0.0.4] - 2022-01-19
+- Fix version string in changelog.
+- Update Query Builder to group search arguments properly.
+- Update Query Builder to replace spaces with pluses in search values as openFDA API documentation requires.
+
+## [0.0.3] - 2022-01-19
 - Update version again because CHANGELOG wasn't updated along with the 0.0.2 release.
 
 ## [0.0.2] - 2022-01-19

data/Gemfile.lock

@@ -1,16 +1,49 @@
 PATH
   remote: .
   specs:
-    open_fda_api (0.0.1)
+    open_fda_api (0.0.9)
+      faraday (~> 1.9)
+      faraday_middleware (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    coderay (1.1.3)
     diff-lcs (1.5.0)
+    faraday (1.9.3)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.3)
+      multipart-post (>= 1.2, < 3)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    faraday_middleware (1.2.0)
+      faraday (~> 1.0)
+    method_source (1.0.0)
+    multipart-post (2.1.1)
     parallel (1.21.0)
     parser (3.1.0.0)
       ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.2.0)
@@ -40,6 +73,7 @@ GEM
     rubocop-ast (1.15.1)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
     unicode-display_width (2.1.0)
 
 PLATFORMS
@@ -47,6 +81,7 @@ PLATFORMS
 
 DEPENDENCIES
   open_fda_api!
+  pry
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 1.7)

data/README.md

@@ -16,37 +16,64 @@ And then execute:
 bundle install
 ```
 
-## Documentation
+## Usage
 
-There are 5 main category of endpoints that openFDA API provides: Drug, Device, Food, Other, and Tobacco.
-
-Each category has further subcategories. Everything is accessible from the `OpenFdaApi.client`.
+```ruby
+client = OpenFdaApi.client
 
+# First 20 results where (fieldA=foo AND fieldB=bar) OR (fieldC=baz AND fieldA exists)
+# Sorted by (fieldD) in descending order
+# Skip the first 8 results
+args = { 
+  search: [{"fieldA" => "foo", "fieldB" => "bar"}, {"fieldC" => "baz", "_exists_" => "fieldA"}],
+  sort: [{"fieldD" => "desc"}],
+  skip: 8,
+  limit: 20 
+}
+
+# Drug API
+client.drugs.adverse_events(args)
+client.drugs.product_labeling(args)
+client.drugs.ndc_directory(args)
+client.drugs.recall_enforcement_reports(args)
+client.drugs.drugs_at_fda(args)
+
+# Device API
+client.device.premarket_501ks(args)
+client.device.classification(args)
+client.device.recall_enforcement_reports(args)
+client.device.adverse_events(args)
+client.device.premarket_approval(args)
+client.device.recalls(args)
+client.device.registrations_and_listings(args)
+client.device.covid19_serological_tests(args)
+client.device.unique_device_identifier(args)
+
+# Food API
+client.food.recall_enforcement_reports(args)
+client.food.adverse_events(args)
+
+# Other API
+client.other.nsde(args)
+client.other.substance_data_reports(args)
+
+# Tobacco API
+client.tobacco.problem_reports(args)
+```
 
-### Drug
+### Querying
 
-The Drug API has the following endpoints: Adverse Events, Product Labeling, NDC Directory, Recall Enforcement Reports, and Drugs@FDA.
+The openFDA API can be queried with these arguments: `search`, `sort`, `count`, `skip`, and `limit`.
 
-Here's how you interact with each:
+`search`, `sort`, and `count` have the same format. They are arrays of hashes. Each hash has a set of fields and values
+that are ANDed together and all the elements in the array are ORed together. Here are some examples to illustrate:
 
-#### Adverse Events
 ```ruby
-require 'open_fda_api'
+search = [{"patient.drug.openfda.pharm_class_epc" => "nonsteroidal+anti-inflammatory+drug" }]
 
-client = OpenFdaApi.client
-drugs_api = client.drugs
-
-arguments = [{"patient.reaction.reactionmeddrapt"=>"fatigue"}, {"occurcountry"=>"ca"}]
-drugs_api.adverse_events(search_arguments: arguments) # => {"meta" => {...}, "results" => [...]}
+# patient.drug.openfda.pharm_class_epc:"nonsteroidal+anti-inflammatory+drug"&count=patient.reaction.reactionmeddrapt.exact
 ```
 
-### Device (Not Implemented Yet)
-### Food (Not Implemented Yet)
-### Other (Not Implemented Yet)
-### Tobacco (Not Implemented Yet)
-
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/bin/console

@@ -11,5 +11,8 @@ require "open_fda_api"
 # require "pry"
 # Pry.start
 
+client = OpenFdaApi::Client.new
+puts "Client is ready: #{client}"
+
 require "irb"
 IRB.start(__FILE__)

data/lib/open_fda_api/client.rb

@@ -1,18 +1,34 @@
 # frozen_string_literal: true
 
-require_relative "./drugs"
+require "faraday"
+require "faraday_middleware"
 
 module OpenFdaApi
   # Gives you access to the main nouns in the openFDA API
   class Client
-    attr_reader :api_key
+    attr_reader :api_key, :adapter
 
-    def initialize(api_key: nil)
+    BASE_URL = "https://api.fda.gov"
+
+    def initialize(api_key: nil, adapter: Faraday.default_adapter, stubs: nil)
       @api_key = api_key
+      @adapter = adapter
+      @stubs   = stubs
     end
 
     def drugs
-      OpenFdaApi::Drugs.new
+      OpenFdaApi::Drugs.new(self)
+    end
+
+    def connection
+      @connection ||= Faraday.new(BASE_URL) do |conn|
+        conn.request :json
+
+        conn.response :dates
+        conn.response :json, content_type: "application/json"
+
+        conn.adapter adapter, @stubs
+      end
     end
   end
 end

data/lib/open_fda_api/drugs.rb

@@ -2,7 +2,7 @@
 
 require "net/http"
 require "json"
-require "open_fda_api/query_builder"
+require "yaml"
 
 module OpenFdaApi
   # Interact with the Drugs API Endpoint:
@@ -12,36 +12,100 @@ module OpenFdaApi
   #  - Recall Enforcement Reports
   #  - Drugs@FDA)
   class Drugs
-    def initialize
+    attr_reader :client, :path_base
+
+    def initialize(client)
+      @client = client
       @host = "api.fda.gov"
       @path_base = "/drug"
     end
 
-    # The openFDA drug adverse event API returns data that has been collected from the
-    # FDA Adverse Event Reporting System (FAERS), a database that contains information on
-    # adverse event and medication error reports submitted to FDA.
-    #
-    # @param search_arguments [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def adverse_events(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "event.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, self.class.valid_adverse_events_fields)
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
     # @return Response from the API parsed as JSON
-    def adverse_events(search_arguments: [])
-      endpoint = "/event.json"
-      query    = build_query(search_arguments)
-      url      = build_url(endpoint, query)
-      make_request(url)
+    def product_labeling(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "label.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def ndc_directory(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "ndc.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def recall_enforcement_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "enforcement.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def drugs_at_fda(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "drugsfda.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    def self.valid_adverse_events_fields
+      @valid_adverse_events_fields ||= ::YAML.load_file("#{__dir__}/adverse_events_fields.yml")
     end
 
     private
 
-    def build_url(endpoint, query)
-      URI::HTTPS.build(host: @host, path: @path_base + endpoint, query: query)
+    def build_query(query_input, valid_search_fields)
+      QueryBuilder.new(query_input: query_input, valid_search_fields: valid_search_fields).build_query
     end
 
-    def build_query(search_arguments)
-      QueryBuilder.new(search: search_arguments).build_query
+    def build_inputs(search:, sort:, count:, skip:, limit:)
+      QueryInputs.new(search: search, sort: sort, count: count, skip: skip, limit: limit)
     end
 
-    def make_request(url)
-      JSON.parse(Net::HTTP.get(url))
+    def make_request(endpoint, query)
+      url = "#{path_base}/#{endpoint}"
+      if query.empty?
+        client.connection.get(url)
+      else
+        client.connection.get(url, query)
+      end.body
     end
   end
 end

data/lib/open_fda_api/query_builder.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module OpenFdaApi
+  class InvalidQueryArgument < ArgumentError; end
+
   # A helper to build queries against the openFDA API
   #
   # The API supports five query parameters. The basic building block of queries is the search parameter.
@@ -23,34 +25,81 @@ module OpenFdaApi
   #   Use in combination with limit to paginate results. Currently, the largest allowed value for the skip parameter
   #   is 25000. See Paging if you require paging through larger result sets.
   class QueryBuilder
-    # @param [Array<Hash>] search
-    def initialize(search: [])
-      @search = build_search_string(search)
+    # @param [Hash] valid_search_fields
+    # @param [QueryInput] query_input
+    def initialize(query_input:, valid_search_fields:)
+      # TODO: Turn validations back on once we get basic functionality working; need to flex on different field types
+      # validate_arguments!(valid_search_fields, query_input: query_input)
+      warn "You've passed in a valid_search_fields arg but it isn't being used right now..." if valid_search_fields
+      @search = build_query_string(query_fields: query_input.search)
+      @sort   = build_query_string(query_fields: query_input.sort)
+      @count  = build_query_string(query_fields: query_input.count)
+      @skip   = build_skip_string(query_input.skip)
+      @limit  = query_input.limit
     end
 
-    # @return [String] the query string portion of a request
+    # @return [Hash] the query string portion of a request
     def build_query
-      # TODO: We currently just build a very basic search string for simple examples like "search=a:b+AND+c:d",
-      # but it is possible to construct more complex queries and we will need to support that. Sorting, counting,
-      # setting limits, skipping records, pagination, converting spaces, phrase matching, grouping, and using dates and
-      # ranges are examples of more complex queries that can be built.
-      @search
+      {
+        search: @search,
+        sort: @sort,
+        count: @count,
+        skip: @skip,
+        limit: @limit
+      }.compact.reject { |_k, v| v.to_s.empty? }
     end
 
     private
 
-    def build_search_string(search)
-      return "" if search.empty?
+    def validate_arguments!(valid_search_fields, query_input:)
+      # `search` keys must exist in adverse_events_fields.yml
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.search)
+      raise InvalidQueryArgument, "'search' has invalid fields: #{invalid_fields}" if invalid_fields.any?
+
+      # `sort` keys must exist in adverse_events_fields.yml
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.sort)
+      raise InvalidQueryArgument, "'sort' has invalid fields: #{invalid_fields}" if invalid_fields.any?
+
+      # `count` keys must exist in adverse_events_fields.yml
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.count)
+      raise InvalidQueryArgument, "'count' has invalid fields: #{invalid_fields}" if invalid_fields.any?
+
+      # `count` and `skip` cannot be set at the same time
+      return unless count_and_skip_set?(query_input.count, query_input.skip)
+
+      raise InvalidQueryArgument, "'count' and 'skip' cannot both be set at the same time!"
+    end
+
+    def build_query_string(query_fields:)
+      return "" if query_fields.empty?
 
-      value = if search.count == 1 # AND case
-                # Turns [{a: b, c: d}] into "a:b+AND+c:d"
-                search.first.map { |k, v| "#{k}:#{v}" }.join("+AND+")
-              else # OR case
-                # Turns [{a: b}, {c: d}] into "a:b+c:d"
-                search.map { |h| "#{h.keys.first}:#{h.values.first}" }.join("+")
-              end
+      build_groupings(query_fields).to_s
+    end
+
+    def build_skip_string(skip)
+      skip.positive? ? skip.to_s : ""
+    end
+
+    def build_groupings(fields)
+      fields.map do |and_args|
+        "(#{and_args.map { |k, v| "#{k}:#{v.gsub(" ", "+")}" }.join("+AND+")})"
+      end.join("+")
+    end
+
+    def get_invalid_fields(valid_search_fields:, fields:)
+      # TODO: valid_search_fields define types and we need to check against those
+      fields.map(&:keys).flatten.select do |field|
+        if field.include?(".") # nested field (e.g. patient.patientagegroup)
+          dig_values = field.split(".").join(",properties,").split(",")
+          valid_search_fields["properties"].dig(*dig_values).nil?
+        else
+          !valid_search_fields["properties"].keys.include?(field.to_s)
+        end
+      end
+    end
 
-      "search=#{value}"
+    def count_and_skip_set?(count, skip)
+      skip.positive? && !count.empty?
     end
   end
 end

data/lib/open_fda_api/query_inputs.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Group of inputs to build the query against the API with
+  class QueryInputs
+    attr_reader :search, :sort, :count, :skip, :limit
+
+    def initialize(**params)
+      @search = params[:search] || []
+      @sort   = params[:sort]   || []
+      @count  = params[:count]  || []
+      @skip   = params[:skip]   || 0
+      @limit  = params[:limit]  || nil
+    end
+  end
+end

data/lib/open_fda_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenFdaApi
-  VERSION = "0.0.3"
+  VERSION = "0.0.9"
 end

data/lib/open_fda_api.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "open_fda_api/version"
-require_relative "open_fda_api/client"
 
 # A Ruby wrapper for the openFDA API: https://open.fda.gov/apis/
 module OpenFdaApi
   class Error < StandardError; end
 
-  def self.client(api_key: nil)
-    OpenFdaApi::Client.new(api_key: api_key)
-  end
+  autoload :Client, "open_fda_api/client"
+  autoload :Drugs,  "open_fda_api/drugs"
+  autoload :QueryInputs, "open_fda_api/query_inputs"
+  autoload :QueryBuilder, "open_fda_api/query_builder"
 end

data/open_fda_api.gemspec

@@ -27,7 +27,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "faraday", "~> 1.9"
+  spec.add_dependency "faraday_middleware", "~> 1.2"
+
+  spec.add_development_dependency "pry"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: open_fda_api
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.9
 platform: ruby
 authors:
 - Hebron George
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-19 00:00:00.000000000 Z
-dependencies: []
+date: 2022-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: 
 email:
 - hebrontgeorge@gmail.com
@@ -35,6 +77,7 @@ files:
 - lib/open_fda_api/client.rb
 - lib/open_fda_api/drugs.rb
 - lib/open_fda_api/query_builder.rb
+- lib/open_fda_api/query_inputs.rb
 - lib/open_fda_api/version.rb
 - open_fda_api.gemspec
 homepage: https://github.com/hebron-george/open_fda_api