melissadata 0.0.1

data/lib/melissadata/constants.rb

@@ -0,0 +1,14 @@
+module MelissaData
+  # Constants used by the system to access data.
+  module Constants
+    # Default execution address
+    DEFAULT_ADDRESS = '0.0.0.0'
+
+    # Default execution port
+    DEFAULT_PORT    = 6000
+  end
+end
+
+module MelissaData
+  include Constants
+end

data/lib/melissadata/env.rb

@@ -0,0 +1,92 @@
+module MelissaData
+  # MelissaData::Env also provides access to the logger, configuration information
+  # and anything else set into the config data during initialization.
+  class Env < Hash
+    include Constants
+
+    # Create a new MelissaData::Env object
+    #
+    # @return [MelissaData::Env] The MelissaData::Env object
+    def initialize
+      self[:start_time] = Time.now.to_f
+      self[:time] = Time.now.to_f
+      self[:trace] = []
+    end
+
+    # Add a trace timer with the given name into the environment. The tracer will
+    # provide information on the amount of time since the previous call to {#trace}
+    # or since the MelissaData::Env object was initialized.
+    #
+    # @example
+    #   trace("initialize hash")
+    #   ....
+    #   trace("Do something else")
+    #
+    # @param name [String] The name of the trace to add
+    def trace(name)
+      self[:trace].push([name, "%.2f" % ((Time.now.to_f - self[:time]) * 1000)])
+      self[:time] = Time.now.to_f
+    end
+
+    # Retrieve the tracer stats for this request environment. This can then be
+    # returned in the headers hash to in development to provide some simple
+    # timing information for the various API components.
+    #
+    # @example
+    #   [200, {}, {:meta => {:trace => env.trace_stats}}, {}]
+    #
+    # @return [Array] Array of [name, time] pairs with a Total entry added.
+    def trace_stats
+      self[:trace] + [['total', self[:trace].collect { |s| s[1].to_f }.inject(:+).to_s]]
+    end
+
+    # Convenience method for accessing the rack.logger item in the environment.
+    #
+    # @return [Logger] The logger object
+    def logger
+      return @logger if @logger
+
+      # Figure out where the output should go to.
+      output = nil
+      if ENV["MELISSADATA_LOG"] == "STDOUT"
+        output = STDOUT
+      elsif ENV["MELISSADATA_LOG"] == "NULL"
+        output = nil
+      elsif ENV["MELISSADATA_LOG"]
+        output = ENV["MELISSADATA_LOG"]
+      else
+        output = nil #log_path.join("#{Time.now.to_i}.log")
+      end
+
+      # Create the logger and custom formatter
+      @logger = Logger.new(output)
+      @logger.formatter = Proc.new do |severity, datetime, progname, msg|
+        "#{datetime} - #{progname} - [#{resource}] #{msg}\n"
+      end
+
+      @logger
+    end
+
+    # @param name [Symbol] The method to check if we respond to it.
+    # @return [Boolean] True if the Env responds to the method, false otherwise
+    def respond_to?(name)
+      return true if has_key?(name.to_s)
+      return true if self['config'] && self['config'].has_key?(name.to_s)
+      super
+    end
+
+    # The MelissaData::Env will provide any of it's keys as a method. It will also provide
+    # any of the keys in the config object as methods. The methods will return
+    # the value of the key. If the key doesn't exist in either hash this will
+    # fall back to the standard method_missing implementation.
+    #
+    # @param name [Symbol] The method to look for
+    # @param args The arguments
+    # @param blk A block
+    def method_missing(name, *args, &blk)
+      return self[name.to_s] if has_key?(name.to_s)
+      return self['config'][name.to_s] if self['config'] && self['config'].has_key?(name.to_s)
+      super(name, *args, &blk)
+    end
+  end
+end

data/lib/melissadata/errors.rb

