address.rb in data_maker-2.3.3

- old
+ new
@@ -1,33 +1,221 @@
 module DataMaker
   module CN
     module Address
+      extend ModuleUtilities
+
       def self.street_address
-        "lastname and street suffix"
+        GenerateAddress.new.street_address
       end
 
-      def self.street_name
+      def self.city(province = nil)
+        address = GenerateAddress.new(province: province)
+        address.generate
+        address.city
       end
 
-      def self.city
+      def self.province(city = nil)
+        address = GenerateAddress.new(city: city)
+        address.generate
+        address.province
       end
 
-      def self.city_prefix
+      def self.postal_code(province = nil)
+        address = GenerateAddress.new(province: province)
+        address.generate
+        address.postal_code
       end
 
-      def self.city_suffix
+      def self.address(province: nil, city: nil, district: nil, struct: false)
+        address  = GenerateAddress.new(province: province, city: city, district: district)
+        struct ? address.address_struct : address.address_string
       end
 
-      def self.unit_no
-      end
+      class GenerateAddress
+        attr_accessor :province, :city, :district, :street_address, :locale, :options
 
-      def self.postcode
-      end
+        def initialize(*args)
+          self.options  = (args.last.is_a?(::Hash) ? args.last : {}).delete_if { |k, v| v.nil? }
+          self.district = options[:district]
+          self.city     = options[:city]
+          self.province = options[:province]
+          self.locale   = options[:locale] || :zh
+          unless options.empty?
+            validate
+          end
+        end
 
-      def self.province
-      end
+        def generate
+          if options.empty?
+            # Generate a random address from a province
+            self.province = provinces.sample
+            self.city     = province_cities.sample
+            self.district = city_districts.nil? ? nil : city_districts.sample
+          end
 
-      def self.full_address
+          if options[:province] && options[:city].nil? && options[:district].nil?
+            self.city     = province_cities.sample
+            self.district = city_districts.nil? ? nil : city_districts.sample
+          end
+
+          if options[:province].nil? && options[:city] && options[:district].nil?
+            self.province = city_province
+            self.district = city_districts.nil? ? nil : city_districts.sample
+          end
+        end
+
+        def street_address
+          [unit_no, street_name, street_suffix].join
+        end
+
+        def address_string
+          generate
+          translate
+          build_address
+        end
+
+        def address_struct
+          generate
+          translate
+          OpenStruct.new(street_address: street_address,
+                         city:           city,
+                         district:       district,
+                         province:       province,
+                         postal_code:    postal_code
+                        )
+        end
+
+        def postal_code
+          postal_code = nil
+          province_postal_codes = DataMaker::CN::Address::PROVINCE_POSTAL_CODES
+          province_postal_codes.to_set.select do |province_postal_code|
+            p, pc = province_postal_code.split(",")
+            p == province ? postal_code = pc : nil
+          end
+          postal_code
+        end
+
+        private
+
+        def translate
+          DataMaker::Config.locale = locale
+          values = { province: province, city: city, district: district }
+          values.each do |key, value|
+            self.send("#{key}=", DataMaker.translate(['data_maker', 'address', key, value].join(".")))
+          end
+        end
+
+        def validate
+          if province
+            unless province_exists?
+              raise ArgumentError, "The province #{province} does not exist!"
+            end
+          end
+
+          if city
+            unless city_exists?
+              raise ArgumentError, "The city #{city} does not exist!"
+            end
+          end
+
+          if district
+            unless district_exists?
+              raise ArgumentError, "The district #{district} does not exist!"
+            end
+          end
+
+          if city.nil? && district
+            raise ArgumentError, "You must always pass a city with a district!"
+          end
+
+          if province && city
+            unless province_has_city?
+              raise ArgumentError, "The province #{province} does not have the city #{city}"
+            end
+          end
+
+          if city && district
+            unless city_has_district?
+              raise ArgumentError, "The city #{city} does not have the district #{district}"
+            end
+          end
+        end
+
+        def provinces
+          DataMaker::CN::Address::PROVINCES
+        end
+
+        def cities
+          DataMaker::CN::Address::CITIES
+        end
+
+        def districts
+          DataMaker::CN::Address::DISTRICTS
+        end
+
+        def build_address
+          address = []
+          address << street_address
+          address << city
+          address << district
+          address << province
+          address << postal_code
+          address.compact.join(", ")
+        end
+
+        def street_name
+          DataMaker::CN::Name::LAST_NAMES.sample
+        end
+
+        def street_suffix
+          DataMaker::CN::Address::STREET_SUFFIXES.sample
+        end
+
+        def unit_no
+          masks = "#" * rand(1..2)
+          DataMaker.numerify(masks)
+        end
+
+        def city_districts
+          raise ArgumentError, "Please pass a city!" if city.nil?
+          d = DataMaker::CN::Address.const_get("#{city}_districts".upcase)
+          d.empty? ? nil : d
+        end
+
+        def city_province
+          province = nil
+          city_provinces = DataMaker::CN::Address::CITY_PROVINCES
+          city_provinces.to_set.select do |city_province|
+            c, p = city_province.split(",")
+            c == city ? province = p : nil
+          end
+          province
+        end
+
+        def province_cities
+          raise ArgumentError, "Please pass a province!" if province.nil?
+          DataMaker::CN::Address.const_get("#{province}_cities".upcase)
+        end
+
+        def province_exists?
+          provinces.to_set.include?(province)
+        end
+
+        def city_exists?
+          cities.to_set.include?(city)
+        end
+
+        def district_exists?
+          districts.to_set.include?(district)
+        end
+
+        def province_has_city?
+          province_cities.to_set.include?(city)
+        end
+
+        def city_has_district?
+          city_districts.to_set.include?(district)
+        end
       end
     end
   end
 end