openphar 0.1.0

data/lib/openphar/exporters/neo4j/relationship_builder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Exporters
+    module Neo4j
+      # Builds Neo4j Cypher relationships between nodes
+      #
+      # Handles:
+      # - Edition relationships (monograph belongs to edition)
+      # - Cross-publisher links (sameSubstanceAs, hasEquivalentIn, similarTo)
+      # - Test specification relationships
+      class RelationshipBuilder
+        attr_reader :registry
+
+        def initialize(registry = nil)
+          @registry = registry || ModelRegistry.new
+        end
+
+        # Builds a Cypher relationship for edition membership
+        #
+        # @param monograph_id [String] The monograph's @id
+        # @param edition_id [String] The edition's @id
+        # @return [String] Cypher MATCH-MERGE statement
+        def build_edition_relationship(monograph_id, edition_id)
+          <<~CYPHER
+            MATCH (m:Monograph {id: #{escape(monograph_id)}})
+            MATCH (e:Edition {id: #{escape(edition_id)}})
+            MERGE (m)-[:BELONGS_TO_EDITION]->(e);
+          CYPHER
+        end
+
+        # Builds a Cypher relationship for cross-publisher links
+        #
+        # @param source_id [String] Source monograph @id
+        # @param target_id [String] Target monograph @id
+        # @param rel_type [String] Relationship type
+        # @return [String] Cypher MATCH-MERGE statement
+        def build_cross_publisher_relationship(source_id, target_id, rel_type)
+          <<~CYPHER
+            MATCH (a:Monograph {id: #{escape(source_id)}})
+            MATCH (b:Monograph {id: #{escape(target_id)}})
+            MERGE (a)-[:#{rel_type}]->(b);
+          CYPHER
+        end
+
+        # Maps a JSON-LD linkType to a Neo4j relationship type
+        #
+        # @param link_type [String] The link type from JSON-LD
+        # @return [String] Neo4j relationship type
+        def map_link_type(link_type)
+          case link_type
+          when 'sameSubstanceAs' then 'SAME_SUBSTANCE_AS'
+          when 'hasEquivalentIn' then 'HAS_EQUIVALENT_IN'
+          when 'similarTo' then 'SIMILAR_TO'
+          else 'RELATED_TO'
+          end
+        end
+
+        # Builds a test specification relationship
+        #
+        # @param monograph_id [String] The monograph's @id
+        # @param test_spec_id [String] The test specification's @id
+        # @return [String] Cypher MATCH-MERGE statement
+        def build_test_spec_relationship(monograph_id, test_spec_id)
+          <<~CYPHER
+            MATCH (m:Monograph {id: #{escape(monograph_id)}})
+            MATCH (t:TestSpec {id: #{escape(test_spec_id)}})
+            MERGE (m)-[:HAS_TEST_SPEC]->(t);
+          CYPHER
+        end
+
+        private
+
+        # Escapes a string for Neo4j Cypher
+        def escape(str)
+          return 'null' if str.nil?
+
+          escaped = str.to_s
+                       .gsub('\\', '\\\\')
+                       .gsub("'", "\\'")
+
+          "'#{escaped}'"
+        end
+      end
+    end
+  end
+end

data/lib/openphar/exporters/neo4j.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Exporters
+    module Neo4j
+      # Neo4j-specific exporters and utilities.
+      #
+      # Handles model-to-Neo4j mapping, property conversion, and Cypher generation.
+
+      autoload :ModelRegistry, 'openphar/exporters/neo4j/model_registry'
+      autoload :PropertyMapper, 'openphar/exporters/neo4j/property_mapper'
+      autoload :NodeBuilder, 'openphar/exporters/neo4j/node_builder'
+      autoload :RelationshipBuilder, 'openphar/exporters/neo4j/relationship_builder'
+    end
+  end
+end

data/lib/openphar/exporters/neo4j_exporter.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "csv"
+require "time"
+
+module Openphar
+  module Exporters
+    # Main Neo4j exporter - orchestrates the export process
+    #
+    # Uses model-driven architecture with separate concerns:
+    # - Neo4j::NodeBuilder: Converts models to Cypher nodes
+    # - Neo4j::RelationshipBuilder: Builds relationships
+    # - Neo4j::PropertyMapper: Maps model attributes to Neo4j properties
+    # - Neo4j::ModelRegistry: Registry of exportable models
+    #
+    # Usage:
+    #   exporter = Openphar::Exporters::Neo4jExporter.new
+    #   exporter.export_monographs("data/jp/crude-drugs/", "output.cypher")
+    #   exporter.export_relationships("output.cypher")
+    class Neo4jExporter
+      attr_reader :output_path, :stats, :node_builder, :relationship_builder
+
+      def initialize(output_path: nil)
+        @output_path = output_path
+        @stats = { nodes: 0, relationships: 0, properties: 0 }
+
+        # Initialize model-driven components (using Neo4j sub-module)
+        registry = Neo4j::ModelRegistry.new
+        mapper = Neo4j::PropertyMapper.new(registry)
+        @node_builder = Neo4j::NodeBuilder.new(mapper)
+        @relationship_builder = Neo4j::RelationshipBuilder.new
+      end
+
+      # Export all monograph files in a directory
+      #
+      # @param directory [String] Path to directory containing JSON-LD files
+      # @param output_path [String] Path for output Cypher file
+      # @param use_merge [Boolean] Use MERGE instead of CREATE (default: false)
+      def export_monographs(directory, output_path = nil, use_merge: false)
+        @output_path = output_path || @output_path
+        @use_merge = use_merge
+        reset_stats
+
+        File.open(@output_path, "w") do |f|
+          f.puts "// Neo4j Cypher Export - Open Pharmacopoeia"
+          f.puts "// Generated: #{Time.now.iso8601}"
+          f.puts "// Import method: #{use_merge ? 'MERGE (idempotent)' : 'CREATE'}"
+          f.puts ""
+          f.puts "// BEGIN TRANSACTION"
+          f.puts "BEGIN;"
+
+          Dir.glob(File.join(directory, "**", "*.jsonld")).sort.each do |file|
+            puts "Processing: #{file}"
+            process_file(file, f)
+          end
+
+          f.puts "COMMIT;"
+        end
+
+        puts "\nExport complete:"
+        puts "  Nodes: #{@stats[:nodes]}"
+        puts "  Relationships: #{@stats[:relationships]}"
+        puts "  Properties: #{@stats[:properties]}"
+
+        @output_path
+      end
+
+      # Export relationships between entities
+      #
+      # @param output_path [String] Path for relationship Cypher
+      def export_relationships(output_path = nil)
+        output_path ||= @output_path.sub(".cypher", "_rels.cypher")
+
+        File.open(output_path, "w") do |f|
+          f.puts "// Neo4j Relationships - Open Pharmacopoeia"
+          f.puts "// Generated: #{Time.now.iso8601}"
+          f.puts ""
+          f.puts "// BEGIN TRANSACTION"
+          f.puts "BEGIN;"
+
+          # Belongs to Edition
+          f.puts "\n// Edition relationships"
+          Dir.glob("data/jp/**/*.jsonld").sort.each do |file|
+            data = JSON.parse(File.read(file))
+            edition_id = data["belongsToEdition"]
+            next unless edition_id
+
+            monograph_id = data["@id"] || data["id"]
+            next unless monograph_id
+
+            f.puts @relationship_builder.build_edition_relationship(monograph_id, edition_id)
+            @stats[:relationships] += 1
+          end
+
+          # Cross-publisher links
+          f.puts "\n// Cross-publisher relationships"
+          Dir.glob("data/cross-publisher/*.jsonld").sort.each do |file|
+            data = JSON.parse(File.read(file))
+            (data["@graph"] || [data]).each do |link|
+              next unless link["linkType"]
+
+              source = link.dig("sourceMonograph", "@id")
+              target = link.dig("targetMonograph", "@id")
+              next unless source && target
+
+              rel_type = @relationship_builder.map_link_type(link["linkType"])
+              f.puts @relationship_builder.build_cross_publisher_relationship(source, target, rel_type)
+              @stats[:relationships] += 1
+            end
+          end
+
+          f.puts "COMMIT;"
+        end
+
+        puts "\nRelationships export complete:"
+        puts "  Relationships: #{@stats[:relationships]}"
+        puts "  Output: #{output_path}"
+
+        output_path
+      end
+
+      # Export to CSV for Neo4j Admin Import
+      #
+      # @param directory [String] Directory with JSON-LD files
+      # @param nodes_path [String] Output path for nodes CSV
+      # @param rels_path [String] Output path for relationships CSV
+      def export_csv(directory, nodes_path, rels_path)
+        nodes_csv = CSV.open(nodes_path, "w")
+        rels_csv = CSV.open(rels_path, "w")
+
+        # Node header
+        nodes_csv << [:id, :type, :monograph_id, :publisher, :status, :label_en, :label_ja]
+
+        # Relationship header
+        rels_csv << [:start_id, :end_id, :type, :properties]
+
+        Dir.glob(File.join(directory, "**", "*.jsonld")).sort.each do |file|
+          data = JSON.parse(File.read(file))
+          next unless data["@id"]
+
+          id = data["@id"]
+          type = data["@type"]
+          node_type = node_builder.registry.node_type_for(type)
+
+          pref_label = data["prefLabel"] || {}
+          label_en = pref_label["en"] || ""
+          label_ja = pref_label["ja"] || ""
+
+          nodes_csv << [
+            id,
+            node_type,
+            data["monographId"] || "",
+            data["publisher"] || "",
+            data["status"] || "",
+            label_en,
+            label_ja
+          ]
+
+          @stats[:nodes] += 1
+        end
+
+        nodes_csv.close
+        rels_csv.close
+
+        puts "\nCSV Export complete:"
+        puts "  Nodes: #{@stats[:nodes]}"
+        puts "  Nodes CSV: #{nodes_path}"
+        puts "  Rels CSV: #{rels_path}"
+
+        { nodes: nodes_path, rels: rels_path }
+      end
+
+      private
+
+      def reset_stats
+        @stats = { nodes: 0, relationships: 0, properties: 0 }
+      end
+
+      def process_file(file, output)
+        data = JSON.parse(File.read(file))
+        return unless data["@id"]
+
+        # Handle @graph format
+        items = data["@graph"] || [data]
+
+        items.each do |item|
+          next unless item["@id"]
+
+          # Use model-driven node builder
+          cypher = node_builder.build(item, use_merge: @use_merge)
+          output.puts cypher
+
+          @stats[:nodes] += 1
+          @stats[:properties] += node_builder.property_count(item)
+        end
+      end
+    end
+  end
+end

data/lib/openphar/exporters.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Exporters
+    # Exporters for outputting data in various formats.
+    #
+    # Handles export to Neo4j, CSV, and other formats.
+
+    autoload :Neo4jExporter, 'openphar/exporters/neo4j_exporter'
+    autoload :CoverageValidator, 'openphar/exporters/coverage_validator'
+
+    # Neo4j sub-module (autoloads its own children)
+    autoload :Neo4j, 'openphar/exporters/neo4j'
+  end
+end

data/lib/openphar/linkers/chp/cross_edition_linker.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Openphar
+  module Linkers
+    module Chp
+      # Links the same monograph across two ChP editions via `sameSubstanceAs`.
+      #
+      # The matcher uses `(book_id, normalized pinyin_title)` as the match
+      # key — pinyin is publisher-assigned, stable across editions, and
+      # disambiguates within volume. When two editions have a monograph with
+      # the same key, both IRIs are emitted as `sameSubstanceAs` targets.
+      #
+      # Input: two enumerables of monographs (anything that responds to
+      # `pinyin_title`, `book_id`, `id`). Output: a hash of
+      # `{source_iri => [target_iris]}` representing the bidirectional links.
+      #
+      class CrossEditionLinker
+        attr_reader :matches, :stats
+
+        # @param edition_a [Enumerable<Openphar::Models::Chp::Monograph>]
+        # @param edition_b [Enumerable<Openphar::Models::Chp::Monograph>]
+        def initialize(edition_a:, edition_b:)
+          @edition_a = edition_a
+          @edition_b = edition_b
+          @matches = {}
+          @stats = { matched: 0, unmatched_a: 0, unmatched_b: 0, multi_match: 0 }
+        end
+
+        def link
+          index_b = build_index(@edition_b)
+          index_a = build_index(@edition_a)
+
+          # Match A -> B
+          index_a.each do |key, iris_a|
+            iris_b = index_b[key]
+            next unless iris_b
+
+            if iris_b.size > 1
+              @stats[:multi_match] += 1
+              next # ambiguous: don't link
+            end
+
+            iri_a = iris_a.first
+            iri_b = iris_b.first
+            @matches[iri_a] = [iri_b]
+            @matches[iri_b] = [iri_a]
+            @stats[:matched] += 1
+          end
+
+          @stats[:unmatched_a] = index_a.size - @stats[:matched]
+          @stats[:unmatched_b] = index_b.size - @stats[:matched]
+          @matches
+        end
+
+        # Serialize links as a JSON-LD graph document.
+        # @return [Hash] JSON-serializable graph.
+        def to_jsonld
+          graph = @matches.map do |source_iri, targets|
+            {
+              "@id" => source_iri,
+              "sameSubstanceAs" => targets,
+            }
+          end
+          {
+            "@context" => "https://www.openphar.org/ontology/context/chp.jsonld",
+            "@type" => "LinkSet",
+            "linkType" => "sameSubstanceAs",
+            "matchCount" => @stats[:matched],
+            "@graph" => graph,
+          }
+        end
+
+        private
+
+        def build_index(edition)
+          index = Hash.new { |h, k| h[k] = [] }
+          edition.each do |monograph|
+            key = match_key(monograph)
+            next unless key
+
+            iri = monograph.respond_to?(:iri) ? monograph.iri : monograph.id
+            index[key] << iri if iri
+          end
+          index
+        end
+
+        def match_key(monograph)
+          pinyin = monograph.pinyin_title
+          return nil unless pinyin && !pinyin.empty?
+
+          normalized = pinyin.downcase.gsub(/[^a-z0-9]/, "")
+          return nil if normalized.empty?
+
+          "#{monograph.book_id}:#{normalized}"
+        end
+      end
+    end
+  end
+end

data/lib/openphar/linkers/chp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Openphar
+  module Linkers
+    # Chinese Pharmacopoeia linkers.
+    #
+    module Chp
+      autoload :CrossEditionLinker, "openphar/linkers/chp/cross_edition_linker"
+    end
+  end
+end