gov_codes 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c91603e5956e6918476045972a183754d150c8bfef8a8f7d33de5159ca4c60
-  data.tar.gz: 72ade76ae58f72cfcc07ff2f301bd3a7067fc5e1fb836ca91438b767ff1198ae
+  metadata.gz: bde662fd124b6754ac6c830f95e58cbcf63d8cce2168f04a410b5fe0df1c80d9
+  data.tar.gz: 77894785fb4edf1bcb2fe575fe6ed55932a7f0eadbd056988bd666742e7c2b06
 SHA512:
-  metadata.gz: cbf18e6e8e9099d19c023e12ed688374335213dc04ec9c95217a2b4f3df085fa29be735d4de828ddea254306357ff7463d4e2346e344ccde9281ac0c593ca258
-  data.tar.gz: 82a5a80e5d3880e65711f7ee09c0d9b3c50b866faf879360997bfec5b98830bd2fe4c49f467e3545800cd80f6e9acd6f3cc41c7735cbdf06c592ff7fdc0ee172
+  metadata.gz: 0c8d2bcb57eb86164c8484b9db9b2c00bf9853a0fa0ef33178a8f02267d4558a88d3ca1834458de46c120a0bf68a0f3f566f65c65c865dda0c51c4ab7352ca05
+  data.tar.gz: 335e26092052f94f0b949cf28cc6c1d3d4194621f641dfa78b9098b05b71ddc6fb71c8a3e1c911d029064ff891b4114ea719a2faee4ab7d3c3d99a57959ed7ca

data/.simplecov

@@ -2,7 +2,8 @@ SimpleCov.start do
   # enable_coverage :branch
 
   # Add any files or directories you want to exclude from coverage
-  add_filter "/test/", "lib/gov_codes/version.rb"
+  add_filter "/test/"
+  add_filter "lib/gov_codes/version.rb"
 
   # Set minimum coverage requirements
   # minimum_coverage 80
@@ -11,5 +12,6 @@ SimpleCov.start do
   track_files "lib/**/*.rb"
 
   # Group files by module
+
   add_group "AFSC", "lib/gov_codes/afsc"
 end

data/CHANGELOG.md

@@ -5,8 +5,58 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## [0.1.0] - 2025-05-02
+## [0.1.1] - 2025-11-17
+
+### Changed
+
+- Test against Ruby 3.3.8 and 3.4.3
+- Officer YAML structure to match Wikipedia (11BX, 11MX, etc.) (4ca6aef)
+- Officer parser to accept letter qualification levels (X, Y, Z) (4ca6aef)
+- Officer lookup to include qualification level in key (4ca6aef)
+- Enlisted/Officer lookups to handle String leaf values (4ca6aef)
+- Use git trailers to track changelog changes. (c83929a)
+
+### Added
+
+- AFSC Officer support (bb96aaa)
+- Data extractor script for Wikipedia (c8ec55b)
+- 1Z Special Warfare career field (Pararescue, Combat Control, TACP) (4ca6aef)
+- Nokogiri gem for HTML parsing (4ca6aef)
+- Reporting identifiers with GovCodes::AFSC::RI (6102656)
+- AFSC.search to return an array of matching codes for the given prefix. (5c5bdf1)
+
+### Removed
+
+- 824 hallucinated codes not found in Wikipedia (4ca6aef)
+
+### Fixed
+
+- Tests updated to use real Wikipedia codes (4ca6aef)
+
+## [0.1.1] - 2025-11-17
+
+### Changed
+
+- Test against Ruby 3.3.8 and 3.4.3
+- Officer YAML structure to match Wikipedia (11BX, 11MX, etc.) (4ca6aef)
+- Officer parser to accept letter qualification levels (X, Y, Z) (4ca6aef)
+- Officer lookup to include qualification level in key (4ca6aef)
+- Enlisted/Officer lookups to handle String leaf values (4ca6aef)
+- Use git trailers to track changelog changes. (c83929a)
 
 ### Added
 
-- AFSC codes
+- AFSC Officer support (bb96aaa)
+- Data extractor script for Wikipedia (c8ec55b)
+- 1Z Special Warfare career field (Pararescue, Combat Control, TACP) (4ca6aef)
+- Nokogiri gem for HTML parsing (4ca6aef)
+- Reporting identifiers with GovCodes::AFSC::RI (6102656)
+- AFSC.search to return an array of matching codes for the given prefix. (5c5bdf1)
+
+### Removed
+
+- 824 hallucinated codes not found in Wikipedia (4ca6aef)
+
+### Fixed
+
+- Tests updated to use real Wikipedia codes (4ca6aef)

