magic_addresses 0.0.12 → 0.0.13

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YTE5ZTVlZjI1ZmUyODQ0YWE0Zjg0Y2ZjYjhiNTZlNjhhZGRkNmFhNA==
-  data.tar.gz: !binary |-
-    OTkzYTVhZmQyZmJiZjJjYjdlMmE5MzVlZWVlODBhNmVjZGM3MTU3MQ==
+SHA1:
+  metadata.gz: 04b5e9909e1b2e874ca012a22f9ec278cb2a6c4f
+  data.tar.gz: dfa7e10310297100ff901bf1abf04dacce29eeee
 SHA512:
-  metadata.gz: !binary |-
-    MjQ3Nzg0NzRkYWNmM2ExMzQwMDBhMjVjZDM0YjM0NWU3NTY4MzhhMWE3Yjk1
-    NjE2NmExNjg3NWRjOWZmOWRjMTEwNTIzYjEyMDAzNzk5MzcwOWVlOGQ5OTdi
-    NGNlNTEzN2NlMGE0NTkxMzMwZGQzOWI5ZTk5OThiYjY3ZDk4NWE=
-  data.tar.gz: !binary |-
-    ZmM2ZDY1N2Q0ZjUyNGRiYzMwYTA1MTMzYzczNjA1YjhhNjI4MjRlOWI3MjIy
-    YWU5Y2MyNDJhMzQyNzEzYTE2ZmUzNTRiYjFmMzkzOGI0OTUyYWVkZTQzN2Vm
-    ODVlNGYwZTkwNjZkZjg0NzVhNzIyMWIxYTJjMTRhMzc0NGFkNmY=
+  metadata.gz: 0d3f5fb35f5dab3de3f50699581e82c117bc591dd5a14f63fa2f1e23115593146a11d374b8c270721801d3112fb31d3ebddd5a974ab1b4b620ee49af8cb4e4a1
+  data.tar.gz: 3e73a954d8c9e3bd148ba8cb876c0ade5a35f5764f2c75c88bad454120b2c3efe65d04f92d20edf42c0d71c79de4394ba17f08974989d997b3b268d5915916e8

data/README.md

@@ -15,7 +15,38 @@ rails g magic_addresses:install
 - 4. **add to your models**
 
 
-#### Model methods
+## Features
+
+- full tranlated addresses
+- allways correct addresses (query to google/verbatim service)
+- addresses, cities, countries, and so one, are uniq (i.e. only one "New-York" with lots of addresses, districts, ..)
+- perfect order ( city has X addresses )
+- postgresql earthdistance included (for distance checks)
+- tested
+
+
+
+
+## New
+since version `0.0.13` addresses are uniq, so the same address never will be saved twice, instead owners share one address
+
+run:
+```ruby
+rails g magic_addresses:update
+```
+to update old addresses and add the new structure
+
+
+##### You can add Earthdistance plugin later!
+run:
+```ruby
+rails g magic_addresses:add_earthdistance
+```
+be sure to activate it in initializer before migrate!
+
+
+
+### Model methods
 
 ```ruby
   has_one_address     # => This model has one address associated with it. (ie: User)
@@ -29,7 +60,7 @@ rails g magic_addresses:install
 
 ```
 
-#### View Mehtods
+### View Mehtods
 
 ```ruby
   
@@ -41,7 +72,7 @@ rails g magic_addresses:install
   
 ```
 
-#### in your Controllers:
+### in your Controllers:
 
 ```ruby
   
@@ -66,6 +97,29 @@ rails g magic_addresses:install
 ```
 
 
+## Configuration
+```ruby
+  
+  MagicAddresses.configure do |config|
+    # in which locales addresses should be saved
+    config.active_locales = [:en, :de]
+    # what is the default language (should be :en, except you don't need english at all)
+    config.default_locale = :en
+    # what is the default country for query
+    config.default_country = "Germany"
+    # add default country in each query ?
+    config.query_defaults = true
+    # only save tranlations when differs from default-locale?
+    config.uniq_translations = true
+    # use a background-process for the lookups ( :none | :sidekiq )
+    config.job_backend = :none
+    # use a postgres earthdistance for distance calculation
+    config.earthdistance = false
+  end
+  
+```
+
+
 
 #### Structure
 
