psgc-rb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d1fd4a6936426a2a2efc694827ffd4d5fd0d33e13a8933ff5df64626edfb1ab
-  data.tar.gz: 552c45ca68904de0614b5d474ba1e055e4b3ef4139b80d6ecad0314de6b97a3c
+  metadata.gz: a1bfa699725cdd1d7ab90c3086d4fa00206eba2fa8bf588a305f9a3c114f9e94
+  data.tar.gz: e58c17f37ca5d80825539bc410cc53725491a1fb1c27a278bab6cef540f9b1f1
 SHA512:
-  metadata.gz: e4e8fd85a964fefa515233771a7551fe3dbd5070ab583aa9d8e45caefd76d084816e5fa46d6f0316c77485ae2da9b3dc5ff77b5594ac982d1d8692e5c74bbd7e
-  data.tar.gz: 7734822468ff709b6b093162220773ce207619ac5453481c4b58a9abeab4e2a555b75ea03533980811a638f7e99570d9e66d6f02ffe27622ac155da14bab98e8
+  metadata.gz: 51ffa2a2928c0e72f75f8bb316c261ac710901c86106583bc40e11b13a5d7205db24ab53fc8a9ceb43ff74793b7ffabd024fec22b231cb9e69fd058bea6ca819
+  data.tar.gz: a5e6fdd95d4455cdabe57a3ec6b5394d8be32c7d6d91f005e97d494c0b6e68ef21b02c1d0ea08e26c91c41187ac85c0e3b85d342eb29c861025526212f84d4c4

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.2.0] - 2026-04-25
+
+### Added
+- Finder methods (`find_region`, `find_province`, `find_city_municipality`, `find_barangay`) for looking up by code or name
+- `hierarchy` method for traversing PSGC relationships (e.g., barangay → city → province → region)
+- `search` method for fuzzy name matching across all geographic levels
+- `valid?` method to check if a PSGC code exists
+- `stats` method to get counts by geographic level
+- CLI tool with `find`, `hierarchy`, `valid`, `stats`, and `export` commands
+- Rails seed generator (`rails generate psgc:seed`)
+- Export methods (`export_csv`, `export_yaml`, `export_geojson`)
+- Support for `:cities` as alias for `:cities_municipalities` level
+
+### Changed
+- Default export level changed from `:barangays` to `:regions` for safer preview
+
+## [0.1.0] - 2026-04-25
+
+### Added
+- Initial release with data loaders for PSGC regions, provinces, cities/municipalities, and barangays

data/README.md

@@ -2,6 +2,8 @@
 
 A Ruby gem providing up-to-date Philippine geographic data from the PSA (Philippine Statistics Authority). Includes Philippine Standard Geographic Codes (PSGC) for regions, provinces, cities/municipalities, and barangays.
 
+Requires Ruby >= 3.2.0.
+
 ## Installation
 
 ```bash
@@ -14,6 +16,8 @@ Or add to Gemfile:
 gem "psgc-rb"
 ```
 
