cbhpm_table 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c4ccbc28d28f9993083a95d200b2753dbbf5e1f39e177bc25f0ca30335c0f0a
-  data.tar.gz: 22b6fa8e6abbc4c5f70aa62774218b3ef2a10704f55d098600663e898310b9df
+  metadata.gz: bd670a3a5f433458080a284fb65a7f5eb0db8c49ac6027218ff1bbc72646a013
+  data.tar.gz: db1a0d5849fc57531760f884881faebb3bf07f787538398a3208493bd35bf98f
 SHA512:
-  metadata.gz: f5d81bc6b6ae62a0e2a55dc3068288a9f2b8a06bec0e5d05ac84da2025171f4b915c83b509b9250c8bc291692d6a09b154ad22d0a0d9692a9e44bc7cb9c7a9af
-  data.tar.gz: ac8bd05bd1c1ea8f8291ec2dfac81f57d4310e825fecf55e208c6074e8a40d8296cd76ae883138dae7b2436c231231851b4524e2c8d97804651608e4dcf56f59
+  metadata.gz: 431d90858a5f234904291f69302be5e3a0ca5b858a6771e7690acbde5d141cea61d9008b19592d6c476fabdc8b2ef6008ffa1227ba48ab55e9ddb71ccc94c153
+  data.tar.gz: d7c6135732956573603735ef6869f2911da5e7ad69c1839450e945ca1982e0d7f8366498fe0e5a7b12708e3fd7f74846625797349a4630e8598ba181d1c46cd7

data/.gitignore

@@ -22,3 +22,5 @@ tmp
 mkmf.log
 *.DS_Store
 **.DS_Store
+/planilhas/
+.~lock.*#

data/AGENTS.md

