magic_addresses 0.0.42 → 0.0.43

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YWM1OGVmYWMxNzU3MDQ1MDY5ZjA0ZjExYzYxYzc0NDczNTA4OTZjZQ==
-  data.tar.gz: !binary |-
-    ZTU0YjRmZGE3NjY4NDZkNGRkMjFmNWYwY2EwZWNmYjVlMTFjNDBkNA==
+SHA1:
+  metadata.gz: 846a852f80f648ff9d56dccd47e93e833b7d0cd9
+  data.tar.gz: efa7826e64ff4c6650217c0f96f692f7594db2f9
 SHA512:
-  metadata.gz: !binary |-
-    ZjFkOGIzYWYxYmVhNWU2NTUzYWRkNWIyNzgzZjNiODcwNTRhZWFlZGI2MzFl
-    ODhjY2IwOTlkZTc0ZGE5YTJlNjQ4ODlmM2U0MmJiYzJiNmFmNTk4ZDAwYmU5
-    ZDRiNzFkMGM5MTdmODczNTdlNWUyMzQzNTBjOGEyNDIyNjcwOTM=
-  data.tar.gz: !binary |-
-    NDA5MDdmMGZkNDBkYTY0N2ZmY2E4OThhMWRjZWFkMzIxNWEyZWQ5ZGU5M2Fi
-    MzM0MTIxODU0MWE3YzkzYjE1NjNkNDBhODNiZTgzNTAzMWVhNzZiNWRhMjlh
-    ZmNhY2M4OTc0ODIyMDBlNjZmYzg3ZjczOTM1MGY2YmYzYTVjOWI=
+  metadata.gz: 3cc46873a9cb142446e57ebb55a784370cc1133ab9610e25dc581c71dcd2932f4cd61a99fb2f021ddd43a772f10b9e806dc467580d1530cd1b3f533cbea750ef
+  data.tar.gz: 33c83e8709a761cf493b0795bb1c91d6d198e3b998a903ab5d41c38962ee975abebe851ad55ac711bf7d5b1d28342a92d62e0c873fba60cd82b451e1469c6f9c

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

@@ -40,6 +40,8 @@ class MagicAddresses::Address < ActiveRecord::Base
   
   serialize       :fetch_address, Hash
   
+  
+  # fetch getter and setter
   %w[fetch_street fetch_number fetch_city fetch_zipcode fetch_country fetch_country_code].each do |key|
     define_method(key) do
       fetch_address && fetch_address[key]
@@ -52,60 +54,85 @@ class MagicAddresses::Address < ActiveRecord::Base
   def street
     fetch_address && fetch_address["fetch_street"] || street_name
   end
-  def street=(value)
-    self.street_name = value
-    self.fetch_address = (fetch_address || {}).merge("fetch_street" => value)
-  end
   # attr_accessor :number (:street_number)
   def number
     fetch_address && fetch_address["fetch_number"] || street_number
   end
-  def number=(value)
-    self.fetch_address = (fetch_address || {}).merge("fetch_number" => value)
-  end
   # attr_accessor :postalcode (:zipcode)
   def postalcode
     fetch_address && fetch_address["fetch_zipcode"] || zipcode
   end
-  def postalcode=(value)
-    self.fetch_address = (fetch_address || {}).merge("fetch_zipcode" => value)
+  # attr_accessor :country_code
+  def country_code
+    fetch_address && fetch_address["fetch_country_code"] || self.send("magic_country") && self.send("magic_country").iso_code
   end
-  
+  # more getter
   %w[country state city district subdistrict].each do |key|
     # attr_accessor key
     define_method(key) do
       fetch_address && fetch_address["fetch_#{key}"] || self.send("magic_#{key}") && self.send("magic_#{key}").name
     end
+  end
+  # settter methods
+  %w[country state city district subdistrict street number postalcode country_code].each do |key|
     define_method("#{key}=") do |value|
-      # self["fetch_#{key}"] = value
-      self.fetch_address = (fetch_address || {}).merge("fetch_#{key}" => value)
+      self.street_name = value  if key == "street"
+      self.fetch_address = (fetch_address || {}).merge("fetch_#{ key == 'postalcode' ? 'zipcode' : key }" => value)
     end
   end
