get_your_rep 0.1.9 → 1.0.0

data/lib/get_your_rep/delegation.rb

@@ -1,87 +1,69 @@
+# frozen_string_literal: true
 module GetYourRep
-
-  # The Delegation class inherits from Array and describes methods that can be called on a Delegation for ease of display and database query.
-  class Delegation < Array
-
-    # Overloads the << operator so the receiving object is not overwritten as an Array, and there are no nested Delegations.
-    def <<(value)
-
-      if value.is_a?(Delegation) || value.is_a?(Array)
-        self.replace(self + value)
-      else
-        super
-      end
-
-    end
-
-    # Overloads the + operator to return a new Delegation instead of an Array.
-    def +(value)
-      super.to_del
-    end
-
-    # Overloads #reverse to return a new Delegation instead of an Array.
-    def reverse
-      self.replace(super)
-    end
-
-    # Collects the first names of every rep in the Delegation.
-    def first_names
-      self.map { |rep| rep.first_name }
-    end
-
-    # Collects the last names of every rep in the Delegation.
-    def last_names
-      self.map { |rep| rep.last_name }
-    end
-
-    # Maps all rep business cards.
-    def business_cards
-      self.map { |rep| rep.business_card }
+  # The Delegation class holds an array of Representative objects. It can enumerate on its reps.
+  class Delegation
+    include Enumerable
+    include GetYourRep::Errors
+
+    # Set the reps attribute, which will hold an array of Representative objects, to an empty array by default.
+    def initialize
+      @reps = []
     end
 
-    # Get the [1] index.
-    def second
-      self[1]
+    # Defines the enumerator methods on the :reps attribute.
+    def each(&block)
+      @reps.each(&block)
     end
 
-    # Get the [2] index.
-    def third
-      self[2]
+    # Merge reps with another Delegation. This will add the reps of other to the reps of self,
+    # and leave other unchanged. Only accepts a Delegation as an argument.
+    def merge(other)
+      if other.is_a?(self.class)
+        other.reps.each { |rep| add_rep(rep) }
+        self
+      else
+        not_a_del_error
+      end
     end
 
-    # Get the [3] index.
-    def fourth
-      self[3]
+    # Returns a frozen duplicate of the reps array.
+    def reps
+      @reps.dup.freeze
     end
 
-    # Get the [4] index.
-    def fifth
-      self[4]
+    # Empties the reps array.
+    def clear_reps
+      @reps.clear
     end
 
-    # Get the [5] index.
-    def sixth
-      self[5]
+    # Add a Representative to the reps array. Only accepts a Representative as an argument.
+    def add_rep(other)
+      if other.is_a?(Representative)
+        @reps << other
+        other.delegation = self unless other.delegation == self
+      else
+        not_a_rep_error
+      end
     end
 
-    # Get the [6] index.
-    def seventh
-      self[6]
+    # Collects the OfficeLocations of all associated reps.
+    def office_locations
+      map(&:office_locations).flatten
     end
 
-    # Get the [7] index.
-    def eigth
-      self[7]
+    # Collects the full names of all associated reps.
+    def names
+      map(&:name)
     end
 
-    # Get the [8] index.
-    def ninth
-      self[8]
+    # Collects the first names of all associated reps.
+    def first_names
+      map(&:first_name)
     end
 
-    # Get the [9] index.
-    def tenth
-      self[9]
+    # Collects the last names of all associated reps.
+    def last_names
+      map(&:last_name)
     end
   end
 end

