govkit-h 0.7.1.0

data/lib/gov_kit/open_states.rb

@@ -0,0 +1,132 @@
+module GovKit
+
+  # Parent class for OpenStates resources
+  # See http://openstates.sunlightlabs.com/api/
+  class OpenStatesResource < Resource
+
+    # Uses default_params from the HTTParty gem.
+    # See HTTParty::ClassMethods:
+    # http://rubydoc.info/gems/httparty/0.7.4/HTTParty/ClassMethods#default_params-instance_method
+    default_params :output => 'json', :apikey => GovKit::configuration.sunlight_apikey
+    base_uri GovKit::configuration.openstates_base_url
+
+    # Do a GET query, with optional parameters.
+    #
+    # OpenStates returns a 404 error when a query
+    # returns nothing.
+    #
+    # So, if a query result is a resource not found error,
+    # we return an empty set.
+    def self.get_uri(uri, options={})
+      begin
+        response = get(uri, options)
+        result = parse(response)
+      rescue ResourceNotFound
+        return []
+      end
+      result
+    end
+
+  end
+
+  # Ruby module for interacting with the Open States Project API
+  # See http://openstates.sunlightlabs.com/api/
+  # Most +find+ and +search+ methods: 
+  # * call HTTParty::ClassMethods#get
+  # * which returns an HTTParty::Response object
+  # * which is passed to GovKit::Resource#parse
+  # * which uses the response to populate a Resource
+  #
+  module OpenStates
+    ROLE_MEMBER = "member"
+    ROLE_COMMITTEE_MEMBER = "committee member"
+    CHAMBER_UPPER = "upper"
+    CHAMBER_LOWER = "lower"
+
+    # The State class represents the state data returned from Open States.
+    #
+    # For details about fields returned, see the Open States documentation, at 
+    # http://openstates.sunlightlabs.com/api/metadata/, 
+    #
+    class State < OpenStatesResource
+      def self.find_by_abbreviation(abbreviation)
+        get_uri("/metadata/#{abbreviation}/")
+      end
+    end
+
+    # The Bill class represents the bill data returned from Open States.
+    #
+    # For details about fields returned, see the Open States documentation, at 
+    # http://openstates.sunlightlabs.com/api/bills/, 
+    #
+    class Bill < OpenStatesResource
+      # http://openstates.sunlightlabs.com/api/v1/bills/ca/20092010/AB 667/
+      def self.find(state_abbrev, session, bill_id, chamber = '')
+        escaped_bill_id = bill_id.gsub(/ /, '%20')
+        escaped_session = session.gsub(/ /, '%20')
+
+        get_uri("/bills/#{state_abbrev.downcase}/#{escaped_session}/#{chamber.blank? ? '' : chamber + '/'}#{escaped_bill_id}/")
+      end
+
+      def self.search(query, options = {})
+        result = get_uri('/bills/', :query => {:q => query}.merge(options))
+        return Array(result)
+      end
+
+      def self.latest(updated_since, ops = {})
+        response = get('/bills/', :query => {:updated_since => updated_since.to_s}.merge(ops))
+        parse(response)
+      end
+    end
+
+    # The Legislator class represents the legislator data returned from Open States.
+    #
+    # For details about fields returned, see the Open States documentation, at 
+    # http://openstates.sunlightlabs.com/api/legislators/, 
+    #
+    class Legislator < OpenStatesResource
+      def self.find(legislator_id)
+        get_uri("/legislators/#{legislator_id}/")
+      end
+
+      def self.search(options = {})
+        result = get_uri('/legislators/', :query => options)
+        return Array(result)
+      end
+    end
+    
+    # The Committee class represents the committee data returned from Open States.
+    #
+    # For details about fields returned, see the Open States documentation, at 
+    # http://openstates.sunlightlabs.com/api/committees/, 
+    #
+    class Committee < OpenStatesResource
+      def self.find(committee_id)
+        get_uri("/committees/#{committee_id}/")
+      end
+
+      def self.search(options = {})
+        get_uri('/committees/', :query => options)
+      end
+    end
+    
+    class Role < OpenStatesResource; end
+
+    class Sponsor < OpenStatesResource; end
+
+    class Version < OpenStatesResource; end
+
+    class Source < OpenStatesResource; end
+
+    class Address < OpenStatesResource; end
+
+    class Action < OpenStatesResource; end
+
+    class Vote < OpenStatesResource
+      def self.find(vote_id)
+        response = get("/votes/#{vote_id}/")
+        parse(response)
+      end
+    end
+  end
+end

