openphar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f9405e27ae7acba11ede41978b5fcc3d698d278f28fe30a0b5b1c46e4ad24d2
+  data.tar.gz: cb691edefe8f0637738fbcee5d31cdd0e8a87ece844cfed873ad15ae1c9db6c3
+SHA512:
+  metadata.gz: 24acfa86829a8c1007c4947ae515d2ac72946b76ad24a54dfdf8b7870b0f2e8c066c76f9359df268360563a26e7533d137b63dbaa8636c0c3a3225b4f4a7f214
+  data.tar.gz: 6726eda92596a64cfd3b4d2dfd21c6f9b59a9960ccef32daac68fc73ce9812a038ac749c851cc4a0a6cb6ec9d052f4c30a11353c7083a66077f2ccacee0e08c5

data/README.adoc

@@ -0,0 +1,221 @@
+= Open Pharmacopoeia
+:toc: macro
+:toclevels: 3
+:sectanchors:
+:sectlinks:
+
+image:https://img.shields.io/badge/ontology-OWL%202-blue[OWL 2 Ontology]
+image:https://img.shields.io/badge/format-JSON--LD-green[JSON-LD Format]
+image:https://img.shields.io/badge/status-development-orange[Development Status]
+
+== Purpose
+
+Open Pharmacopoeia provides a harmonized ontology for representing pharmacopoeia monographs from multiple publishers. The project enables cross-publisher comparison of quality standards by normalizing test methods and specifications.
+
+This project integrates with link:data-herbapedia[https://github.com/lutaml/data-herbapedia] for botanical and medicine system data, while open-pharmacopoeia focuses on quality standards and test specifications.
+
+== Architecture
+
+.Open-Pharmacopoeia Architecture Layers
+[source]
+----
+data-herbapedia:  Plant → Part → Preparation → Medicine System Profiles
+                                              ↓
+open-pharmacopoeia:                      PharmacopoeiaMonograph
+                                              ├── TestSpecification
+                                              ├── Assay
+                                              └── SafetyInformation
+----
+
+=== Integration with data-herbapedia
+
+[cols="1,2"]
+|===
+| Layer | Responsibility
+
+| data-herbapedia | Botanical data (PlantSpecies, PlantPart), HerbalPreparation, Medicine System Profiles (TCM, Ayurveda, Western)
+| open-pharmacopoeia | Quality standards (TestSpecification, Assay), Test methods (HarmonizedMethod), Publisher-specific data
+|===
+
+The key integration point is `op:referencesPreparation`, which links a PharmacopoeiaMonograph to a HerbalPreparation in data-herbapedia.
+
+== Features
+
+* **Harmonized Ontology** - Common vocabulary for representing pharmacopoeia monographs from any publisher
+* **Cross-Publisher Comparison** - Harmonized test methods enable comparison across publishers
+* **Crude Drug Support** - Extended model for herbal medicines with macroscopic/microscopic descriptions
+* **data-herbapedia Integration** - Links to botanical and medicine system data
+* **Multilingual Support** - Full internationalization with language-tagged strings
+* **SHACL Validation** - Shapes for validating monograph data
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'open-pharmacopoeia', git: 'https://github.com/lutaml/open-pharmacopoeia'
+----
+
+And then execute:
+
+[source,shell]
+----
+bundle install
+----
+
+== Usage
+
+=== Loading a Monograph
+
+[source,ruby]
+----
+require 'open_pharmacopoeia'
+
+# Load from JSON-LD
+monograph = OpenPharmacopoeia::CrudeDrugMonograph.from_json(File.read('data/jp/radix-ginseng.jsonld'))
+
+# Access monograph properties
+monograph.label("en")  #=> "Ginseng Radix"
+monograph.publisher.name  #=> "Japan Pharmacopoeia"
+monograph.assays.each do |assay|
+  puts "#{assay.assay_target}: #{assay.limit}"
+end
+----
+
+=== Creating a New Monograph
+
+[source,ruby]
+----
+require 'open_pharmacopoeia'
+
+monograph = OpenPharmacopoeia::CrudeDrugMonograph.new(
+  monograph_id: "JP18-001",
+  publisher: OpenPharmacopoeia::Publisher.find("JP"),
+  pref_label: { "en" => "Ginseng Radix", "ja" => "人参" },
+  references_preparation: "https://www.herbapedia.org/entity/preparation/dried-ginseng-root"
+)
+
+# Add test specification
+monograph.test_specifications << OpenPharmacopoeia::PhysicalSpecification.new(
+  test_name: "Total Ash",
+  test_type: OpenPharmacopoeia::TestType.find("Physical"),
+  harmonized_method: OpenPharmacopoeia::HarmonizedMethod.find("TotalAsh"),
+  limit: OpenPharmacopoeia::Limit.new(
+    limit_type: OpenPharmacopoeia::LimitType.find("NotMoreThan"),
+    limit_value: 4.2,
+    limit_unit: OpenPharmacopoeia::Unit.find("percent")
+  )
+)
+----
+
+== Ontology Structure
+
+=== Core Classes
+
+[cols="1,3"]
+|===
+| Class | Description
+
+| `op:PharmacopoeiaMonograph` | Central class representing a pharmacopoeia monograph
+| `op:CrudeDrugMonograph` | Extended monograph for herbal medicines
+| `op:TestSpecification` | Generic test specification (value object)
+| `op:AssaySpecification` | Quantitative analysis specification
+| `op:PuritySpecification` | Impurity limit specification
+| `op:HarmonizedMethod` | Harmonized test method for cross-publisher comparison
+| `op:Publisher` | Pharmacopoeia publisher enumeration
+|===
+
+=== External References
+
+Monographs reference external entities in data-herbapedia:
+
+[source,turtle]
+----
+op:Ginseng-Monograph
+    op:referencesPreparation <https://www.herbapedia.org/entity/preparation/dried-ginseng-root> ;
+    op:referencesTCMProfile <https://www.herbapedia.org/system/tcm/profile/ren-shen> .
+----
+
+=== Test Method Harmonization
+
+[source,turtle]
+----
+# Harmonized method with publisher equivalents
+method:HPLC a op:HarmonizedMethod ;
+    rdfs:label "HPLC"@en ;
+    op:jpReference "as directed under Liquid Chromatography <2.01>" ;
+    op:equivalentMethod api:Appendix-2.2.29 ;
+    op:equivalentMethod hkcmms:Appendix-IV-B .
+----
+
+== File Structure
+
+[source]
+----
+open-pharmacopoeia/
+├── ontology/
+│   ├── core/
+│   │   ├── pharmacopoeia.ttl     # Core classes and properties
+│   │   └── unit.ttl              # Measurement units
+│   ├── quality/
+│   │   └── test-method.ttl       # Harmonized test methods
+│   └── context/
+│       └── pharmacopoeia.jsonld  # JSON-LD context
+├── data/
+│   ├── jp/                       # Japan Pharmacopoeia monographs
+│   ├── hkcmms/                   # Hong Kong CMMS monographs
+│   └── api/                      # Ayurvedic Pharmacopoeia of India
+├── shapes/
+│   └── monograph-shapes.ttl      # SHACL validation shapes
+├── tools/
+│   └── lib/
+│       └── open_pharmacopoeia/   # Ruby models
+└── reference-docs/               # Reference pharmacopoeia documents
+----
+
+== Supported Publishers
+
+[cols="1,2,1"]
+|===
+| Code | Name | Country
+
+| AHP | American Herbal Pharmacopoeia | US
+| API | Ayurvedic Pharmacopoeia of India | IN
+| JP | Japan Pharmacopoeia | JP
+| HKCMMS | Hong Kong Chinese Materia Medica Standards | HK
+| THP | Thai Herbal Pharmacopoeia | TH
+| CMHerbarium | CM Herbarium | CN
+| WHO | WHO Monographs on Selected Medicinal Plants | INT
+| UPB | Unani Pharmacopoeia of Bangladesh | BD
+| UPI | Unani Pharmacopoeia of India | IN
+| APB | Ayurvedic Pharmacopoeia of Bangladesh | BD
+| APS | Ayurvedic Pharmacopoeia of Sri Lanka | LK
+|===
+
+== IRI Namespaces
+
+[cols="1,2"]
+|===
+| Prefix | Namespace
+
+| `op:` | `https://www.openphar.org/ontology/core/`
+| `method:` | `https://www.openphar.org/ontology/method/`
+| `unit:` | `https://www.openphar.org/ontology/core/unit/`
+| `herbapedia:` | `https://www.herbapedia.org/entity/`
+|===
+
+== Development
+
+After checking out the repo, run:
+
+[source,shell]
+----
+bundle install
+bundle exec rake spec    # Run tests
+bundle exec rubocop      # Run linter
+----
+
+== License
+
+This project is available as open source under the terms of the MIT License.

data/lib/openphar/cli/main.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Cli
+    # Main CLI for the openphar gem
+    class Main < Thor
+      package_name "openphar"
+
+      desc "version", "Show the openphar version"
+      def version
+        puts "openphar #{Openphar::VERSION}"
+      end
+
+      desc "validate FILE", "Validate a JSON-LD monograph file"
+      option :format, aliases: "-f", default: "jsonld", desc: "Input format (jsonld, ttl)"
+      def validate(file)
+        puts "Validating #{file}..."
+        # TODO: Implement SHACL validation
+        puts "Validation complete"
+      end
+
+      desc "transform INPUT OUTPUT", "Transform monograph data to JSON-LD"
+      option :publisher, aliases: "-p", required: true, desc: "Publisher code (JP, PhInt, API, etc.)"
+      option :edition, aliases: "-e", desc: "Edition identifier (jp18, phint13, etc.)"
+      option :link, type: :boolean, default: false, desc: "Link to data-herbapedia"
+      def transform(input, output)
+        puts "Transforming #{input} to #{output}..."
+        puts "Publisher: #{options[:publisher]}"
+        puts "Edition: #{options[:edition]}" if options[:edition]
+
+        # Read input
+        content = File.read(input)
+
+        # Parse based on publisher
+        parser = parser_for(options[:publisher], content)
+        monographs = parser.parse
+
+        puts "Found #{monographs.length} monographs"
+
+        # Transform to JSON-LD
+        transformer = Transformers::JsonldTransformer.new
+        result = transformer.transform_graph(
+          monographs,
+          publisher: options[:publisher],
+          edition: options[:edition]
+        )
+
+        # Write output
+        File.write(output, JSON.pretty_generate(result))
+        puts "Output written to #{output}"
+      end
+
+      desc "link FILE", "Link monographs to data-herbapedia entities"
+      option :herbapedia, aliases: "-H", desc: "Path to data-herbapedia directory"
+      def link(file)
+        puts "Linking #{file} to data-herbapedia..."
+
+        linker = Linkers::HerbapediaLinker.new(
+          herbapedia_data_path: options[:herbapedia]
+        )
+
+        # Read and parse JSON-LD
+        data = JSON.parse(File.read(file))
+
+        # Link each monograph
+        if data["@graph"]
+          data["@graph"].map! do |monograph|
+            linker.link_monograph(monograph)
+          end
+        else
+          data = linker.link_monograph(data)
+        end
+
+        # Write updated file
+        File.write(file, JSON.pretty_generate(data))
+        puts "Links added to #{file}"
+      end
+
+      desc "publishers", "List all supported pharmacopoeia publishers"
+      def publishers
+        puts "Supported Publishers:"
+        puts "-" * 60
+        Publisher.all.each do |publisher|
+          puts format("%-10s %s (%s)",
+                      publisher.code,
+                      publisher.name["en"],
+                      publisher.country)
+        end
+      end
+
+      desc "editions", "List available pharmacopoeia editions"
+      def editions
+        edition_dir = File.join(Openphar.data_path, "edition")
+        return puts "No editions found" unless File.directory?(edition_dir)
+
+        puts "Available Editions:"
+        puts "-" * 60
+
+        Dir.glob("#{edition_dir}/*/*.jsonld").each do |file|
+          data = JSON.parse(File.read(file))
+          next unless data["@graph"]
+
+          data["@graph"].each do |item|
+            next unless item["@type"] == "Edition"
+
+            label = item["prefLabel"]&.values&.first || item["editionNumber"]
+            count = item["monographCount"] || "unknown"
+            puts format("%-20s %s monographs", label, count)
+          end
+        end
+      end
+
+      desc "compare MONOGRAPH_ID", "Compare a monograph across publishers"
+      option :format, aliases: "-f", default: "table", desc: "Output format (table, json)"
+      def compare(monograph_id)
+        puts "Comparing #{monograph_id} across publishers..."
+        puts "Not implemented yet"
+      end
+
+      private
+
+      def parser_for(publisher, content)
+        case publisher.upcase
+        when "JP"
+          Parsers::JpHtmlParser.new(content)
+        else
+          raise Error, "Unknown publisher: #{publisher}"
+        end
+      end
+    end
+  end
+end
+
+# Register as a binary
+if __FILE__ == $PROGRAM_NAME
+  Openphar::Cli::Main.start(ARGV)
+end

data/lib/openphar/cli.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Cli
+    # Command-line interface for Openphar.
+    #
+    # Provides CLI commands for parsing, exporting, and validating data.
+
+    autoload :Main, 'openphar/cli/main'
+  end
+end

data/lib/openphar/core/slug_generator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Core
+    # Unified slug generator for consistent URL-safe identifier generation.
+    #
+    # Consolidates multiple slug generation implementations into a single class.
+    # All slugs are lowercase, hyphen-separated, and contain only alphanumeric
+    # characters and hyphens.
+    #
+    # @example Basic usage
+    #   SlugGenerator.generate("Zingiberis Rhizoma")
+    #   # => "zingiberis-rhizoma"
+    #
+    # @example With fallback
+    #   SlugGenerator.generate(nil)
+    #   # => "unknown"
+    #
+    # @example Latin name handling
+    #   SlugGenerator.generate_latin("Acacia (Gum Arabic)")
+    #   # => "acacia-gum-arabic"
+    class SlugGenerator
+      # Default slug for nil/empty inputs
+      DEFAULT_SLUG = 'unknown'
+
+      class << self
+        # Generate a URL-safe slug from any name.
+        #
+        # @param name [String, nil] The name to convert to a slug
+        # @return [String] A URL-safe slug
+        def generate(name)
+          return DEFAULT_SLUG unless name
+
+          result = name.to_s.downcase
+                       .gsub(/[^a-z0-9\s-]/, '')
+                       .strip
+                       .gsub(/\s+/, '-')
+                       .gsub(/-+/, '-')
+                       .sub(/^-/, '')
+                       .sub(/-$/, '')
+
+          result.empty? ? DEFAULT_SLUG : result
+        end
+
+        # Generate a slug optimized for Latin pharmaceutical names.
+        #
+        # Latin names often have specific formatting like:
+        # - "Zingiberis Rhizoma" (binomial form)
+        # - "Acacia (Gum Arabic)" (with common name)
+        #
+        # @param latin_name [String, nil] The Latin name to convert
+        # @return [String] A URL-safe slug
+        def generate_latin(latin_name)
+          return DEFAULT_SLUG unless latin_name
+
+          # Remove content in parentheses (common names)
+          cleaned = latin_name.to_s.gsub(/\s*\([^)]*\)\s*/, ' ').strip
+
+          result = cleaned.downcase
+                          .gsub(/[^a-z0-9\s-]/, '')
+                          .strip
+                          .gsub(/\s+/, '-')
+                          .gsub(/-+/, '-')
+                          .sub(/^-/, '')
+                          .sub(/-$/, '')
+
+          result.empty? ? DEFAULT_SLUG : result
+        end
+
+        # Generate a slug from a title with potential English and Latin parts.
+        #
+        # Titles often come in formats like:
+        # - "Abacavir sulfate (Abacaviri sulfas)"
+        # - "Ginger Rhizome"
+        #
+        # @param title [String, nil] The title to convert
+        # @return [String] A URL-safe slug
+        def generate_from_title(title)
+          return DEFAULT_SLUG unless title
+
+          # Extract English name (before parentheses if present)
+          english_part = title.to_s.split(/\s*\(/).first.strip
+
+          generate(english_part)
+        end
+
+        # Generate a unique slug, appending a number if necessary.
+        #
+        # @param name [String, nil] The base name
+        # @param existing_slugs [Set<String>, Array<String>] Slugs that already exist
+        # @return [String] A unique slug
+        def generate_unique(name, existing_slugs)
+          base_slug = generate(name)
+          return base_slug unless existing_slugs.include?(base_slug)
+
+          counter = 1
+          loop do
+            candidate = "#{base_slug}-#{counter}"
+            return candidate unless existing_slugs.include?(candidate)
+
+            counter += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openphar/core.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Core
+    # Core utilities for Openphar
+    #
+    # Contains shared utility classes used throughout the library.
+
+    autoload :SlugGenerator, 'openphar/core/slug_generator'
+  end
+end

data/lib/openphar/errors/configuration_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when configuration is invalid.
+    class ConfigurationError < Openphar::Error; end
+  end
+end

data/lib/openphar/errors/monograph_not_found_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when a monograph cannot be found.
+    class MonographNotFoundError < Openphar::Error
+      attr_reader :monograph_id
+
+      def initialize(monograph_id)
+        @monograph_id = monograph_id
+        super("Monograph not found: #{monograph_id}")
+      end
+    end
+  end
+end

data/lib/openphar/errors/parse_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when parsing fails.
+    class ParseError < Openphar::Error
+      attr_reader :source, :details
+
+      def initialize(source, details = nil)
+        @source = source
+        @details = details
+        message = "Failed to parse: #{source}"
+        message += " - #{details}" if details
+        super(message)
+      end
+    end
+  end
+end

data/lib/openphar/errors/unknown_format_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when an unknown export format is specified.
+    class UnknownFormatError < Openphar::Error; end
+  end
+end

data/lib/openphar/errors/unknown_publisher_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when an unknown publisher is referenced.
+    class UnknownPublisherError < Openphar::Error; end
+  end
+end

data/lib/openphar/errors/unknown_type_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when an unknown monograph type is referenced.
+    class UnknownTypeError < Openphar::Error; end
+  end
+end

data/lib/openphar/errors/validation_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Raised when validation fails.
+    class ValidationError < Openphar::Error
+      attr_reader :errors
+
+      def initialize(errors = [])
+        @errors = errors
+        super("Validation failed: #{errors.join(', ')}")
+      end
+    end
+  end
+end

data/lib/openphar/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Errors
+    # Error classes for Openphar.
+    #
+    # Provides specific exception types for different error conditions.
+
+    autoload :UnknownPublisherError, 'openphar/errors/unknown_publisher_error'
+    autoload :UnknownTypeError, 'openphar/errors/unknown_type_error'
+    autoload :UnknownFormatError, 'openphar/errors/unknown_format_error'
+    autoload :MonographNotFoundError, 'openphar/errors/monograph_not_found_error'
+    autoload :ParseError, 'openphar/errors/parse_error'
+    autoload :ValidationError, 'openphar/errors/validation_error'
+    autoload :ConfigurationError, 'openphar/errors/configuration_error'
+  end
+end