-  
-  def country_code
-    fetch_address && fetch_address["fetch_country_code"] || self.send("magic_country") && self.send("magic_country").iso_code
-  end
-  def country_code=(value)
-    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
-  
-  
-  
+
+
+
   # =====> C A L L B A C K S <=============================================================== #
   ## 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 <===================================================================== #
-  
+
+
   # =====> C L A S S - M E T H O D S <======================================================= #
+  def self.get_one( owner, params )
+    # => that = self.new( city: params[:city], postalcode: params[:postalcode], street: params[:street], number:  params[:number], country: params[:country] )
+    # => that.owner = owner
+    # => that.save
+    # => that.trigger_build_address_associations
+    # puts "> get_one( #{ owner.class },  #{params}  )"
+    if params[:id].present? && self.find( params[:id].to_i )
+      current = self.find( params[:id].to_i )
+      # if params[:postalcode].present? || params[:postalcode].present? || params[:postalcode].present? || params[:postalcode].present?
+      checker = []
+      [:street, :number, :postalcode, :city, :country].each do |prm|
+        if params[prm].present? && ( "#{ params[prm] }" != "#{ current.send("#{prm}") }" )
+          checker << true
+          puts "#{prm}:  #{ params[prm] }  !=  #{ current.send("#{prm}") }"
+        end
+      end
+      if checker.include?( true )
+        that = self.new( city: params[:city], postalcode: params[:postalcode], street: params[:street], number:  params[:number], country: params[:country] )
+        that.trigger_build_address_associations
+      else
+        current
+      end
+    else
+      if params[:postalcode].present? && params[:city].present?
+        that = self.new( city: params[:city], postalcode: params[:postalcode], street: params[:street], number:  params[:number], country: params[:country] )
+        that.trigger_build_address_associations
+      else
+        nil
+      end
+    end
+  end
+  
   
   # =====> I N S T A N C E - M E T H O D S <================================================= #
   
+  def update_fetch_address( atts = {} )
+    self.fetch_address = (self.fetch_address || {}).merge( atts )
+  end
+  
+  
   def presentation( style = "full", type = "inline" )
     adr = []
     adr << "#{street} #{number}".strip if street.present?
@@ -126,6 +153,10 @@ class MagicAddresses::Address < ActiveRecord::Base
     addressibles.map { |that| ::MagicAddresses::OwnerProxy.new( that ) }
   end
   
+  def owner=(this)
+    self.addressibles.where( owner_type: this.class.to_s, owner_id: this.id ).first_or_create!
+  end
+  
   def touch_owners
     addressibles.map { |that| that.owner.touch }
   end
@@ -152,9 +183,7 @@ private
   end
   
   
-  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}"
-    
+  def build_fetch_address_addr
     if self.fetch_city.present? || self.fetch_zipcode.present?
       self.fetch_address["addr"] = []
       # MagicAddresses::GeoCoder
@@ -166,8 +195,10 @@ private
         self.fetch_address["addr"] << "#{self.fetch_country || self.fetch_country_code}".strip if self.fetch_country || self.fetch_country
       end
     end
-    
-    
+  end
+  
+  
+  def build_fetch_address_geo_data
     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)
@@ -175,55 +206,76 @@ private
       self.fetch_address["fetched"] = true
       self.status = "fetched"
     end
+  end
+  
+  def set_address_defaults( geo_data )
+    if geo_data
+      self.street_default = geo_data.street         if geo_data.street
+      self.zipcode        = geo_data.postal_code    if geo_data.postal_code
+      self.street_number  = geo_data.street_number  if geo_data.street_number
+      # set geo-position
+      self.latitude       = geo_data.latitude       if geo_data.latitude
+      self.longitude      = geo_data.longitude      if geo_data.longitude
+    end
+  end
+  
+  
+  def build_address_associations
+    dev_log "- - - - - - - - - - - - - - - - -"
+    dev_log " A D D R E S S - B U I L D E R !  ->  #{self.street} #{self.number} #{self.city} #{self.postalcode}"
     
+    build_fetch_address_addr( )
+    
+    build_fetch_address_geo_data( )
     
     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}"