data/lib/gov_kit/railtie.rb

@@ -0,0 +1,24 @@
+require 'govkit'
+
+module GovKit
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'govkit.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          GovKit::Railtie.insert
+        end
+      end
+    end
+  end
+
+  # This class exists in order to run its insert method while
+  # Rails is loading.
+  # This then adds GovKit::ActsAsNoteworthy to ActiveRecord::Base.
+  # See http://api.rubyonrails.org/classes/Rails/Railtie.html
+  class Railtie
+    def self.insert
+      ActiveRecord::Base.send(:include, GovKit::ActsAsNoteworthy)
+    end
+  end
+end

data/lib/gov_kit/resource.rb

@@ -0,0 +1,190 @@
+module GovKit
+
+
+  # This is the parent class for the classes that wrap
+  # the data returned to govkit.
+  #
+  # Subclasses are responsible for fetching the data from 
+  # different web services; Resource will then parse the returned data,
+  # converting returned fields to instance methods.
+  #
+  # Initialize a Resource with a hash of attributes, or an array of hashes.
+  # For each attribute, add a getter and setter to this instance.
+  # @example
+  #   res = Resource.new { "aaa" => "111", "bbb" => "222", "ccc" => "333" }
+  #   res.aaa == "111"
+  #   res.bbb == "222"
+  #   res.ccc == "333"
+  #
+  # Includes {http://rdoc.info/github/jnunemaker/httparty/master/HTTParty/ClassMethods HTTParty}, which provides convenience methods like get().
+  class Resource
+    include HTTParty
+    format :json
+
+    # The attributes data returned by the service.
+    attr_reader :attributes
+
+    # The response returned by the service.
+    attr_reader :raw_response
+
+    def initialize(attributes = {})
+      @attributes = {}
+      @raw_response = attributes
+
+      unload(attributes)
+    end
+
+    # @return [Hash] the response object, potentially useful for comparison on sync
+    #
+    def to_md5
+      Digest::MD5.hexdigest(@raw_response.body)
+    end
+
+    # Handles the basic responses we might get back from a web service.
+    #
+    # On failure, throws an error.
+    #
+    # If a service returns something other than a 404 when an object is not found,
+    # you'll need to handle that in the subclass.
+    #
+    # @param [Object] response the object.
+    # @return [Resource] a new Resource created from the response.
+    #
+    def self.parse(response)
+
+      if response.class == HTTParty::Response
+        case response.response
+          when Net::HTTPNotFound
+            raise ResourceNotFound, "404 Not Found"
+          when Net::HTTPGone
+            raise ResourceNotFound, "404 Not Found"
+          when Net::HTTPUnauthorized
+            raise NotAuthorized, "401 Not Authorized; have you set up your API key?"
+          when Net::HTTPServerError
+            raise ServerError, '5xx server error'
+          when Net::HTTPClientError
+            raise ClientError, '4xx client error'
+        end
+      end
+
+      return [] unless !response.blank?
+
+      instantiate(response)
+    end
+
+    # Instantiate new GovKit::Resources.
+    #
+    # @param [Hash] record a hash of values returned by a service, or an array of hashes.
+    # @return [Resource]
+    #
+    # If +record+ is a hash, return a single GovKit::Resource.
+    # If it is an array, return an array of GovKit::Resources.
+    #
+    def self.instantiate(record)
+      if record.is_a?(Array)
+        instantiate_collection(record)
+      else
+        new(record)
+      end
+    end
+
+    # Instantiate a set of records.
+    #
+    # @return [Array] Array of records
+    # @param [Array] collection An array of records
+    def self.instantiate_collection(collection)
+      collection.collect! { |record| new(record) }
+    end
+
+    # Given a hash of attributes, assign it to the @attributes member.
+    # Then for each attribute, create or set a pair of member accessors with the name
+    # of the attribute's key.
+    #
+    # If the value of the attribute is itself an array or a hash,
+    # then create a new class with the (singularized) key as a name, and with a parent class of Resource,
+    # and initialize it with the hash.
+    #
+    # @param [Hash] attributes the attributes returned by the web service.
+    #
+    def unload(attributes)
+      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+
+      attributes.each do |key, value|
+        @attributes[key.to_s] =
+          case value
+            when Array
+              resource = resource_for_collection(key)
+              value.map do |attrs|
+                if attrs.is_a?(String) || attrs.is_a?(Numeric)
+                  attrs.duplicable? ? attrs.dup : attrs
+                else
+                  resource.new(attrs)
+                end
+              end
+            when Hash
+              resource = find_or_create_resource_for(key)
+              resource.new(value)
+            else
+              value.dup rescue value
+          end
+      end
+      self
+    end
+
+    private
+
+    # Finds a member of the GovKit module with the given name.
+    # If the resource doesn't exist, creates it.
+    #
+    def resource_for_collection(name)
+      find_or_create_resource_for(name.to_s.singularize)
+    end
+
+    # Searches each module in +ancestors+ for members named +resource_name+
+    # Returns the named resource
+    # Throws a NameError if none of the resources in the list contains +resource_name+
+    #
+    def find_resource_in_modules(resource_name, ancestors)
+      if namespace = ancestors.detect { |a| a.constants.include?(resource_name.to_sym) }
+        return namespace.const_get(resource_name)
+      else
+        raise NameError, "Namespace for #{namespace} not found"
+      end
+    end
+
+    # Searches the GovKit module for a resource with the name +name+, cleaned and camelized
+    # Returns that resource.
+    # If the resource isn't found, it's created.
+    #
+    def find_or_create_resource_for(name)
+      resource_name = name.to_s.gsub(/^[_\-+]/,'').gsub(/^(\-?\d)/, "n#{$1}").gsub(/(\s|-)/, '').camelize
+      if self.class.parents.size > 1
+        find_resource_in_modules(resource_name, self.class.parents)
+      else
+        self.class.const_get(resource_name)
+      end
+    rescue NameError
+      if self.class.const_defined?(resource_name)
+        resource = self.class.const_get(resource_name)
+      else
+        resource = self.class.const_set(resource_name, Class.new(GovKit::Resource))
+      end
+      resource
+    end
+
+    def method_missing(method_symbol, * arguments) #:nodoc:
+      method_name = method_symbol.to_s
+
+      case method_name.last
+        when "="
+          attributes[method_name.first(-1)] = arguments.first
+        when "?"
+          !attributes[method_name.first(-1)].blank?
+        when "]"
+          attributes[arguments.first.to_s]
+        else
+          attributes.has_key?(method_name) ? attributes[method_name] : super
+      end
+    end
+  end
+end