@@ -0,0 +1,83 @@
+# This file contains all of the internal errors in MelissaData's core
+# commands, actions, etc.
+
+module MelissaData
+  # This module contains all of the internal errors in MelissaData's core.
+  # These errors are _expected_ errors and as such don't typically represent
+  # bugs in MelissaData itself. These are meant as a way to detect errors and
+  # display them in a user-friendly way.
+  #
+  # # Defining a new Error
+  #
+  # To define a new error, inherit from {MelissaDataError}, which lets MelissaData
+  # know that this is an expected error, and also gives you some helpers for
+  # providing exit codes and error messages. An example is shown below, then
+  # it is explained:
+  #
+  #     class MyError < MelissaData::Errors::MelissaDataError
+  #       error_key "my_error"
+  #     end
+  #
+  # This creates an error with an I18n error key of "my_error." {MelissaDataError}
+  # uses I18n to look up error messages, in the "melissadata.errors" namespace. So
+  # in the above, the error message would be the translation of "melissadata.errors.my_error"
+  #
+  # If you don't want to use I18n, you can override the {#initialize} method and
+  # set your own error message.
+  #
+  # # Raising an Error
+  #
+  # To raise an error, it is nothing special, just raise it like any normal
+  # exception:
+  #
+  #     raise MyError.new
+  #
+  # Eventually this exception will bubble out to the `melissadata` binary which
+  # will show a nice error message. And if it is raised in the middle of a
+  # middleware sequence, then {Action::Warden} will catch it and begin the
+  # recovery process prior to exiting.
+  module Errors
+    # Main superclass of any errors in MelissaData. This provides some
+    # convenience methods for setting the error key.  The error key is
+    # used as a default message from I18n.
+    class MelissaDataError < StandardError
+      def self.error_key(key=nil, namespace=nil)
+        define_method(:error_key) { key }
+        error_namespace(namespace) if namespace
+      end
+
+      def self.error_namespace(namespace)
+        define_method(:error_namespace) { namespace }
+      end
+
+      def initialize(message=nil, *args)
+        message = { :_key => message } if message && !message.is_a?(Hash)
+        message = { :_key => error_key, :_namespace => error_namespace }.merge(message || {})
+        message = translate_error(message)
+
+        super
+      end
+
+      # The default error namespace which is used for the error key.
+      # This can be overridden here or by calling the "error_namespace"
+      # class method.
+      def error_namespace; "melissadata.errors"; end
+
+      # The key for the error message. This should be set using the
+      # {error_key} method but can be overridden here if needed.
+      def error_key; nil; end
+
+      protected
+
+      def translate_error(opts)
+        return nil if !opts[:_key]
+        I18n.t("#{opts[:_namespace]}.#{opts[:_key]}", opts)
+      end
+    end
+
+    class DiscNotFound < MelissaDataError
+      error_key(:disc_not_found)
+    end
+
+  end
+end

data/lib/melissadata/melissadata.rb

