melissadata 0.0.1

data/lib/melissadata/native_object/base.rb

@@ -0,0 +1,79 @@
+module MelissaData::NativeObject
+  class Base
+    attr_reader :obj, :license, :input, :output, :result_codes, :results_string
+    attr_writer :data_dir
+
+    def initialize(opts={})
+      @license  = opts[:license]  || "DEMO"
+
+      unless obj.SetLicenseString(@license)
+        @license = "DEMO"
+        puts "Invalid License: Running in DEMO MODE."
+      end
+
+      if obj.respond_to?(:InitializeDataFiles) && obj.InitializeDataFiles != 0
+        raise obj.GetInitializeErrorString
+      end
+    end
+
+    # Example: geo.process(:zip => '84108')
+    #   - If invalid input (required fields are missing), return {}
+    #   - Call subclass's parse_input - this should call methods on the MelissaData object
+    #   - Call subclass's assign_values - pull out information from the object into the output hash
+    #   - Processes result codes
+    def process(opts={})
+      @input = @defaults.merge(opts)
+      return {} unless valid_input?
+
+      parse_input
+      @results_string = obj.GetResults.to_s
+      assign_values
+      process_result_codes
+
+      output.reduce({}) do |hsh,pair|
+        val = pair.last
+        val.strip! if val.respond_to?(:strip)
+        hsh[pair.first] = val if val.present?
+        hsh
+      end
+    end
+
+    def parse_input
+      raise "Needs to be overridden"
+    end
+
+    def assign_values
+      @output = {}
+    end
+
+    def valid_input?
+      @required_fields.blank? || input.any?{ |k,v| @required_fields.include?(k) && v.present? }
+    end
+
+    def process_result_codes
+      status_messages = []
+      error_messages = []
+
+      @results_string.split(",").each do |lookup|
+        if (match = @result_codes.detect{ |c,m| c == lookup })
+          code, message = *match
+
+          if code[1] == 'E'
+            error_messages << message
+          else
+            status_messages << message
+          end
+        end
+      end
+
+      output[:result_codes] = @results_string
+      output[:messages] = {}
+      output[:messages][:status] = status_messages if status_messages.present?
+      output[:messages][:error] = error_messages if error_messages.present?
+    end
+
+    def data_dir
+      @data_dir ||= '/opt/melissa_data/data'
+    end
+  end
+end

data/lib/melissadata/native_object/client.rb

@@ -0,0 +1,33 @@
+module MelissaData::NativeObject
+
+    class Client
+      attr_reader :license
+
+      def initialize(license='INVALID LICENSE')
+        @license = license
+        @email_object = MelissaData::Email.new(:license => license)
+      end
+
+      def process_email(email=nil)
+        email ||= ''
+        output = {}
+        input = {:email => email.to_s}
+        output = @email_object.process(input)
+        output.delete_if{ |k,v| v.to_s.strip == "" }
+        output
+      end
+
+      def email_build_number
+        @email_object.obj.GetBuildNumber
+      end
+
+      def version
+        MelissaData::VERSION
+      end
+
+      def address
+        "SharedObjects"
+      end
+    end
+
+end

data/lib/melissadata/native_object/email.rb

@@ -0,0 +1,61 @@
+module MelissaData::NativeObject
+  class Email < Base
+    def initialize(opts={})
+      @obj = MdEmailRubyWrapper::MdEmail.new
+      obj.SetPathToEmailFiles(data_dir)
+      obj.SetCorrectSyntax(1) # Enable/disable syntax correction
+      obj.SetStandardizeCasing(1) # Enable/disable lowercasing of email
+      obj.SetDatabaseLookup(1) # Enable/disable lookups against internal database of known domain names
+      obj.SetMXLookup(0) # Enable/disable DNS lookups for MX records (slower - but can be more accurate)
+      obj.SetUpdateDomain(1)
+
+      @result_codes = [
+        ['ES01', "Valid domain name"],
+        ['ES02', "Invalid domain name"],
+        ['ES03', "Domain name could not be verified"],
+        ['ES10', "Syntax was changed/corrected"],
+        ['ES11', "Top level domain was changed"],
+        ['ES12', "Domain name spelling was corrected"],
+        ['ES13', "Domain name was updated"],
+        ['EE01', "Syntax error in email address"],
+        ['EE02', "Top level domain not found"],
+        ['EE03', "Mail server not found"]
+      ]
+
+      @defaults = {
+        :email => ''
+      }
+
+      # At least one of these needs to be present
+      @required_fields = [:email]
+
+      super
+    end
+
+    def parse_input
+      obj.VerifyEmail(input[:email].to_s)
+    end
+
+    def assign_values
+      @output = {
+        :mailbox_name => obj.GetMailBoxName,
+        :domain_name => obj.GetDomainName,
+        :top_level_domain => obj.GetTopLevelDomain,
+        :top_level_domain_description => obj.GetTopLevelDomainDescription,
+        :email => obj.GetEmailAddress,
+        :lookup_code => obj.GetStatusCode
+      }
+
+      # V - Verified
+      # U - Unverified - not confirmed by lookup, but was not in the invalid domains list
+      # X - Bad email address - either not located by MX lookup, or was on the invalid domains list
+      if output[:lookup_code] == 'U'
+        obj.SetMXLookup(1)
+        obj.VerifyEmail(input[:email])
+        obj.SetMXLookup(0)
+
+        process_result_codes
+      end
+    end
+  end
+end