+      if self.id && self.id.present?
+        loockups = MagicAddresses::Address.where.not( id: self.id )
+      else
+        loockups = MagicAddresses::Address.unscoped
+      end
+      sames = loockups.where(
+                                latitude: geo_data.latitude, longitude: geo_data.longitude, 
+                                zipcode: geo_data.postal_code, street_default: geo_data.street, street_number: geo_data.street_number 
+                             )
+      if sames.any?
+        dev_log "! found similar address .. will use that !"
         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.addressibles.map{ |x| x.update_column(:address_id, that.id) }
         self.destroy
-        
+        dev_log
         ## inform address owners
         that.touch_owners
+        ## return address
+        that
       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
-          ::MagicAddresses::AddressWorker.perform_async( self.id )
+        if self.status == "translated"
+          dev_log "! allready set-up ... change!"
+          dev_log
         else
-          complete_translated_attributes()
+          # set default values
+          set_address_defaults( geo_data )
+          # translate other languages
+          if MagicAddresses.configuration.job_backend == :sidekiq
+            ::MagicAddresses::AddressWorker.perform_async( self.id )
+          else
+            complete_translated_attributes()
+          end
+          self.save
+          dev_log
+          ## inform address owners
+          self.touch_owners
+          ## return address
+          self
         end
         
-        self.save
-        
-        ## inform address owners
-        self.touch_owners
       end
       
     end
     
+    
   end
   
   
@@ -241,8 +293,10 @@ private
     
     if geo_data.any?
       # build street parameters
+      dev_log ">>> Street"
       street_params = []
       geo_data.each do |key, stuff|
+        dev_log "    #{key}:  #{ stuff.street }"
         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))
@@ -252,13 +306,12 @@ private
       end
       # set street parameters if present
       if street_params.any?
-        dev_log "empty street translations"
         # reset translations (avoid empty translation in default language)
         # => self.translations = []
         self.translations.delete_all
         # set street parameters
         self.translations_attributes = street_params
-        dev_log "set new street translations"
+        dev_log "    set translations: #{ street_params.map{ |k| k[:locale] }.join(", ") }"
       end
       
       self.street_default = geo_data[default_locale].street if geo_data[default_locale] && geo_data[default_locale].street
@@ -294,7 +347,8 @@ private
   ## Build Associations
   
   def connet_address_association( that, geo_data )
-    dev_log ">>> #{that.to_s.upcase}: #{ geo_data[default_locale].send(that) }"
+    this = "magic_#{that}".to_sym
+    dev_log "#{that.to_s.upcase} (#{this}):   #{ geo_data[default_locale].send(that) }"
     that_params = { default_name: geo_data[default_locale].send(that).to_s }
     that_params[ that == :country ? :iso_code : :short_name ] = geo_data[default_locale].send( "#{that}_code".to_sym ).to_s
     that_params.merge!({ country_id: self.magic_country.id })     if [:city, :state].include?(that) && self.magic_country
@@ -302,12 +356,8 @@ private
     that_params.merge!({ city_id: self.magic_city.id })           if [:district, :subdistrict].include?(that) && self.magic_city
     that_params.merge!({ district_id: self.magic_district.id })   if that == :subdistrict && self.magic_district
     
-    this = "magic_#{that}".to_sym
-    
     self.attributes = { this => "MagicAddresses::#{that.to_s.classify}".constantize.unscoped.where( that_params ).first_or_create! }# unless self.send(that)
     
-    dev_log "#{that} .. #{this}"
-    
     # self.send(this).translations = []
     self.send(this).translations.delete_all
     self.send(this).translations_attributes = lng_params( that, geo_data )
@@ -319,7 +369,7 @@ private
   def lng_params( that, geo_data )
     lng_params = []
     geo_data.each do |key, stuff|
-      dev_log "#{that.to_s.titleize}-Params (#{key}) ... #{stuff.send(that)}"
+      dev_log "    #{key}:   #{stuff.send(that)}"
       
       if MagicAddresses.configuration.uniq_translations
         # => only save locale if different from default-locale:
@@ -331,11 +381,15 @@ private
     lng_params
   end
   
+  def update_fetch_address( atts = {} )
+    self.fetch_address = (self.fetch_address || {}).merge( atts )
+  end
+  
   def dev_log( stuff = " " )
-    if !Rails.env.production?
-      Rails.logger.info "###"
+    if Rails.env.test?
+      puts "#: #{stuff}"
+    elsif !Rails.env.production?
       Rails.logger.info "###   #{stuff}"
-      Rails.logger.info "###"
     end
   end
   

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