@@ -0,0 +1,164 @@
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__)) unless $LOAD_PATH.include?(File.expand_path('..', File.dirname(__FILE__)))
+require 'pathname'
+require 'i18n'
+require 'thor'
+require 'thor/group'
+require 'thor/actions'
+require 'active_support/core_ext'
+
+module MelissaData
+  module_function
+
+  autoload :Env,        'melissadata/env'
+  autoload :CLI,        'melissadata/cli'
+  autoload :Errors,     'melissadata/errors'
+  autoload :Constants,  'melissadata/constants'
+
+  ENVIRONMENTS = [:development, :production, :test, :staging]
+
+  # Retrieves the current melissadata environment
+  #
+  # @return [String] the current environment
+  def env
+    @env or fail "environment has not been set"
+  end
+
+  # Sets the current melissadata environment
+  #
+  # @param [String|Symbol] env the environment symbol of [dev | development | prod | production | test]
+  def env=(e)
+    es = case(e.to_sym)
+    when :dev  then :development
+    when :prod then :production
+    else e.to_sym
+    end
+
+    if ENVIRONMENTS.include?(es)
+      @env = es
+    else
+      fail "did not recognize environment: #{e}, expected one of: #{ENVIRONMENTS.join(', ')}"
+    end
+  end
+
+  # Determines if we are in the production environment
+  #
+  # @return [Boolean] true if current environment is production, false otherwise
+  def prod?
+    env == :production
+  end
+
+  # Determines if we are in the development environment
+  #
+  # @return [Boolean] true if current environment is development, false otherwise
+  def dev?
+    env == :development
+  end
+
+  # Determines if we are in the test environment
+  #
+  # @return [Boolean] true if current environment is test, false otherwise
+  def test?
+    env == :test
+  end
+
+  # Determines if we are in the staging environment
+  #
+  # @return [Boolean] true if current environment is staging.
+  def staging?
+    env == :staging
+  end
+
+  def gem_root
+    @gem_root ||= Pathname.new(File.expand_path('../../../', __FILE__))
+  end
+end
+
+I18n.load_path << File.expand_path("templates/locales/en.yml", MelissaData.gem_root)
+
+require 'melissadata/command'
+require 'melissadata/version'
+
+
+# require 'rubygems'
+# require 'active_support/core_ext'
+# require 'melissadata/constants'
+# require 'melissadata/commands'
+# require 'melissadata/exceptions'
+
+# module MelissaData
+#   module_function
+
+#   ENVIRONMENTS = [:development, :production, :vagrant, :test, :staging]
+
+#   # Retrieves the current MelissaData environment
+#   #
+#   # @return [String] the current environment
+#   def env
+#     @env or fail "environment has not been set"
+#   end
+
+#   # Sets the current MelissaData environment
+#   #
+#   # @param [String|Symbol] env the environment symbol of [dev | development | prod | production | test]
+#   def env=(e)
+#     es = case(e.to_sym)
+#     when :dev  then :development
+#     when :prod then :production
+#     else e.to_sym
+#     end
+
+#     if ENVIRONMENTS.include?(es)
+#       @env = es
+#     else
+#       fail "did not recognize environment: #{e}, expected one of: #{ENVIRONMENTS.join(', ')}"
+#     end
+#   end
+
+#   def client=(c)
+#     @client = c
+#   end
+
+#   def client
+#     raise "Client has not yet been setup" if @client.nil?
+#     @client
+#   end
+
+#   def lib_path
+#     @lib_path ||= File.dirname(__FILE__)
+#   end
+
+#   # Determines if we are in the production environment
+#   #
+#   # @return [Boolean] true if current environment is production, false otherwise
+#   def prod?
+#     env == :production
+#   end
+
+#   # Determines if we are in the development environment
+#   #
+#   # @return [Boolean] true if current environment is development, false otherwise
+#   def dev?
+#     env == :development
+#   end
+
+#   # Determines if we are in the test environment
+#   #
+#   # @return [Boolean] true if current environment is test, false otherwise
+#   def test?
+#     env == :test
+#   end
+
+#   # Determines if we are in the staging environment
+#   #
+#   # @return [Boolean] true if current environment is staging.
+#   def staging?
+#     env == :staging
+#   end
+
+#   # Determines if we are in the vagrant environment
+#   #
+#   # @return [Boolean] true if current environment is vagrant.
+#   def vagrant?
+#     env == :vagrant
+#   end
+# end

data/lib/melissadata/native_object.rb

@@ -0,0 +1,19 @@
+module MelissaData
+  module NativeObject
+    autoload :Base,       'melissadata/native_object/base'
+    autoload :Client,     'melissadata/native_object/client'
+
+    autoload :Address,    'melissadata/native_object/address'
+    autoload :Email,      'melissadata/native_object/email'
+    autoload :Geo,        'melissadata/native_object/geo'
+    autoload :IpLocator,  'melissadata/native_object/ip_locator'
+    autoload :Name,       'melissadata/native_object/name'
+    autoload :Phone,      'melissadata/native_object/phone'
+  end
+end
+
+%w[
+  mdAddrRubyWrapper mdEmailRubyWrapper mdGeoRubyWrapper mdNameRubyWrapper mdPhoneRubyWrapper mdIpLocatorRubyWrapper
+].each do |obj|
+  require File.join('/opt/melissadata/lib', obj)
+end

data/lib/melissadata/native_object/address.rb