data/lib/gov_kit/search_engines.rb

@@ -0,0 +1,7 @@
+module GovKit::SearchEngines
+  autoload :GoogleNews, 'gov_kit/search_engines/google_news'
+  autoload :GoogleBlog, 'gov_kit/search_engines/google_blog'
+  autoload :Technorati, 'gov_kit/search_engines/technorati'
+  autoload :Bing, 'gov_kit/search_engines/bing'
+  autoload :Wikipedia, 'gov_kit/search_engines/wikipedia'
+end

data/lib/gov_kit/search_engines/bing.rb

@@ -0,0 +1,38 @@
+module GovKit
+  module SearchEngines
+    class Bing
+      def self.search(query=[], options={})
+        host = GovKit::configuration.bing_base_url
+        query = [query, options[:geo]].compact.join('+')
+
+        options['Sources'] ||= 'news'
+
+        path = "/json.aspx?Query=#{URI::encode(query)}&AppId=#{GovKit::configuration.bing_appid}&Sources=#{options['Sources']}"
+
+        doc = JSON.parse(make_request(host, path))
+
+        mentions = []
+
+        if news_items = doc['SearchResponse']['News']
+          puts "#{news_items['Results'].size} from Bing"
+          news_items['Results'].each do |i|
+            mention = GovKit::Mention.new
+            mention.title = i['Title']
+            mention.search_source = 'Bing'
+            mention.date = DateTime.parse(i['Date'])
+            mention.excerpt = i['Snippet']
+            mention.source = i['Source']
+            mention.url = i['Url']
+
+            mentions << mention
+          end
+        end
+        mentions
+      end
+
+      def self.make_request(host, path)
+        Net::HTTP.get(host, path)
+      end
+    end
+  end
+end