@@ -15,7 +15,7 @@ class MagicAddresses::Addressible < ActiveRecord::Base
   
   
   # =====> C A L L B A C K S <=============================================================== #
-  after_commit :log_some_stuff
+  # after_commit :log_some_stuff
   
   # =====>  P  R  I  V  A  T  E  !  <======================================================== # # # # # # # #
 private

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

@@ -47,7 +47,7 @@ module MagicAddresses
                     through: :addressible, 
                     source: :address
         
-        accepts_nested_attributes_for :addressible, :address, allow_destroy: true, reject_if: :all_blank
+        # accepts_nested_attributes_for :addressible, :address, allow_destroy: true, reject_if: :all_blank
       end
       
       
@@ -83,6 +83,16 @@ module MagicAddresses
         self.addressible.build_address(params)
       end
       
+      def address_attributes=( params )
+        # puts "address_attributes"
+        self.address = MagicAddresses::Address.get_one( self, params )
+      end
+      
+      def addressible_attributes=( params )
+        # puts "addressible_attributes"
+        self.address = MagicAddresses::Address.get_one( self, params[:address_attributes] )
+      end
+      
     end #> InstanceMethods
     
     module NestedInstanceMethods

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

@@ -8,17 +8,17 @@ class MagicAddresses::GeoCoder
       begin
         search_via_google
         results = Geocoder.search( q, language: language )
-        log "google Geocoded:   #{results.to_yaml}"
+        log " - google:   [#{results.count}]"
         return results
       rescue Exception => e
-        log "Google -- #{e}"
+        log "! Google-Error:   #{e} !"
         sleep 0.3
         attempts += 1
       end while attempts < 3
       unless results
         search_via_nominatim
         results = Geocoder.search( q, language: language )
-        log "nominatim Geocoded:   #{results.to_yaml}"
+        log " - nominatim:   [#{results.count}]"
       end
     else
       results = []
@@ -35,11 +35,11 @@ class MagicAddresses::GeoCoder
     Geocoder.configure( :lookup => :nominatim )
   end
   
-  def self.log( stuff = "+ geo + geo + geo + geo + geo + geo + " )
-    if Rails.env.development?
-      Rails.logger.info "+ geo + geo + geo + geo + geo + geo + "
-      Rails.logger.info stuff
-      Rails.logger.info "+ geo + geo + geo + geo + geo + geo + "
+  def self.log( stuff = " " )
+    if Rails.env.test?
+      puts "#: #{stuff}"
+    elsif !Rails.env.production?
+      Rails.logger.info "###   #{stuff}"
     end
   end
   

data/lib/app/models/magic_addresses.rb

@@ -1,6 +1,9 @@
 # encoding: utf-8
 module MagicAddresses
+  
+  # =====> C L A S S - M E T H O D S <======================================================= #
   def self.table_name_prefix
     'mgca_'
   end
+  
 end

data/lib/magic_addresses/version.rb

@@ -1,3 +1,3 @@
 module MagicAddresses
-  VERSION = "0.0.42"
+  VERSION = "0.0.43"
 end

data/spec/models/magic_addresses/address_spec.rb

@@ -136,6 +136,9 @@ describe MagicAddresses::Address do
   describe "fetches correct address after save" do
     
     let(:user){ User.create!(name: "Some User", address_attributes: { street: "Heinz-Kapelle-Str.", number: "6", postalcode: 10407, city: "Berlin", country:"Germany"}) }