+Note: If using the Rails generator, Rails >= 6.1 is required. Each target model (Region, Province, City, or Barangay) must have a unique index on its code column for upsert_all to work.
+
 ## Usage
 
 ```ruby
@@ -34,8 +38,94 @@ Psgc.cities_municipalities
 # Get all barangays
 Psgc.barangays
 # => [{:code=>"1400101001", :name=>"Bagtayan", :city_municipality_code=>"1400101000"}, ...]
+
+# Foreign-key fields (e.g., :region_code on a province, :province_code on a city)
+# store a prefix of the parent's full 10-digit code.
+
+# Finder methods
+Psgc.find_region(code: "1300000000")
+# => {:code=>"1300000000", :name=>"National Capital Region (NCR)"}
+
+Psgc.find_province(code: "1400100000")
+# => {:code=>"1400100000", :name=>"Abra", :region_code=>"14"}
+
+Psgc.find_city_municipality(code: "1400101000")
+# => {:code=>"1400101000", :name=>"Bangued", :province_code=>"1400"}
+
+Psgc.find_barangay(code: "1400101001")
+# => {:code=>"1400101001", :name=>"Bagtayan", :city_municipality_code=>"1400101000"}
+
+# Find by name (case-insensitive substring match)
+Psgc.find_region(name: "National Capital")
+# => {:code=>"1300000000", :name=>"National Capital Region (NCR)"}
+
+# Hierarchy traversal
+Psgc.hierarchy("1400101001")
+# => {:code=>"1400101001", :barangay=>{...}, :city_municipality=>{...}, :province=>{...}, :region=>{...}}
+
+# Search across all levels
+Psgc.search("cebu")
+# => {:regions=>[...], :provinces=>[...], :cities_municipalities=>[...], :barangays=>[...]}
+
+Psgc.search("san", limit: 5)
+# => {:regions=>[...], :provinces=>[...], :cities_municipalities=>[...], :barangays=>[...]}
+#   (each level capped at 5 results)
+
+# Validate PSGC code
+Psgc.valid?("1400101001")  # => true
+Psgc.valid?("9999999999") # => false
+
+# Statistics
+Psgc.stats
+# => {:regions=>Integer, :provinces=>Integer, :cities_municipalities=>Integer, :barangays=>Integer}
+
+# Export data
+Psgc.export_csv(level: :regions)
+Psgc.export_csv(level: :provinces)
+Psgc.export_csv(level: :cities_municipalities)  # or :cities
+Psgc.export_csv(level: :barangays)
+
+Psgc.export_yaml(level: :regions)
+Psgc.export_geojson(level: :regions)
 ```
 
+## CLI
+
+```bash
+# Find by name
+psgc find Manila
+psgc find Cebu --limit 10
+
+# Show hierarchy
+psgc hierarchy 1400101001
+
+# Validate code
+psgc valid 1400101001
+
+# Statistics
+psgc stats
+
+# Export data
+psgc export --csv
+psgc export --csv --level=provinces
+psgc export --yaml --level=barangays
+psgc export --geojson --level=cities
+```
+
+## Rails Generator
+
+Generate seed data for your Rails app (requires Rails >= 6.1):
+
+```bash
+rails generate psgc:seed
+rails generate psgc:seed --level=provinces
+rails generate psgc:seed --level=cities
+rails generate psgc:seed --level=barangays
+rails generate psgc:seed --region-model=Region --province-model=Province --city-model=City --barangay-model=Barangay
+```
+
+Valid levels: `all` (default), `regions`, `provinces`, `cities` or `cities_municipalities`, `barangays`.
+
 ## Data Source
 
 Data is sourced from the PSA PSGC Publication Datafile, released quarterly.
@@ -51,6 +141,8 @@ To update data:
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
 
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for data update instructions.
+
 ## License
 
-The gem is available as open source under the terms of the MIT License.
+Released under the [MIT License](./LICENSE).

data/exe/psgc

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "psgc"
+require "psgc/cli"
+
+exit(Psgc::CLI.run(ARGV) ? 0 : 1)

data/lib/generators/psgc/seed_generator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Psgc
+  module Generators
+    class SeedGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      VALID_LEVELS = %w[all regions provinces cities cities_municipalities barangays].freeze
+
+      class_option :level,
+        type: :string,
+        default: "all",
+        desc: "Geographic level: all, regions, provinces, cities/cities_municipalities, barangays"
+
+      class_option :region_model,
+        type: :string,
+        default: "Region",
+        desc: "Model name for regions"
+
+      class_option :province_model,
+        type: :string,
+        default: "Province",
+        desc: "Model name for provinces"
+
+      class_option :city_model,
+        type: :string,
+        default: "City",
+        desc: "Model name for cities/municipalities"
+
+      class_option :barangay_model,
+        type: :string,
+        default: "Barangay",
+        desc: "Model name for barangays"
+
+      def create_seed_file
+        validate_level!
+        template "seed.rb.erb", "db/seeds.rb"
+      end
+
+      private
+
+      def validate_level!
+        return if VALID_LEVELS.include?(options[:level])
+
+        raise ArgumentError, "Invalid level: #{options[:level]}. Valid: #{VALID_LEVELS.join(', ')}"
+      end
+
+      def level
+        options[:level]
+      end
+
+      def region_model
+        options[:region_model]
+      end
+
+      def province_model
+        options[:province_model]
+      end
+
+      def city_model
+        options[:city_model]
+      end
+
+      def barangay_model
+        options[:barangay_model]
+      end
+    end
+  end
+end

