openphar 0.1.0

data/lib/openphar/parsers/jp_ja_html_parser.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Parsers
+    # Parser for Japanese (JA) Japan Pharmacopoeia HTML monographs
+    #
+    # Parses JP monographs from Japanese HTML files where:
+    # - class="s1" contains Japanese names
+    # - class="s2" contains Latin names
+    # - class="s5" contains section headers
+    # - class="s3" contains content paragraphs
+    #
+    # Japanese section headers:
+    # - 生薬の性状 / 性状 - Macroscopic Description
+    # - 顕微鏡的性状 - Microscopic Description
+    # - 確認試験 - Identification
+    # - 純度試験 - Purity
+    # - 異物 - Foreign Matter
+    # - 乾燥減量 - Loss on Drying
+    # - 灰分 - Total Ash
+    # - 酸不溶性灰分 - Acid Insoluble Ash
+    # - エキス量 - Extractive
+    # - 定量法 - Assay
+    # - 貯法 - Storage
+    # - 容器 - Container
+    class JpJaHtmlParser < JpHtmlParserBase
+      # Japanese section patterns for crude drugs
+      CRUDE_DRUG_SECTION_PATTERNS = {
+        definition: /(?:生薬の性状|性状|成分規格)/,
+        macroscopic_description: /生薬の性状/,
+        microscopic_description: /顕微鏡的性状/,
+        identification: /確認試験/,
+        purity: /純度試験/,
+        foreign_matter: /異物/,
+        loss_on_drying: /乾燥減量/,
+        total_ash: /灰分/,
+        acid_insoluble_ash: /酸不溶性灰分/,
+        extractive: /エキス量/,
+        assay: /定量法/,
+        storage: /貯法/,
+        container: /容器/
+      }.freeze
+
+      # Japanese section patterns for chemical drugs
+      CHEMICAL_DRUG_SECTION_PATTERNS = {
+        specification: /成分規格/,
+        description: /性状/,
+        identification: /確認試験/,
+        purity: /純度試験/,
+        loss_on_drying: /乾燥減量/,
+        residue_on_ignition: /強熱残分/,
+        assay: /定量法/,
+        storage: /貯法/
+      }.freeze
+
+      # CSS selectors for Japanese HTML
+      JAPANESE_NAME_SELECTOR = "p.s1"
+      LATIN_NAME_SELECTOR = "p.s2"
+      CONTENT_SELECTOR = "p.s3"
+      SECTION_HEADER_CLASS = "s5"
+
+      # Reference marker patterns (Japanese uses 〈〉 instead of <>)
+      REFERENCE_PATTERN = /〈([^〉]+)〉/
+
+      attr_reader :monographs
+
+      # Initialize parser with HTML content
+      #
+      # @param html_content [String] The HTML content to parse
+      # @param monograph_type [Symbol] :crude_drug or :chemical_drug
+      def initialize(html_content, monograph_type: :crude_drug)
+        super(html_content)
+        @monograph_type = monograph_type
+        @section_patterns = if monograph_type == :crude_drug
+                              CRUDE_DRUG_SECTION_PATTERNS
+                            else
+                              CHEMICAL_DRUG_SECTION_PATTERNS
+                            end
+      end
+
+      # Parse all monographs from the document
+      #
+      # @return [Array<Hash>] Array of parsed monograph data
+      def parse
+        @monographs = []
+        current_monograph = nil
+
+        # Iterate through all paragraph elements
+        document.css("p").each do |paragraph|
+          classes = paragraph.classes
+
+          if classes.include?("s1") && monograph_name?(paragraph.text)
+            # Start of a new monograph
+            if current_monograph
+              @monographs << current_monograph
+            end
+
+            current_monograph = start_new_monograph(paragraph)
+          elsif current_monograph && classes.include?("s2")
+            # Latin name follows Japanese name
+            latin_name = extract_latin_name(paragraph.text)
+            current_monograph[:latin_name] = latin_name if latin_name
+          elsif current_monograph
+            # Check for section headers (s5 class)
+            if classes.include?(SECTION_HEADER_CLASS)
+              current_section = detect_section(paragraph.text)
+              current_monograph[:current_section] = current_section
+            else
+              # Content for current section
+              add_content_to_section(current_monograph, paragraph.text)
+            end
+          end
+        end
+
+        # Don't forget the last monograph
+        @monographs << current_monograph if current_monograph
+
+        @monographs
+      end
+
+      private
+
+      # Check if text is a monograph name (not just a section title)
+      #
+      # @param text [String] The paragraph text
+      # @return [Boolean] true if it appears to be a monograph name
+      def monograph_name?(text)
+        cleaned = text.strip
+        # Remove zero-width characters and other invisible Unicode
+        cleaned = cleaned.gsub(/\p{Zs}|\p{Cf}/, "").strip
+
+        return false if cleaned.empty?
+
+        # Filter out section headers and category titles
+        return false if cleaned.match?(/^(生薬等|医薬品|一般試験法|第[一二三四五六七八九十]+版)/)
+        return false if cleaned.length > 30
+
+        # Must contain at least one Japanese character (Hiragana, Katakana, or Kanji)
+        # and be a reasonable length for a monograph name
+        return false unless cleaned.match?(/[\p{Hiragana}\p{Katakana}\p{Han}]{2,}/)
+
+        true
+      end
+
+      # Start a new monograph with Japanese name
+      #
+      # @param paragraph [Nokogiri::XML::Element] The paragraph element
+      # @return [Hash] New monograph hash
+      def start_new_monograph(paragraph)
+        {
+          japanese_name: paragraph.text.strip,
+          latin_name: nil,
+          sections: {},
+          current_section: :definition
+        }
+      end
+
+      # Extract Latin name from paragraph text
+      #
+      # @param text [String] The paragraph text
+      # @return [String, nil] The Latin name or nil
+      def extract_latin_name(text)
+        # Latin names typically have uppercase words
+        # Format: "Common Name LATIN NAME"
+        parts = text.strip.split
+        latin_parts = parts.select { |p| p.match?(/^[A-Z]+$/) || p.match?(/^[A-Z][a-z]+$/) }
+
+        return nil if latin_parts.empty?
+
+        # Find where Latin name starts (usually after common name)
+        latin_start = parts.index { |p| p.match?(/^[A-Z]{2,}/) }
+        return nil unless latin_start
+
+        parts[latin_start..].join(" ")
+      end
+
+      # Detect section type from header text
+      #
+      # @param text [String] The header text
+      # @return [Symbol, nil] The section type
+      def detect_section(text)
+        cleaned = text.strip
+
+        @section_patterns.each do |section_type, pattern|
+          return section_type if cleaned.match?(pattern)
+        end
+
+        nil
+      end
+
+      # Add content to the current section
+      #
+      # @param monograph [Hash] The monograph hash
+      # @param content [String] The content to add
+      def add_content_to_section(monograph, content)
+        return unless content && monograph[:current_section]
+
+        section = monograph[:current_section]
+        monograph[:sections][section] ||= []
+        monograph[:sections][section] << clean_content(content)
+      end
+
+      # Clean content text
+      #
+      # @param text [String] Raw text
+      # @return [String] Cleaned text
+      def clean_content(text)
+        text.strip.gsub(/\s+/, " ")
+      end
+
+      # Convert Japanese reference markers to standard format
+      #
+      # @param text [String] Text with Japanese markers
+      # @return [String] Text with standard markers
+      def normalize_references(text)
+        text.gsub(REFERENCE_PATTERN, '<\1>')
+      end
+    end
+  end
+end