data/README.md

@@ -31,7 +31,7 @@ require 'gov_codes/afsc'
 
 # Find an enlisted AFSC code
 code = GovCodes::AFSC.find("1A1X2")
-puts code.name # => "Aircrew operations"
+puts code.name # => "Mobility force aviator"
 puts code.career_field # => "1A"
 puts code.career_field_subdivision # => "1A1"
 puts code.skill_level # => "X"
@@ -39,12 +39,58 @@ puts code.specific_afsc # => "1A1X2"
 puts code.shredout # => nil
 
 # Find an officer AFSC code
-code = GovCodes::AFSC.find("11M4")
-puts code.name # => "Pilot"
+code = GovCodes::AFSC.find("11MX")
+puts code.name # => "Mobility pilot"
 puts code.career_group # => "11"
 puts code.functional_area # => "M"
-puts code.qualification_level # => "4"
+puts code.qualification_level # => "X"
 puts code.shredout # => nil
+
+# Find a Reporting Identifier (RI) or Special Duty Identifier (SDI)
+code = GovCodes::AFSC.find("8A400")
+puts code.name # => "Talent management consultant"
+puts code.career_field # => "8A"
+puts code.identifier # => "400"
+puts code.suffix # => nil
+
+# Find a code with a shredout/suffix
+code = GovCodes::AFSC.find("11BXA")
+puts code.name # => "B-1"
+puts code.specific_afsc # => "11BX"
+puts code.shredout # => "A"
+```
+
+### Searching for Codes
+
+You can search for all codes matching a prefix:
+
+```ruby
+# Search for all Special Warfare codes
+results = GovCodes::AFSC.search("1Z")
+results.each do |code|
+  puts "#{code.specific_afsc}: #{code.name}"
+end
+# Output:
+# 1Z1X1: Pararescue
+# 1Z2X1: Combat control
+# 1Z3X1: Tactical air control party (TACP)
+# 1Z4X1: Special reconnaissance
+
+# Search for Bomber Pilot shredouts
+results = GovCodes::AFSC.search("11BX")
+results.each do |code|
+  shredout = code.shredout ? code.shredout.to_s : ""
+  puts "#{code.specific_afsc}#{shredout}: #{code.name}"
+end
+# Output:
+# 11BX: Bomber pilot
+# 11BXA: B-1
+# 11BXB: B-2
+# 11BXC: B-52
+# ...
+
+# Search is case-insensitive
+GovCodes::AFSC.search("1z1") # Same as search("1Z1")
 ```
 
 ### Extending with Custom AFSC Codes

data/Rakefile

@@ -13,4 +13,5 @@ require "reissue/gem"
 
 Reissue::Task.create :reissue do |task|
   task.version_file = "lib/gov_codes/version.rb"
+  task.fragment = :git # Enable git trailer extraction for changelog
 end

data/checksums/gov_codes-0.1.0.gem.sha512

@@ -0,0 +1 @@
+a47544403935737f6dc23d24d03620744582275e6f585ca3dd7610b01efde9afbafe3b54949b5fc16c67d92b56a5175ec4109237d7eda96df86821eab3c2c8ef

data/lib/gov_codes/afsc/enlisted.rb

@@ -2,8 +2,6 @@ require "strscan"
 require "yaml"
 require_relative "../data_loader"
 
-puts "Loading enlisted.rb"
-
 module GovCodes
   module AFSC
     module Enlisted
@@ -38,22 +36,25 @@ module GovCodes
           return result unless career_field_letter
           result[:career_field] = :"#{career_group}#{career_field_letter}"
 
-          # Scan for subdivision digit and combine with career field
+          # Scan for subdivision digit
           subdivision_digit = scanner.scan(/\d/)
           return result unless subdivision_digit
           result[:career_field_subdivision] = :"#{result[:career_field]}#{subdivision_digit}"
 
-          # Scan for skill level
-          skill_level = scanner.scan(/[\dX]/)
-          return result unless skill_level
-          result[:skill_level] = skill_level.to_sym
+          # Scan for skill level letter (usually X)
+          skill_level_letter = scanner.scan(/[A-Z]/)
+          return result unless skill_level_letter
+          result[:skill_level] = skill_level_letter.to_sym
+
+          # Scan for skill level digit
+          skill_level_digit = scanner.scan(/\d/)
+          return result unless skill_level_digit
 
-          # Scan for specific AFSC digit and combine with previous components
-          specific_digit = scanner.scan(/\d/)
-          return result unless specific_digit
-          result[:specific_afsc] = :"#{result[:career_field_subdivision]}#{result[:skill_level]}#{specific_digit}"
+          # Subcategory is subdivision digit + letter + digit (e.g. '1X2')
+          result[:subcategory] = :"#{subdivision_digit}#{skill_level_letter}#{skill_level_digit}"
 
-          result[:subcategory] = result[:specific_afsc][2..4].to_sym
+          # Build specific AFSC
+          result[:specific_afsc] = :"#{result[:career_field_subdivision]}#{skill_level_letter}#{skill_level_digit}"
 
           # Scan for shredout (optional)
           result[:shredout] = scanner.scan(/[A-Z]/)&.to_sym
@@ -66,6 +67,7 @@ module GovCodes
       end
 
       extend GovCodes::DataLoader
+
       DATA = data
 
       Code = Data.define(
@@ -86,11 +88,25 @@ module GovCodes
           parser = Parser.new(code)
           result = parser.parse
 
-          return nil if result.reject { |_, v| v.nil? }.empty?
+          # Return nil if parsing failed or required fields are missing
+          return nil if result.reject { |_, v| v.nil? }.empty? ||
+            result[:career_group].nil? ||
+            result[:career_field].nil? ||
+            result[:career_field_subdivision].nil? ||
+            result[:skill_level].nil? ||
+            result[:specific_afsc].nil? ||
+            result[:subcategory].nil?
+
+          # Additional validation: check for invalid characters or too long codes
+          return nil if code.length > 7 ||
+            code.match?(/[^A-Z0-9]/)
 
           # Find the name by recursively searching the codes hash
           name = find_name_recursive(result)
 
+          # Return nil if name is 'Unknown'
+          return nil if name == "Unknown"
+
           # Add the name to the result
           result[:name] = name
 
@@ -98,6 +114,69 @@ module GovCodes
           Code.new(**result)
         end
       end
+
+      def self.find_name_recursive(result)
+        data = DATA
+
+        # Career field (e.g., "9Z")
+        cf = result[:career_field]&.to_sym
+        return "Unknown" unless cf && data[cf]
+        name = data[cf][:name]
+        data = data[cf][:subcategories]
+
+        # Subcategory (e.g., "0X1" from "9Z0X1")
+        if data && result[:subcategory]
+          sub = result[:subcategory].to_sym
+          lookup_value = data[sub]
+          if lookup_value
+            if lookup_value.is_a?(Hash)
+              name = lookup_value[:name] || name
+              data = lookup_value[:subcategories]
+            else
+              # String value (leaf node)
+              name = lookup_value
+              data = nil
+            end
+          end
+        end
+
+        # Shredout (optional, e.g., :A)
+        if data && result[:shredout]
+          lookup_value = data[result[:shredout]]
+          if lookup_value
+            name = lookup_value.is_a?(Hash) ? (lookup_value[:name] || name) : (lookup_value || name)
+          end
+        end
+
+        name || "Unknown"
+      end
+
+      def self.search(prefix)
+        results = []
+        prefix = prefix.to_s.upcase
+        collect_codes_recursive(DATA, "", prefix, results)
+        results.map { |code| find(code) }.compact
+      end
+
+      def self.collect_codes_recursive(data, current_code, prefix, results)
+        return unless data.is_a?(Hash)
+
+        data.each do |key, value|
+          code = "#{current_code}#{key}"
+
+          if value.is_a?(Hash) && value[:name]
+            # This is a node with a name and possibly subcategories
+            results << code if code.start_with?(prefix)
+            collect_codes_recursive(value[:subcategories], code, prefix, results) if value[:subcategories]
+          elsif value.is_a?(String)
+            # This is a leaf node (simple string value)
+            results << code if code.start_with?(prefix)
+          elsif value.is_a?(Hash)
+            # Nested subcategories without a name at this level
+            collect_codes_recursive(value, current_code, prefix, results)
+          end
+        end
+      end
     end
   end
 end