data/lib/generators/psgc/templates/seed.rb.erb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "psgc"
+
+# Auto-generated seed file for PSGC geographic data
+# Run with: rails db:seed
+#
+# Model names can be customized via generator options:
+#   rails g psgc:seed --region-model=Address::Region --province-model=PsgcProvince
+
+<% if level == "all" || level == "regions" -%>
+# Regions (<%= Psgc.regions.length %>)
+<%= region_model %>.upsert_all(Psgc.regions, unique_by: :code)
+<% end -%>
+
+<% if level == "all" || level == "provinces" -%>
+# Provinces (<%= Psgc.provinces.length %>)
+<%= province_model %>.upsert_all(Psgc.provinces, unique_by: :code)
+<% end -%>
+
+<% if level == "all" || level == "cities" || level == "cities_municipalities" -%>
+# Cities/Municipalities (<%= Psgc.cities_municipalities.length %>)
+<%= city_model %>.upsert_all(Psgc.cities_municipalities, unique_by: :code)
+<% end -%>
+
+<% if level == "all" || level == "barangays" -%>
+# Barangays (<%= Psgc.barangays.length %>)
+<%= barangay_model %>.upsert_all(Psgc.barangays, unique_by: :code)
+<% end -%>
+
+puts "PSGC seed data loaded successfully"

