melissa 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fb291d59288648da0db3f3c32dd53dc59fe4fb51
+  data.tar.gz: c3108433ae2a69e654267e172b77cbee2e546258
+SHA512:
+  metadata.gz: 7adf1de091986fe471e96f2b090feeab46d88bff99ba672b464319e469ea905b2d3965eb9ceffa314b7bdaff95431b09161c501df5f732e1e04b9641d9098c3c
+  data.tar.gz: 6f02f3f05fb70f0d4d9eb13e3ccded9465e6c603c70a6f10597d3370a2a3a648c983625de481291ed0fead33566dc561a6df4ec8b40eed797d913d4a5ba3615a

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea
+InstalledFiles
+_yardoc
+bin/
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor

data/.jruby-version

@@ -0,0 +1 @@
+jruby-1.7.9

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in melissa.gemspec
+gemspec
+
+gem 'rake'
+gem 'minitest'
+gem 'minitest-reporters'
+gem 'minitest-stub_any_instance'
+gem 'shoulda-context'

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    melissa (0.0.1)
+      activesupport
+      ffi
+      minitest
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    ansi (1.5.0)
+    builder (3.2.2)
+    ffi (1.9.6)
+    ffi (1.9.6-java)
+    i18n (0.7.0)
+    json (1.8.2)
+    json (1.8.2-java)
+    minitest (5.4.0)
+    minitest-reporters (1.0.8)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    minitest-stub_any_instance (1.0.0)
+    rake (10.4.2)
+    ruby-progressbar (1.7.1)
+    shoulda-context (1.2.1)
+    thread_safe (0.3.4)
+    thread_safe (0.3.4-java)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  melissa!
+  minitest
+  minitest-reporters
+  minitest-stub_any_instance
+  rake
+  shoulda-context

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Svetlana Marinskaya
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+# Melissa
+
+Configurable interface to Melissa Data Address and GeoCoder objects
+
+##Description
+
+Melissa Gem allows you to use ruby wrappers for Melissa Data's AddrObj and GeoPoint objects or use the mock objects depending on configuration.
+
+Address Object’s functionality is divided into four interfaces, AddressCheck, Parse,
+StreetData, and Data. We are using AddressCheck Interface.
+
+The AddressCheck Interface verifies and standardizes your address data using the
+most current data from the U. S. Postal Service®. The programming logic used by
+AddressCheck is CASS Certified™. This stringent certification ensures the quality of
+the data that is passed through the AddressCheck Interface and must be renewed
+every year.
+
+The GeoCoder Object enables you to access geographic data using your
+ZIP Code™ and optional Plus4. You will be able to obtain latitude and
+longitude geographic coordinates, census tract and block numbers, as well as
+county name and FIPS numbers.
+
+The Standard version of GeoCoder Object includes GeoPoints 11-digit
+(ZIP + 4 + 2) doorstop geolocation data on over 121,827,000 addresses in
+the United States.
+GeoPoints data is multi-sourced, including interpolated points mathematically
+calculated for valid addresses where no GeoPoints data is found, and covers
+95 percent of all U.S. delivery addresses, business and residential.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'melissa'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install melissa
+
+## Usage
+
+It is recommended to read the following config options from environment variables
+From Melissa Data documentation:
+The license string should be entered as an environment variable named
+MD_LICENSE. This allows you to update your license string without editing
+and recompiling your code
+
+ ```ruby
+      self.config_path = ENV['MELISSA_CONFIG_PATH'] if ENV['MELISSA_CONFIG_PATH']
+      self.home        = ENV['MELISSA_HOME'] if ENV['MELISSA_HOME']
+      @data_path       = ENV['MELISSA_DATA_PATH'] if ENV['MELISSA_DATA_PATH']
+      @addr_obj_lib    = ENV['MELISSA_ADDR_OBJ_LIB'] if ENV['MELISSA_ADDR_OBJ_LIB']
+      @geo_point_lib   = ENV['MELISSA_GEO_POINT_LIB'] if ENV['MELISSA_GEO_POINT_LIB']
+      @license         = ENV['MD_LICENSE'] if ENV['MD_LICENSE']
+ ```
+It is also possible to set HOME and LICENSE variables in configuration file, which can be accesses
+
+  ```ruby
+       Melissa.configure do |config|
+         config.config_path = "/etc/config/melissa"
+       end
+  ```
+
+A suite number can be passed at the end of the values passed to :address
+option, or as the parameter of either the :address2 or the :suite option.
+If the value passed to the :address option cannot be verified, Address Object
+will attempt to verify the value passed via the :address2 option. See Address
+Handling in Melissa Data Documentation for more information.
+If you use :zip option, :city and :state parameters are optional.
+Likewise, if :city and :state are populated, :zip is optional. If possible, it is the
+best practice to pass all three values if possible, because Address Object will use
+the values to validate each other.
+
+  ```ruby
+  #create AddrObj
+   valid_addr_obj = ::Melissa.addr_obj(
+              :address => '9802 Brompton Dr',
+              :city => 'Tampa',
+              :state => 'Fl',
+              :zip => '33626'
+          )
+   #use it to get deliverypoint
+   deliverypoint = valid_addr_obj.delivery_point
+
+   #create GeoPoint Object
+   geo_point_obj = ::Melissa.geo_point(valid_addr_obj)
+   #use it
+   latitude = geo_point_obj.latitude
+   longitude= geo_point_obj.longitude
+   #or
+   geo_point_obj = ::Melissa.geo_point(:zip => 'zip', :plus4 => 'plus4', :delivery_point_code => 'delivery_point_code')
+
+  ```
+
+The calls to Melissa Data library will be attempted only if Melissa Data library is loaded.
+Otherwise mock objects will be used. This way there is no need to install Melissa Data library on development machine.
+The following rules are used in mocking AddrObj Library:
+1. if zip_code is present, addres object is valid.
+2. to mock delivery point: "#{zip_code}1234#{last 2 digits of zip code}".
+   For example, zip_code = 33613     =>    delivery_point = 33613123413
+
+Mocked GeoPoint object will return following values:
+
+    ```ruby
+        @latitude = 36.20687
+        @longitude = -115.27857
+        @time_zone_code = '08'
+        @resultcodes = ['AS01']
+        @is_valid = true
+    ```
+
+## Meta
+
+* Code: `git clone git://github.com/smarinskaya/melissa.git`
+* Home: <https://github.com/smarinskaya/Melissa>
+* Bugs: <http://github.com/smarinskaya/Melissa/issues>
+* Gems: TODO
+
+
+## Authors
+
+1. [Brad Pardee](https://github.com/bpardee)
+2. [Svetlana Marinskaya](https://github.com/smarinskaya)
+
+
+##Aknowlegments
+
+Configuration pattern is developed based on Brandon Hilkert blog
+http://brandonhilkert.com/blog/ruby-gem-configuration-patterns/
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end

data/config/melissa

@@ -0,0 +1,2 @@
+HOME    =    path_to_home_directory
+LICENSE =    valid_license_key

data/lib/melissa.rb

@@ -0,0 +1,57 @@
+module Melissa
+
+  class << self
+    attr_writer :config
+  end
+
+  def self.addr_obj(attrs)
+    if config.mode == :live
+      raise LoadError, "Melissa AddrObj was not loaded!" unless config.addr_obj_lib_loaded
+      AddrObjLive.new(attrs)
+    else
+      AddrObjMock.new(attrs)
+    end
+  end
+
+  def self.geo_point(attrs)
+    if config.mode == :live
+      raise LoadError, "Melissa GeoPoint object was not loaded!" unless config.geo_point_lib_loaded
+      GeoPointLive.new(attrs)
+    else
+      GeoPointMock.new(attrs)
+    end
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.reset
+    @config = Config.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+end
+
+require 'melissa/railtie' if defined?(Rails)
+
+require "melissa/version"
+require "melissa/config"
+require 'melissa/addr_obj'
+require 'melissa/geo_point'
+require 'melissa/addr_obj_live'
+require 'melissa/geo_point_live'
+require 'melissa/addr_obj_mock'
+require 'melissa/geo_point_mock'
+
+
+#valid_address_obj = ::Melissa.adrr_obj(:address => 'valid street', :city => 'Tampa', :state => 'FL', :zip => '33626')
+#puts "addr=#{valid_address_obj.address}"
+#puts "deliverypoint=#{valid_address_obj.delivery_point}"
+
+#g = ::Melissa.geo_point(valid_address_obj)
+#puts "lat,long=#{g.latitude},#{g.longitude}"
+#or
+#g = ::Melissa.geo_point(:zip => 'zip', :plus4 => 'plus4', :delivery_point_code => 'delivery_point_code')

data/lib/melissa/addr_obj.rb

@@ -0,0 +1,92 @@
+require 'active_support/all' #TODO I can narrow down this
+
+module Melissa
+  class AddrObj
+    AddressStruct = Struct.new(:number, :pre_directional, :name, :suffix, :post_directional)
+
+    @@melissa_attributes = %w(
+    Company
+    LastName
+    Address
+    Address2
+    Suite
+    City
+    CityAbbreviation
+    State
+    Zip
+    Plus4
+    CarrierRoute
+    DeliveryPointCode
+    DeliveryPointCheckDigit
+    CountyFips
+    CountyName
+    AddressTypeCode
+    AddressTypeString
+    Urbanization
+    CongressionalDistrict
+    LACS
+    LACSLinkIndicator
+    RBDI
+    PrivateMailbox
+    TimeZoneCode
+    TimeZone
+    Msa
+    Pmsa
+    DefaultFlagIndicator
+    SuiteStatus
+    EWSFlag
+    CMRA
+    DsfNoStats
+    DsfVacant
+    CountryCode
+    ZipType
+    FalseTable
+    DPVFootnotes
+    LACSLinkReturnCode
+    SuiteLinkReturnCode
+    ELotNumber
+    ELotOrder
+  )
+
+    # See http://www.melissadata.com/lookups/resultcodes.asp
+    @@good_codes = ['AS01', 'AS02']
+    @@bad_codes = ['AC02', 'AC03']
+
+    def delivery_point
+      "#{zip}#{plus4}#{delivery_point_code}"
+    end
+
+    def time_zone_offset
+      GeoPoint.time_zone_offset(self.time_zone_code, self.state)
+    end
+
+    def address_struct
+      @address_struct = begin
+        if valid?
+          if address_type_string == 'Street' || address_type_string == 'Highrise'
+            match = self.address.match /^(\S+)\s?(N|NE|E|SE|S|SW|W|NW|) (\S.*?)\s?(N|NE|E|SE|S|SW|W|NW|)$/
+          end
+        elsif self.address
+          match = self.address.match /^(\d\S*)\s?(N|NE|E|SE|S|SW|W|NW|) (\S.*?)\s?(N|NE|E|SE|S|SW|W|NW|)$/
+        end
+        if match
+          # Parse out the optional suffix
+          street_match = match[3].match /(\S.*?)( [A-Za-z]{2,4}|)$/
+          if street_match
+            name, suffix = street_match[1], street_match[2].strip
+          else
+            name, suffix = match[3], ''
+          end
+          AddressStruct.new(match[1], match[2], name, suffix, match[4])
+        elsif self.address
+          AddressStruct.new('', '', self.address, '', '')
+        else
+          AddressStruct.new
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/melissa/addr_obj_live.rb

@@ -0,0 +1,117 @@
+require 'ffi'
+
+module Melissa
+  class AddrObjLive < AddrObj
+    begin
+      extend FFI::Library
+
+      ffi_lib Melissa.config.addr_obj_lib if defined?(FFI)
+      attr_functions = @@melissa_attributes.map { |name| ["mdAddrGet#{name}".to_sym, [:pointer], :string] }
+
+      functions = attr_functions + [
+          # method # parameters        # return
+          [:mdAddrCreate, [], :pointer],
+          [:mdAddrSetLicenseString, [:pointer, :string], :int],
+          [:mdAddrSetPathToUSFiles, [:pointer, :string], :void],
+          [:mdAddrInitializeDataFiles, [:pointer], :int],
+          [:mdAddrClearProperties, [:pointer], :void],
+          [:mdAddrSetCompany, [:pointer, :string], :void],
+          [:mdAddrSetAddress, [:pointer, :string], :void],
+          [:mdAddrSetAddress2, [:pointer, :string], :void],
+          [:mdAddrSetSuite, [:pointer, :string], :void],
+          [:mdAddrSetCity, [:pointer, :string], :void],
+          [:mdAddrSetState, [:pointer, :string], :void],
+          [:mdAddrSetZip, [:pointer, :string], :void],
+          [:mdAddrSetUrbanization, [:pointer, :string], :void],
+          [:mdAddrSetCountryCode, [:pointer, :string], :void],
+          [:mdAddrVerifyAddress, [:pointer], :int],
+          [:mdAddrGetResults, [:pointer], :string],
+          [:mdAddrDestroy, [:pointer], :void],
+          [:mdAddrGetLicenseExpirationDate, [:pointer], :string],
+          [:mdAddrGetExpirationDate, [:pointer], :string],
+      ]
+
+      functions.each do |func|
+        begin
+          attach_function(*func)
+        rescue Object => e
+          raise "Could not attach #{func}, #{e.message}"
+        end
+      end
+
+      attr_reader *@@melissa_attributes.map { |name| name.underscore.to_sym }
+
+      # Get all the attributes out up-front so we can destroy the h_addr_lib object
+      class_eval <<-EOS
+      define_method(:fill_attributes) do |h_addr_lib|
+        #{@@melissa_attributes.map { |name| "@#{name.underscore} = mdAddrGet#{name}(h_addr_lib)" }.join("\n")}
+      end
+      EOS
+
+      def self.with_mdaddr
+        h_addr_lib = mdAddrCreate
+        mdAddrSetLicenseString(h_addr_lib, Melissa.config.license)
+        mdAddrSetPathToUSFiles(h_addr_lib, Melissa.config.data_path)
+        mdAddrInitializeDataFiles(h_addr_lib)
+        yield h_addr_lib
+      ensure
+        mdAddrDestroy(h_addr_lib)
+      end
+
+      #This function returns a date value corresponding to the date when the current license
+      #string expires.
+
+      def self.license_expiration_date
+        Date.parse(with_mdaddr { |h_addr_lib| mdAddrGetLicenseExpirationDate(h_addr_lib) })
+      end
+
+      def self.days_until_license_expiration
+        #I compare Date objects. I think it is more accurate.
+        #self.license_expiration_date returns string in format: "YYYY-MM-DD"
+        (self.license_expiration_date - Date.today).to_i
+      end
+
+     # U.S. Only — This function returns a date value representing the
+     # date when the current U.S. data files expire. This date enables you to confirm that the
+     # data files you are using are the latest available.
+
+      def self.data_expiration_date
+        Date.strptime(with_mdaddr { |h_addr_lib| mdAddrGetExpirationDate(h_addr_lib) }, '%m-%d-%Y')
+      end
+
+      def self.days_until_data_expiration
+        (self.data_expiration_date - Date.today).to_i
+      end
+
+      def initialize(opts)
+        self.class.with_mdaddr do |h_addr_lib|
+          # clear any properties from a previous call
+          mdAddrClearProperties(h_addr_lib)
+
+          mdAddrSetCompany(h_addr_lib, opts[:company] || '');
+          mdAddrSetAddress(h_addr_lib, opts[:address] || '');
+          mdAddrSetAddress2(h_addr_lib, opts[:address2] || '');
+          mdAddrSetSuite(h_addr_lib, opts[:suite] || '');
+          mdAddrSetCity(h_addr_lib, opts[:city] || '');
+          mdAddrSetState(h_addr_lib, opts[:state] || '');
+          mdAddrSetZip(h_addr_lib, opts[:zip] || '');
+          mdAddrSetUrbanization(h_addr_lib, opts[:urbanization] || '');
+          mdAddrSetCountryCode(h_addr_lib, opts[:country_code] || '');
+          mdAddrVerifyAddress(h_addr_lib);
+
+          @resultcodes = mdAddrGetResults(h_addr_lib).split(',')
+          fill_attributes(h_addr_lib)
+        end
+      end
+
+      def valid?
+        # Make sure there is at least 1 good code and no bad codes
+        (@resultcodes & @@good_codes).present? && (@resultcodes & @@bad_codes).empty?
+      end
+    rescue LoadError => e
+      Melissa.config.addr_obj_lib_loaded = false
+    else
+      Melissa.config.addr_obj_lib_loaded = true
+    end
+  end
+end

data/lib/melissa/addr_obj_mock.rb

@@ -0,0 +1,46 @@
+# Fake out Melissa data in Dev and Test environments. For local tests, and for Release and Hotfix
+module Melissa
+  class AddrObjMock < AddrObj
+
+    # Since we're faking it, create accessors that just return the corresponding opts value except the ones we dummy in the ctor
+    @@melissa_attributes.each do |name|
+      name = name.underscore
+      class_eval <<-EOS
+        define_method(:#{name}) do
+          @#{name} ||= (@opts[:#{name}] || nil)
+        end
+      EOS
+    end
+
+    #Mock
+    def initialize(opts)
+      @opts = opts
+      #@urbanization        = opts[:urbanization] || ''
+      @resultcodes = ['AS01']
+      @address_type_string = 'Street'
+    end
+
+    #Mock
+    def delivery_point_code
+      point_code = nil
+      point_code = self.zip[3..5] if self.zip.present?
+      return point_code
+    end
+
+    #Mock
+    def delivery_point_check_digit
+      self.city && (self.city.sum % 10).to_s
+    end
+
+    #Mock
+    def plus4
+      return '1234'
+    end
+
+    #Mock
+    def valid?
+      #we will mock delivery point if zip code is present.
+      return self.zip.present?
+    end
+  end
+end

data/lib/melissa/config.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module Melissa
+
+  MODES = [:mock, :live]
+
+  class Config
+
+    attr_accessor :mode, :license, :data_path, :addr_obj_lib, :addr_obj_lib_loaded
+    attr_accessor :geo_point_lib, :geo_point_lib_loaded
+
+    def initialize
+      #It is recommended to read the following config options from environment variables
+      #From Melissa Data documentation:
+      #The license string should be entered as an environment variable named
+      #MD_LICENSE. This allows you to update your license string without editing
+      #and recompiling your code
+
+      self.config_path = ENV['MELISSA_CONFIG_PATH'] if ENV['MELISSA_CONFIG_PATH']
+      self.home = ENV['MELISSA_HOME'] if ENV['MELISSA_HOME']
+      @data_path = ENV['MELISSA_DATA_PATH'] if ENV['MELISSA_DATA_PATH']
+      @addr_obj_lib = ENV['MELISSA_ADDR_OBJ_LIB'] if ENV['MELISSA_ADDR_OBJ_LIB']
+      @geo_point_lib = ENV['MELISSA_GEO_POINT_LIB'] if ENV['MELISSA_GEO_POINT_LIB']
+      @license = ENV['MD_LICENSE'] if ENV['MD_LICENSE']
+    end
+
+    #you can configure config_path from your code using:
+    #   Melissa.configure do |config|
+    #     config.config_path = "/etc/config/melissa"
+    #   end
+    def config_path=(config_path)
+      File.open(config_path, 'r') do |fin|
+        fin.each do |line|
+          line.strip!
+          next if line.empty? || line[0] == '#'
+          equal_index = line.index('=')
+          key = line[0, equal_index].strip.downcase
+          value = line[(equal_index+1)..-1].strip
+          send("#{key}=", value)
+        end
+      end
+    rescue Errno::ENOENT
+      raise "Configuration file couldn't be found. We need #{config_path}"
+    end
+
+    def home=(home)
+      @addr_obj_lib = "#{home}/AddrObj/libmdAddr.so"
+      @geo_point_lib = "#{home}/GeoObj/libmdGeo.so"
+      @data_path = "#{home}/data"
+    end
+
+    def addr_obj_lib_loaded=(value)
+      @addr_obj_lib_loaded = value
+      @mode ||= :live if value
+    end
+
+    def geo_point_library_loaded=(value)
+      @geo_point_lib_loaded = value
+      @mode ||= :live if value
+    end
+  end
+end
+

data/lib/melissa/geo_point.rb

@@ -0,0 +1,75 @@
+require "melissa/config"
+
+module Melissa
+  class GeoPoint
+    @@melissa_attributes = %w(
+    Latitude
+    Longitude
+    CensusTract
+    CensusBlock
+    CountyFips
+    CountyName
+    PlaceCode
+    PlaceName
+    TimeZoneCode
+    TimeZone
+    CBSACode
+    CBSATitle
+    CBSALevel
+    CBSADivisionCode
+    CBSADivisionTitle
+    CBSADivisionLevel
+  )
+
+    @@codes = {
+        'GS01' => 'Record was coded to the ZIP + 4 centroid (U.S.) or or the full 6-digit Postal Code level (Canada).',
+        'GS02' => 'Record was coded to the ZIP + 2 centroid.',
+        'GS03' => 'Record was coded to the 5-digit ZIP Code centroid (U.S.) or or the first 3-digit Postal Code level (Canada).',
+        'GS05' => 'Record was coded to rooftop level.(Available On-Premise only)',
+        'GS06' => 'Record was coded to interpolated rooftop level.(Available On-Premise only)*',
+        'GE01' => 'ZIP Code Error. An invalid ZIP Code was entered.',
+        'GE02' => 'ZIP Code not found. The submitted ZIP Code was not found in the database.',
+        'GE03' => 'Demo Mode. GeoCoder Object is in Demo Mode and a ZIP Code outside the demo range was detected.',
+        'GE04' => 'The GeoCoder Object data files are expired. Please update with the latest data files.',
+        'GE05' => 'Geocoding for the country of input record is disabled for your license. Please contact your sales representative to enable.',
+    }
+
+    # See http://www.melissadata.com/lookups/resultcodes.asp
+    @@good_codes = ['GS01', 'GS02', 'GS03', 'GS05', 'GS06']
+    #@@bad_codes   = ['GE01', 'GE02']
+    @@fatal_codes = ['GE03', 'GE04', 'GE05']
+
+    @@time_zones = {
+        '04' => 'Atlantic/Bermuda',
+        '05' => 'US/Eastern',
+        '06' => 'US/Central',
+        '07' => 'US/Mountain',
+        '08' => 'US/Pacific',
+        '09' => 'US/Alaska',
+        '10' => 'US/Hawaii',
+        '11' => 'US/Samoa',
+        '13' => 'Pacific/Majuro',
+        '14' => 'Pacific/Guam',
+        '15' => 'Pacific/Palau'
+    }
+
+    def valid?
+      # Make sure there is at least 1 good code
+      @is_valid
+    end
+
+    def time_zone_offset
+      GeoPoint.time_zone_offset(self.time_zone_code, @addr_obj.state)
+    end
+
+    # Hack for AddrObj to share code
+    def self.time_zone_offset(time_zone_code, state=nil)
+      time_zone = @@time_zones[time_zone_code]
+      return nil unless time_zone
+      time_zone = 'US/Arizona' if state == 'AZ'
+      return Time.now.in_time_zone(time_zone).utc_offset / -60
+    end
+  end
+end
+
+

data/lib/melissa/geo_point_live.rb

@@ -0,0 +1,126 @@
+require 'ffi'
+
+module Melissa
+  class GeoPointLive < GeoPoint
+    extend FFI::Library
+
+    begin
+      ffi_lib Melissa.config.geo_point_lib
+      attr_functions = @@melissa_attributes.map { |name| ["mdGeoGet#{name}".to_sym, [:pointer], :string] }
+
+      functions = attr_functions + [
+          # method # parameters        # return
+          [:mdGeoCreate, [], :pointer],
+          [:mdGeoSetLicenseString, [:pointer, :string], :int],
+          [:mdGeoSetPathToGeoCodeDataFiles, [:pointer, :string], :void],
+          [:mdGeoSetPathToGeoPointDataFiles, [:pointer, :string], :void],
+          [:mdGeoInitializeDataFiles, [:pointer], :int],
+          [:mdGeoGeoPoint, [:pointer, :string, :string, :string], :int],
+          [:mdGeoGetResults, [:pointer], :string],
+          [:mdGeoDestroy, [:pointer], :void],
+          [:mdGeoGetLicenseExpirationDate, [:pointer], :string],
+          [:mdGeoGetExpirationDate, [:pointer], :string],
+      ]
+
+      functions.each do |func|
+        begin
+          attach_function(*func)
+        rescue Object => e
+          raise "Could not attach #{func}, #{e.message}"
+        end
+      end
+
+      attr_reader *@@melissa_attributes.map { |name| name.underscore.to_sym }
+
+      # Get all the attributes out up-front so we can destroy the mdGeo object
+      class_eval <<-EOS
+        define_method(:fill_attributes) do |mdGeo|
+          #{@@melissa_attributes.map { |name| "@#{name.underscore} = mdGeoGet#{name}(mdGeo)" }.join("\n")}
+        end
+      EOS
+
+      def self.with_mdgeo
+        mdGeo = mdGeoCreate
+        mdGeoSetLicenseString(mdGeo, Melissa.config.license)
+        mdGeoSetPathToGeoCodeDataFiles(mdGeo, Melissa.config.data_path)
+        mdGeoSetPathToGeoPointDataFiles(mdGeo, Melissa.config.data_path)
+        result = mdGeoInitializeDataFiles(mdGeo)
+        if result != 0
+          raise mdGeoGetInitializeErrorString(mdGeo)
+        end
+        yield mdGeo
+      ensure
+        mdGeoDestroy(mdGeo) if mdGeo
+      end
+
+      #This function returns a date value corresponding to the date when the current license
+      #string expires.
+      def self.license_expiration_date
+        Date.parse(with_mdgeo { |mdGeo| mdGeoGetLicenseExpirationDate(mdGeo) })
+      end
+
+      def self.days_until_license_expiration
+        #I compare Date objects. I think it is more accurate.
+        #self.license_expiration_date returns string in format: "YYYY-MM-DD"
+        (self.license_expiration_date - Date.today).to_i
+      end
+
+      # his function returns a date value representing the
+      # date when the current data files expire. This date enables you to confirm that the
+      # data files you are using are the latest available.
+      def self.expiration_date
+        Date.parse(with_mdgeo { |mdGeo| mdGeoGetExpirationDate(mdGeo)})
+      end
+
+      def self.days_until_data_expiration
+        #I compare Date objects. I think it is more accurate.
+        #self.license_expiration_date returns string in format: "YYYY-MM-DD"
+        (self.expiration_date - Date.today).to_i
+      end
+
+      def initialize(opts)
+        @is_valid = false
+
+        self.class.with_mdgeo do |mdGeo|
+          if opts.kind_of?(AddrObj)
+            mdGeoGeoPoint(mdGeo, opts.zip || '', opts.plus4 || '', opts.delivery_point_code || '')
+          elsif opts.kind_of?(Hash)
+            mdGeoGeoPoint(mdGeo, opts[:zip] || '', opts[:plus4] || '', opts[:delivery_point_code] || '')
+          else
+            raise "Invalid call to GeoPoint, unknown object #{opts.inspect}"
+          end
+          @resultcodes = mdGeoGetResults(mdGeo).split(',')
+          fatals = @resultcodes & @@fatal_codes
+          @is_valid = fatals.blank?
+          if @is_valid
+            fill_attributes(mdGeo)
+            # Convert from strings to actual types
+            if @latitude.blank?
+              @latitude = nil
+            else
+              @latitude = @latitude.to_f
+            end
+            if @longitude.blank?
+              @longitude = nil
+            else
+              @longitude = @longitude.to_f
+            end
+            if @latitude == 0.0 && @longitude == 0.0
+              @latitude = nil
+              @longitude = nil
+              @is_valid = false
+            end
+          else
+            fatals.each do |fatal_code|
+              raise "FATAL ERROR Melissa GeoPoint returned #{fatal_code}-#{@@codes[fatal_code]}"
+            end
+          end
+        end
+      end
+    rescue LoadError => e
+      Melissa.config.geo_point_library_loaded = false
+    else
+      Melissa.config.geo_point_library_loaded = true
+    end
+  end
+end

data/lib/melissa/geo_point_mock.rb

@@ -0,0 +1,28 @@
+module Melissa
+  class GeoPointMock < GeoPoint
+    # Since we're faking it, create accessors that just return the corresponding opts value except the ones we dummy in the ctor
+    @@melissa_attributes.each do |name|
+      name = name.underscore
+      class_eval <<-EOS
+        define_method(:#{name}) do
+          @#{name} ||= (@opts[:#{name}] || '')
+        end
+      EOS
+    end
+
+    def initialize(addr_obj)
+      @is_valid = false
+
+      if addr_obj.kind_of?(AddrObj)
+        @addr_obj = addr_obj
+      else
+        raise "Invalid call to GeoPoint, unknown object #{addr_obj.inspect}"
+      end
+      @latitude = 36.20687
+      @longitude = -115.27857
+      @time_zone_code = '08'
+      @resultcodes = ['AS01']
+      @is_valid = true
+    end
+  end
+end

data/lib/melissa/railtie.rb

@@ -0,0 +1,11 @@
+module Melissa
+  class Railtie < Rails::Railtie #:nodoc:
+    # Make the Melissa config available in the Rails application config
+    config.before_configuration do
+      config_file = Rails.root.join('config', 'melissa.txt')
+      if config_file.file?
+        Melissa.config.config_path = config_file
+      end
+    end
+  end
+end

data/lib/melissa/version.rb

@@ -0,0 +1,3 @@
+module Melissa
+  VERSION = "0.0.1"
+end

data/melissa.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/melissa/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Brad Pardee', 'Svetlana Marinskaya']
+  gem.email         = ['bradpardee@gmail.com', 'svetlana.marinskaya@gmail.com']
+  gem.description   = %q{Configurable interface to Melissa Data Address and GeoPoint objects}
+  gem.summary       = %q{Melissa allows you to use ruby wrappers for Melissa Data's AddrObj and GeoPoint objects or use the mock objects depending on configuration.}
+  gem.homepage      = "https://github.com/smarinskaya/Melissa"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "melissa"
+  gem.require_paths = ["lib"]
+  gem.version       = Melissa::VERSION
+
+  gem.add_dependency 'activesupport' # added to support underscore method.
+  gem.add_dependency 'minitest'      # added as a dependency of activesupport and for testing.
+  gem.add_dependency 'ffi'           #used for converting c libraries to ruby
+end

data/test/addr_obj_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+
+class AddrObjTest < Minitest::Test
+  describe Melissa::AddrObj do
+
+    describe "live mode" do
+      before do
+        Melissa.config.mode = :live if Melissa.config.addr_obj_lib_loaded
+      end
+
+      describe "valid?" do
+        it 'handles valid data' do
+          skip "Not run in mock mode" unless Melissa.config.mode == :live
+          valid_address = Melissa.addr_obj(
+              :address => '2517 Surfwood Dr',
+              :city => 'Las Vegas',
+              :state => 'NV',
+              :zip => '89128'
+          )
+          assert valid_address.valid?
+          assert_equal '2517 Surfwood Dr', valid_address.address
+          assert_equal 'Las Vegas', valid_address.city
+          assert_equal '89128718217', valid_address.delivery_point
+        end
+
+        it 'flags invalid data' do
+          skip "Not run in mock mode" unless Melissa.config.mode == :live
+          # Zip points to Schenectady, NY
+          invalid_address = Melissa.addr_obj(
+              :address => '123 Who Dr',
+              :city => 'WhoVille',
+              :state => 'IN',
+              :zip => '12345'
+          )
+          assert !invalid_address.valid?
+        end
+      end
+
+      describe "delivery_point" do
+        it 'sets delivery point for valid data' do
+          skip "Not run in mock mode" unless Melissa.config.mode == :live
+          valid_address = Melissa.addr_obj(
+              :address => '2517 Surfwood Dr',
+              :city => 'Las Vegas',
+              :state => 'NV',
+              :zip => '89128'
+          )
+          assert_equal '89128718217', valid_address.delivery_point
+        end
+      end
+
+      describe 'number of days till licence expires' do
+        it 'checks if we have more than 30 days till license expiration date' do
+          skip "Not run in mock mode" unless Melissa.config.mode == :live
+          valid_address = Melissa.addr_obj(
+              :address => '2517 Surfwood Dr',
+              :city => 'Las Vegas',
+              :state => 'NV',
+              :zip => '89128'
+          )
+          assert_operator 30, :<, valid_address.class.days_until_license_expiration
+        end
+      end
+    end
+
+    describe "mock mode" do
+      before do
+        Melissa.config.mode = :mock
+      end
+      describe "valid?" do
+        it 'handles valid data' do
+          valid_address = Melissa.addr_obj(
+              :address => '9802 Brompton Dr',
+              :city => 'Tampa',
+              :state => 'Fl',
+              :zip => '33626'
+          )
+          assert valid_address.valid?
+          assert_equal '9802 Brompton Dr', valid_address.address
+          assert_equal 'Tampa', valid_address.city
+          assert_equal '33626123426', valid_address.delivery_point
+        end
+
+        it 'flags invalid data' do
+          # Zip points to Schenectady, NY
+          invalid_address = Melissa.addr_obj(
+              :address => '123 Who Dr',
+              :city => 'WhoVille',
+              :state => 'IN',
+              :zip => ''
+          )
+          assert !invalid_address.valid?
+        end
+      end
+
+      describe "delivery_point" do
+        it 'sets delivery point for valid data' do
+          valid_address = Melissa.addr_obj(
+              :address => '9802 Brompton Dr',
+              :city => 'Tampa',
+              :state => 'Fl',
+              :zip => '33626'
+          )
+          assert_equal '33626123426', valid_address.delivery_point
+        end
+      end
+    end
+  end
+end

data/test/geo_point_test.rb

@@ -0,0 +1,65 @@
+#require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'test_helper'
+
+class GeoPointTest < Minitest::Test
+
+  describe Melissa::GeoPoint do
+    before do
+      Melissa.config.mode = :live  if  Melissa.config.addr_obj_lib_loaded
+    end
+
+    describe 'valid?' do
+      it 'creates valid GeoPoint object from valid Address Object' do
+        skip "Not run in mock mode" unless Melissa.config.mode == :live
+        valid_addr_obj = Melissa.addr_obj(
+            :address => '2517 SURFWOOD DR',
+            :city => 'LAS VEGAS',
+            :state => 'NV',
+            :zip => '89128'
+        )
+        geo_point_obj = Melissa.geo_point(valid_addr_obj)
+        assert geo_point_obj.valid?
+        assert_includes 36.2..36.3, geo_point_obj.latitude
+        assert_includes -115.3..-115.2, geo_point_obj.longitude
+        # offset = Time.now.in_time_zone('US/Eastern').dst? ? 240 : 300
+        # assert_equal offset, geo_point.time_zone_offset
+        #For the address above:
+        #g.time_zone_offset
+        #=> 480
+      end
+      it 'creates valid GeoPoint object from the Hash' do
+        skip "Not run in mock mode" unless Melissa.config.mode == :live
+        geo_point_obj= Melissa.geo_point(
+            :zip => '89128',
+            :plus4 =>  '7182',
+            :delivery_point_code => '17'
+        )
+
+        assert geo_point_obj.valid?
+        assert_includes 36.2..36.3, geo_point_obj.latitude
+        assert_includes -115.3..-115.2, geo_point_obj.longitude
+        # offset = Time.now.in_time_zone('US/Eastern').dst? ? 240 : 300
+        # assert_equal offset, geo_point.time_zone_offset
+        #For the address above:
+        #g.time_zone_offset
+        #=> 480
+      end
+    end
+
+    describe 'number of days till licence expires' do
+      it 'checks if we have more than 30 days till license expiration date' do
+        skip "Not run in mock mode" unless Melissa.config.mode == :live
+        valid_addr_obj = Melissa.addr_obj(
+            :address => '2517 SURFWOOD DR',
+            :city => 'LAS VEGAS',
+            :state => 'NV',
+            :zip => '89128'
+        )
+        geo_point = Melissa.geo_point(valid_addr_obj)
+        assert_operator 30, :<, geo_point.class.days_until_license_expiration
+      end
+    end
+  end
+end
+
+

data/test/melissa_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class MelissaTest < Minitest::Test
+
+  describe 'Melissa.addr_obj' do
+    before do
+      Melissa.config.mode = :live if  Melissa.config.addr_obj_lib_loaded
+    end
+
+    describe "live mode" do
+      it 'initializes AddrObjLive object' do
+        skip "Not run in mock mode" unless Melissa.config.mode == :live
+        valid_address = Melissa.addr_obj(
+            :address => '9802 Brompton Dr',
+            :city => 'Tampa',
+            :state => 'Fl',
+            :zip => '33626'
+        )
+        assert_kind_of Melissa::AddrObjLive, valid_address
+      end
+    end
+
+    describe "mock mode" do
+      before do
+        Melissa.config.mode = :mock
+      end
+
+      it 'initializes AddrObjMock object' do
+        valid_address = Melissa.addr_obj(
+            :address => '9802 Brompton Dr',
+            :city => 'Tampa',
+            :state => 'Fl',
+            :zip => '33626'
+        )
+        assert_kind_of Melissa::AddrObjMock, valid_address
+      end
+    end
+  end
+
+  describe 'Melissa.geo_point' do
+    before do
+      Melissa.config.mode = :live if  Melissa.config.addr_obj_lib_loaded
+    end
+
+    describe "live mode" do
+      it 'initializes GeoPointLive object' do
+        skip "Not run in mock mode" unless Melissa.config.mode == :live
+        valid_addr_obj = Melissa.addr_obj(
+            :address => '9802 Brompton Dr',
+            :city => 'Tampa',
+            :state => 'Fl',
+            :zip => '33626'
+        )
+        geo_point_obj = Melissa.geo_point(valid_addr_obj)
+        assert_kind_of Melissa::GeoPointLive, geo_point_obj
+      end
+    end
+
+    describe "mock mode" do
+      before do
+        Melissa.config.mode = :mock
+      end
+
+      it 'initializes GeoPointMock object' do
+        valid_addr_obj = Melissa.addr_obj(
+            :address => '9802 Brompton Dr',
+            :city => 'Tampa',
+            :state => 'Fl',
+            :zip => '33626'
+        )
+        geo_point_obj = Melissa.geo_point(valid_addr_obj)
+        assert_kind_of Melissa::GeoPointMock, geo_point_obj
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'melissa'
+require 'minitest/autorun'
+require 'minitest/pride'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: melissa
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brad Pardee
+- Svetlana Marinskaya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Configurable interface to Melissa Data Address and GeoPoint objects
+email:
+- bradpardee@gmail.com
+- svetlana.marinskaya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".jruby-version"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- config/melissa
+- lib/melissa.rb
+- lib/melissa/addr_obj.rb
+- lib/melissa/addr_obj_live.rb
+- lib/melissa/addr_obj_mock.rb
+- lib/melissa/config.rb
+- lib/melissa/geo_point.rb
+- lib/melissa/geo_point_live.rb
+- lib/melissa/geo_point_mock.rb
+- lib/melissa/railtie.rb
+- lib/melissa/version.rb
+- melissa.gemspec
+- test/addr_obj_test.rb
+- test/geo_point_test.rb
+- test/melissa_test.rb
+- test/test_helper.rb
+homepage: https://github.com/smarinskaya/Melissa
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Melissa allows you to use ruby wrappers for Melissa Data's AddrObj and GeoPoint
+  objects or use the mock objects depending on configuration.
+test_files:
+- test/addr_obj_test.rb
+- test/geo_point_test.rb
+- test/melissa_test.rb
+- test/test_helper.rb