govkit 0.0.2 → 0.1.0

data/lib/govkit/fifty_states.rb

@@ -1,188 +0,0 @@
-require 'httparty'
-
-module Govkit::FiftyStates
-
-  ROLE_MEMBER = "member"
-  ROLE_COMMITTEE_MEMBER = "committee member"
-  CHAMBER_UPPER = "upper"
-  CHAMBER_LOWER = "lower"
-
-  class FiftyStatesError < StandardError
-    attr_reader :response
-
-    def initialize(response, message = nil)
-      @response = response
-      @message  = message
-    end
-
-    def to_s
-      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
-    end
-  end
-
-  class NotauthorizedError < FiftyStatesError;
-  end
-
-  class InvalidRequestError < StandardError;
-  end
-
-  class NotFoundError < FiftyStatesError;
-  end
-
-  class NameError < FiftyStatesError;
-  end
-
-  class Base
-    include HTTParty
-    format :json
-    default_params :output => 'json', :apikey => Govkit::configuration.fiftystates_apikey
-    base_uri Govkit::configuration.fiftystates_base_url
-
-    attr_accessor :attributes
-
-    def initialize(attributes = {})
-      @attributes = {}
-      unload(attributes)
-    end
-
-    class << self
-      def instantiate_record(record)
-        new(record)
-      end
-
-      def instantiate_collection(collection)
-        collection.collect! { |record| instantiate_record(record) }
-      end
-      
-      def parse(json)
-        instantiate_record(json)
-      end
-    end
-
-    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
-    def resource_for_collection(name)
-      find_resource_for(name.to_s.singularize)
-    end
-
-    def find_resource_in_modules(resource_name, module_names)
-      receiver = Object
-      namespaces = module_names[0, module_names.size-1].map do |module_name|
-        receiver = receiver.const_get(module_name)
-      end
-      if namespace = namespaces.reverse.detect { |ns| ns.const_defined?(resource_name) }
-        return namespace.const_get(resource_name)
-      else
-        raise NameError, "Namespace for #{namespace} not found"
-      end
-    end
-
-    def find_resource_for(name)
-      resource_name = name.to_s.camelize
-      ancestors = self.class.name.split("::")
-      if ancestors.size > 1
-        find_resource_in_modules(resource_name, ancestors)
-      else
-        self.class.const_get(resource_name)
-      end
-    rescue NameError
-      #TODO: May be we should create new classes based on unknown records
-    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)]
-        when "]"
-          attributes[arguments.first.to_s]
-        else
-          attributes.has_key?(method_name) ? attributes[method_name] : super
-      end
-    end
-  end
-
-  class State < Base
-    def self.find_by_abbreviation(abbreviation)
-      response = get("/#{abbreviation}")
-      instantiate_record(response)
-    end
-  end
-
-  class Bill < Base
-    # http://fiftystates-dev.sunlightlabs.com/api/ca/20092010/lower/bills/AB667/
-    def self.find(state_abbrev, session, chamber, bill_id)
-      response = get("/#{state_abbrev}/#{session}/#{chamber}/bills/#{bill_id}/")
-      instantiate_record(response)
-    end
-
-    def self.search(query, options = {})
-      response = get('/bills/search', :query => {:q => query}.merge(options))
-      instantiate_collection(response)
-    end
-
-    def self.latest(updated_since, state_abbrev)
-      response = get('/bills/latest/', :query => {:updated_since => updated_since, :state => state_abbrev})
-      instantiate_collection(response)
-    end
-  end
-
-  class Legislator < Base
-    def self.find(legislator_id)
-      response = get("/legislators/#{legislator_id}")
-      instantiate_record(response)
-    end
-
-    def self.search(options = {})
-      response = get('/legislators/search', :query => options)
-      instantiate_collection(response)
-    end
-  end
-
-  class Session < Base; end
-
-  class Role < Base; end
-
-  class Action < Base; end
-
-  class Vote < Base
-    def self.find(vote_id)
-      response = get("/votes/#{vote_id}")
-      instantiate_record(response)
-    end
-  end
-
-  class Roll < Base; end
-
-  class Sponsor < Base; end
-
-  class Version < Base; end
-
-  class Source < Base; end
-end

data/lib/govkit/vote_smart.rb

@@ -1,146 +0,0 @@
-require 'httparty'
-
-module Govkit::VoteSmart
-  class VoteSmartError < StandardError
-    attr_reader :response
-
-    def initialize(response, message = nil)
-      @response = response
-      @message  = message
-    end
-
-    def to_s
-      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
-    end
-  end
-
-  class NotauthorizedError < VoteSmartError;
-  end
-
-  class InvalidRequestError < StandardError;
-  end
-
-  class NotFoundError < VoteSmartError;
-  end
-
-  class NameError < VoteSmartError;
-  end
-
-  class Base
-    include HTTParty
-    default_params :o => 'JSON', :key => Govkit::configuration.votesmart_apikey
-    base_uri Govkit::configuration.votesmart_base_url
-
-    attr_accessor :attributes
-
-    def initialize(attributes = {})
-      @attributes = {}
-      unload(attributes)
-    end
-
-    class << self
-      def instantiate_record(record)
-        new(record)
-      end
-
-      def instantiate_collection(collection)
-        collection.collect! { |record| instantiate_record(record) }
-      end
-
-      def parse(json)
-        instantiate_record(json)
-      end
-    end
-
-    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
-    def resource_for_collection(name)
-      find_or_create_resource_for(name.to_s.singularize)
-    end
-
-    def find_resource_in_modules(resource_name, module_names)
-      receiver = Object
-      namespaces = module_names[0, module_names.size-1].map do |module_name|
-        receiver = receiver.const_get(module_name)
-      end
-      if namespace = namespaces.reverse.detect { |ns| ns.const_defined?(resource_name) }
-        return namespace.const_get(resource_name)
-      else
-        raise NameError, "Namespace for #{namespace} not found"
-      end
-    end
-
-    def find_or_create_resource_for(name)
-      resource_name = name.to_s.camelize
-      ancestors = self.class.name.split("::")
-      if ancestors.size > 1
-        find_resource_in_modules(resource_name, ancestors)
-      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(Base))
-      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)]
-        when "]"
-          attributes[arguments.first.to_s]
-        else
-          attributes.has_key?(method_name) ? attributes[method_name] : super
-      end
-    end
-  end
-
-  class Address < Base
-    class << self
-      def find(candidate_id)
-        response = get("/Address.getOffice", :query => {"candidateId" => candidate_id})
-        instantiate_record(response['address'])
-      end
-    end
-  end
-
-  class WebAddress < Base
-    class << self
-      def find(candidate_id)
-        response = get("/Address.getOfficeWebAddress", :query => {"candidateId" => candidate_id})
-        instantiate_record(response['webaddress'])
-      end
-    end
-  end
-end