@@ -0,0 +1,52 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents (Claude Code, Codex, etc.) when working with code in this repository.
+
+## Overview
+
+`cbhpm_table` is a small Ruby gem that wraps the CBHPM (Classificação Brasileira Hierarquizada de Procedimentos Médicos) Excel spreadsheets published by the Associação Médica Brasileira, exposing their rows as Hashes. It depends on `roo-xls` (which brings `roo`) to read `.xls` and `.xlsx` files.
+
+## Commands
+
+```bash
+bundle install                                   # install dependencies
+bundle exec rake                                 # run the full spec suite (default task, documentation format)
+bundle exec rspec                                # run specs directly (this is what CI runs)
+bundle exec rspec spec/cbhpm_table_spec.rb:42    # run a single example by line number
+bundle exec rubocop                              # lint (.rubocop.yml disables StringLiterals and AsciiComments)
+bundle exec rake build                           # build the gem into pkg/ (bundler gem tasks)
+```
+
+`spec_helper` (auto-required via `.rspec`) starts SimpleCov, which writes to `coverage/`.
+
+## Architecture
+
+All logic lives in a single class, `CBHPMTable`, in `lib/cbhpm_table.rb`.
+
+- **Edition detection is by exact file basename.** `VERSION_FOR_FILE` maps the spreadsheet's basename (e.g. `"CBHPM 2012.xlsx"`, plus the mojibake names of the old 3a/4a/5a editions) to an edition hash. A file whose name isn't in that map has no edition metadata, and the constructor raises unless an explicit `headers_hash` is passed as the second argument to `CBHPMTable.new`.
+- **Each edition hash** (`CBHPM3a`, `CBHPM2012`, … also registered in `VERSIONS`) holds `file_basename`, `edition_name`, `start_date`/`end_date` (strings in `dd/mm/yyyy` format), and `header_format`: a map from column index to output key (`code`, `name`, `cir_size`, `uco`, `aux_qty`, `an_size`). Column layouts differ between editions: the pre-2012 `.xls` files start at column 0, the 2012+ `.xlsx`/`.xlsm` files start at column 4. From 2022 on, column 12 ("Novo Porte Anest") also maps to `an_size`.
+- **Reader selection** goes by file extension through `ROO_CLASS_FOR_EXTENSION` (`.xls` → `Roo::Excel`, `.xlsx`/`.xlsm` → `Roo::Excelx`). The extension match is case-sensitive.
+- **Row access:** `headers` applies `header_format` to the raw first row. `row(i)` also normalizes the values (see below). `each_row` skips the first (header) row; with no block it returns an Enumerator. `rows` is `each_row.to_a`.
+- **Normalization (all editions).** The spreadsheets mix types in the same column, so `import_row` normalizes every value:
+  - `nil` and blank strings become `nil`. Zero stays `0`, because porte 0 is valid.
+  - `code` becomes a String. Punctuation is stripped when 8 digits remain (`"4.02.01.02-3"` and `"3110428-2"`).
+  - `name` has its whitespace squeezed and stripped.
+  - `cir_size` is upcased (the 2020+ spreadsheets have a `9c` for code 31303366).
+  - `uco` becomes a Float, also when it comes as a String with a decimal comma (`"0,750"`).
+  - `aux_qty`/`an_size` become Integers (`"5"` → `5`).
+  - Values that can't be parsed are kept as stripped Strings, never silently corrected.
+- **Columns mapped to the same key.** In `import_row` the rightmost non-blank value wins. From 2022 on, this makes a valid "Novo Porte Anest" override the old "Porte Anestés.", so the application only ever sees `an_size`. In `headers`, the first column's label is kept.
+- **Discarded rows.** `each_row` keeps rows in a Hash keyed by `code`. Rows without code are dropped, and a duplicated code overwrites the earlier row while keeping its position. The gem imports; it doesn't report spreadsheet errors.
+- **Original spreadsheets.** Keep them locally in `planilhas/` (git-ignored). The integration specs use them when present and are skipped otherwise.
+
+### Adding a new CBHPM edition
+
+Past additions (see the 2016/2018/2020/2022 commits) follow this pattern:
+1. Add a `CBHPMxxxx = VERSIONS[:cbhpmxxxx] = { ... }` constant.
+2. Add its basename to `VERSION_FOR_FILE`.
+3. The newest edition currently has `end_date: ""` (open-ended), so set a real `end_date` on it when a newer edition supersedes it.
+4. Bump `CBHPMTable::VERSION` in `lib/cbhpm_table/version.rb` in a separate commit.
+
+## Tests
+
+The specs use a trimmed fixture, `spec/cbhpm/cbhpm_cut_for_testing.xlsx`, which `VERSION_FOR_FILE` maps to the 2012 edition. The real CBHPM spreadsheets are not in the repo. Specs for the 2022/2026 spreadsheets run only when they are in `planilhas/`.

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+## 0.1.0 - 2026-10-04
+
+### Added
+- Support to CBHPM 2022 (`CBHPM_2022_atualizado.xlsm`) and CBHPM 2026 (`CBHPM_2026.xlsm`).
+- Reading of `.xlsm` files.
+- From 2022 on, the "Novo Porte Anest" column overrides `an_size` when present. Zero is a valid porte.
+- AGENTS.md with guidance for AI coding agents.
+
+### Changed
+- Row values are normalized for every edition. This changes the returned types:
+  - `code` is a String. Punctuation is stripped when 8 digits remain (`"3110428-2"` → `"31104282"`).
+  - `name` has its whitespace squeezed.
+  - `cir_size` is upcased (`"9c"` in the 2020+ spreadsheets → `"9C"`).
+  - `uco` is a Float, also when the spreadsheet has a decimal comma (`"0,750"`).
+  - `aux_qty` and `an_size` are Integers.
+  - Blank cells are `nil`.
+- Rows without code and rows with duplicated codes are discarded. The last row read for a code wins.
+- CBHPM 2020 now ends on 31/12/2021.
+- Requires Ruby >= 4.0.0. The development dependency on Bundler is no longer pinned to 1.x.
+
+## 0.0.8 - 2022-06-06
+- Support to CBHPM 2016, 2018 and 2020.
+- Fix the file basename of CBHPM 2014.
+
+## 0.0.7 - 2018-03-05
+- Support to CBHPM 2014.
+
+## 0.0.6 - 2016-04-18
+- Support to the 3rd and 4th CBHPM editions.
+
+## 0.0.5 - 2015-06-24
+- Require Ruby >= 1.9.3.
+
+## 0.0.4 - 2015-06-24
+- Remove the header indication from rows.
+
+## 0.0.3 - 2014-10-29
+- Add `#version_format`, `#start_date` and `#end_date`.
+
+## 0.0.2 - 2014-10-28
+- Add `#edition_name`.
+
+## 0.0.1 - 2014-10-28
+- Initial release.

data/README.md

