worlddb-models 2.2.2 → 2.3.0

data/lib/worlddb/models/state.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+module WorldDb
+  module Model
+
+
+class State < StateBase
+
+  belongs_to :country,  class_name: 'Country', foreign_key: 'country_id'
+
+  has_many   :parts,    class_name: 'Part',    foreign_key: 'state_id'  # x    / ADM2
+  has_many   :counties, class_name: 'County',  foreign_key: 'state_id'  # ADM2 / ADM3
+  has_many   :munis,    class_name: 'Muni',    foreign_key: 'state_id'  # ADM3 / ADM4
+  has_many   :cities,   class_name: 'City',    foreign_key: 'state_id'
+
+  def place_kind   # use place_kind_of_code ??
+    'ADM1'   # note: for now assumes always level 1
+  end
+  
+  def state_id  # return top-level (e.g. adm1) state_id
+    id
+  end
+
+end # class State
+
+
+class Part < StateBase    ## optional ADM2 e.g. Regierungsbezirke in Bayern, etc.
+
+  belongs_to :state,     class_name: 'State',  foreign_key: 'state_id'
+
+  has_many   :counties,  class_name: 'County', foreign_key: 'part_id'
+  has_many   :cities,    class_name: 'City',   foreign_key: 'part_id'
+
+  def place_kind   # use place_kind_of_code ??
+    'ADM2'   # note: for now assumes always level 2
+  end
+
+  def country_id  # return country_id via top-level (e.g. adm1) state; -- used for auto-creating cities
+    state.country_id
+  end
+
+end # class Part
+
+
+class County < StateBase   ## note: might be ADM2 or ADM3
+
+  belongs_to :state, class_name: 'State',  foreign_key: 'state_id'
+  belongs_to :part,  class_name: 'Part',   foreign_key: 'part_id'  ## optional assoc (used if level=3 and not 2)
+
+  has_many   :munis,  class_name: 'Muni',  foreign_key: 'county_id'
+  has_many   :cities, class_name: 'City',  foreign_key: 'county_id'
+
+  def place_kind   # use place_kind_of_code ??
+    "ADM#{level}"   # note: might be ADM2 or ADM3
+  end
+
+  def country_id  # return country_id via top-level (e.g. adm1) state
+    state.country_id
+  end
+
+end # class County
+
+
+class Muni < StateBase   ## note: might be ADM3 or ADM4
+
+  belongs_to :state,  class_name: 'State',  foreign_key: 'state_id'
+  belongs_to :county, class_name: 'County', foreign_key: 'county_id'
+
+  has_many   :cities, class_name: 'City',   foreign_key: 'muni_id'
+
+  def place_kind   # use place_kind_of_code ??
+    "ADM#{level}"   # note: might be ADM3 or ADM4
+  end
+
+  def country_id  # return country_id via top-level (e.g. adm1) state
+    state.country_id
+  end
+
+end # class Muni
+
+
+  end # module Model
+end # module WorldDb

data/lib/worlddb/models/{region.rb → state_base.rb}

@@ -4,29 +4,35 @@ module WorldDb
   module Model
 
 
-class Region < ActiveRecord::Base
+class StateBase < ActiveRecord::Base
+
+  self.abstract_class = true
 
   extend TextUtils::TagHelper  # will add self.find_tags, self.find_tags_in_attribs!, etc.
 
   # NB: use extend - is_<type>? become class methods e.g. self.is_<type>? for use in
   #   self.create_or_update_from_values
-  extend TextUtils::ValueHelper  # e.g. is_year?, is_region?, is_address?, is_taglist? etc.
+  extend TextUtils::ValueHelper  # e.g. is_year?, is_address?, is_taglist? etc.
 
   belongs_to :place,   class_name: 'Place',   foreign_key: 'place_id'
-  belongs_to :country, class_name: 'Country', foreign_key: 'country_id'
-
-  has_many :cities, class_name: 'City', foreign_key: 'region_id'
 
-  has_many_tags
+  has_many_tags   # note: check if working w/ base class (statebase) -- use/try concern??
 