data/lib/openphar/parsers/phint_json_parser.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "json"
+require "nokogiri"
+
+module Openphar
+  module Parsers
+    # Parser for International Pharmacopoeia (Ph.Int.) JSON files
+    #
+    # This parser creates Lutaml::Model instances (not hashes) for proper
+    # model-driven architecture. All output uses model classes.
+    #
+    # Ph.Int. data files are JSON with embedded HTML content:
+    # {
+    #   "id": "6.1.1",
+    #   "title": "Abacavir sulfate (Abacaviri sulfas)",
+    #   "data": {
+    #     "t": "Title",
+    #     "b": "<p>HTML body content...</p>",
+    #     "c": []
+    #   }
+    # }
+    class PhIntJsonParser
+      attr_reader :monographs, :stats
+
+      def initialize
+        @monographs = []
+        @stats = { total: 0, parsed: 0, failed: 0 }
+      end
+
+      # Parse a single Ph.Int. JSON file
+      #
+      # @param file_path [String] Path to JSON file
+      # @return [Monograph, nil] Parsed monograph model instance
+      def parse_file(file_path)
+        @stats[:total] += 1
+
+        begin
+          content = File.read(file_path, encoding: "UTF-8")
+          data = JSON.parse(content)
+          monograph = parse_data(data)
+          if monograph
+            @monographs << monograph
+            @stats[:parsed] += 1
+          end
+          monograph
+        rescue JSON::ParserError => e
+          puts "  ERROR: Invalid JSON - #{e.message}"
+          @stats[:failed] += 1
+          nil
+        rescue StandardError => e
+          puts "  ERROR: #{e.message}"
+          @stats[:failed] += 1
+          nil
+        end
+      end
+
+      # Parse all Ph.Int. JSON files in a directory
+      #
+      # @param directory [String] Directory containing JSON files
+      # @return [Array<Monograph>] Parsed monograph model instances
+      def parse_directory(directory)
+        json_files = Dir.glob(File.join(directory, "b.*.json"))
+        puts "Found #{json_files.count} Ph.Int. JSON files"
+
+        json_files.sort.each do |file|
+          puts "Parsing: #{File.basename(file)}"
+          parse_file(file)
+        end
+
+        @monographs
+      end
+
+      private
+
+      # Parse Ph.Int. data structure and create model instance
+      #
+      # @param data [Hash] Raw JSON data
+      # @return [Monograph] Model instance
+      def parse_data(data)
+        return nil unless data["id"] && data["data"]
+
+        id = data["id"]
+        title = data["title"] || data["data"]["t"]
+        body_html = data["data"]["b"]
+
+        # Extract sections from HTML
+        sections = parse_html_body(body_html)
+
+        # Determine monograph type and create appropriate model
+        create_monograph_model(id, title, sections)
+      end
+
+      # Parse HTML body content to extract sections
+      #
+      # @param html [String] HTML content
+      # @return [Hash] Extracted sections
+      def parse_html_body(html)
+        return {} if html.nil? || html.empty?
+
+        doc = Nokogiri::HTML.fragment(html)
+        {
+          molecular_formula: extract_molecular_formula(doc),
+          molecular_weight: extract_molecular_weight(doc),
+          cas_number: extract_cas_number(doc),
+          chemical_name: extract_chemical_name(doc),
+          description: extract_section_content(doc, "Description"),
+          solubility: extract_section_content(doc, "Solubility"),
+          storage: extract_section_content(doc, "Storage"),
+          definition: extract_section_content(doc, "Definition"),
+          identity_tests: extract_section_content(doc, "Identity tests"),
+          related_substances: extract_section_content(doc, "Related substances"),
+          assay: extract_section_content(doc, "Assay"),
+          impurities: extract_impurities(doc)
+        }
+      end
+
+      # Create the appropriate model instance based on type
+      def create_monograph_model(id, title, sections)
+        slug = generate_slug(title)
+        en_name, la_name = parse_title(title)
+
+        base_attrs = {
+          id: "https://www.openphar.org/data/phint/monographs/#{slug}",
+          monograph_id: "PhInt13-#{id}",
+          pref_label: { "en" => en_name, "la" => la_name }.compact,
+          publisher: "WHO",
+          status: "Official",
+          belongs_to_edition: "https://www.openphar.org/data/edition/phint/phint13"
+        }
+
+        case determine_monograph_type(id, sections)
+        when "RadiopharmaceuticalMonograph"
+          create_radiopharmaceutical_model(base_attrs, sections)
+        when "DosageFormMonograph"
+          create_dosage_form_model(base_attrs, sections)
+        when "TestMethod"
+          create_test_method_model(base_attrs, title, sections)
+        when "Reagent"
+          create_reagent_model(base_attrs, title, sections)
+        else
+          create_chemical_drug_model(base_attrs, sections)
+        end
+      end
+
+      # Create ChemicalDrugMonograph model instance
+      def create_chemical_drug_model(attrs, sections)
+        # Build attributes hash, only including non-nil values
+        model_attrs = attrs.dup
+
+        # Only add molecular_weight if it's a valid number
+        if sections[:molecular_weight] && sections[:molecular_weight] > 0
+          model_attrs[:molecular_weight] = sections[:molecular_weight]
+        end
+
+        model_attrs[:molecular_formula] = sections[:molecular_formula] if sections[:molecular_formula]
+        model_attrs[:cas_number] = sections[:cas_number] if sections[:cas_number]
+        model_attrs[:systematic_name] = { "en" => sections[:chemical_name] } if sections[:chemical_name]
+        model_attrs[:definition] = { "en" => sections[:definition] } if sections[:definition]
+        model_attrs[:test_specifications] = build_test_specifications(sections)
+
+        ChemicalDrugMonograph.new(**model_attrs)
+      end
+
+      # Create RadiopharmaceuticalMonograph model instance
+      def create_radiopharmaceutical_model(attrs, sections)
+        model_attrs = attrs.dup
+
+        # Only add molecular_weight if it's a valid number
+        if sections[:molecular_weight] && sections[:molecular_weight] > 0
+          model_attrs[:molecular_weight] = sections[:molecular_weight]
+        end
+
+        model_attrs[:molecular_formula] = sections[:molecular_formula] if sections[:molecular_formula]
+        model_attrs[:cas_number] = sections[:cas_number] if sections[:cas_number]
+
+        PhIntRadiopharmaceuticalMonograph.new(**model_attrs)
+      end
+
+      # Create DosageFormMonograph model instance
+      def create_dosage_form_model(attrs, _sections)
+        PhIntDosageFormMonograph.new(**attrs)
+      end
+
+      # Create TestMethod model instance
+      def create_test_method_model(attrs, title, _sections)
+        PhIntTestMethod.new(
+          **attrs,
+          method_id: attrs[:monograph_id],
+          pref_label: { "en" => title }
+        )
+      end
+
+      # Create Reagent model instance
+      def create_reagent_model(attrs, title, _sections)
+        PhIntReagent.new(
+          **attrs,
+          reagent_id: attrs[:monograph_id],
+          pref_label: { "en" => title }
+        )
+      end
+
+      # Extract molecular formula from HTML
+      def extract_molecular_formula(doc)
+        formula_elem = doc.at_xpath(".//p[contains(., 'Relative molecular mass')]")
+        return nil unless formula_elem
+
+        prev_elem = formula_elem.previous_element
+        return nil unless prev_elem
+
+        text = prev_elem.text.gsub(/<sub>/i, "").gsub(/<\/sub>/i, "").strip
+        text if text.match?(/\([A-Z][a-z]?\d*\)/)
+      end
+
+      # Extract molecular weight from HTML
+      def extract_molecular_weight(doc)
+        weight_elem = doc.at_xpath(".//p[contains(., 'Relative molecular mass')]")
+        return nil unless weight_elem
+
+        match = weight_elem.text.match(/(\d+\.?\d*)/)
+        match[1].to_f if match
+      end
+
+      # Extract CAS number from HTML
+      def extract_cas_number(doc)
+        cas_elem = doc.at_xpath(".//p[contains(., 'CAS Reg. No')]")
+        return nil unless cas_elem
+
+        match = cas_elem.text.match(/CAS Reg\. No\.\s*(\d+-\d+-\d+)/i)
+        match[1] if match
+      end
+
+      # Extract chemical name from HTML
+      def extract_chemical_name(doc)
+        name_elem = doc.at_xpath(".//p[contains(., 'Chemical name')]")
+        return nil unless name_elem
+
+        text = name_elem.text.sub(/Chemical name\.\s*/i, "").strip
+        text if text.length > 10
+      end
+
+      # Extract content for a specific section
+      def extract_section_content(doc, section_name)
+        header = doc.at_xpath(".//p[contains(., '#{section_name}')]")
+        return nil unless header
+
+        text = header.text.sub(/.*#{section_name}\.?\s*/i, "").strip
+        text unless text.empty?
+      end
+
+      # Extract impurities list
+      def extract_impurities(doc)
+        impurities = []
+
+        doc.xpath(".//p[contains(., 'Impurities')]/following-sibling::p").each do |p|
+          text = p.text.strip
+          next if text.empty?
+
+          if text.match?(/^[A-Z]\.\s/)
+            impurities << {
+              letter: text[0],
+              description: text[3..].strip
+            }
+          end
+        end
+
+        impurities
+      end
+
+      # Determine monograph type from ID and sections
+      def determine_monograph_type(id, _sections)
+        case id
+        when /^6\.1\./ then "ChemicalDrugMonograph"
+        when /^6\.2\./ then "DosageFormMonograph"
+        when /^6\.3\./ then "RadiopharmaceuticalMonograph"
+        when /^6\.4\./ then "CrudeDrugMonograph"
+        when /^7\./ then "TestMethod"
+        when /^9\./ then "Reagent"
+        else "ChemicalDrugMonograph"
+        end
+      end
+
+      # Parse title into English and Latin names
+      def parse_title(title)
+        return [title, nil] unless title
+
+        match = title.match(/^(.+?)\s*\(([^)]+)\)/)
+        if match
+          [match[1].strip, match[2].strip]
+        else
+          [title, nil]
+        end
+      end
+
+      # Generate URL-safe slug from title using SlugGenerator
+      def generate_slug(title)
+        Openphar::Core::SlugGenerator.generate_from_title(title)
+      end
+
+      # Build TestSpecification model instances
+      def build_test_specifications(sections)
+        specs = []
+
+        if sections[:identity_tests]
+          specs << IdentificationSpecification.new(
+            test_name: { "en" => "Identity tests" },
+            test_type: "TestType-Identification",
+            test_conditions: { "en" => sections[:identity_tests] }
+          )
+        end
+
+        if sections[:related_substances]
+          specs << PuritySpecification.new(
+            test_name: { "en" => "Related substances" },
+            test_type: "TestType-Purity",
+            test_conditions: { "en" => sections[:related_substances] }
+          )
+        end
+
+        if sections[:assay]
+          specs << AssaySpecification.new(
+            test_name: { "en" => "Assay" },
+            test_type: "TestType-Assay",
+            test_conditions: { "en" => sections[:assay] }
+          )
+        end
+
+        specs
+      end
+    end
+  end
+end