data/lib/get_your_rep/errors.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module GetYourRep
+  # Custom Error handling classes and methods.
+  module Errors
+    # Errors for invalid or inadequate addresses.
+    class AddressError < ArgumentError
+      # Raise when the address is not a string or an integer.
+      # Supports integers for zip codes.
+      def invalid_address_type
+        'Entry must be of types String or Integer'
+      end
+
+      # Raise when a rep cannot be found with the given parameters.
+      def reps_not_found
+        "Error message received. Some reps were not found. Confirm your address and check your parameters. \
+Try a full address if you used a zip."
+      end
+    end
+
+    # Errors raised when type-specific operations are performed invalidly.
+    # These operations will generally be association-building operations.
+    class GetYourRepTypeError < TypeError
+      def not_a_rep # :nodoc:
+        'Object must be a Representative.'
+      end
+
+      def not_an_office # :nodoc:
+        'Object must be an OfficeLocation.'
+      end
+
+      def not_a_delegation # :nodoc:
+        'Object must be a Delegation.'
+      end
+    end
+
+    # Error raised when CLI command is invalid.
+    class CommandNotFoundError < NoMethodError
+      def command_not_found # :nodoc:
+        "Command not found. Use 'help' command for a list of possible commands."
+      end
+    end
+
+    def not_an_office_error # :nodoc:
+      raise GetYourRepTypeError
+    rescue GetYourRepTypeError => error
+      puts error.not_an_office
+    end
+
+    def not_a_del_error # :nodoc:
+      raise GetYourRepTypeError
+    rescue GetYourRepTypeError => error
+      puts error.not_a_delegation
+    end
+
+    def not_a_rep_error # :nodoc:
+      raise GetYourRepTypeError
+    rescue GetYourRepTypeError => error
+      puts error.not_a_rep
+    end
+
+    def address_type_error # :nodoc:
+      raise AddressError
+    rescue AddressError => error
+      puts error.invalid_address_type.bold.red
+    end
+
+    def command_not_found_error # :nodoc:
+      raise CommandNotFoundError
+    rescue CommandNotFoundError => error
+      puts error.command_not_found.bold.red
+    end
+
+    def reps_not_found_error # :nodoc:
+      raise AddressError
+    rescue AddressError => error
+      puts error.reps_not_found.bold.red
+    end
+  end
+end

data/lib/get_your_rep/get_your_rep_module.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# GetYourRep module functions.
+module GetYourRep
+  module_function
+
+  include GetYourRep::Errors
+
+  # Get all reps using Google for national legislators,
+  # and OpenStates for state reps.
+  def all_reps(address)
+    @delegation = Google.all_reps(address, congress_only: true)
+    open_states = OpenStates.all_reps(address)
+    @delegation.merge(open_states)
+  end
+
+  # Check if an address value is a zip code or a full address.
+  def address_is_a_zip?(address)
+    address = convert_int_address_to_string(address)
+    if address.is_a?(String)
+      address =~ /^\d{5}(-\d{4})?$/ ? true : false
+    else
+      address_type_error
+    end
+  end
+
+  # Convert a zip code to a street address using Geocoder to convert zip to coordinates
+  # and coordinates to an address.
+  def convert_zip_to_address(address)
+    @coordinates = Geocoder.coordinates(address)
+    address      = Geocoder.address(@coordinates)
+    trim_street_number(address)
+  end
+
+  # If a street number is a range reduce it to one number.
+  def trim_street_number(address)
+    address    = address.split(' ')
+    address[0] = address[0].split('-').shift
+    address.join(' ')
+  end
+
+  # Parses a String address and prepares for an HTTP request. Accepts Strings and Integers as args.
+  def parse_address(address)
+    address = convert_int_address_to_string(address)
+    if address.is_a?(String)
+      address.tr(',', '').split.join('%20')
+    else
+      address_type_error
+    end
+  end
+
+  # Geocode an address and returns the coordinates.
+  def get_coordinates(address)
+    address = convert_int_address_to_string(address)
+    if address.is_a?(String)
+      Geocoder.coordinates(address)
+    else
+      address_type_error
+    end
+  end
+
+  # Converts an integer to a string in case a zip was input as an int.
+  def convert_int_address_to_string(address)
+    if address.is_a?(Integer)
+      format('0%o', address)
+    else
+      address
+    end
+  end
+
+  # Creates an empty delegation if no reps were found.
+  def handle_reps_not_found_error
+    reps_not_found_error
+    puts response
+    Delegation.new
+  end
+end

data/lib/get_your_rep/google.rb

@@ -1,194 +1,72 @@
+# frozen_string_literal: true
 module GetYourRep
-
   # Retrieve your elected representatives from the Google Civic Information API, parse it from
   # JSON, and assemble it into a usable Ruby Hash-like object called a Representative.
   # Representatives are then wrapped in an Array-like object called a Delegation.
   #
   # You must configure your own Google API key as an environment variable using the constant name
   # 'GOOGLE_API_KEY' in order for this gem to work.