data/lib/gov_kit/search_engines/google_blog.rb

@@ -0,0 +1,32 @@
+module GovKit
+  module SearchEngines
+    class GoogleBlog
+      def self.search(query=[], options = {})
+        query = [query, options[:geo]].compact.join('+')
+        host = GovKit::configuration.google_blog_base_url
+        path = "/blogsearch_feeds?q=#{URI::encode(query)}&hl=en&output=rss&num=50"
+
+        doc = Nokogiri::XML(make_request(host, path))
+
+        mentions = []
+
+        doc.xpath('//item').each do |i|
+          mention = GovKit::Mention.new
+          mention.title = i.xpath('title').inner_text
+          mention.search_source = 'Google Blogs'
+          mention.date = i.xpath('dc:date').inner_text
+          mention.excerpt = i.xpath('description').inner_text
+          mention.source = i.xpath('dc:publisher').inner_text
+          mention.url = i.xpath('link').inner_text
+
+          mentions << mention
+        end
+        mentions
+      end
+
+      def self.make_request(host, path)
+        response = Net::HTTP.get(host, path)
+      end
+    end
+  end
+end

data/lib/gov_kit/search_engines/google_news.rb

@@ -0,0 +1,47 @@
+module GovKit
+  module SearchEngines
+
+    # Class to wrap access to Google News.
+    class GoogleNews
+
+      # Fetches stories about a topic from google news.
+      # Returns an array of GovKit::Mention objects.
+      #
+      # query: The query wanted For example:
+      # mentions = GoogleNews.search("Nancy Pelosi")
+      #
+      # options: Any additional parameters to the search. eg.:
+      # :geo => 'Texas' will add &geo=Texas to the URL.
+      # :num => 100 will show 100 results per page.
+      # 
+      def self.search(query=[], options={})
+        query = Array(query).join('+')
+        host = GovKit::configuration.google_news_base_url
+        options[:num] ||= 50
+
+        path = "/news?q=#{URI::encode(query)}&output=rss" + '&' + options.map { |k, v| URI::encode(k.to_s) + '=' + URI::encode(v.to_s) }.join('&')
+
+        doc = Nokogiri::XML(make_request(host, path))
+
+        mentions = []
+
+        doc.xpath('//item').each do |i|
+          mention = GovKit::Mention.new
+          mention.title = i.xpath('title').inner_text.split(" - ").first
+          mention.date = i.xpath('pubDate').inner_text
+          mention.excerpt = i.xpath('description').inner_text
+          mention.source = i.xpath('title').inner_text.split(" - ").last
+          mention.url = i.xpath('link').inner_text
+
+          mentions << mention
+        end
+
+        mentions
+      end
+
+      def self.make_request(host, path)
+        response = Net::HTTP.get(host, path)
+      end
+    end
+  end
+end