data/lib/psgc/cli.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Psgc
+  class CLI
+    COMMANDS = %w[find hierarchy valid stats export help].freeze
+
+    def self.run(argv = ARGV)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {}
+      @success = false
+    end
+
+    def run
+      return help if @argv.empty?
+
+      parse_options
+
+      unless @command && COMMANDS.include?(@command)
+        $stderr.puts "Error: unknown command '#{@command}'"
+        return false
+      end
+
+      send(@command)
+      @success
+    end
+
+    private
+
+    def parse_options
+      @options[:limit] = 20
+      @options[:export_format] = :csv
+      @options[:export_level] = :regions
+
+      begin
+        OptionParser.new do |opts|
+          opts.on("-h", "--help") { @options[:help] = true }
+          opts.on("--version") { @options[:version] = true }
+          opts.on("--limit=N", Integer) { |n| @options[:limit] = n }
+          opts.on("--csv") { @options[:export_format] = :csv }
+          opts.on("--yaml") { @options[:export_format] = :yaml }
+          opts.on("--geojson") { @options[:export_format] = :geojson }
+          opts.on("--level=L") { |l| @options[:export_level] = l.to_sym }
+        end.parse!(@argv)
+      rescue OptionParser::InvalidOption => e
+        $stderr.puts "Error: #{e.message}"
+        @command = nil
+        return
+      end
+
+      @command = @argv.shift
+      @command ||= "help"
+    end
+
+    def find
+      return help if @options[:help]
+      return version if @options[:version]
+      return help_find if @argv.empty?
+
+      query = @argv.join(" ")
+      results = Psgc.search(query, limit: @options[:limit])
+
+      has_results = false
+      [:regions, :provinces, :cities_municipalities, :barangays].each do |level|
+        items = results[level]
+        next unless items && !items.empty?
+
+        has_results = true
+        puts "=== #{level.to_s.tr('_', ' ').capitalize} (#{items.length}) ==="
+        items.each do |item|
+          puts "  #{item[:code]} #{item[:name]}"
+        end
+      end
+
+      @success = has_results
+      help_find unless has_results
+    end
+
+    def help_find
+      puts "Usage: psgc find <query> [options]"
+      puts "  Fuzzy search across all geographic levels."
+      puts "  --limit=N    Limit results per level (default: 20)"
+      puts ""
+      puts "Examples:"
+      puts "  psgc find Manila"
+      puts "  psgc find Cebu --limit 10"
+      @success = false
+    end
+
+    def hierarchy
+      return help if @options[:help]
+      return version if @options[:version]
+      return help_hierarchy if @argv.empty?
+
+      code = @argv.first
+      unless code && code.match?(/^\d{10}$/)
+        $stderr.puts "Error: code must be exactly 10 digits"
+        @success = false
+        return
+      end
+
+      result = Psgc.hierarchy(code)
+      return help_hierarchy("Invalid code") unless result && result.any? { |k, v| k != :code && v }
+
+      puts "Code: #{result[:code]}"
+
+      if result[:region]
+        puts "Region: #{result[:region][:code]} #{result[:region][:name]}"
+      end
+      if result[:province]
+        puts "Province: #{result[:province][:code]} #{result[:province][:name]}"
+      end
+      if result[:city_municipality]
+        puts "City/Municipality: #{result[:city_municipality][:code]} #{result[:city_municipality][:name]}"
+      end
+      if result[:barangay]
+        puts "Barangay: #{result[:barangay][:code]} #{result[:barangay][:name]}"
+      end
+
+      @success = true
+    end
+
+    def help_hierarchy(msg = nil)
+      puts "Usage: psgc hierarchy <code>"
+      puts "  Show full hierarchy for a PSGC code."
+      puts ""
+      puts "Examples:"
+      puts "  psgc hierarchy 1378040012"
+      puts "  psgc hierarchy 1400000000"
+      $stderr.puts msg if msg
+      @success = false
+    end
+
+    def valid
+      return help if @options[:help]
+      return version if @options[:version]
+      return help_valid if @argv.empty?
+
+      code = @argv.first
+      valid = Psgc.valid?(code)
+
+      if valid
+        puts "Valid PSGC code: #{code}"
+      else
+        puts "Invalid PSGC code: #{code}"
+      end
+      @success = valid
+    end
+
+    def help_valid
+      puts "Usage: psgc valid <code>"
+      puts "  Check if PSGC code exists."
+      puts ""
+      puts "Examples:"
+      puts "  psgc valid 1378040012"
+      puts "  psgc valid 9999999999"
+      @success = false
+    end
+
+    def stats
+      return help if @options[:help]
+      return version if @options[:version]
+
+      result = Psgc.stats
+      printf "%-22s %d\n", "Regions:", result[:regions]
+      printf "%-22s %d\n", "Provinces:", result[:provinces]
+      printf "%-22s %d\n", "Cities/Municipalities:", result[:cities_municipalities]
+      printf "%-22s %d\n", "Barangays:", result[:barangays]
+
+      @success = true
+    end
+
+    def export
+      return help if @options[:help]
+      return version if @options[:version]
+
+      format = @options[:export_format]
+      level = @options[:export_level]
+
+      begin
+        case format
+        when :csv
+          puts Psgc.export_csv(level: level)
+        when :yaml
+          puts Psgc.export_yaml(level: level)
+        when :geojson
+          puts Psgc.export_geojson(level: level)
+        end
+      rescue ArgumentError => e
+        $stderr.puts "Error: #{e.message}"
+        @success = false
+        return
+      end
+
+      @success = true
+    end
+
+    def help
+      puts "Usage: psgc <command> [options]"
+      puts ""
+      puts "Commands:"
+      puts "  find <query>       Fuzzy search across all geographic levels"
+      puts "  hierarchy <code>   Show full hierarchy for a PSGC code"
+      puts "  valid <code>       Check if PSGC code exists"
+      puts "  stats              Show statistics"
+      puts "  export             Export data in various formats (CSV, YAML, GeoJSON)"
+      puts ""
+      puts "Run 'psgc <command> --help' for more details."
+      @success = true
+    end
+
+    def version
+      puts "psgc-rb #{Psgc::VERSION}"
+      @success = true
+    end
+  end
+end

data/lib/psgc.rb

@@ -3,7 +3,7 @@
 require "json"
 
 module Psgc
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
   class Error < StandardError; end
 
@@ -11,20 +11,22 @@ module Psgc
     File.expand_path("../../data", __FILE__)
   end
 
+  @data_mutex = Mutex.new
+
   def self.regions
-    @regions ||= load_data("regions")
+    @regions || @data_mutex.synchronize { @regions ||= load_data("regions") }
   end
 
   def self.provinces
-    @provinces ||= load_data("provinces")
+    @provinces || @data_mutex.synchronize { @provinces ||= load_data("provinces") }
   end
 
   def self.cities_municipalities
-    @cities_municipalities ||= load_data("cities_municipalities")
+    @cities_municipalities || @data_mutex.synchronize { @cities_municipalities ||= load_data("cities_municipalities") }
   end
 
   def self.barangays
-    @barangays ||= load_data("barangays")
+    @barangays || @data_mutex.synchronize { @barangays ||= load_data("barangays") }
   end
 
   def self.load_data(type)