@@ -0,0 +1,124 @@
+module MelissaData::NativeObject
+  class Address < Base
+    def initialize(opts={})
+      @obj = MdAddrRubyWrapper::MdAddr.new
+      obj.SetPathToUSFiles(data_dir)
+      obj.SetUseUSPSPreferredCityNames(1)
+
+      @result_codes = [
+        ['AS01', "Address matched to postal database"],
+        ['AS09', "Foreign postal code detected"],
+        ['AS10', "Address matched to CMRA"],
+        ['AS12', "Address deliverable by non-USPS carriers"],
+        ['AS13', "Address has been updated by LACS"],
+        ['AS14', "Suite appended by SuiteLink"],
+        ['AS15', "Suite appended by AddressPlus"],
+        ['AS16', "Address is vacant"],
+        ['AS17', "Alternate delivery"],
+        ['AE01', "Zip code"],
+        ['AE02', "Unknown street"],
+        ['AE03', "Component mismatch"],
+        ['AE04', "Non-deliverable address"],
+        ['AE05', "Multiple match"],
+        ['AE06', "Early warning system error"],
+        ['AE07', "Missing minimum address input"],
+        ['AE08', "Suite range invalid"],
+        ['AE09', "Suite range missing"],
+        ['AE10', "Primary range invalid"],
+        ['AE11', "Primary range missing"],
+        ['AE12', "PO, HC, or RR box number invalid"],
+        ['AE13', "PO, HC, or RR box number missing"],
+        ['AE14', "CMRA secondary missing"],
+        ['AE15', "Demo mode"],
+        ['AE16', "Expired database"]
+      ]
+
+      @defaults = {
+        :company => '',
+        :address => '',
+        :address2 => '',
+        :city => '',
+        :state => '',
+        :zip => '',
+        :last_name => ''
+      }
+
+      # At least one of these needs to be present
+      @required_fields = [:address, :city, :state, :zip]
+
+      super
+    end
+
+    def parse_input
+      obj.ClearProperties
+      obj.SetCompany   input[:company].to_s
+      obj.SetAddress   input[:address].to_s
+      obj.SetAddress2  input[:address2].to_s
+      obj.SetCity      input[:city].to_s
+      obj.SetState     input[:state].to_s
+      obj.SetZip       input[:zip].to_s
+      obj.SetLastName  input[:last_name].to_s
+
+      obj.VerifyAddress
+    end
+
+    def assign_values
+      @output = {
+        :company => obj.GetCompany,
+        :address => obj.GetAddress,
+        :address2 => obj.GetAddress2,
+        :suite => obj.GetSuite,
+        :city => obj.GetCity,
+        :state => obj.GetState,
+        :zip => obj.GetZip,
+        :plus4 => obj.GetPlus4,
+        :country_code => obj.GetCountryCode,
+        :urbanization => obj.GetUrbanization,
+
+        :parsed_address_range => obj.GetParsedAddressRange,
+        :parsed_pre_direction => obj.GetParsedPreDirection,
+        :parsed_street_name => obj.GetParsedStreetName,
+        :parsed_post_direction => obj.GetParsedPostDirection,
+        :parsed_suffix => obj.GetParsedSuffix,
+        :parsed_suite_name => obj.GetParsedSuiteName,
+        :parsed_suite_range => obj.GetParsedSuiteRange,
+        :parsed_garbage => obj.GetParsedGarbage,
+        :parsed_private_mailbox_name => obj.GetParsedPrivateMailboxName,
+        :parsed_private_mailbox_number => obj.GetParsedPrivateMailboxNumber,
+
+        :carrier_route => obj.GetCarrierRoute,
+        :delivery_point_code => obj.GetDeliveryPointCode,
+        :delivery_point_check_digit => obj.GetDeliveryPointCheckDigit,
+
+        :address_type_code => obj.GetAddressTypeCode,
+        :address_type_string => obj.GetAddressTypeString,
+
+        :city_abbrev => obj.GetCityAbbreviation,
+
+        :cmra => obj.GetCMRA, # Commercial Mail Receiving Agency
+        :private_mailbox => obj.GetPrivateMailbox, # mailbox number at the CMRA
+
+        :msa => obj.GetMsa,
+        :pmsa => obj.GetPmsa,
+
+        :time_zone => obj.GetTimeZone,
+        :time_zone_code => obj.GetTimeZoneCode,
+
+        :county_name => obj.GetCountyName,
+        :county_fips => obj.GetCountyFips,
+        :congressional_district => obj.GetCongressionalDistrict,
+        :zip_type_code => obj.GetZipType
+      }
+
+      output[:zip_type] = case output[:zip_type_code]
+                            when 'P' then 'PO Boxes only'
+                            when 'U' then 'Unique - organization or government'
+                            when 'M' then 'Military'
+                            else       'Standard'
+                          end
+
+      output[:zip9] = "#{output[:zip]}-#{output[:plus4]}" if output[:plus4].present?
+      output[:zip11] = "#{output[:zip9]}-#{output[:delivery_point_code]}" if output[:delivery_point_code].present?
+    end
+  end
+end