@@ -45,6 +45,19 @@ cbhpm_table.each_row do |row|
 end
 ```
 
+Supported editions: 3a, 4a, 5a, 2010, 2012, 2014, 2016, 2018, 2020, 2022 and 2026
+(`.xls`, `.xlsx` and `.xlsm`). The edition is detected by the file basename.
+
+Row values are normalized for every edition:
+* `code` and `name` come as Strings.
+* `cir_size` comes upcased (the 2020+ spreadsheets have a `9c`).
+* `uco` comes as a Float.
+* `aux_qty` and `an_size` come as Integers.
+* Blank cells come as `nil`.
+
+From the 2022 edition on, `an_size` already takes the "Novo Porte Anest" column
+into account. Rows without code and rows with duplicated codes are discarded.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/cbhpm_table/fork )

data/cbhpm_table.gemspec

@@ -20,10 +20,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  # This gem will work with 1.9.3 or greater...
-  spec.required_ruby_version = '>= 1.9.3'
+  # This gem requires Ruby 4.0.0 or greater.
+  spec.required_ruby_version = '>= 4.0.0'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "simplecov"

data/lib/cbhpm_table/version.rb

@@ -1,3 +1,3 @@
 class CBHPMTable
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

data/lib/cbhpm_table.rb

@@ -36,8 +36,12 @@ class CBHPMTable
     fail "Can't find predefined headers for #{cbhpm_path}" unless @headers_hash
   end
 
+  # When several columns map to the same key, the first column names it.
   def headers
-    row(first_row_index)
+    header_row = roo.row(first_row_index)
+    headers_hash.each_with_object({}) do |(col, name), mapped_row|
+      mapped_row[name] ||= header_row[col]
+    end
   end
 
   def first_row_index
@@ -48,14 +52,52 @@ class CBHPMTable
     import_row(roo.row(row_index))
   end
 
+  # When several columns map to the same key, the rightmost non-blank value
+  # wins. From CBHPM 2022 on, this makes a valid "Novo Porte Anest" override
+  # the old "Porte Anestés." in an_size. Zero is a valid porte.
   def import_row(row_array)
-    imported_row = {}
+    headers_hash.each_with_object({}) do |(col, name), imported_row|
+      value = normalize(name, row_array[col])
+      imported_row[name] = value unless value.nil? && imported_row.key?(name)
+    end
+  end
+
+  def normalize(name, value)
+    return nil if value.nil? || (value.is_a?(String) && value.strip.empty?)
 
-    headers_hash.each do |col, name|
-      imported_row[name] = row_array[col]
+    case name
+    when "code" then normalize_code(value)
+    when "name" then value.to_s.gsub(/\s+/, " ").strip
+    when "cir_size" then value.is_a?(String) ? value.strip.upcase : value
+    when "uco" then normalize_decimal(value)
+    when "aux_qty", "an_size" then normalize_integer(value)
+    else value.is_a?(String) ? value.strip : value
     end
+  end
+
+  def normalize_code(value)
+    return integer_value(value).to_s if value.is_a?(Numeric)
+    code = value.strip
+    digits = code.delete(".-")
+    digits.match?(/\A\d{8}\z/) ? digits : code
+  end
 
-    imported_row
+  def normalize_decimal(value)
+    return value.to_f if value.is_a?(Numeric)
+    decimal = value.strip
+    decimal.match?(/\A\d+([.,]\d+)?\z/) ? decimal.tr(",", ".").to_f : decimal
+  end
+
+  def normalize_integer(value)
+    integer_value(value) || (value.is_a?(String) ? value.strip : value)
+  end
+
+  def integer_value(value)
+    case value
+    when Integer then value
+    when Float then value.to_i if value == value.to_i
+    when String then value.strip.to_i if value.strip.match?(/\A\d+\z/)
+    end
   end
 
   def rows
@@ -76,12 +118,18 @@ class CBHPMTable
 
   attr_reader :cbhpm_path
 
-  def each_row
+  # Rows without code are silently discarded. So are duplicated codes: the
+  # last row read for a code overwrites the previous ones, keeping the
+  # position of the first.
+  def each_row(&block)
     return to_enum(:each_row) unless block_given?
-    roo_enum = roo.to_enum(:each)
-    _skip_header = roo_enum.next
-    loop do
-      yield import_row(roo_enum.next)
+    unique_rows.each_value(&block)
+  end
+
+  def unique_rows
+    @unique_rows ||= roo.to_enum(:each).drop(1).each_with_object({}) do |row_array, rows|
+      imported_row = import_row(row_array)
+      rows[imported_row["code"]] = imported_row unless imported_row["code"].nil?
     end
   end
 
@@ -102,7 +150,9 @@ class CBHPMTable
   end
 
   private :first_row_index, :import_row, :fetch_version_format
-  private :fetch_headers_hash
+  private :fetch_headers_hash, :normalize
+  private :normalize_code, :normalize_decimal, :normalize_integer
+  private :integer_value, :unique_rows
 
   VERSIONS = {}
 
@@ -223,6 +273,36 @@ class CBHPMTable
         11 => "an_size"
       },
       start_date: "01/01/2020",
+      end_date: "31/12/2021" }
+
+  CBHPM2022 = VERSIONS[:cbhpm2022] =
+    { file_basename: "CBHPM_2022_atualizado.xlsm",
+      edition_name: "2022",
+      header_format: {
+        4 => "code",
+        5 => "name",
+        8 => "cir_size",
+        9 => "uco",
+        10 => "aux_qty",
+        11 => "an_size",
+        12 => "an_size"
+      },
+      start_date: "01/01/2022",
+      end_date: "31/12/2025" }
+
+  CBHPM2026 = VERSIONS[:cbhpm2026] =
+    { file_basename: "CBHPM_2026.xlsm",
+      edition_name: "2026",
+      header_format: {
+        4 => "code",
+        5 => "name",
+        8 => "cir_size",
+        9 => "uco",
+        10 => "aux_qty",
+        11 => "an_size",
+        12 => "an_size"
+      },
+      start_date: "01/01/2026",
       end_date: "" }
   
   VERSION_FOR_FILE = {
@@ -235,7 +315,10 @@ class CBHPMTable
     "CBHPM 2016.xlsx" => CBHPM2016,
     "CBHPM 2018.xlsx" => CBHPM2018,
     "CBHPM 2020.xlsx" => CBHPM2020,
+    "CBHPM_2022_atualizado.xlsm" => CBHPM2022,
+    "CBHPM_2026.xlsm" => CBHPM2026,
     "cbhpm_cut_for_testing.xlsx" => CBHPM2012 }
 
-  ROO_CLASS_FOR_EXTENSION = { ".xls" => Roo::Excel, ".xlsx" => Roo::Excelx }
+  ROO_CLASS_FOR_EXTENSION = { ".xls" => Roo::Excel, ".xlsx" => Roo::Excelx,
+                              ".xlsm" => Roo::Excelx }
 end

data/spec/cbhpm_table_spec.rb

@@ -96,4 +96,145 @@ describe CBHPMTable do
       expect(cbhpm_table.end_date).to eq "31/12/2013"
     end
   end
+
+  describe "normalization of mixed cell types" do
+    let(:header_format) do
+      CBHPMTable::CBHPM2026[:header_format]
+    end
+    let(:table) do
+      CBHPMTable.new("spec/cbhpm/cbhpm_cut_for_testing.xlsx", header_format)
+    end
+
+    def raw_row(values)
+      Array.new(13).tap do |row|
+        { "code" => 4, "name" => 5, "cir_size" => 8, "uco" => 9,
+          "aux_qty" => 10, "an_size" => 11, "novo_porte_anest" => 12 }
+          .each { |name, col| row[col] = values[name] }
+      end
+    end
+
+    def import(values)
+      table.send(:import_row, raw_row(values))
+    end
+
+    it "converts numeric codes to String" do
+      expect(import("code" => 40901688)["code"]).to eq "40901688"
+      expect(import("code" => 40901688.0)["code"]).to eq "40901688"
+    end
+
+    it "removes the punctuation of 8 digit codes" do
+      expect(import("code" => "4.02.01.02-3")["code"]).to eq "40201023"
+      expect(import("code" => "3110428-2")["code"]).to eq "31104282"
+      expect(import("code" => "330735114")["code"]).to eq "330735114"
+    end
+
+    it "squeezes whitespace in names" do
+      name = " Ablação de alvos\nintracerebrais  "
+      expect(import("name" => name)["name"]).to eq "Ablação de alvos intracerebrais"
+    end
+
+    it "upcases cir_size" do
+      expect(import("cir_size" => " 9c ")["cir_size"]).to eq "9C"
+    end
+
+    it "converts uco to Float, accepting decimal comma" do
+      expect(import("uco" => "0,750")["uco"]).to eq 0.75
+      expect(import("uco" => 7.39)["uco"]).to eq 7.39
+    end
+
+    it "converts portes and aux_qty to Integer, keeping zero" do
+      expect(import("an_size" => "5")["an_size"]).to eq 5
+      expect(import("an_size" => 5)["an_size"]).to eq 5
+      expect(import("an_size" => "0")["an_size"]).to eq 0
+      expect(import("aux_qty" => 2.0)["aux_qty"]).to eq 2
+    end
+
+    it "turns blank strings into nil" do
+      row = import("cir_size" => "", "uco" => "  ", "an_size" => " ")
+      expect(row.values_at("cir_size", "uco", "an_size")).to eq [nil, nil, nil]
+    end
+
+    it "keeps unparseable values as String" do
+      expect(import("aux_qty" => "2A")["aux_qty"]).to eq "2A"
+    end
+
+    describe "anesthetic size resolution" do
+      it "prefers the new an_size" do
+        expect(import("an_size" => 3, "novo_porte_anest" => 5)["an_size"]).to eq 5
+      end
+
+      it "accepts zero as a valid new an_size" do
+        expect(import("an_size" => 2, "novo_porte_anest" => 0)["an_size"]).to eq 0
+      end
+
+      it "falls back to the old an_size when the new one is blank" do
+        expect(import("an_size" => "3", "novo_porte_anest" => nil)["an_size"]).to eq 3
+        expect(import("an_size" => "3", "novo_porte_anest" => "")["an_size"]).to eq 3
+      end
+
+      it "maps both columns to an_size" do
+        expect(import("an_size" => 3, "novo_porte_anest" => 4).keys).to eq(
+          %w[code name cir_size uco aux_qty an_size])
+      end
+    end
+  end
+
+  describe "duplicated codes and rows without code" do
+    let(:roo) { instance_double(Roo::Excelx) }
+
+    before do
+      allow(Roo::Excelx).to receive(:new).and_return(roo)
+      allow(roo).to receive(:each).and_yield([])
+        .and_yield(row_array(10101012, "Primeira "))
+        .and_yield(row_array("10101020", "Outra"))
+        .and_yield(row_array(nil, ""))
+        .and_yield(row_array(" ", nil))
+        .and_yield(row_array("10101012", "Primeira"))
+    end
+
+    def row_array(code, name)
+      Array.new(12).tap { |row| row[4] = code; row[5] = name }
+    end
+
+    it "keeps only the last row read for each code, discarding rows without code" do
+      expect(cbhpm_table.rows.map { |r| r.values_at("code", "name") }).to eq(
+        [%w[10101012 Primeira], %w[10101020 Outra]])
+    end
+  end
+
+  %w[CBHPM_2022_atualizado.xlsm CBHPM_2026.xlsm].each do |basename|
+    describe "original spreadsheet #{basename}" do
+      path = File.join("planilhas", basename)
+      before { skip "#{path} not available" unless File.exist?(path) }
+
+      let(:table) { CBHPMTable.new(path) }
+      let(:rows_by_code) { table.rows.to_h { |row| [row["code"], row] } }
+
+      it "is detected by its basename" do
+        expect(table.edition_name).to eq basename[/\d{4}/]
+      end
+
+      it "returns every code as an 8 digit String" do
+        expect(rows_by_code.keys).to all(match(/\A\d{8}\z/))
+      end
+
+      it "returns no duplicated codes" do
+        expect(table.rows.size).to eq rows_by_code.size
+      end
+
+      it "exposes the same keys as the previous editions" do
+        expect(table.headers.keys).to eq %w[code name cir_size uco aux_qty an_size]
+        expect(table.headers["an_size"]).to eq "Porte Anestés."
+      end
+
+      it "upcases the lowercase cir_size of the spreadsheet" do
+        expect(rows_by_code["31303366"]["cir_size"]).to eq "9C"
+      end
+
+      it "applies the new anesthetic size" do
+        expect(rows_by_code["40202798"]["an_size"]).to eq 5
+        expect(rows_by_code["40201015"]["an_size"]).to eq 0
+      end
+    end
+  end
 end

metadata

@@ -1,29 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: cbhpm_table
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Abinoam Praxedes Marques Jr.
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -92,6 +91,8 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- AGENTS.md
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -106,7 +107,6 @@ homepage: https://github.com/abinoam/cbhpm_table
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -114,15 +114,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 4.0.20
 specification_version: 4
 summary: CBHPM Table. A simple wrapper around the CBHPM excel files.
 test_files: