bibframe_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fcbdeff768bfbc758d78355aa9f9de7e98a513cc0a0c63a43ac1e2b9b2c4e6bb
+  data.tar.gz: c2e8be5aed30fa4cb8a6bc88c5d0e70b267b3b2c3b73aa5a141fc76169696c74
+SHA512:
+  metadata.gz: 1be2ad497cc3ba26bf0eca414bcdc27cf80aaebae69db92fb469462fec0f85cf2ad28aff7a7f3b00f993b31c408804cff391434b97de96387135c424bc2b34ad
+  data.tar.gz: a09548d0df9b71f46188ac47935dd1dc13e827259183ce716a8b9aac2e555a016c7a07f9cd9770c3c38957514718df3163162447d551c484ac53afcab1dfd56a

data/README.md

@@ -0,0 +1,261 @@
+# BibframeRuby
+
+A Ruby gem for parsing [BIBFRAME](https://www.loc.gov/bibframe/) data into Ruby objects. Currently supports JSON-LD, with Turtle and RDF/XML support planned.
+
+Built on the [RDF.rb](https://github.com/ruby-rdf/rdf) ecosystem, BibframeRuby converts BIBFRAME documents into typed Ruby objects with idiomatic accessors and linked relationships.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "bibframe_ruby"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install bibframe_ruby
+```
+
+## Usage
+
+### Parsing JSON-LD
+
+```ruby
+require "bibframe_ruby"
+
+# Parse a JSON-LD string
+json = File.read("work.jsonld")
+graph = BibframeRuby.parse(json)
+
+# Or parse directly from a file (format detected from extension)
+graph = BibframeRuby.parse_file("work.jsonld")
+
+# Parse from a remote URI (fetches the content)
+graph = BibframeRuby.parse_uri("https://id.loc.gov/resources/hubs/4076e139-793f-bb85-515c-840510066bac.jsonld")
+```
+
+### Accessing Resources
+
+The returned `Graph` provides typed collections:
+
+```ruby
+graph.works      # => [BibframeRuby::Work, ...]
+graph.instances  # => [BibframeRuby::Instance, ...]
+graph.items      # => [BibframeRuby::Item, ...]
+graph.hubs       # => [BibframeRuby::Hub, ...]
+graph.resources  # => all parsed resources
+```
+
+### Working with a Work
+
+```ruby
+work = graph.works.first
+
+work.id
+# => "https://dev.bcld.info/works/25305194-1115-43ab-8a7c-4ef586a1e8e5"
+
+work.types
+# => ["Monograph", "Text", "Work"]
+
+work.title.main_title
+# => "The dungeon anarchist's cookbook"
+
+work.title.non_sort_num
+# => "4"
+
+work.language
+# => "http://id.loc.gov/vocabulary/languages/eng"
+
+work.genre_forms
+# => ["http://id.loc.gov/authorities/genreForms/gf2023026123", ...]
+
+work.summary
+# => "\"Welcome to the Gun Show! The top ten list is populated..."
+
+work.classifications.length
+# => 2
+```
+
+### Contributions
+
+```ruby
+contribution = work.contributions.first
+
+contribution.primary?
+# => true
+
+contribution.role
+# => "http://id.loc.gov/vocabulary/relators/aut"
+
+contribution.agent.id
+# => "http://id.loc.gov/rwo/agents/no2023085548"
+```
+
+### Working with an Instance
+
+When you parse both a Work and its Instance, the relationships are automatically linked:
+
+```ruby
+instance = graph.instances.first
+
+instance.title.main_title
+# => "The dungeon anarchist's cookbook"
+
+instance.extent
+# => "532 pages"
+
+instance.dimensions
+# => "24 cm"
+
+instance.edition_statement
+# => "First Ace edition"
+
+instance.publication_statement
+# => "New York: Ace, 2024"
+
+# Bidirectional linking
+instance.work.title.main_title
+# => "The dungeon anarchist's cookbook"
+
+work.instances.first == instance
+# => true
+```
+
+### Working with a Hub
+
+Hubs are abstract resources that bridge between Works — commonly used for authority-linked title/author combinations.
+
+```ruby
+graph = BibframeRuby.parse_file("hub.jsonld")
+hub = graph.hubs.first
+
+hub.id
+# => "http://id.loc.gov/resources/hubs/4076e139-793f-bb85-515c-840510066bac"
+
+hub.types
+# => ["Work", "Hub", "Series"]
+
+hub.title.main_title
+# => "Dungeon crawler Carl (Series)"
+
+hub.contributions.first.primary?
+# => true
+
+hub.relations.length
+# => 1
+```
+
+### Identifiers
+
+```ruby
+instance.identifiers.length
+# => 2
+
+lccn = instance.identifiers.find { |id| id.types.include?("Lccn") }
+isbn = instance.identifiers.find { |id| id.types.include?("Isbn") }
+```
+
+### Hash-Style Property Access
+
+Any property can be accessed by name, even if there is no named accessor:
+
+```ruby
+work["language"]
+# => "http://id.loc.gov/vocabulary/languages/eng"
+
+work["aap"]
+# => "Dinniman, Matt. The dungeon anarchist's cookbook"
+```
+
+### Combining Multiple Documents
+
+To parse related documents together (e.g., a Work and its Instance), combine their RDF graphs before building:
+
+```ruby
+work_graph = BibframeRuby::Parser.new(work_json, format: :jsonld).parse
+instance_graph = BibframeRuby::Parser.new(instance_json, format: :jsonld).parse
+
+# Merge statements into one graph
+instance_graph.each_statement { |s| work_graph << s }
+
+# Build with linked relationships
+result = BibframeRuby::Graph.from_rdf(work_graph)
+
+result.works.first.instances.first.extent
+# => "532 pages"
+```
+
+### Stub Resources
+
+When a parsed document references an external resource by URI (e.g., an agent in the Library of Congress), a stub `Resource` is created with just the `id` set:
+
+```ruby
+agent = work.contributions.first.agent
+agent.id
+# => "http://id.loc.gov/rwo/agents/no2023085548"
+
+agent.is_a?(BibframeRuby::Resource)
+# => true
+```
+
+## Model Reference
+
+| Class | Accessors |
+|-------|-----------|
+| `Resource` | `id`, `types`, `properties`, `[]`, `[]=` |
+| `Work` | `title`, `contributions`, `instances`, `language`, `subjects`, `genre_forms`, `summary`, `classifications`, `relations` |
+| `Instance` | `title`, `work`, `identifiers`, `extent`, `carrier`, `media`, `provision_activity`, `edition_statement`, `dimensions`, `publication_statement`, `items` |
+| `Hub` | `title`, `contributions`, `language`, `identifiers`, `relations`, `label` |
+| `Item` | `instance`, `held_by`, `shelf_mark` |
+| `Contribution` | `agent`, `role`, `primary?` |
+| `Title` | `main_title`, `subtitle`, `non_sort_num` |
+| `Agent` | `label` |
+| `Person` | `label` (inherits from Agent) |
+| `Organization` | `label` (inherits from Agent) |
+| `Subject` | `label`, `source` |
+
+All models inherit from `Resource` and support hash-style access via `[]` for any property.
+
+## Supported Formats
+
+| Format | Status | File Extension |
+|--------|--------|----------------|
+| JSON-LD | Supported | `.jsonld` |
+| Turtle | Planned | `.ttl` |
+| RDF/XML | Planned | `.rdf` |
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+### Running Tests
+
+```bash
+bundle exec rspec
+```
+
+With documentation output:
+
+```bash
+bundle exec rspec --format documentation
+```
+
+### Console
+
+You can run `bin/console` for an interactive prompt to experiment with the gem.
+
+## Requirements
+
+- Ruby >= 3.2.0
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/aaron-collier/bibframe_ruby.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/bibframe_ruby/graph.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Graph
+    attr_reader :works, :instances, :items, :hubs, :resources
+
+    def initialize(works:, instances:, items:, resources:, hubs: [])
+      @works = works
+      @instances = instances
+      @items = items
+      @hubs = hubs
+      @resources = resources
+    end
+
+    def self.from_rdf(rdf_graph)
+      result = GraphBuilder.new(rdf_graph).build
+      new(
+        works: result[:works],
+        instances: result[:instances],
+        items: result[:items],
+        hubs: result[:hubs],
+        resources: result[:resources].values
+      )
+    end
+  end
+end

data/lib/bibframe_ruby/graph_builder.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class GraphBuilder
+    BF = "http://id.loc.gov/ontologies/bibframe/"
+    BFLC = "http://id.loc.gov/ontologies/bflc/"
+    RDF_TYPE = RDF.type.to_s
+    RDFS_LABEL = RDF::RDFS.label.to_s
+
+    TYPE_MAP = {
+      "#{BF}Hub" => Hub,
+      "#{BF}Work" => Work,
+      "#{BF}Instance" => Instance,
+      "#{BF}Item" => Item,
+      "#{BF}Contribution" => Contribution,
+      "#{BF}PrimaryContribution" => Contribution,
+      "#{BF}Title" => Title,
+      "#{BF}Person" => Person,
+      "#{BF}Organization" => Organization,
+      "#{BF}Subject" => Subject
+    }.freeze
+
+    # Maps BIBFRAME predicates to Ruby property names
+    PROPERTY_MAP = {
+      "#{BF}title" => "title",
+      "#{BF}mainTitle" => "main_title",
+      "#{BF}subtitle" => "subtitle",
+      "#{BFLC}nonSortNum" => "non_sort_num",
+      "#{BF}contribution" => "contributions",
+      "#{BF}hasInstance" => "instances",
+      "#{BF}instanceOf" => "work",
+      "#{BF}hasItem" => "items",
+      "#{BF}itemOf" => "instance",
+      "#{BF}language" => "language",
+      "#{BF}summary" => "summary",
+      "#{BF}genreForm" => "genre_forms",
+      "#{BF}classification" => "classifications",
+      "#{BF}relation" => "relations",
+      "#{BF}identifiedBy" => "identifiers",
+      "#{BF}extent" => "extent",
+      "#{BF}carrier" => "carrier",
+      "#{BF}media" => "media",
+      "#{BF}provisionActivity" => "provision_activity",
+      "#{BF}editionStatement" => "edition_statement",
+      "#{BF}dimensions" => "dimensions",
+      "#{BF}publicationStatement" => "publication_statement",
+      "#{BF}responsibilityStatement" => "responsibility_statement",
+      "#{BF}issuance" => "issuance",
+      "#{BF}agent" => "agent",
+      "#{BF}role" => "role",
+      "#{BF}heldBy" => "held_by",
+      "#{BF}shelfMark" => "shelf_mark",
+      "#{BF}content" => "content",
+      "#{BF}subject" => "subjects",
+      RDFS_LABEL => "label",
+      "#{BF}code" => "code",
+      "#{BF}source" => "source",
+      "#{BF}status" => "status",
+      "#{BF}date" => "date",
+      "#{BF}seriesEnumeration" => "series_enumeration",
+      "#{BF}associatedResource" => "associated_resource",
+      "#{BF}relationship" => "relationship",
+      "#{BF}adminMetadata" => "admin_metadata",
+      "#{BF}derivedFrom" => "derived_from",
+      "#{BF}assigner" => "assigner",
+      "#{BF}classificationPortion" => "classification_portion",
+      "#{BF}itemPortion" => "item_portion",
+      "#{BF}edition" => "edition",
+      "#{BF}descriptionLevel" => "description_level",
+      "#{BF}descriptionLanguage" => "description_language",
+      "#{BF}descriptionAuthentication" => "description_authentication",
+      "#{BFLC}catalogerId" => "cataloger_id",
+      "#{BFLC}aap" => "Authorized Access Point",
+      "#{BFLC}aap-normalized" => "aap_normalized",
+      "#{BFLC}simpleDate" => "simple_date",
+      "#{BFLC}simpleAgent" => "simple_agent",
+      "#{BFLC}simplePlace" => "simple_place"
+    }.freeze
+
+    # Properties that always hold arrays
+    ARRAY_PROPERTIES = %w[
+      contributions instances items genre_forms classifications
+      relations identifiers subjects admin_metadata
+    ].freeze
+
+    # Properties whose blank-node value should be collapsed to its rdfs:label string
+    LABEL_COLLAPSE_PROPERTIES = %w[summary extent].freeze
+
+    def initialize(rdf_graph)
+      @rdf_graph = rdf_graph
+      @resources = {}
+      @stubs = {}
+    end
+
+    def build
+      grouped = group_by_subject
+      extract_resources(grouped)
+      link_relationships
+
+      {
+        resources: @resources,
+        works: @resources.values.select { |r| r.is_a?(Work) },
+        instances: @resources.values.select { |r| r.is_a?(Instance) },
+        items: @resources.values.select { |r| r.is_a?(Item) },
+        hubs: @resources.values.select { |r| r.is_a?(Hub) }
+      }
+    end
+
+    private
+
+    def group_by_subject
+      groups = Hash.new { |h, k| h[k] = [] }
+      @rdf_graph.each_statement { |s| groups[s.subject] << s }
+      groups
+    end
+
+    def extract_resources(grouped)
+      grouped.each do |subject, statements|
+        # Skip blank nodes that will be resolved inline as sub-resources
+        next if subject.is_a?(RDF::Node)
+
+        types = extract_types(statements)
+        klass = resolve_class(types)
+        type_names = types.map { |t| t.to_s.split(%r{[/#]}).last }
+
+        resource = klass.new(
+          id: subject.to_s,
+          types: type_names
+        )
+
+        populate_properties(resource, statements, grouped)
+        register_resource(subject, resource)
+      end
+    end
+
+    def extract_types(statements)
+      statements
+        .select { |s| s.predicate.to_s == RDF_TYPE }
+        .map(&:object)
+    end
+
+    def resolve_class(types)
+      type_strings = types.map(&:to_s)
+      TYPE_MAP.each do |type_uri, klass|
+        return klass if type_strings.include?(type_uri)
+      end
+      Resource
+    end
+
+    def populate_properties(resource, statements, grouped)
+      statements.each do |stmt|
+        next if stmt.predicate.to_s == RDF_TYPE
+
+        prop_name = PROPERTY_MAP[stmt.predicate.to_s] || stmt.predicate.to_s.split(%r{[/#]}).last
+        value = resolve_value(stmt.object, grouped, prop_name)
+        next if value.nil?
+
+        if ARRAY_PROPERTIES.include?(prop_name)
+          resource[prop_name] ||= []
+          resource[prop_name] << value
+        elsif resource[prop_name].nil?
+          resource[prop_name] = value
+        elsif resource[prop_name].is_a?(Array)
+          resource[prop_name] << value
+        else
+          resource[prop_name] = [resource[prop_name], value]
+        end
+      end
+
+      # Mark contribution as primary if PrimaryContribution is in its types
+      return unless resource.is_a?(Contribution)
+
+      types_uris = statements
+                   .select { |s| s.predicate.to_s == RDF_TYPE }
+                   .map { |s| s.object.to_s }
+      resource["primary"] = true if types_uris.include?("#{BF}PrimaryContribution")
+    end
+
+    def resolve_value(object, grouped, prop_name = nil)
+      case object
+      when RDF::Node
+        resolve_blank_node(object, grouped, prop_name)
+      when RDF::URI
+        object.to_s
+      when RDF::Literal
+        object.object.to_s
+      else
+        object.to_s
+      end
+    end
+
+    def resolve_blank_node(node, grouped, prop_name = nil)
+      return nil unless grouped.key?(node)
+
+      sub_statements = grouped[node]
+      types = extract_types(sub_statements)
+      klass = resolve_class(types)
+      type_names = types.map { |t| t.to_s.split(%r{[/#]}).last }
+
+      sub_resource = klass.new(types: type_names)
+      populate_properties(sub_resource, sub_statements, grouped)
+      register_resource(node, sub_resource)
+
+      # Collapse label-only resources to their string label
+      return sub_resource["label"] if LABEL_COLLAPSE_PROPERTIES.include?(prop_name) && sub_resource["label"]
+
+      sub_resource
+    end
+
+    def register_resource(subject, resource)
+      key = subject.to_s
+      @resources[key] = resource
+    end
+
+    def link_relationships
+      link_work_instances
+      link_instance_items
+      replace_uri_stubs
+    end
+
+    def link_work_instances
+      @resources.values.select { |r| r.is_a?(Work) }.each do |work|
+        next unless work["instances"]
+
+        work["instances"] = work["instances"].map do |ref|
+          uri = ref.is_a?(String) ? ref : ref.id
+          @resources[uri] || stub_for(uri)
+        end
+      end
+
+      @resources.values.select { |r| r.is_a?(Instance) }.each do |instance|
+        next unless instance["work"]
+
+        uri = instance["work"].is_a?(String) ? instance["work"] : instance["work"].id
+        instance["work"] = @resources[uri] || stub_for(uri)
+      end
+    end
+
+    def link_instance_items
+      @resources.values.select { |r| r.is_a?(Instance) }.each do |instance|
+        next unless instance["items"]
+
+        instance["items"] = instance["items"].map do |ref|
+          uri = ref.is_a?(String) ? ref : ref.id
+          @resources[uri] || stub_for(uri)
+        end
+      end
+
+      @resources.values.select { |r| r.is_a?(Item) }.each do |item|
+        next unless item["instance"]
+
+        uri = item["instance"].is_a?(String) ? item["instance"] : item["instance"].id
+        item["instance"] = @resources[uri] || stub_for(uri)
+      end
+    end
+
+    def replace_uri_stubs
+      # Replace any remaining string URI references in contribution agents
+      @resources.values.select { |r| r.is_a?(Contribution) }.each do |contrib|
+        next unless contrib["agent"].is_a?(String)
+
+        contrib["agent"] = @resources[contrib["agent"]] || stub_for(contrib["agent"])
+      end
+    end
+
+    def stub_for(uri)
+      @stubs[uri] ||= Resource.new(id: uri)
+    end
+  end
+end

data/lib/bibframe_ruby/models/agent.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Agent < Resource
+    def label
+      self["label"]
+    end
+  end
+end

data/lib/bibframe_ruby/models/contribution.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Contribution < Resource
+    def agent
+      self["agent"]
+    end
+
+    def role
+      self["role"]
+    end
+
+    def primary?
+      self["primary"] == true
+    end
+  end
+end

data/lib/bibframe_ruby/models/hub.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Hub < Resource
+    def title
+      self["title"]
+    end
+
+    def contributions
+      self["contributions"] || []
+    end
+
+    def language
+      self["language"]
+    end
+
+    def identifiers
+      self["identifiers"] || []
+    end
+
+    def relations
+      self["relations"] || []
+    end
+
+    def label
+      self["label"]
+    end
+  end
+end

data/lib/bibframe_ruby/models/instance.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Instance < Resource
+    def title
+      self["title"]
+    end
+
+    def work
+      self["work"]
+    end
+
+    def identifiers
+      self["identifiers"] || []
+    end
+
+    def extent
+      self["extent"]
+    end
+
+    def carrier
+      self["carrier"]
+    end
+
+    def media
+      self["media"]
+    end
+
+    def provision_activity
+      self["provision_activity"]
+    end
+
+    def edition_statement
+      self["edition_statement"]
+    end
+
+    def dimensions
+      self["dimensions"]
+    end
+
+    def publication_statement
+      self["publication_statement"]
+    end
+
+    def items
+      self["items"] || []
+    end
+  end
+end

data/lib/bibframe_ruby/models/item.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Item < Resource
+    def instance
+      self["instance"]
+    end
+
+    def held_by
+      self["held_by"]
+    end
+
+    def shelf_mark
+      self["shelf_mark"]
+    end
+  end
+end

data/lib/bibframe_ruby/models/organization.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Organization < Agent
+  end
+end

data/lib/bibframe_ruby/models/person.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Person < Agent
+  end
+end

data/lib/bibframe_ruby/models/subject.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Subject < Resource
+    def label
+      self["label"]
+    end
+
+    def source
+      self["source"]
+    end
+  end
+end

data/lib/bibframe_ruby/models/title.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Title < Resource
+    def main_title
+      self["main_title"]
+    end
+
+    def subtitle
+      self["subtitle"]
+    end
+
+    def non_sort_num
+      self["non_sort_num"]
+    end
+  end
+end

data/lib/bibframe_ruby/models/work.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Work < Resource
+    def title
+      self["title"]
+    end
+
+    def contributions
+      self["contributions"] || []
+    end
+
+    def instances
+      self["instances"] || []
+    end
+
+    def language
+      self["language"]
+    end
+
+    def subjects
+      self["subjects"] || []
+    end
+
+    def genre_forms
+      self["genre_forms"] || []
+    end
+
+    def summary
+      self["summary"]
+    end
+
+    def classifications
+      self["classifications"] || []
+    end
+
+    def relations
+      self["relations"] || []
+    end
+
+    def aap
+      self["aap"]
+    end
+  end
+end

data/lib/bibframe_ruby/parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rdf"
+require "json/ld"
+require "rdf/turtle"
+
+module BibframeRuby
+  class Parser
+    EXTENSION_MAP = {
+      ".jsonld" => :jsonld,
+      ".ttl" => :turtle,
+      ".rdf" => :rdfxml
+    }.freeze
+
+    READER_MAP = {
+      jsonld: JSON::LD::Reader,
+      turtle: RDF::Turtle::Reader
+    }.freeze
+
+    def initialize(input, format: :jsonld)
+      @input = input
+      @format = format
+    end
+
+    def parse
+      reader_class = READER_MAP.fetch(@format) do
+        raise BibframeRuby::Error, "Unsupported format: #{@format}"
+      end
+
+      graph = RDF::Graph.new
+      reader_class.new(@input) { |reader| graph << reader }
+      graph
+    end
+
+    def self.format_for_extension(ext)
+      EXTENSION_MAP.fetch(ext) do
+        raise BibframeRuby::Error, "Unknown file extension: #{ext}"
+      end
+    end
+  end
+end

data/lib/bibframe_ruby/resource.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module BibframeRuby
+  class Resource
+    attr_reader :id, :types
+    attr_accessor :properties
+
+    def initialize(id: nil, types: [], properties: {})
+      @id = id
+      @types = types
+      @properties = properties
+    end
+
+    def [](key)
+      @properties[key.to_s]
+    end
+
+    def []=(key, value)
+      @properties[key.to_s] = value
+    end
+  end
+end

data/lib/bibframe_ruby/version.rb

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

data/lib/bibframe_ruby.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require_relative "bibframe_ruby/version"
+require_relative "bibframe_ruby/resource"
+require_relative "bibframe_ruby/models/title"
+require_relative "bibframe_ruby/models/work"
+require_relative "bibframe_ruby/models/instance"
+require_relative "bibframe_ruby/models/item"
+require_relative "bibframe_ruby/models/contribution"
+require_relative "bibframe_ruby/models/agent"
+require_relative "bibframe_ruby/models/person"
+require_relative "bibframe_ruby/models/organization"
+require_relative "bibframe_ruby/models/subject"
+require_relative "bibframe_ruby/models/hub"
+require_relative "bibframe_ruby/parser"
+require_relative "bibframe_ruby/graph_builder"
+require_relative "bibframe_ruby/graph"
+
+module BibframeRuby
+  class Error < StandardError; end
+
+  def self.parse(input, format: :jsonld)
+    rdf_graph = Parser.new(input, format: format).parse
+    Graph.from_rdf(rdf_graph)
+  end
+
+  def self.parse_file(path)
+    ext = File.extname(path)
+    format = Parser.format_for_extension(ext)
+    input = File.read(path)
+    parse(input, format: format)
+  end
+
+  def self.parse_uri(uri, redirect_limit: 5)
+    raise Error, "Too many redirects" if redirect_limit.zero?
+
+    parsed_uri = URI.parse(uri)
+    response = Net::HTTP.get_response(parsed_uri)
+
+    if response.is_a?(Net::HTTPSuccess)
+      ext = File.extname(parsed_uri.path)
+      format = ext.empty? ? :jsonld : Parser.format_for_extension(ext)
+      parse(response.body, format: format)
+    elsif response.is_a?(Net::HTTPRedirection)
+      parse_uri(response["location"], redirect_limit: redirect_limit - 1)
+    else
+      raise Error, "HTTP error: #{response.code} #{response.message}"
+    end
+  end
+end

data/sig/bibframe_ruby.rbs

@@ -0,0 +1,4 @@
+module BibframeRuby
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: bibframe_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aaron Collier
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-ld
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdf-rdfxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby gem for parsing various BIBFRAME supported formats for display.
+email:
+- aaron.collier@stanford.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/bibframe_ruby.rb
+- lib/bibframe_ruby/graph.rb
+- lib/bibframe_ruby/graph_builder.rb
+- lib/bibframe_ruby/models/agent.rb
+- lib/bibframe_ruby/models/contribution.rb
+- lib/bibframe_ruby/models/hub.rb
+- lib/bibframe_ruby/models/instance.rb
+- lib/bibframe_ruby/models/item.rb
+- lib/bibframe_ruby/models/organization.rb
+- lib/bibframe_ruby/models/person.rb
+- lib/bibframe_ruby/models/subject.rb
+- lib/bibframe_ruby/models/title.rb
+- lib/bibframe_ruby/models/work.rb
+- lib/bibframe_ruby/parser.rb
+- lib/bibframe_ruby/resource.rb
+- lib/bibframe_ruby/version.rb
+- sig/bibframe_ruby.rbs
+homepage: https://github.com/aaron-collier/bibframe_ruby
+licenses: []
+metadata:
+  homepage_uri: https://github.com/aaron-collier/bibframe_ruby
+  source_code_uri: https://github.com/aaron-collier/bibframe_ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby gem for parsing various BIBFRAME supported formats for display.
+test_files: []