@@ -105,7 +159,7 @@ Address:
 ```
 
 
-.. will more info, sometimes ...
+.. will add more info, sometimes ...
 
 
 This project rocks and uses MIT-LICENSE.

data/app/views/magic_addresses/addresses/_address_fields.html.erb

@@ -3,7 +3,7 @@
 <% idkey = "locations_attributes_#{rand(999999)}_" %>
 <div class="map_form">
 	
-		<input type="text" id="<%= idkey %>map_data" class="mgca_map_data <%= style %>" placeholder="<%= placeholder %>" value="<%= f.object.presentation %>" />
+		<input type="text" id="<%= idkey %>map_data" class="mgca_map_data <%= style %>" placeholder="<%= placeholder %>" value="<%= f.object ? f.object.presentation : "" %>" autocomplete="false" role="presentation" />
 		
 		<div class="hidden_mgca_form">
 		  <div class="row">

data/app/views/magic_addresses/addresses/_addresses_fields.html.erb

@@ -8,7 +8,7 @@
 	</div>
 	
 	<div class="fields">
-		<input type="text" id="<%= idkey %>map_data" class="mgca_short_data <%= style %>" placeholder="<%= placeholder %>" value="<%= f.object.presentation %>"/>
+		<input type="text" id="<%= idkey %>map_data" class="mgca_short_data <%= style %>" placeholder="<%= placeholder %>" value="<%= f.object ? f.object.presentation : "" %>" autocomplete="false" role="presentation" />
 		<%= f.hidden_field :street, class: "mgca_txt street", id: "#{idkey}street" %>
 		<%= f.hidden_field :street_number, class: "mgca_txt street_number", id: "#{idkey}street_number" %>
 		<%= f.hidden_field :latitude, id: "#{idkey}latitude", class: "mgca_latitude" %>

data/lib/app/models/magic_addresses/address.rb

@@ -10,7 +10,14 @@ class MagicAddresses::Address < ActiveRecord::Base
   
   
   # =====> A S S O Z I A T I O N S <========================================================= #
-  belongs_to :owner,              polymorphic: true
+  has_many :addressibles,         class_name: "MagicAddresses::Addressible",  foreign_key: :address_id
+  
+  
+  ## add associations (set in configuration)
+  MagicAddresses.configuration.address_owners.each do |key,type|
+    has_many key.to_sym, through: :addressibles, source: :owner, source_type: type
+  end
+  
   
   belongs_to :magic_country,      class_name: "MagicAddresses::Country",      foreign_key: :country_id
   belongs_to :magic_state,        class_name: "MagicAddresses::State",        foreign_key: :state_id
@@ -23,13 +30,14 @@ class MagicAddresses::Address < ActiveRecord::Base
   #     address.street_name                                      # => street in I18n.locale
   #     address.read_attribute(:street_name, locale: :de)        # => street in german (:de), no fallback
   #
-  # translates :street_name, fallbacks_for_empty_translations: true #, table_name: "mgca_addresses"
   mgca_translate :street_name
   
   acts_as_geolocated lat: 'latitude', lng: 'longitude' if MagicAddresses.configuration.earthdistance
   
   
   # =====> A T T R I B U T E S <============================================================= #
+  # accepts_nested_attributes_for :translations
+  
   serialize       :fetch_address, Hash
   
   %w[fetch_street fetch_number fetch_city fetch_zipcode fetch_country fetch_country_code].each do |key|
@@ -81,16 +89,16 @@ class MagicAddresses::Address < ActiveRecord::Base
     self.fetch_address = (fetch_address || {}).merge("fetch_country_code" => value)
   end
   
+  def owner=(this)
+    self.addressibles.where( owner_type: this.class.to_s, owner_id: this.id ).first_or_create!
+  end
   
-  # accepts_nested_attributes_for :translations
-  
-  
-  # =====> V A L I D A T I O N <============================================================= #
-  # => validates :owner, :presence => true
   
   
   # =====> C A L L B A C K S <=============================================================== #
-  after_save :build_address_associations_if_needed
+  ## now in addressible or doesnt work nested ..
+  # => after_save :build_address_associations_if_needed
+  # => after_create :build_address_associations_if_needed
   
   # =====> S C O P E S <===================================================================== #
   
@@ -114,11 +122,25 @@ class MagicAddresses::Address < ActiveRecord::Base
     end
   end
   
+  def owners
+    addressibles.map { |that| ::MagicAddresses::OwnerProxy.new( that ) }
+  end
+  
+  def trigger_build_address_associations
+    build_address_associations()
+  end
+  
+  def trigger_complete_translated_attributes
+    complete_translated_attributes()
+  end
+  
+  
   # =====>  P  R  I  V  A  T  E  !  <======================================================== # # # # # # # #
 private
   
   def build_address_associations_if_needed
-    if self.new_record? || self.fetch_street.present? || self.fetch_city.present? || self.fetch_zipcode.present? || self.fetch_number.present?
+    #if self.new_record? || self.fetch_street.present? || self.fetch_city.present? || self.fetch_zipcode.present? || self.fetch_number.present?
+    if self.new_record? || !["fetched", "translated"].include?( self.status )
       build_address_associations
     else
       true
@@ -128,52 +150,94 @@ private
   def build_address_associations
     dev_log "triggered   A D D R E S S - B U I L D E R ! - - #{self.street} #{self.number} #{self.city} #{self.zipcode}"
     
-    addr = []
     if self.fetch_city.present? || self.fetch_zipcode.present?
+      self.fetch_address["addr"] = []
       # MagicAddresses::GeoCoder
-      addr << "#{self.fetch_street} #{self.fetch_number}".strip if self.fetch_street
-      addr << "#{self.fetch_zipcode} #{self.fetch_city}".strip if self.fetch_city || self.fetch_zipcode
-      addr << "#{self.fetch_country || self.fetch_country_code || MagicAddresses.configuration.default_country}".strip
+      self.fetch_address["addr"] << "#{self.fetch_street} #{self.fetch_number}".strip if self.fetch_street
+      self.fetch_address["addr"] << "#{self.fetch_zipcode} #{self.fetch_city}".strip if self.fetch_city || self.fetch_zipcode
+      if MagicAddresses.configuration.query_defaults
+        self.fetch_address["addr"] << "#{self.fetch_country || self.fetch_country_code || MagicAddresses.configuration.default_country}".strip
+      else
+        self.fetch_address["addr"] << "#{self.fetch_country || self.fetch_country_code}".strip if self.fetch_country || self.fetch_country
+      end
     end
     
-    self.fetch_address = {}
     
-    geo_data = {}
-    if addr.any?
-      # => gd = Geocoder.search( self.fetch_address, params: { language: "en" })
-      gd = MagicAddresses::GeoCoder.search( addr.join(", "), default_locale )
-      geo_data[default_locale] =  gd.first if gd.first
-      MagicAddresses.configuration.active_locales.each do |lcl|
-        unless lcl.to_s == default_locale
-          sleep 0.3
-          gd = MagicAddresses::GeoCoder.search( addr.join(", "), lcl.to_s )
-          geo_data[lcl.to_s] =  gd.first if gd.first
+    if self.fetch_address["addr"] && self.fetch_address["addr"].any?
+      self.fetch_address["geo_data"] = {}
+      gd = MagicAddresses::GeoCoder.search(self.fetch_address["addr"].join(", "), default_locale)
+      self.fetch_address["geo_data"][default_locale] =  gd.first if gd.first
+      self.fetch_address["fetched"] = true
+      self.status = "fetched"
+    end
+    
+    
+    if self.fetch_address["geo_data"] && self.fetch_address["geo_data"].any?
+      geo_data = self.fetch_address["geo_data"][default_locale]
+      sames = MagicAddresses::Address.where(  latitude:       geo_data.latitude, 
+                                              longitude:      geo_data.longitude, 
+                                              zipcode:        geo_data.postal_code, 
+                                              street_number:  geo_data.street_number )
+      dev_log "Address.count: #{ MagicAddresses::Address.all.count } .. . .. SAMES.count: #{ sames.count }"
+      if sames.any? && sames.first != self
+        dev_log "   found similar address .. will use that !!!"
+        dev_log "addressibles   #{self.addressibles.count}"
+        that = sames.first
+        dev_log "owners - #{self.owners.inspect}"
+        self.addressibles.each do |x|
+          dev_log "kill - #{x.address_id}"
+          x.address_id = that.id
+          x.save
+          # x.owner.touch
+          dev_log "kill - #{x.address_id}"
+        end
+        self.destroy
+      else
+        dev_log "   geo_data  is present !!!"
+        self.street_default = geo_data.street if geo_data && geo_data.street
+        self.zipcode = geo_data.postal_code if geo_data && geo_data.postal_code
+        self.street_number = geo_data.street_number if geo_data && geo_data.street_number
+        # set geo-position
+        self.latitude = geo_data.latitude if geo_data && geo_data.latitude
+        self.longitude = geo_data.longitude if geo_data && geo_data.longitude
+        # translate other languages
+        
+        if MagicAddresses.configuration.job_backend == :sidekiq
+          AddressWorker.perform_async( self.id )
+        else
+          complete_translated_attributes()
         end
+        
+        self.save
       end
+      
     end
-    if geo_data.any?
-      dev_log "   geo_data  is present !!!"
-      # set default values
-      self.street_default = geo_data[default_locale].street if geo_data[default_locale] && geo_data[default_locale].street
-      self.zipcode = geo_data[default_locale].postal_code if geo_data[default_locale] && geo_data[default_locale].postal_code
-      self.street_number = geo_data[default_locale].street_number if geo_data[default_locale] && geo_data[default_locale].street_number
-      # set geo-position
-      self.latitude = geo_data[default_locale].latitude if geo_data[default_locale] && geo_data[default_locale].latitude
-      self.longitude = geo_data[default_locale].longitude if geo_data[default_locale] && geo_data[default_locale].longitude
-    end
-    complete_translated_attributes( geo_data )
     
-    self.fetch_address = {}
-    self.save
   end
   
   
-  def complete_translated_attributes( geo_data = {} )
+  def complete_translated_attributes
+    
+    MagicAddresses.configuration.active_locales.each do |lcl|
+      unless lcl.to_s == default_locale
+        sleep 0.3
+        gd = MagicAddresses::GeoCoder.search( self.fetch_address["addr"].join(", "), lcl.to_s )
+        self.fetch_address["geo_data"][lcl.to_s] =  gd.first if gd.first
+      end
+    end
+    
+    geo_data = self.fetch_address["geo_data"]
+    
     if geo_data.any?
       # build street parameters
       street_params = []
       geo_data.each do |key, stuff|
-        street_params << { locale: key.to_s, street_name: stuff.street } if stuff.street # && ((stuff.street != geo_data[default_locale].street) || (default_locale == key.to_s))
+        if MagicAddresses.configuration.uniq_translations
+          # => only save locale if different from default-locale:
+          street_params << { locale: key.to_s, street_name: stuff.street } if stuff.street && ((stuff.street != geo_data[default_locale].street) || (default_locale == key.to_s))
+        else
+          street_params << { locale: key.to_s, street_name: stuff.street } if stuff.street
+        end
       end
       # set street parameters if present
       if street_params.any?
@@ -209,6 +273,10 @@ private
         connet_address_association( :subdistrict, geo_data )
       end
       
+      self.fetch_address  = {}
+      self.status         = "translated"
+      self.save
+      
     end
   end
   
@@ -229,7 +297,8 @@ private
     
     dev_log "#{that} .. #{this}"
     
-    self.send(this).translations = []
+    # self.send(this).translations = []
+    self.send(this).translations.delete_all
     self.send(this).translations_attributes = lng_params( that, geo_data )
     self.send(this).save
   end
@@ -240,7 +309,13 @@ private
     lng_params = []
     geo_data.each do |key, stuff|
       dev_log "#{that.to_s.titleize}-Params (#{key}) ... #{stuff.send(that)}"
-      lng_params << { locale: key.to_s, name: stuff.send(that) } if stuff.send(that) # && ((stuff.send(that) != geo_data[default_locale].send(that)) || (key.to_s == default_locale))
+      
+      if MagicAddresses.configuration.uniq_translations
+        # => only save locale if different from default-locale:
+        lng_params << { locale: key.to_s, name: stuff.send(that) } if stuff.send(that) && ((stuff.send(that) != geo_data[default_locale].send(that)) || (key.to_s == default_locale))
+      else
+        lng_params << { locale: key.to_s, name: stuff.send(that) } if stuff.send(that)
+      end
     end
     lng_params
   end

data/lib/app/models/magic_addresses/addressible.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+class MagicAddresses::Addressible < ActiveRecord::Base
+  
+  belongs_to :owner,      polymorphic: true
+  belongs_to :address,    class_name: "MagicAddresses::Address",    foreign_key: :address_id
+  
+  after_create :log_some_stuff
+  
+private
+  
+  def log_some_stuff
+    Rails.logger.info "==="
+    Rails.logger.info "===  #{self.inspect}"
+    Rails.logger.info "==="
+    self.address ? self.address.trigger_build_address_associations : true
+    Rails.logger.info "==="
+    Rails.logger.info "===  #{self.inspect}"
+    Rails.logger.info "==="
+  end
+  
+end

data/lib/app/models/magic_addresses/association.rb

@@ -11,31 +11,58 @@ module MagicAddresses
       
       
       def has_addresses
-        has_many    :addresses, 
+        # has_many    :addresses, 
+        #             as: :owner, 
+        #             class_name: "MagicAddresses::Address", 
+        #             dependent: :destroy
+        
+        has_many    :addressibles,  
                     as: :owner, 
-                    class_name: "MagicAddresses::Address", 
+                    class_name: "MagicAddresses::Addressible", 
                     dependent: :destroy
+        
+        has_many    :addresses, 
+                    through: :addressibles, 
+                    source: :address
+        
         accepts_nested_attributes_for :addresses, allow_destroy: true, reject_if: :all_blank
       end
       
       
       def has_one_address
-        has_one     :address, -> { where(default: true) },
-                    as: :owner,
-                    class_name: "MagicAddresses::Address",
-                    autosave: true,
+        send :include, OneInstanceMethods
+        # has_one     :address, -> { where(default: true) },
+        #             as: :owner,
+        #             class_name: "MagicAddresses::Address",
+        #             autosave: true,
+        #             dependent: :destroy
+        
+        has_one     :addressible, 
+                    -> { where(default: true) }, 
+                    as: :owner, 
+                    class_name: "MagicAddresses::Addressible", 
                     dependent: :destroy
-        accepts_nested_attributes_for :address, allow_destroy: true, reject_if: :all_blank
+        
+        has_one     :address, 
+                    through: :addressible, 
+                    source: :address
+        
+        accepts_nested_attributes_for :addressible, :address, allow_destroy: true, reject_if: :all_blank
       end
       
       
       def has_nested_address
-        send :include, InstanceMethods
-        has_one     :address,
-                    as: :owner,
-                    class_name: "MagicAddresses::Address",
-                    autosave: true,
-                    dependent: :destroy
+        send :include, NestedInstanceMethods
+        # has_one     :address,
+        #             as: :owner,
+        #             class_name: "MagicAddresses::Address",
+        #             autosave: true,
+        #             dependent: :destroy
+        
+        has_one     :addressible, -> { where(default: true) }, 
+                    as: :owner, class_name: "MagicAddresses::Addressible", dependent: :destroy
+        has_one     :address,     through: :addressibles, source: :address
+        
         delegate    :street, :number, :postalcode, :city, :district, :subdistrict, :state, :country,
                     :street=, :number=, :postalcode=, :city=, :country=, 
                     to: :address, allow_nil: true
@@ -46,8 +73,17 @@ module MagicAddresses
       
     end #> ClassMethods
   
-    ##   I N S T A N C E - M E T H O D S   # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
-    module InstanceMethods
+    ##   I N S T A N C E - M E T H O D S   # # # # # # # # # # # # # # # # # # # # # # # 
+    module OneInstanceMethods
+      
+      # => http://stackoverflow.com/a/6989403/1470996
+      def build_address(params)
+        self.address = MagicAddresses::Address.new(params)
+      end
+      
+    end #> InstanceMethods
+    
+    module NestedInstanceMethods
       
       # http://stackoverflow.com/a/4033761
       def address_with_build

data/lib/app/models/magic_addresses/owner_proxy.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+class MagicAddresses::OwnerProxy
+  
+  attr_accessor :this, :addressible_id, :owner_id, :owner_type, :name
+  
+  def initialize( addressible )
+    self.this           = addressible.owner
+    self.addressible_id = addressible.id
+    self.owner_id       = addressible.owner_id
+    self.owner_type     = addressible.owner_type
+    self.name           = addressible.owner && addressible.owner.respond_to?(:name) ? addressible.owner.name : nil
+  end
+  
+end

data/lib/generators/magic_addresses/add_earthdistance_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/migration'
+
+module MagicAddresses
+  module Generators
+    class AddEarthdistanceGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      desc "add magic_addresses earthdistance migrations"
+
+      def self.next_migration_number(path)
+        unless @prev_migration_nr
+          @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        else
+          @prev_migration_nr += 1
+        end
+        @prev_migration_nr.to_s
+      end
+
+      def copy_migrations
+        migration_template( "earthdistance_migration.rb", "db/migrate/add_earthdistance.rb" )
+      end
+
+    end
+  end
+end

data/lib/generators/magic_addresses/templates/earthdistance_migration.rb

@@ -0,0 +1,32 @@
+class AddEarthdistance < ActiveRecord::Migration
+  def self.up
+    
+    # comented out to avoid PG::InsufficientPrivilege-ERROR
+    # add with cap postgresql:add_extensions
+    # => execute "CREATE EXTENSION IF NOT EXISTS cube"
+    # => execute "CREATE EXTENSION IF NOT EXISTS earthdistance"
+    
+    if Rails.env.development? || Rails.env.test?
+      enable_extension "cube"
+      enable_extension "earthdistance"
+    end
+    
+    unless index_exists?(:mgca_addresses, [:latitude,:longitude], name: "mgca_addresses_earthdistance_ix")
+      add_earthdistance_index :mgca_addresses, lat: 'latitude', lng: 'longitude'
+    end
+    
+  end
+
+  def self.down
+    # => execute "DROP EXTENSION IF EXISTS earthdistance"
+    # => execute "DROP EXTENSION IF EXISTS cube"
+    # comented out in staging and production to avoid PG::InsufficientPrivilege-ERROR .. add with cap postgresql:remove_extensions
+    if Rails.env.development? || Rails.env.test?
+      disable_extension "earthdistance"
+      disable_extension "cube"
+    end
+    
+    remove_index :mgca_addresses, [:latitude,:longitude], name: "mgca_addresses_earthdistance_ix"
+    
+  end
+end

data/lib/generators/magic_addresses/templates/geocoder_initializer.rb

@@ -1,5 +1,6 @@
 # Geocoder initialer slightly changed to work with magic_addresses
 Geocoder.configure(
+
   # geocoding options
   :timeout      => 5,           # geocoding service timeout (secs)
   :lookup       => :google,     # name of geocoding service (symbol)
@@ -15,14 +16,15 @@ Geocoder.configure(
   # (if you want to implement custom error handling);
   # supports SocketError and TimeoutError
   # :always_raise => [],
-  
+
   # needs to raise OverQueryLimitError to change lookup type when appears
   :always_raise => [Geocoder::OverQueryLimitError],
 
   # calculation options
   # :units     => :mi,       # :km for kilometers or :mi for miles
   # :distances => :linear    # :spherical or :linear
-  
+
   # needed for nominatim lookups
   :http_headers => { "User-Agent" => "YOUR-APP-NAME", "Accept-Language" => "de" },
+
 )

data/lib/generators/magic_addresses/templates/magic_addresses_migration.rb

@@ -147,6 +147,11 @@ class AddMagicAddresses < ActiveRecord::Migration
   end
   def down
     
+    # when use postgres earthdistance
+    if MagicAddresses.configuration.earthdistance
+      remove_index :mgca_addresses, [:latitude,:longitude], name: "mgca_addresses_earthdistance_ix"
+    end
+    
     ## Addresses
     remove_index  :mgca_addresses, :subdistrict_id
     remove_index  :mgca_addresses, :district_id

data/lib/generators/magic_addresses/templates/magic_initializer.rb

@@ -1,12 +1,18 @@
 MagicAddresses.configure do |config|
+  # Address Owners .. all models that use addresses (name + class_name => {users: "User", things: "Namespace::Thing"}) 
+  config.address_owners     = {}
   # in which locales addresses should be saved
-  config.active_locales = [:en, :de]
+  config.active_locales     = [:en, :de]
   # what is the default language (should be :en, except you don't need english at all)
-  config.default_locale = :en
-  # what is the default country (for lookup)
-  config.default_country = "Germany"
-  # use a background-process for the lookups
-  config.job_backend = :none
-  # use a postgres earthdistance for distance calculation
-  config.earthdistance = false
-end
+  config.default_locale     = :en
+  # what is the default country for query
+  config.default_country    = "Germany"
+  # add default country in each query ?
+  config.query_defaults     = true
+  # only save tranlations when differs from default-locale?
+  config.uniq_translations  = false
+  # use background-process for the lookups ( :none | :sidekiq )
+  config.job_backend        = :none
+  # use postgres earthdistance for distance calculation
+  config.earthdistance      = false
+end