+    
+    # let(:user){ User.create!(name: "Some User", addressible_attributes: { address_attributes: { street: "Heinz-Kapelle-Str.", number: "6", postalcode: 10407, city: "Berlin", country:"Germany"}}) }
+    
     # let(:address){ MagicAddresses::Address.create!(name: "Another", owner: user) }
     let(:address){ 
       user.address
@@ -182,12 +185,12 @@ describe MagicAddresses::Address do
       expect( MagicAddresses::Subdistrict.all.count ).to eq( 1 )
       
       # address attributes should be set
-      expect( address.number ).to eq( "6" )
-      expect( address.street_number ).to eq( "6" )
-      expect( address.postalcode ).to eq( 10407 )
-      expect( address.zipcode ).to eq( 10407 )
-      expect( address.street ).to eq( "Heinz-Kapelle-Straße" )
-      expect( address.street_name ).to eq( "Heinz-Kapelle-Straße" )
+      expect( user.address.number ).to eq( "6" )
+      expect( user.address.street_number ).to eq( "6" )
+      expect( user.address.postalcode ).to eq( 10407 )
+      expect( user.address.zipcode ).to eq( 10407 )
+      expect( user.address.street ).to match( /Heinz-Kapelle-Str[.|aße]{1,3}/ )
+      expect( user.address.street_name ).to match( /Heinz-Kapelle-Str[.|aße]{1,3}/ )
       
       # all virtual atts and associations should be equal
       expect( address.country ).to eq( "Germany" )

data/spec/models/user_spec.rb

@@ -35,4 +35,167 @@ RSpec.describe User, type: :model do
     
   end
   
+  
+  it "does not change address for other owners" do
+    
+    addr = { street: "Heinz-Kapelle-Str.", number: "6", postalcode: "10407", city: "Berlin"}
+    usr1 = { name: "tom", address_attributes: addr }
+    usr2 = { name: "tim", address_attributes: addr }
+    
+    u1 = User.create!( usr1 )
+    u2 = User.create!( usr2 )
+    
+    # sleep 3
+    
+    expect( User.all.count ).to eq 2
+    expect( MagicAddresses::Address.all.count ).to eq 1
+    
+    u1 = User.find_by( name: "tom" )
+    u2 = User.find_by( name: "tim" )
+    
+    u2.update( address_attributes: addr.merge({ number: 8 }) )
+    
+    expect( MagicAddresses::Address.all.count ).to eq 2
+    expect( MagicAddresses::Addressible.where(default: true).count ).to eq 2
+    
+    expect( u1.address.id ).to eq MagicAddresses::Address.first.id
+    expect( u2.address.id ).to eq MagicAddresses::Address.last.id
+    
+    expect( u1.address.id ).not_to eq u2.address.id
+    
+  end
+  
+  
+  it "does not change address for other owners" do
+    
+    addr = { street: "Heinz-Kapelle-Str.", number: "6", postalcode: "10407", city: "Berlin"}
+    usr1 = { name: "tom", addressible_attributes: {address_attributes: addr} }
+    usr2 = { name: "tim", addressible_attributes: {address_attributes: addr} }
+    
+    u1 = User.create!( usr1 )
+    u2 = User.create!( usr2 )
+    
+    # sleep 3
+    
+    expect( User.all.count ).to eq 2
+    expect( MagicAddresses::Address.all.count ).to eq 1
+    
+    u1 = User.find_by( name: "tom" )
+    u2 = User.find_by( name: "tim" )
+    
+    u2.update( addressible_attributes: { address_attributes: addr.merge({ number: 8 }) } )
+    
+    expect( u1.address.id ).to eq MagicAddresses::Address.first.id
+    expect( u2.address.id ).to eq MagicAddresses::Address.last.id
+    
+    expect( u1.address.id ).not_to eq u2.address.id
+    
+  end
+  
+  
+  it "does not save address without changes" do
+    addr = { street: "Heinz-Kapelle-Str.", number: "6", postalcode: "10407", city: "Berlin"}
+    usr1 = { name: "tom", address_attributes: addr }
+    usr2 = { name: "tim", addressible_attributes: {address_attributes: addr} }
+    
+    u1 = User.create!( usr1 )
+    u2 = User.create!( usr2 )
+    
+    expect( User.all.count ).to eq 2
+    expect( MagicAddresses::Address.all.count ).to eq 1
+    
+    u1 = User.find_by( name: "tom" )
+    u2 = User.find_by( name: "tim" )
+    
+    u2.update( addressible_attributes: { id: u2.addressible.id, address_attributes: addr.merge({ id: u2.address.id, number: "4" }) } )
+    
+    expect( u1.address.id ).to eq MagicAddresses::Address.first.id
+    expect( u2.address.id ).to eq MagicAddresses::Address.last.id
+    
+    expect( u1.address.id ).not_to eq u2.address.id
+    
+  end
+  
+  it "does not update address without changes" do
+    addr = { street: "Heinz-Kapelle-Str.", number: "6", postalcode: "10407", city: "Berlin"}
+    usr1 = { name: "tom", address_attributes: addr }
+    usr2 = { name: "tim", addressible_attributes: {address_attributes: addr} }
+    
+    u1 = User.create!( usr1 )
+    u2 = User.create!( usr2 )
+    
+    expect( User.all.count ).to eq 2
+    expect( MagicAddresses::Address.all.count ).to eq 1
+    
+    u1 = User.find_by( name: "tom" )
+    u2 = User.find_by( name: "tim" )
+    
+    u1.update( address_attributes: addr.merge({ id: u1.address.id }) )
+    u2.update( addressible_attributes: { id: u2.addressible.id, address_attributes: addr.merge({ id: u2.address.id }) } )
+    
+    expect( MagicAddresses::Address.all.count ).to eq 1
+    
+    expect( u1.address.id ).to eq MagicAddresses::Address.first.id
+    expect( u2.address.id ).to eq MagicAddresses::Address.first.id
+    
+  end
+  
+  describe "(magic) Address" do
+    it { should respond_to :addressible }
+    it { should respond_to :address }
+    it 'creates address magic' do
+      @that = User.create!( name: "Acme" )
+      # @that = User.create!( name: "Acme", address_attributes: {street: "Reinhardtstraße", number: "9", postalcode: "10117", city: "Berlin", country: "Germany"} )
+      # @that.build_address( {street: "Reinhardtstraße", number: "9", postalcode: "10117", city: "Berlin", country: "Germany"} )
+      @that.address = MagicAddresses::Address.create( street: "Reinhardtstraße", number: "9", postalcode: "10117", city: "Berlin", country: "Germany" )
+      @that.save
+      @that.address.trigger_build_address_associations
+      # sleep 2
+      @that = User.last
+      expect( @that.address ).not_to eql( nil )
+      expect( @that.address.street ).to eql( "Reinhardtstraße" )
+      expect( @that.address.longitude ).not_to eql( nil )
+    end
+    
+    it 'doesn`t change address for multiple companies', focus: true do
+      @that = User.create!( name: "Acme", addressible_attributes: {address_attributes: {street: "Reinhardtstraße", number: "9", postalcode: "10117", city: "Berlin", country: "Germany"}} )
+      # @that.address.trigger_build_address_associations
+      # sleep 4
+      @that = @that.reload
+      expect( @that.address ).not_to eql( nil )
+      expect( @that.address.street ).to eql( "Reinhardtstraße" )
+      expect( @that.address.longitude ).not_to eql( nil )
+      
+      @this = User.create!( name: "Apple", addressible_attributes: {address_attributes: {street: "Reinhardtstraße", number: "9", postalcode: "10117", city: "Berlin", country: "Germany"}} )
+      
+      @this = @this.reload
+      # @this.address.trigger_build_address_associations
+      # sleep 2
+      @this = @this.reload
+      expect( @this.address ).not_to eql( nil )
+      expect( @this.address.street ).to eql( "Reinhardtstraße" )
+      expect( @this.address.longitude ).not_to eql( nil )
+      
+      puts "#####"
+      
+      # => @that.address.street = "Reinhardtstraße"
+      # => @that.address.number = "7"
+      # => @that.address.postalcode = "10117"
+      # => @that.address.city = "Berlin"
+      # => @that.save
+      
+      @that.update( addressible_attributes: {address_attributes: {street: "Reinhardtstraße", number: "7", postalcode: "10117", city: "Berlin", country: "Germany"}} )
+      
+      @that = @that.reload
+      @this = @this.reload
+      
+      expect( @that.address.id ).not_to eql( @this.address.id )
+      expect( @that.address.number ).not_to eql( @this.address.number )
+      expect( @that.address.number ).to eql( "7" )
+      expect( @this.address.number ).to eql( "9" )
+      
+    end
+      
+  end
+  
 end

metadata

@@ -1,111 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: magic_addresses
 version: !ruby/object:Gem::Version
-  version: 0.0.42
+  version: 0.0.43
 platform: ruby
 authors:
 - Torsten Wetzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: globalize
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 5.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 5.0.1
 - !ruby/object:Gem::Dependency
   name: geocoder
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
   name: activerecord-postgres-earthdistance
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.3'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
 description: Easy sortable and translated addresses uses google-api with nominatim
@@ -1101,17 +1101,17 @@ 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.4.8
+rubygems_version: 2.5.0
 signing_key: 
 specification_version: 4
 summary: A really nice address plugin we offten use.