@@ -33,4 +35,215 @@ module Psgc
 
     JSON.parse(File.read(file_path), symbolize_names: true)
   end
-end
+
+  def self.find_region(code: nil, name: nil)
+    return nil unless code || name
+    find(regions, code: code, name: name)
+  end
+
+  def self.find_province(code: nil, name: nil, region_code: nil)
+    return nil unless code || name || region_code
+    find(provinces, code: code, name: name, region_code: region_code)
+  end
+
+  def self.find_city_municipality(code: nil, name: nil, province_code: nil)
+    return nil unless code || name || province_code
+    find(cities_municipalities, code: code, name: name, province_code: province_code)
+  end
+
+  def self.find_barangay(code: nil, name: nil, city_municipality_code: nil)
+    return nil unless code || name || city_municipality_code
+    find(barangays, code: code, name: name, city_municipality_code: city_municipality_code)
+  end
+
+  # Finds first match in collection using AND semantics.
+  # All non-nil criteria must match for a result.
+  # Name matching is case-insensitive substring.
+  # Code attributes (*_code) use bidirectional prefix matching:
+  #   "v.start_with?(item[k]) || item[k].start_with?(v)"
+  #   e.g., region_code "14" matches stored "1400000000" and vice versa.
+  #
+  # @param collection [Array<Hash>] data collection
+  # @param code [String, nil] exact PSGC code
+  # @param name [String, nil] case-insensitive substring match
+  # @param attrs [Hash] additional match criteria
+  # @return [Hash, nil] first matching item or nil
+  def self.find(collection, code: nil, name: nil, **attrs)
+    collection.each do |item|
+      matches = true
+      matches &&= item[:code] == code if code
+      matches &&= item[:name].to_s.downcase.include?(name.to_s.downcase) if name
+      attrs.each do |k, v|
+        next unless v
+        if k.to_s.end_with?("_code")
+          matches &&= v.to_s.start_with?(item[k].to_s) || item[k].to_s.start_with?(v.to_s)
+        else
+          matches &&= item[k] == v
+        end
+      end
+      return item if matches
+    end
+    nil
+  end
+
+  # Traverses PSGC hierarchy for a given code.
+  # Uses prefix matching because parent codes are prefixes of child codes
+  # (e.g., city code is prefix of barangay code).
+  #
+  # @param code [String, Integer] 10-digit PSGC code
+  # @return [Hash{Symbol => Hash, nil}] hash with :code and found geographic levels
+  def self.hierarchy(code)
+    return nil unless code.to_s.match?(/^\d{10}$/)
+    code = code.to_s
+
+    result = { code: code }
+
+    if code.end_with?("000000")
+      result[:region] = find_region(code: code)
+    elsif code.end_with?("0000")
+      result[:province] = find_province(code: code)
+      result[:city_municipality] = find_city_municipality(code: code) unless result[:province]
+    elsif code.end_with?("00")
+      result[:city_municipality] = find_city_municipality(code: code)
+    else
+      result[:barangay] = find_barangay(code: code)
+    end
+
+    if result[:barangay]
+      city = cities_municipalities.find { |c| c[:code].start_with?(result[:barangay][:city_municipality_code]) }
+      result[:city_municipality] = city
+      if city
+        province = provinces.find { |p| p[:code].start_with?(city[:province_code]) }
+        result[:province] = province
+      end
+    elsif result[:city_municipality]
+      province = provinces.find { |p| p[:code].start_with?(result[:city_municipality][:province_code]) }
+      result[:province] = province
+    end
+
+    if result[:province]
+      region = regions.find { |r| r[:code].start_with?(result[:province][:region_code]) }
+      result[:region] = region
+    end
+
+    result[:region] ||= regions.find { |r| r[:code].start_with?(code[0, 2]) }
+
+    result
+  end
+
+  # @param query [String] search term (case-insensitive substring match)
+  # @param levels [Array<Symbol>] which levels to search (:regions, :provinces, :cities, :cities_municipalities, :barangays)
+  # @param limit [Integer] max matches per level (not total)
+  # @return [Hash{Symbol => Array}] hash with requested level keys and matching records
+  def self.search(query, levels: nil, limit: nil)
+    return {} unless query && !query.to_s.strip.empty?
+
+    query_down = query.to_s.downcase
+    levels ||= [:regions, :provinces, :cities_municipalities, :barangays]
+
+    result = {}
+    levels.each do |level|
+      collection = collection_for(level)
+
+      matches = collection.select { |item| item[:name].to_s.downcase.include?(query_down) }
+      matches = matches.first(limit) if limit
+      result[level] = matches
+    end
+
+    result
+  end
+
+  # @param code [String, Integer] 10-digit PSGC code
+  # @return [Boolean] true if code exists in any level
+  def self.valid?(code)
+    return false unless code && code.to_s.match?(/^\d{10}$/)
+
+    code_str = code.to_s
+
+    if code_str.end_with?("000000")
+      regions.any? { |r| r[:code] == code_str }
+    elsif code_str.end_with?("0000")
+      provinces.any? { |p| p[:code] == code_str } ||
+        cities_municipalities.any? { |c| c[:code] == code_str }
+    elsif code_str.end_with?("00")
+      cities_municipalities.any? { |c| c[:code] == code_str } ||
+        barangays.any? { |b| b[:code] == code_str }
+    else
+      barangays.any? { |b| b[:code] == code_str }
+    end
+  end
+
+  # @return [Hash{Symbol => Integer}] counts by level
+  def self.stats
+    {
+      regions: regions.length,
+      provinces: provinces.length,
+      cities_municipalities: cities_municipalities.length,
+      barangays: barangays.length
+    }
+  end
+
+  # @param level [Symbol] geographic level
+  # @return [Symbol] normalized level (:cities -> :cities_municipalities)
+  def self.normalize_level(level)
+    case level
+    when :cities then :cities_municipalities
+    else level
+    end
+  end
+
+  def self.collection_for(level)
+    normalized = normalize_level(level)
+
+    case normalized
+    when :regions then regions
+    when :provinces then provinces
+    when :cities_municipalities then cities_municipalities
+    when :barangays then barangays
+    else raise ArgumentError, "unknown level: #{level}. Valid: :regions, :provinces, :cities, :cities_municipalities, :barangays"
+    end
+  end
+
+  def self.export_csv(level: :regions, include_headers: true)
+    require "csv"
+    collection = collection_for(level)
+
+    headers = collection.first.keys.map(&:to_s)
+
+    CSV.generate do |csv|
+      csv << headers if include_headers
+      collection.each do |item|
+        csv << headers.map { |h| item[h.to_sym] }
+      end
+    end
+  end
+
+  def self.export_yaml(level: :regions)
+    require "yaml"
+    collection = collection_for(level)
+
+    { normalize_level(level) => collection }.to_yaml
+  end
+
+  # @return [String] GeoJSON FeatureCollection
+  # Note: geometry is null because PSGC data has no geographic coordinates.
+  def self.export_geojson(level: :regions)
+    collection = collection_for(level)
+
+    features = collection.map do |item|
+      props = item.dup
+      props.delete(:code)
+      {
+        type: "Feature",
+        id: item[:code],
+        geometry: nil,
+        properties: props
+      }
+    end
+
+    {
+      type: "FeatureCollection",
+      features: features
+    }.to_json
+  end
+end

metadata

@@ -1,23 +1,53 @@
 --- !ruby/object:Gem::Specification
 name: psgc-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Al Kevin Tan
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
 description: A Ruby gem providing up-to-date Philippine geographic data from the PSA.
   Includes all regions, provinces, cities, municipalities, and barangays with PSGC
   codes.
 email:
 - alkevintan@gmail.com
-executables: []
+executables:
+- psgc
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - CONTRIBUTING.md
 - LICENSE
 - README.md
@@ -26,13 +56,17 @@ files:
 - data/cities_municipalities.json
 - data/provinces.json
 - data/regions.json
+- exe/psgc
+- lib/generators/psgc/seed_generator.rb
+- lib/generators/psgc/templates/seed.rb.erb
 - lib/psgc.rb
+- lib/psgc/cli.rb
 homepage: https://github.com/alkevintan/psgc-rb
 licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/alkevintan/psgc-rb
-  source_code_uri: https://github.com/alkevintan/psgc-rb
+  source_code_uri: https://github.com/alkevintan/psgc-rb/tree/v0.2.0
 rdoc_options: []
 require_paths:
 - lib