-  class Google
-
-    # The Google API key is used to access data from the Google Civic Information API. You must
-    # obtain your own and configure it as an environment variable on your system.
-    API_KEY = ENV['GOOGLE_API_KEY']
-
-    # Initiates a chain of class method calls that will instantiate a
-    # Delegation object and return it.
-    # Supported options for :level are "national"(default) and "state".
-    # Supported options for :role are "representative"(default), "senator", "executive" and "vice executive".
-    def self.now(address, level: 'national', role: 'representative')
-      address = convert_zip_to_address(address) if address_is_a_zip?(address)
-      @address = parse_address(address)
-      @level = level
-      @role = role
-      get_rep
-    end
-
-    #Returns reps in Congress and State Legislature, plus Governor and Lieutenant Governor.
-    def self.all(address)
-      top_level_reps(address)
-
-      @role  = 'representative'
-      state_rep = get_rep
-
-      @role  = 'senator'
-      state_sen = get_rep
-
-      #Check the Open States API if Google can't find state reps.
-      if state_rep.empty? && state_sen.empty?
-        @reps << GetYourRep::OpenStates.now(@coordinates)
-      else
-        @reps << state_rep
-        @reps << state_sen
+  module Google
+    class << self
+      include GetYourRep
+
+      # Holds the parsed address for the HTTP request.
+      attr_accessor :address
+      # Holds the Delegation object which will be returned by the all_reps class method.
+      attr_accessor :delegation
+      # Holds the raw JSON data response from the API.
+      attr_accessor :response
+
+      # The Google API key is used to access data from the Google Civic Information API. You must
+      # obtain your own and configure it as an environment variable on your system.
+      API_KEY = ENV['GOOGLE_API_KEY']
+
+      # Makes the call to the Google API and delivers the response after parsing.
+      # Returns a GetYourRep::Delegation object, holding a collection of GetYourRep::Representatives
+      def all_reps(address, congress_only: nil)
+        init(address)
+        ask_google_api(congress_only: congress_only)
+        deliver_response
       end
 
-    end
-
-    def self.top_level_reps(address)
-      @reps = now(address)
-
-      @role = 'senator'
-      @reps << get_rep
-
-      @level = 'state'
-      @role  = 'executive'
-      @reps  << get_rep
-
-      @role = 'vice executive'
-      @reps << get_rep
-    end
-
-    # Parses a String address and prepares for an HTTP request. Accepts Strings and Integers as args.
-    def self.parse_address(address)
-      address = '0%o' % address if address.is_a?(Integer)
-      raise "Entry must be of types String or Integer" if !address.is_a?(String)
-      address = address.tr(',', '').split.join('%20')
-    end
-
-    # Unparses a parsed address
-    # def self.unparsed_address(address)
-    #   address.split('%20').join(' ')
-    # end
-
-    # Check if an address value is a zip code or a full address.
-    def self.address_is_a_zip?(address)
-      address = '0%o' % address if address.is_a?(Integer)
-      raise "Entry must be of types String or Integer" if !address.is_a?(String)
-      !(address =~ /^\d{5}(-\d{4})?$/).nil?
-    end
-
-    # Convert a zip code to a street address using Geocoder to convert zip to coordinates
-    # and coordinates to an address.
-    def self.convert_zip_to_address(address)
-      @coordinates = Geocoder.coordinates(address)
-      address = Geocoder.address(@coordinates)
-      trim_street_number(address)
-    end
-
-    # If a street number is a range reduce it to one number.
-    def self.trim_street_number(address)
-      address = address.split(' ')
-      address[0] = address[0].split('-').shift
-      address.join(' ')
-    end
-
-    # Sets parameters for and executes Google API request.
-    def self.get_rep
+      private
 