data/lib/melissadata/native_object/geo.rb

@@ -0,0 +1,61 @@
+module MelissaData::NativeObject
+  class Geo < Base
+    def initialize(opts={})
+      @obj = MdGeoRubyWrapper::MdGeo.new
+      obj.SetPathToGeoCodeDataFiles(data_dir)
+      obj.SetPathToGeoPointDataFiles(data_dir)
+
+      @result_codes = [
+        ['GS01', "Geocoded to ZIP+4"],
+        ['GS02', "Geocoded to ZIP+2"],
+        ['GS03', "Geocoded to ZIP"],
+        ['GS05', "Geocoded to rooftop level"],
+        ['GS06', "Geocoded to interpolated rooftop level"],
+        ['GE01', "Invalid zip code"],
+        ['GE02', "Zip code not found"],
+        ['GE03', "Demo mode"],
+        ['GE04', "Expired database"]
+      ]
+
+      @defaults = {
+        :zip => '',
+        :plus4 => ''
+      }
+
+      # At least one of these needs to be present
+      @required_fields = [:zip]
+
+      super
+    end
+
+    def parse_input
+      if ((dpc = input[:delivery_point_code]) || (dpc = input[:dpc])).present?
+        obj.GeoPoint(input[:zip].to_s, input[:plus4].to_s, dpc.to_s)
+      else
+        obj.GeoCode(input[:zip].to_s, input[:plus4].to_s)
+      end
+    end
+
+    def assign_values
+      @output = {
+        :lat => obj.GetLatitude,
+        :lng => obj.GetLongitude,
+        :county_name => obj.GetCountyName,
+        :county_fips => obj.GetCountyFips,
+        :census_tract => obj.GetCensusTract,
+        :census_block => obj.GetCensusBlock,
+        :place_name => obj.GetPlaceName,
+        :place_code => obj.GetPlaceCode,
+        :time_zone => obj.GetTimeZone,
+        :time_zone_code => obj.GetTimeZoneCode,
+
+        :cbsa_code => obj.GetCBSACode,
+        :cbsa_level => obj.GetCBSALevel,
+        :cbsa_title => obj.GetCBSATitle,
+        :cbsa_division_code => obj.GetCBSADivisionCode,
+        :cbsa_division_title => obj.GetCBSADivisionTitle,
+        :cbsa_division_level => obj.GetCBSADivisionLevel
+      }
+    end
+  end
+end

data/lib/melissadata/native_object/ip_locator.rb

@@ -0,0 +1,41 @@
+module MelissaData::NativeObject
+  class IpLocator < Base
+    def initialize(opts={})
+      @obj = MdIpLocatorRubyWrapper::MdIpLocator.new
+      obj.SetPathToIpLocatorFiles(data_dir)
+
+      @result_codes = [
+        ['IS01', "IP Address found in database"],
+        ['IS02', "IP Address unknown"],
+        ['IE01', "IP Address was empty or not well formed"]
+      ]
+
+      @defaults = {
+        :ip => ''
+      }
+
+      # At least one of these needs to be present
+      @required_fields = [:ip]
+
+      super
+    end
+
+    def parse_input
+      obj.LocateIpAddress(input[:ip].to_s)
+    end
+
+    def assign_values
+      @output = {
+        :domain_name => obj.GetDomainName,
+        :isp => obj.GetISP,
+        :city => obj.GetCity,
+        :region => obj.GetRegion,
+        :zip => obj.GetZip,
+        :country => obj.GetCountry,
+        :country_abbrev => obj.GetCountryAbbreviation,
+        :lat => obj.GetLatitude,
+        :lng => obj.GetLongitude
+      }
+    end
+  end
+end

data/lib/melissadata/native_object/name.rb

