openphar 0.1.0

data/lib/openphar/registry/type_registry.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Registry
+    # Central registry for mapping JSON-LD @type to Ruby model classes.
+    #
+    # This registry provides a single source of truth for type mappings,
+    # decoupling type resolution from specific exporters (like Neo4j).
+    #
+    # ## Built-in Types
+    #
+    # The registry comes pre-populated with all core and publisher-specific
+    # model types. Publishers can register additional types at runtime.
+    #
+    # @example Looking up a model class
+    #   klass = TypeRegistry.for('CrudeDrugMonograph')
+    #   # => Openphar::Models::CrudeDrugMonograph
+    #
+    # @example Registering a custom type
+    #   TypeRegistry.register('CustomType', MyCustomModel)
+    #
+    # @example Checking if a type is registered
+    #   TypeRegistry.registered?('CrudeDrugMonograph') # => true
+    #
+    class TypeRegistry
+      class << self
+        # Returns the model class for a given JSON-LD @type.
+        #
+        # @param type [String] The JSON-LD @type value
+        # @return [Class, nil] The model class or nil if not found
+        def for(type)
+          return nil if type.nil? || type.empty?
+
+          entry = registry[type]
+          entry.is_a?(Proc) ? entry.call : entry
+        end
+
+        # Registers a new type-to-class mapping.
+        #
+        # @param type [String] The JSON-LD @type value
+        # @param model_class [Class, Proc] The model class or a lambda
+        # @return [void]
+        def register(type, model_class)
+          registry[type] = model_class
+        end
+
+        # Unregisters a type mapping.
+        #
+        # @param type [String] The JSON-LD @type value
+        # @return [void]
+        def unregister(type)
+          registry.delete(type)
+        end
+
+        # Checks if a type is registered.
+        #
+        # @param type [String] The JSON-LD @type value
+        # @return [Boolean] True if registered
+        def registered?(type)
+          registry.key?(type)
+        end
+
+        # Returns all registered type names.
+        #
+        # @return [Array<String>] List of registered types
+        def all_types
+          registry.keys
+        end
+
+        # Returns all registered model classes.
+        #
+        # @return [Array<Class>] List of model classes
+        def all_classes
+          registry.values.map { |v| v.is_a?(Proc) ? v.call : v }
+        end
+
+        # Clears all registered types (useful for testing).
+        #
+        # @return [void]
+        def clear
+          @registry = nil
+        end
+
+        # Resets to default registrations.
+        #
+        # @return [void]
+        def reset
+          clear
+        end
+
+        private
+
+        # Returns the registry hash, initializing with defaults if needed.
+        #
+        # @return [Hash] The type-to-class registry
+        def registry
+          @registry ||= build_default_registry
+        end
+
+        # Builds the default registry with all built-in types.
+        #
+        # @return [Hash] The default registry
+        def build_default_registry
+          {
+            # Core monograph types
+            'Monograph' => lambda { Models::Monograph },
+            'CrudeDrugMonograph' => lambda { Models::CrudeDrugMonograph },
+            'ChemicalDrugMonograph' => lambda { Models::ChemicalDrugMonograph },
+            'FormulationMonograph' => lambda { Models::FormulationMonograph },
+            'VitaminMonograph' => lambda { Models::VitaminMonograph },
+            'AminoAcidMonograph' => lambda { Models::AminoAcidMonograph },
+            'MineralSubstanceMonograph' => lambda { Models::MineralSubstanceMonograph },
+            'BiologicalSubstanceMonograph' => lambda { Models::BiologicalSubstanceMonograph },
+
+            # Test specification types
+            'TestSpecification' => lambda { Models::TestSpecification },
+            'AssaySpecification' => lambda { Models::AssaySpecification },
+            'PuritySpecification' => lambda { Models::PuritySpecification },
+            'PhysicalSpecification' => lambda { Models::PhysicalSpecification },
+            'IdentificationSpecification' => lambda { Models::IdentificationSpecification },
+
+            # Bibliographic types
+            'Edition' => lambda { Models::Edition },
+            'Supplement' => lambda { Models::Supplement },
+            'Publisher' => lambda { Models::Publisher },
+
+            # Quantitative types
+            'Limit' => lambda { Models::Limit },
+
+            # JP-specific types
+            'KampoFormula' => lambda { Models::JP::KampoFormula },
+
+            # Ph.Int.-specific types
+            'RadiopharmaceuticalMonograph' => lambda { Models::PhInt::RadiopharmaceuticalMonograph },
+            'DosageFormMonograph' => lambda { Models::PhInt::DosageFormMonograph },
+            'TestMethod' => lambda { Models::PhInt::TestMethod },
+            'Reagent' => lambda { Models::PhInt::Reagent },
+            'TestSolution' => lambda { Models::PhInt::TestSolution },
+            'VolumetricSolution' => lambda { Models::PhInt::VolumetricSolution },
+            'BufferSolution' => lambda { Models::PhInt::BufferSolution },
+            'ReferenceSubstance' => lambda { Models::PhInt::ReferenceSubstance }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/openphar/registry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Openphar
+  # Registry layer for model type resolution.
+  #
+  # Provides a central registry for mapping JSON-LD @type values
+  # to Ruby model classes. This decouples type resolution from
+  # specific exporters (like Neo4j) and provides a single source
+  # of truth for type mappings.
+  #
+  # @example Registering a custom model type
+  #   Openphar::Registry::TypeRegistry.register(
+  #     'CustomMonograph',
+  #     Openphar::Models::CustomMonograph
+  #   )
+  #
+  # @example Looking up a model class by type
+  #   klass = Openphar::Registry::TypeRegistry.for('CrudeDrugMonograph')
+  #   # => Openphar::Models::CrudeDrugMonograph
+  module Registry
+    autoload :TypeRegistry, 'openphar/registry/type_registry'
+    autoload :PublisherRegistry, 'openphar/registry/publisher_registry'
+  end
+end

data/lib/openphar/repositories/monograph_repository.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'singleton'
+
+module Openphar
+  module Repositories
+    # Central repository for monograph data access.
+    #
+    # Provides:
+    # - Caching of loaded monographs
+    # - Multiple indexes for fast lookups
+    # - Query interface for common operations
+    #
+    # This replaces scattered Dir.glob and JSON.parse calls throughout
+    # the codebase with a single, consistent data access layer.
+    #
+    # @example Loading and querying monographs
+    #   repo = MonographRepository.instance
+    #   repo.load_directory("./data/jp/crude-drugs")
+    #
+    #   # Find by ID
+    #   monograph = repo.find("https://www.openphar.org/data/jp/crude-drugs/ginger")
+    #
+    #   # Find by CAS number
+    #   monograph = repo.find_by_cas("50-00-0")
+    #
+    #   # Get all monographs for a publisher
+    #   jp_monographs = repo.all_for_publisher("JP")
+    class MonographRepository
+      include Singleton
+
+      # @return [Hash<String, Lutaml::Model::Serializable>] Cache of id => monograph
+      attr_reader :cache
+
+      # @return [Hash] Indexes for fast lookups
+      attr_reader :indexes
+
+      def initialize
+        clear
+      end
+
+      # Clear all cached data and indexes.
+      #
+      # @return [void]
+      def clear
+        @cache = {}
+        @indexes = {
+          cas_number: {},
+          latin_name: {},
+          japanese_name: {},
+          publisher: {},
+          edition: {},
+          slug: {}
+        }
+      end
+
+      # Load all monographs from a directory.
+      #
+      # @param path [String] Directory containing JSON-LD files
+      # @param publisher [String, nil] Optional publisher code to filter by
+      # @return [Integer] Number of monographs loaded
+      def load_directory(path, publisher: nil)
+        files = Dir.glob(File.join(path, '**/*.jsonld'))
+        count = 0
+
+        files.sort.each do |file|
+          count += 1 if load_file(file, publisher: publisher)
+        end
+
+        count
+      end
+
+      # Load a single monograph file.
+      #
+      # @param path [String] Path to the JSON-LD file
+      # @param publisher [String, nil] Optional publisher code
+      # @return [Lutaml::Model::Serializable, nil] The loaded monograph or nil on failure
+      def load_file(path, publisher: nil)
+        data = JSON.parse(File.read(path, encoding: 'UTF-8'))
+        monograph = deserialize(data)
+        register(monograph) if monograph
+      rescue JSON::ParserError => e
+        warn "Warning: Could not parse #{path}: #{e.message}"
+        nil
+      rescue StandardError => e
+        warn "Warning: Error loading #{path}: #{e.message}"
+        nil
+      end
+
+      # Register a monograph in the cache and indexes.
+      #
+      # @param monograph [Lutaml::Model::Serializable] The monograph to register
+      # @return [Lutaml::Model::Serializable] The registered monograph
+      def register(monograph)
+        @cache[monograph.id] = monograph
+        index_monograph(monograph)
+        monograph
+      end
+
+      # Find a monograph by its ID.
+      #
+      # @param id [String] The monograph's @id
+      # @return [Lutaml::Model::Serializable, nil] The monograph or nil if not found
+      def find(id)
+        @cache[id]
+      end
+
+      # Find a monograph by CAS Registry Number.
+      #
+      # @param cas_number [String] The CAS number
+      # @return [Lutaml::Model::Serializable, nil] The monograph or nil if not found
+      def find_by_cas(cas_number)
+        return nil unless cas_number
+
+        @indexes[:cas_number][normalize_cas(cas_number)]
+      end
+
+      # Find a monograph by Latin pharmaceutical name.
+      #
+      # @param name [String] The Latin name
+      # @return [Lutaml::Model::Serializable, nil] The monograph or nil if not found
+      def find_by_latin_name(name)
+        return nil unless name
+
+        @indexes[:latin_name][normalize_name(name)]
+      end
+
+      # Find a monograph by Japanese name.
+      #
+      # @param name [String] The Japanese name
+      # @return [Lutaml::Model::Serializable, nil] The monograph or nil if not found
+      def find_by_japanese_name(name)
+        return nil unless name
+
+        @indexes[:japanese_name][name.to_s.strip]
+      end
+
+      # Find a monograph by URL slug.
+      #
+      # @param slug [String] The URL slug
+      # @return [Lutaml::Model::Serializable, nil] The monograph or nil if not found
+      def find_by_slug(slug)
+        return nil unless slug
+
+        @indexes[:slug][slug.to_s.downcase.strip]
+      end
+
+      # Get all monographs for a specific publisher.
+      #
+      # @param code [String] The publisher code (e.g., "JP", "WHO")
+      # @return [Array<Lutaml::Model::Serializable>] Array of monographs
+      def all_for_publisher(code)
+        @indexes[:publisher][code.to_s.upcase] || []
+      end
+
+      # Get all monographs for a specific edition.
+      #
+      # @param edition_id [String] The edition @id
+      # @return [Array<Lutaml::Model::Serializable>] Array of monographs
+      def all_for_edition(edition_id)
+        @indexes[:edition][edition_id] || []
+      end
+
+      # Iterate over all monographs.
+      #
+      # @yield [Lutaml::Model::Serializable] Each monograph
+      # @return [Enumerator] If no block given
+      def each(&block)
+        return @cache.each_value unless block_given?
+
+        @cache.each_value(&block)
+      end
+
+      # Select monographs matching a condition.
+      #
+      # @yield [Lutaml::Model::Serializable] Each monograph
+      # @return [Array<Lutaml::Model::Serializable>] Matching monographs
+      def select(&block)
+        @cache.values.select(&block)
+      end
+
+      # Count of all cached monographs.
+      #
+      # @return [Integer]
+      def count
+        @cache.size
+      end
+
+      # All cached monographs.
+      #
+      # @return [Array<Lutaml::Model::Serializable>]
+      def all
+        @cache.values
+      end
+
+      # Check if a monograph exists.
+      #
+      # @param id [String] The monograph's @id
+      # @return [Boolean]
+      def exists?(id)
+        @cache.key?(id)
+      end
+
+      # Get monograph IDs for fuzzy matching.
+      #
+      # @return [Array<String>] All monograph IDs
+      def ids
+        @cache.keys
+      end
+
+      private
+
+      # Deserialize JSON data to the appropriate model class.
+      #
+      # @param data [Hash] The parsed JSON data
+      # @return [Lutaml::Model::Serializable, nil] The model instance or nil
+      def deserialize(data)
+        return nil unless data['@id']
+
+        type = data['@type'] || 'Monograph'
+        model_class = model_class_for_type(type)
+
+        return nil unless model_class
+
+        # Use Lutaml::Model's from_json method
+        model_class.from_json(data.to_json)
+      rescue StandardError => e
+        warn "Warning: Could not deserialize #{data['@id']}: #{e.message}"
+        nil
+      end
+
+      # Get the model class for a JSON-LD type.
+      #
+      # @param type [String] The @type value
+      # @return [Class, nil] The model class
+      def model_class_for_type(type)
+        # Try registry first (if available)
+        if defined?(Registry::TypeRegistry)
+          model_class = Registry::TypeRegistry.model_class_for(type)
+          return model_class if model_class
+        end
+
+        # Fallback to known types
+        type_to_class_map[type]
+      end
+
+      # Map of type names to model classes.
+      #
+      # @return [Hash<String, Class>]
+      def type_to_class_map
+        @type_to_class_map ||= {
+          # Core monograph types
+          'Monograph' => Models::Monograph,
+          'CrudeDrugMonograph' => Models::CrudeDrugMonograph,
+          'ChemicalDrugMonograph' => Models::ChemicalDrugMonograph,
+          'FormulationMonograph' => Models::FormulationMonograph,
+          'VitaminMonograph' => Models::VitaminMonograph,
+          'AminoAcidMonograph' => Models::AminoAcidMonograph,
+          'MineralSubstanceMonograph' => Models::MineralSubstanceMonograph,
+          'BiologicalSubstanceMonograph' => Models::BiologicalSubstanceMonograph,
+          # JP types
+          'KampoFormula' => Models::JP::KampoFormula,
+          # Ph.Int. types
+          'RadiopharmaceuticalMonograph' => Models::PhInt::RadiopharmaceuticalMonograph,
+          'DosageFormMonograph' => Models::PhInt::DosageFormMonograph,
+          'TestMethod' => Models::PhInt::TestMethod,
+          'Reagent' => Models::PhInt::Reagent,
+          'TestSolution' => Models::PhInt::TestSolution,
+          'VolumetricSolution' => Models::PhInt::VolumetricSolution,
+          'BufferSolution' => Models::PhInt::BufferSolution,
+          'ReferenceSubstance' => Models::PhInt::ReferenceSubstance
+        }
+      end
+
+      # Index a monograph for fast lookups.
+      #
+      # @param monograph [Lutaml::Model::Serializable] The monograph to index
+      def index_monograph(monograph)
+        # Index by CAS number
+        index_by_cas(monograph)
+
+        # Index by names
+        index_by_names(monograph)
+
+        # Index by publisher
+        index_by_publisher(monograph)
+
+        # Index by edition
+        index_by_edition(monograph)
+
+        # Index by slug
+        index_by_slug(monograph)
+      end
+
+      def index_by_cas(monograph)
+        return unless monograph.respond_to?(:cas_number) && monograph.cas_number
+
+        key = normalize_cas(monograph.cas_number)
+        @indexes[:cas_number][key] = monograph
+      end
+
+      def index_by_names(monograph)
+        return unless monograph.respond_to?(:pref_label)
+
+        # Latin name
+        if monograph.pref_label['la']
+          key = normalize_name(monograph.pref_label['la'])
+          @indexes[:latin_name][key] = monograph
+        end
+
+        # Japanese name
+        return unless monograph.pref_label['ja']
+
+        key = monograph.pref_label['ja'].to_s.strip
+        @indexes[:japanese_name][key] = monograph
+      end
+
+      def index_by_publisher(monograph)
+        return unless monograph.respond_to?(:publisher) && monograph.publisher
+
+        key = monograph.publisher.to_s.upcase
+        (@indexes[:publisher][key] ||= []) << monograph
+      end
+
+      def index_by_edition(monograph)
+        return unless monograph.respond_to?(:belongs_to_edition) && monograph.belongs_to_edition
+
+        key = monograph.belongs_to_edition
+        (@indexes[:edition][key] ||= []) << monograph
+      end
+
+      def index_by_slug(monograph)
+        return unless monograph.id
+
+        # Extract slug from ID
+        slug = monograph.id.split('/').last
+        @indexes[:slug][slug.downcase] = monograph
+      end
+
+      def normalize_cas(cas)
+        cas.to_s.strip
+      end
+
+      def normalize_name(name)
+        name.to_s.downcase.gsub(/[^a-z0-9]/, '')
+      end
+    end
+  end
+end

data/lib/openphar/repositories.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Repositories
+    # Repository pattern for data access.
+    #
+    # Provides caching, indexing, and query interfaces for monograph data.
+
+    autoload :MonographRepository, 'openphar/repositories/monograph_repository'
+  end
+end

data/lib/openphar/transformers/jsonld_transformer.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Openphar
+  module Transformers
+    # Transforms parsed monograph data to JSON-LD format
+    class JsonldTransformer
+      attr_reader :context, :base_iri
+
+      def initialize(context: nil, base_iri: nil)
+        @context = context || default_context
+        @base_iri = base_iri || Openphar.base_iri
+      end
+
+      # Transform a monograph hash to JSON-LD
+      def transform(monograph_data, publisher: nil, edition: nil)
+        {
+          "@context" => context,
+          "@id" => monograph_iri(monograph_data[:id], publisher),
+          "@type" => monograph_type(monograph_data),
+          "prefLabel" => build_labels(monograph_data),
+          "monographId" => monograph_data[:id],
+          "publisher" => publisher_iri(publisher),
+          "belongsToEdition" => edition_iri(edition),
+          "definition" => { "en" => monograph_data[:definition] },
+          "testSpecification" => build_test_specifications(monograph_data)
+        }.compact
+      end
+
+      # Transform multiple monographs to a JSON-LD graph
+      def transform_graph(monographs_data, publisher: nil, edition: nil)
+        {
+          "@context" => context,
+          "@graph" => monographs_data.map do |data|
+            transform(data, publisher: publisher, edition: edition)
+          end
+        }
+      end
+
+      private
+
+      def default_context
+        "#{base_iri}/ontology/context/pharmacopoeia.jsonld"
+      end
+
+      def monograph_iri(id, publisher)
+        slug = id.to_s.downcase.gsub(/\s+/, "-").gsub(/[^a-z0-9-]/, "")
+        "#{base_iri}/data/#{publisher.downcase}/monographs/#{slug}"
+      end
+
+      def publisher_iri(publisher)
+        "#{base_iri}/ontology/core/#{publisher}"
+      end
+
+      def edition_iri(edition)
+        return nil unless edition
+
+        "#{base_iri}/data/edition/#{edition.downcase}"
+      end
+
+      def monograph_type(data)
+        # Determine monograph type based on content
+        if data[:botanical_source] || data[:macroscopic_description]
+          "CrudeDrugMonograph"
+        elsif data[:molecular_formula]
+          "ChemicalDrugMonograph"
+        else
+          "PharmacopoeiaMonograph"
+        end
+      end
+
+      def build_labels(data)
+        labels = { "en" => data[:name] }
+        labels["ja"] = data[:japanese_name] if data[:japanese_name]
+        labels.compact
+      end
+
+      def build_test_specifications(data)
+        specs = []
+
+        # Add assay specification
+        if data[:assay]
+          specs << {
+            "@type" => "AssaySpecification",
+            "testName" => { "en" => "Assay" },
+            "testType" => "TestType-Assay",
+            "testDescription" => { "en" => data[:assay] }
+          }
+        end
+
+        # Add purity specification
+        if data[:purity]
+          specs << {
+            "@type" => "PuritySpecification",
+            "testName" => { "en" => "Purity" },
+            "testType" => "TestType-Purity",
+            "testDescription" => { "en" => data[:purity] }
+          }
+        end
+
+        specs.empty? ? nil : specs
+      end
+    end
+  end
+end

data/lib/openphar/transformers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Transformers
+    # Transformers for converting data between formats.
+    #
+    # Handles conversion from internal models to various output formats.
+
+    autoload :JsonldTransformer, 'openphar/transformers/jsonld_transformer'
+  end
+end

data/lib/openphar/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Openphar
+  VERSION = "0.1.0"
+end