-  validates :key,  format: { with: /#{REGION_KEY_PATTERN}/,  message: REGION_KEY_PATTERN_MESSAGE }
-  validates :code, format: { with: /#{REGION_CODE_PATTERN}/, message: REGION_CODE_PATTERN_MESSAGE }, allow_nil: true
+  validates :key,  format: { with: /#{STATE_KEY_PATTERN}/,  message: STATE_KEY_PATTERN_MESSAGE }
+  validates :code, format: { with: /#{STATE_CODE_PATTERN}/, message: STATE_CODE_PATTERN_MESSAGE }, allow_nil: true
 
   ### recursive self-reference - use "generic" node??
-  ## has_many :nodes, class_name: 'Region', foregin_key: 'region_id'
-  belongs_to :parent,  class_name: 'Region', foreign_key: 'region_id'
-  has_many   :regions, class_name: 'Region', foreign_key: 'region_id'  ## subregions
+  ## has_many :nodes, class_name: 'State', foreign_key: 'state_id'
+  # belongs_to :parent,  class_name: 'State', foreign_key: 'state_id'
+  # has_many   :states,  class_name: 'State', foreign_key: 'state_id'  ## substates
 
+  ## begin compat
+  def title()       name;              end
+  def title=(value) self.name = value; end
+
+  def synonyms()       alt_names;              end
+  def synonyms=(value) self.alt_names = value; end
+  ## end
 
   before_create :on_create
   before_update :on_update
@@ -41,20 +47,6 @@ class Region < ActiveRecord::Base
     place.update_attributes!( name: name, kind: place_kind )
   end
 
-  def is_district?()  d? == true; end
-  def is_county?()    c? == true; end
-
-  def place_kind   # use place_kind_of_code ??
-    ### fix: use "generic" level counter - make it a database field (default/top level is 1)
-    if is_district?
-      'ADM2'
-    elsif is_county?
-      'ADM3'
-    else
-      'ADM1'
-    end
-  end
-
 
   def all_names( opts={} )
     ### fix:
@@ -70,15 +62,25 @@ class Region < ActiveRecord::Base
   end
 
 
+  def self.parse( *args )
+    ## remove (extract) attribs hash (if last arg is a hash n present)
+    more_attribs = args.last.is_a?(Hash) ? args.pop : {}  ## extract_options!
+    values       = args
+  
+    self.create_or_update_from_values( values, more_attribs )
+  end
 
   def self.create_or_update_from_values( values, more_attribs={} )
 
     ## key & title & country required
     attribs, more_values = find_key_n_title( values )
+    ## fix/hack: change :title to :name
+    ## attribs[:name] = attribs[:title]; attribs.delete( :title )
     attribs = attribs.merge( more_attribs )
 
     ## check for optional values
-    Region.create_or_update_from_attribs( attribs, more_values )
+    puts "[debug] StateBase.create_or_update_from_values calling #{self.name}"  # note: assume self is derived class (object)
+    self.create_or_update_from_attribs( attribs, more_values )
   end
 
 
@@ -107,7 +109,7 @@ class Region < ActiveRecord::Base
       elsif match_number( value ) do |num|  # numeric (nb: can use any _ or spaces inside digits e.g. 1_000_000 or 1 000 000)
               value_numbers << num
             end
-      elsif value =~ /#{REGION_CODE_PATTERN}/  ## assume two or three-letter code
+      elsif value =~ /#{STATE_CODE_PATTERN}/  ## assume two or three-letter code
         new_attributes[ :code ] = value
       elsif (values.size==(index+1)) && is_taglist?( value )   # tags must be last entry
         logger.debug "   found tags: >>#{value}<<"
@@ -129,27 +131,40 @@ class Region < ActiveRecord::Base
     end  # if value_numbers.size > 0
 
     ## todo: assert that country_id is present/valid, that is, NOT null
-    rec = Region.find_by_key_and_country_id( new_attributes[ :key ], new_attributes[ :country_id] )
+    puts "[debug] StateBase.create_or_update_from_attribs calling #{self.name}.where"  # note: assume self is derived class (object)
+    # note: was self.find_by_key_and_country_id
+    if self == State
+      ## note: state scoped by country (all others by top-level state and NOT country)
+      rec = self.where(
+                    key:         new_attributes[ :key ],
+                    country_id:  new_attributes[ :country_id] ).first
+    else
+      rec = self.where(
+                    key:      new_attributes[ :key ],
+                    state_id: new_attributes[ :state_id] ).first
+    end
 
     if rec.present?
-      logger.debug "update Region #{rec.id}-#{rec.key}:"
+      logger.debug "update #{self.name} #{rec.id}-#{rec.key}:"
     else
-      logger.debug "create Region:"
-      rec = Region.new
+      logger.debug "create #{self.name}:"    ## e.g. self.name => State, County, Muni, etc.
+      puts "[debug] StateBase.create_or_update_from_attribs calling #{self.name}.new"  # note: assume self is derived class (object)
+      rec = self.new
     end
-      
+
     logger.debug new_attributes.to_json
-   
+
     rec.update_attributes!( new_attributes )
 
     #################
     # auto add capital cities
+    #  - note: get added to top-level state (e.g. adm1)
 
     City.create_or_update_from_titles( value_cities,
-                                            region_id:  rec.id,
+                                            state_id:  rec.state_id,
                                             country_id: rec.country_id )
 
-    ### todo/fix: add captial ref to country/region
+    ### todo/fix: add captial ref to country/state
     ## todo/fix: use update_from_title and only allow one capital city
 
 
@@ -185,7 +200,8 @@ class Region < ActiveRecord::Base
 
 
 
-end # class Region
+end # class State
 
   end # module Model
 end # module WorldDb
+

data/lib/worlddb/models/tagdb/tag.rb

@@ -7,7 +7,7 @@ class Tag
 
   has_many :cities,    :through => :taggings, :source => :taggable, source_type: 'WorldDb::Model::City',    class_name: 'WorldDb::Model::City'
   has_many :countries, :through => :taggings, :source => :taggable, source_type: 'WorldDb::Model::Country', class_name: 'WorldDb::Model::Country'
-  has_many :regions,   :through => :taggings, :source => :taggable, source_type: 'WorldDb::Model::Region',  class_name: 'WorldDb::Model::Region'
+  has_many :states,    :through => :taggings, :source => :taggable, source_type: 'WorldDb::Model::State',   class_name: 'WorldDb::Model::State'
 
 end  # class Tag
 

data/lib/worlddb/models.rb

@@ -42,30 +42,31 @@ require 'worlddb/models/forward'
 require 'worlddb/models/name'
 require 'worlddb/models/place'
 require 'worlddb/models/continent'
-require 'worlddb/models/continent_compat'    # todo: move to compat gem
 require 'worlddb/models/country'
-require 'worlddb/models/country_compat'      # todo: move to compat gem
 require 'worlddb/models/country_code'
-require 'worlddb/models/region'
-require 'worlddb/models/region_compat'       # todo: move to compat gem
+require 'worlddb/models/state_base'
+require 'worlddb/models/state'
+require 'worlddb/models/city_base'
 require 'worlddb/models/city'
-require 'worlddb/models/city_compat'         # todo: move to compat gem
 require 'worlddb/models/lang'
-require 'worlddb/models/lang_compat'         # todo: move to compat gem 
 require 'worlddb/models/usage'
 
 require 'worlddb/models/tagdb/tag'
 require 'worlddb/models/tagdb/tagging'
 
+require 'worlddb/helpers/value_helper'  # Note: extends module TextUtils(!!)::ValueHelper
 
 
-require 'worlddb/schema'       # NB: requires worlddb/models (include WorldDB::Models)
+require 'worlddb/schema'       # Note: requires worlddb/models (include WorldDB::Models)
 require 'worlddb/matcher'
+require 'worlddb/matcher_adm'
 
+require 'worlddb/readers/base'
 require 'worlddb/readers/lang'
 require 'worlddb/readers/usage'
 require 'worlddb/readers/country'
-require 'worlddb/readers/region'
+require 'worlddb/readers/state'
+require 'worlddb/readers/state_tree'
 require 'worlddb/readers/city'
 
 require 'worlddb/reader'
@@ -74,6 +75,8 @@ require 'worlddb/reader_zip'
 require 'worlddb/deleter'
 require 'worlddb/stats'
 
+require 'worlddb/tree_reader'
+
 
 module WorldDb
 

data/lib/worlddb/patterns.rb

@@ -33,11 +33,11 @@ module WorldDb
   COUNTRY_CODE_PATTERN_MESSAGE = "expected three uppercase letters A-Z (and _) /#{COUNTRY_CODE_PATTERN}/"
 
 
-  REGION_KEY_PATTERN = '\A[a-z]+\z'
-  REGION_KEY_PATTERN_MESSAGE = "expected one or more lowercase letters a-z /#{REGION_KEY_PATTERN}/"
+  STATE_KEY_PATTERN = '\A[a-z]+\z'
+  STATE_KEY_PATTERN_MESSAGE = "expected one or more lowercase letters a-z /#{STATE_KEY_PATTERN}/"
 
-  REGION_CODE_PATTERN = '\A[A-Z_]{2,3}\z'
-  REGION_CODE_PATTERN_MESSAGE = "expected two or three uppercase letters A-Z (and _) /#{REGION_CODE_PATTERN}/"
+  STATE_CODE_PATTERN = '\A[A-Z_]{2,3}\z'
+  STATE_CODE_PATTERN_MESSAGE = "expected two or three uppercase letters A-Z (and _) /#{STATE_CODE_PATTERN}/"
 
 
   CITY_KEY_PATTERN = '\A[a-z]{3,}\z'

data/lib/worlddb/reader.rb

@@ -10,7 +10,7 @@ class ReaderBase
 ## make models available in sportdb module by default with namespace
 #  e.g. lets you use City instead of Models::City
   include Models
-  include Matcher  # e.g. match_cities_for_country, match_regions_for_country, etc.
+  include Matcher  # e.g. match_cities_for_country, match_states_for_country, etc.
 
 ## value helpers e.g. is_year?, is_taglist? etc.
   include TextUtils::ValueHelper
@@ -21,9 +21,9 @@ class ReaderBase
 
 
   def initialize( opts={} )
-    ## option: do NOT generate/add any tags for countries/regions/cities
+    ## option: do NOT generate/add any tags for countries/states/cities
     @skip_tags =  opts[:skip_tags].present? ? true : false
-    ## option: for now issue warning on update, that is, if key/record (country,region,city) already exists
+    ## option: for now issue warning on update, that is, if key/record (country,state,city) already exists
     @strict    =  opts[:strict].present? ? true : false
   end
 
@@ -80,56 +80,85 @@ class ReaderBase
     elsif match_cities_for_country( name ) do |country_key|  #  name =~ /\/([a-z]{2})\/cities/
             ## auto-add required country code (from folder structure)
             country = Country.find_by_key!( country_key )
-            logger.debug "Country #{country.key} >#{country.title} (#{country.code})<"
+            logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
 
             r = create_city_reader( name, country_id: country.id )
             r.read()
           end
-    elsif match_regions_abbr_for_country( name ) do |country_key|   # name =~ /\/([a-z]{2})\/regions\.abbr/
-            load_regions_xxx( country_key, 'abbr', name )
+    elsif match_tree_for_country( name ) do |country_key|
+            ## auto-add required country code (from folder structure)
+            country = Country.find_by_key!( country_key )
+            logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
+
+            r = create_tree_reader( name, country_id: country.id )
+            r.read()
           end
-    elsif match_regions_iso_for_country( name ) do |country_key|  # name =~ /\/([a-z]{2})\/regions\.iso/
-            load_regions_xxx( country_key, 'iso', name )
+    elsif match_states_abbr_for_country( name ) do |country_key|   # name =~ /\/([a-z]{2})\/states\.abbr/
+            load_states_xxx( country_key, 'abbr', name )
           end
-    elsif match_regions_nuts_for_country( name ) do |country_key|  # name =~ /\/([a-z]{2})\/regions\.nuts/
-            load_regions_xxx( country_key, 'nuts', name )
+    elsif match_states_iso_for_country( name ) do |country_key|  # name =~ /\/([a-z]{2})\/states\.iso/
+            load_states_xxx( country_key, 'iso', name )
           end
-    elsif match_adm3_for_country( name ) do |country_key,region_key,adm2_name|
+    elsif match_states_nuts_for_country( name ) do |country_key|  # name =~ /\/([a-z]{2})\/states\.nuts/
+            load_states_xxx( country_key, 'nuts', name )
+          end
+    elsif match_adm3_counties_for_country( name ) do |country_key, state_key, part_name|
             ## auto-add required country code (from folder structure)
             country = Country.find_by_key!( country_key )
-            logger.debug "Country #{country.key} >#{country.title} (#{country.code})<"
-            region  = Region.find_by_key_and_country_id!( region_key, country.id )
-            logger.debug "Region (Adm1) #{region.key} >#{region.title}<"
+            logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
+            state  = State.find_by_key_and_country_id!( state_key, country.id )
+            logger.debug "State (ADM1) #{state.key} >#{state.name}<"
+
             ### todo: move find adm2 to model for (re)use !!!
-            adm2    = Region.where( "lower(name) = ? AND country_id = ?",
-                                     adm2_name, country.id ).first   ## check - first needed? returns ary??
-            if adm2.nil?
-              puts "*** error/warn: fix - skipping adm3 - adm2 '#{adm2_name}' not found"
+            part = Part.where( "lower(name) = ? AND state_id = ?",
+                                     part_name, state.id ).first   ## check - first needed? returns ary??
+            if part.nil?
+              logger.error "fix!! - skipping adm3_counties - part (ADM2) '#{part_name}' not found"
               next
             end
-            logger.debug "Region (Adm2) #{adm2.key} >#{adm2.title}<"
+            logger.debug "Part (ADM2) #{part.key} >#{part.name}<"
 
-            r = create_region_reader( name, country_id: country.id, region_id: adm2.id, level:3, c:true )
-            r.read()
+            st = create_county_reader( name, 
+                                       state_id: state.id,
+                                       part_id: part.id,
+                                       level: 3 )   # note: change county level to 3 (default is 2)
+            st.read()
           end
-    elsif match_adm2_for_country( name ) do |country_key,region_key|
+    elsif match_adm2_counties_for_country( name ) do |country_key,state_key|
             ## auto-add required country code (from folder structure)
             country = Country.find_by_key!( country_key )
-            logger.debug "Country #{country.key} >#{country.title} (#{country.code})<"
-            region  = Region.find_by_key_and_country_id!( region_key, country.id )
-            logger.debug "Region (Adm1) #{region.key} >#{region.title}<"
-
-            r = create_region_reader( name, country_id: country.id, region_id: region.id, level:2, d:true )
-            r.read()
+            logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
+            state  = State.find_by_key_and_country_id!( state_key, country.id )
+            logger.debug "State (ADM1) #{state.key} >#{state.name}<"
+
+            st = create_county_reader( name,
+                                       state_id: state.id,
+                                       ## part_id: nil,
+                                       level: 2 )
+            st.read()
+          end
+    elsif match_adm2_parts_for_country( name ) do |country_key,state_key|
+            ## auto-add required country code (from folder structure)
+            country = Country.find_by_key!( country_key )
+            logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
+            state  = State.find_by_key_and_country_id!( state_key, country.id )
+            logger.debug "State (ADM2) #{state.key} >#{state.name}<"
+
+            st = create_part_reader( name,
+                                     state_id: state.id,
+                                     level: 2 )
+            st.read()
           end
-    ### fix: change to match_adm1_for_country()
-    elsif match_regions_for_country( name ) do |country_key|  # name =~ /\/([a-z]{2})\/regions/
+    ### fix: change to match_adm1_states_for_country() - why? why not??
+    elsif match_states_for_country( name ) do |country_key|  # name =~ /\/([a-z]{2})\/states/
             ## auto-add required country code (from folder structure)
             country = Country.find_by_key!( country_key )
-            logger.debug "Country #{country.key} >#{country.title} (#{country.code})<"
+            logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
 
-            r = create_region_reader( name, country_id: country.id, region_id: nil, level:1, s:true )
-            r.read()
+            st = create_state_reader( name,
+                                      country_id: country.id,
+                                      level: 1 )
+            st.read()
           end
     else
       logger.error "unknown world.db fixture type >#{name}<"
@@ -138,17 +167,17 @@ class ReaderBase
   end
 
 
-  ### use RegionAttrReader
-  def load_regions_xxx( country_key, xxx, name )
+  ### use StateAttrReader
+  def load_states_xxx( country_key, xxx, name )
     country = Country.find_by_key!( country_key )
-    logger.debug "Country #{country.key} >#{country.title} (#{country.code})<"
+    logger.debug "Country #{country.key} >#{country.name} (#{country.code})<"
 
     reader = create_hash_reader( name )
 
     reader.each do |key, value|
-      region = Region.find_by_country_id_and_key!( country.id, key )
-      region.send( "#{xxx}=", value )
-      region.save!
+      state = State.find_by_country_id_and_key!( country.id, key )
+      state.send( "#{xxx}=", value )
+      state.save!
     end
   end
 

data/lib/worlddb/reader_file.rb

@@ -40,14 +40,47 @@ class Reader < ReaderBase
     CountryReader.from_file( path, more_attribs )
   end
 
-  def create_region_reader( name, more_attribs={} )
+  def create_state_reader( name, more_attribs={} )
     path = "#{@include_path}/#{path_to_real_path(name)}.txt"
 
-    logger.info "parsing data (region) '#{name}' (#{path})..."
+    logger.info "parsing data (state) '#{name}' (#{path})..."
 
-    RegionReader.from_file( path, more_attribs )
+    StateReader.from_file( path, more_attribs )
   end
 
+  def create_part_reader( name, more_attribs={} )
+    path = "#{@include_path}/#{path_to_real_path(name)}.txt"
+
+    logger.info "parsing data (part) '#{name}' (#{path})..."
+
+    PartReader.from_file( path, more_attribs )
+  end
+
+  def create_county_reader( name, more_attribs={} )
+    path = "#{@include_path}/#{path_to_real_path(name)}.txt"
+
+    logger.info "parsing data (county) '#{name}' (#{path})..."
+
+    CountyReader.from_file( path, more_attribs )
+  end
+
+  def create_muni_reader( name, more_attribs={} )
+    path = "#{@include_path}/#{path_to_real_path(name)}.txt"
+
+    logger.info "parsing data (muni) '#{name}' (#{path})..."
+
+    MuniReader.from_file( path, more_attribs )
+  end
+
+
+  def create_tree_reader( name, more_attribs={} )
+    path = "#{@include_path}/#{path_to_real_path(name)}.txt"
+    logger.info "parsing data (state tree) '#{name}' (#{path})..."
+
+    StateTreeReader.from_file( path, more_attribs )
+  end
+
+
   def create_city_reader( name, more_attribs={} )
     path = "#{@include_path}/#{path_to_real_path(name)}.txt"
     logger.info "parsing data (city) '#{name}' (#{path})..."

data/lib/worlddb/reader_zip.rb

@@ -85,13 +85,43 @@ class ZipReader < ReaderBase
     CountryReader.from_zip( @zip_file, path, more_attribs )
   end
 
-  def create_region_reader( name, more_attribs={} )
+  def create_state_reader( name, more_attribs={} )
     path = name_to_zip_entry_path( name )
-    logger.info "parsing data (region) in zip '#{name}' (#{path})..."
+    logger.info "parsing data (state) in zip '#{name}' (#{path})..."
 
-    RegionReader.from_zip( @zip_file, path, more_attribs )
+    StateReader.from_zip( @zip_file, path, more_attribs )
   end
 
+  def create_part_reader( name, more_attribs={} )
+    path = name_to_zip_entry_path( name )
+    logger.info "parsing data (part) in zip '#{name}' (#{path})..."
+
+    PartReader.from_zip( @zip_file, path, more_attribs )
+  end
+
+  def create_county_reader( name, more_attribs={} )
+    path = name_to_zip_entry_path( name )
+    logger.info "parsing data (county) in zip '#{name}' (#{path})..."
+
+    CountyReader.from_zip( @zip_file, path, more_attribs )
+  end
+
+  def create_muni_reader( name, more_attribs={} )
+    path = name_to_zip_entry_path( name )
+    logger.info "parsing data (muni) in zip '#{name}' (#{path})..."
+
+    MuniReader.from_zip( @zip_file, path, more_attribs )
+  end
+
+
+  def create_tree_reader( name, more_attribs={} )
+    path = name_to_zip_entry_path( name )
+    logger.info "parsing data (state tree) in zip '#{name}' (#{path})..."
+
+    StateTreeReader.from_zip( @zip_file, path, more_attribs )
+  end
+
+
   def create_city_reader( name, more_attribs={} )
     path = name_to_zip_entry_path( name )
     logger.info "parsing data (city) in zip '#{name}' (#{path})..."