data/lib/openphar/parsers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Parsers
+    # Parsers for various pharmacopoeia data formats.
+    #
+    # All parsers inherit from BaseMonographParser and return
+    # Lutaml::Model instances (not hashes).
+
+    # Abstract base class
+    autoload :BaseMonographParser, 'openphar/parsers/base_monograph_parser'
+
+    # Japan Pharmacopoeia parsers
+    autoload :JpHtmlParserBase, 'openphar/parsers/jp_html_parser_base'
+    autoload :JpHtmlParser, 'openphar/parsers/jp_html_parser'
+    autoload :JpJaHtmlParser, 'openphar/parsers/jp_ja_html_parser'
+
+    # International Pharmacopoeia parser
+    autoload :PhIntJsonParser, 'openphar/parsers/phint_json_parser'
+  end
+end

data/lib/openphar/registry/publisher_registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Registry
+    # Registry for pharmacopoeia publishers.
+    class PublisherRegistry
+      class << self
+        def get(code)
+          return nil if code.nil? || code.empty?
+          registry[code.to_s.upcase]
+        end
+
+        def register(code, info)
+          registry[code.to_s.upcase] = info
+        end
+
+        def registered?(code)
+          !get(code).nil?
+        end
+
+        def all_codes
+          registry.keys
+        end
+
+        def namespace_for(code)
+          info = get(code)
+          return nil unless info
+          info[:namespace_module]
+        end
+
+        def clear
+          @registry = nil
+        end
+
+        private
+
+        def registry
+          @registry ||= {
+            'JP' => { namespace_module: Models::JP },
+            'PHINT' => { namespace_module: Models::PhInt }
+          }
+        end
+      end
+    end
+  end
+end