@@ -0,0 +1,74 @@
+module MelissaData::NativeObject
+  class Name < Base
+    def initialize(opts={})
+      @obj = MdNameRubyWrapper::MdName.new
+      obj.SetPathToNameFiles(data_dir)
+
+      @result_codes = [
+        ['NS01', "Parsing was successful"],
+        ['NS02', "There was a parse error"],
+        ['NS03', "The spelling of the FirstName field was corrected"],
+        ['NS04', "The spelling of the FirstName2 field was corrected"],
+        ['NE01', "Two names were detected but the FullName string was not in a recognized format"],
+        ['NE02', "Multiple first names - could not accurately genderize"],
+        ['NE03', "A vulgarity was detected in the first name"],
+        ['NE04', "The name contained words found on the list of nuisance names [such as Mickey Mouse]"],
+        ['NE05', "The name contained words normally found in a company name"],
+        ['NE06', "The named contained a non-alphabetic character"]
+      ]
+
+      @defaults = {
+        :first_name => '',
+        :last_name => ''
+      }
+
+      # At least one of these needs to be present
+      @required_fields = [:first_name, :last_name, :full_name]
+
+      # 0 - don't correct spelling of first name
+      # 1 - attempt to correct common misspellings of first name
+      obj.SetFirstNameSpellingCorrection(1) 
+
+      # Formatting of the FullName input
+      # 1 - Definitely Full
+      # 2 - Very Likely Full
+      # 3 - Probably Full
+      # 4 - Varying (default)
+      # 5 - Probably Inverse
+      # 6 - Very Likely Inverse
+      # 7 - Definitely Inverse
+      # 8 - Mixed First Name
+      # 9 - Mixed Last Name
+      obj.SetPrimaryNameHint(1)
+
+      super
+    end
+
+    def parse_input
+      input[:full_name] = ("%s %s" % [input[:first_name], input[:last_name]]) if input[:full_name].blank?
+      obj.ClearProperties
+      obj.SetFullName input[:full_name].to_s
+      obj.Parse
+    end
+
+    def assign_values
+      genders = {
+        'M' => 'Male',
+        'F' => 'Female',
+        'U' => 'Unknown first name',
+        'N' => 'Neutral first name'
+      }
+
+      @output = {
+        :prefix => obj.GetPrefix,
+        :first_name => obj.GetFirstName,
+        :middle_name => obj.GetMiddleName,
+        :last_name => obj.GetLastName,
+        :suffix => obj.GetSuffix,
+        :gender => obj.GetGender,
+        :gender_string => genders[obj.GetGender]
+      }
+      # status_messages << "First name spelling was corrected" if name_obj.GetChangeCode == 1
+    end
+  end
+end

data/lib/melissadata/native_object/phone.rb

@@ -0,0 +1,96 @@
+module MelissaData::NativeObject
+  class Phone < Base
+    def initialize(opts={})
+      @obj = MdPhoneRubyWrapper::MdPhone.new
+      if obj.Initialize(data_dir) != 0
+        raise obj.GetInitializeErrorString
+      end
+
+      @result_codes = [
+        ["PS01", "10 digit match"],
+        ["PS02", "7 digit match"],
+        ["PS03", "Corrected Area Code"],
+        ["PS04", "Outside Demo Range"],
+        ["PS05", "Expired Database"],
+        ["PS06", "Updated Area Code"],
+        ["PS07", "Exchange Type: Cell Phone"],
+        ["PS08", "Exchange Type: Land Line"],
+        ["PS09", "Exchange Type: VOIP"],
+        ["PS10", "Phone Type: Residential"],
+        ["PS11", "Phone Type: Business"],
+        ["PS12", "Phone Type: Small Business or Home Office"],
+        ["PE01", "Bad area code"],
+        ["PE02", "Blank phone number"],
+        ["PE03", "Bad phone number - too many or too few digits"],
+        ["PE04", "Multiple phone matches"],
+        ["PE05", "Bad prefix - does not exist in the database"],
+        ["PE06", "Bad zip code"]
+      ]
+
+      @defaults = {
+        :phone => '',
+        :zip => ''
+      }
+
+      # At least one of these needs to be present
+      @required_fields = [:phone]
+
+      super
+    end
+
+    def parse_input
+      obj.Lookup(input[:phone].to_s, input[:zip].to_s)
+    end
+
+    def assign_values
+      @output = {
+        :lat => obj.GetLatitude,
+        :lng => obj.GetLongitude,
+        :city => obj.GetCity,
+        :state => obj.GetState,
+        :county_name => obj.GetCountyName,
+        :county_fips => obj.GetCountyFips,
+        :country_code => obj.GetCountryCode,
+        :time_zone => obj.GetTimeZone,
+        :time_zone_code => obj.GetTimeZoneCode,
+        :msa => obj.GetMsa,
+        :pmsa => obj.GetPmsa,
+        :time_zone => obj.GetTimeZone,
+        :time_zone_code => obj.GetTimeZoneCode,
+        :area_code => obj.GetAreaCode,
+        :prefix => obj.GetPrefix,
+        :suffix => obj.GetSuffix,
+        :extension => obj.GetExtension
+      }
+
+      codes = result_codes.split(',')
+      output[:exchange_type] =  if codes.include?('PS07')
+                                  'Cell Phone'
+
+                                elsif codes.include?('PS08')
+                                  'Land Line'
+
+                                elsif codes.include?('PS09')
+                                  'VOIP'
+                                end
+
+      output[:phone_type] = if codes.include?('PS07')
+                              'Residential'
+
+                            elsif codes.include?('PS07')
+                              'Business'
+
+                            elsif codes.include?('PS07')
+                              'Small Business or Home Office'
+                            end
+
+      # if opts[:zip].present?
+      #   phone_obj.CorrectAreaCode(opts[:phone], opts[:zip])
+      #   hsh[:new_area_code] = phone_obj.GetNewAreaCode
+      # end
+
+      output[:formatted_phone] = "(#{output[:area_code]}) #{output[:prefix]}-#{output[:suffix]}"
+      output[:formatted_phone] << " x#{output[:extension]}" if output[:extension].present?
+    end
+  end
+end