-      level = case @level
-              when 'national'
-                'country'
-              when 'state'
-                'administrativeArea1'
-              else
-                @level
-              end
-
-      role =  case @role
-              when 'representative'
-                'legislatorLowerBody'
-              when 'senator'
-                'legislatorUpperBody'
-              when 'executive'
-                'headOfGovernment'
-              when 'vice executive'
-                'deputyHeadOfGovernment'
-              else
-                @role
-              end
-
-      url = "https://www.googleapis.com/civicinfo/v2/representatives?address=#{@address}%20&includeOffices=true&levels=#{level}&roles=#{role}&fields=offices%2Cofficials&key=#{API_KEY}"
-      @response = HTTParty.get(url).parsed_response
-      deliver_response
-    end
-
-    def self.deliver_response
-      if @response.empty?
-        puts "'Google can't find a rep with that address. Checking the Open States API."
-        return GetYourRep::Delegation.new
-      elsif @response['error']
-        puts 'Error message received. Confirm and re-enter your address and check your parameters.'
-        puts @response
-        return GetYourRep::Delegation.new
+      def init(address)
+        address          = convert_zip_to_address(address) if address_is_a_zip?(address)
+        self.address     = parse_address(address)
       end
-      parse_rep
-      @delegation
-    end
 
-    # Parses the JSON response and assembles it into a Delegation object,
-    # except for social media attributes, which are handles by .parse_channels.
-    def self.parse_rep
-
-      @delegation = GetYourRep::Delegation.new
-      @officials = @response['officials']
-
-      @officials.each do |official|
-        @delegation << GetYourRep::Representative[
-          :name,             official['name'],
-          :office,           @response['offices'].first['name'],
-          :party,            official['party'],
-          :phone,            official['phones'] || [],
-          :office_locations, offices(official),
-          :email,            official['emails'] || [],
-          :url,              (official['urls'].first if official['urls']),
-          :photo,            official['photoUrl'],
-        ]
-        parse_channels(official) if official['channels']
+      def ask_google_api(congress_only: nil)
+        if congress_only
+          url = "https://www.googleapis.com/civicinfo/v2/representatives?address=#{address}%20&includeOffices=true&\
+levels=country&roles=legislatorLowerBody&roles=legislatorUpperBody&fields=offices%2Cofficials&key=#{API_KEY}"
+        else
+          url = "https://www.googleapis.com/civicinfo/v2/representatives?address=#{address}%20&includeOffices=true&\
+levels=country&levels=administrativeArea1&roles=legislatorLowerBody&roles=legislatorUpperBody&roles=headOfGovernment\
+&roles=deputyHeadOfGovernment&fields=offices%2Cofficials&key=#{API_KEY}"
+        end
+        self.response = HTTParty.get(url).parsed_response
       end
-    end
-
-    def self.offices(official)
-      offices = []
 
-      if official['address']
-        official['address'].each do |office|
-          office_hash = {}
-
-          if office['line1'].downcase.match(/(state|house|senate|assembly|capitol|dirksen|reyburn|rayburn|legislative|legislature|government)+/)
-            office_hash[:type] = 'capitol'
-          else
-            office_hash[:type] = 'district'
-          end
-
-          office_hash[:line_1] = office['line1']
-          office_hash[:line_2] = office['line_2']
-          office_hash[:line_3] = "#{office['city'].capitalize}, #{office['state']} #{office['zip']}"
-          offices << office_hash
+      def deliver_response
+        if response.empty? || response['error']
+          handle_reps_not_found_error
+        else
+          parse_reps
+          delegation
         end
       end
 
-      offices
-    end
+      def parse_reps
+        self.delegation = Delegation.new
 
-    # Parses social media handles and adds them to the Delegation object.
-    def self.parse_channels(official)
-      official['channels'].each do |channel|
-        @delegation.last[channel['type'].downcase.to_sym] = channel['id']
+        response['officials'].each_with_index do |official, index|
+          external_rep = GoogleRep.new(official)
+          rep_hash     = external_rep.build_hash(response['offices'], index)
+          new_rep      = Representative.new(rep_hash)
+          delegation.add_rep(new_rep)
+        end
       end
-      @delegation.last[:twitter]    = nil unless @delegation.last[:twitter]
-      @delegation.last[:facebook]   = nil unless @delegation.last[:facebook]
-      @delegation.last[:youtube]    = nil unless @delegation.last[:youtube]
-      @delegation.last[:googleplus] = nil unless @delegation.last[:googleplus]
     end
   end
 end