rdf-ordered-repo 3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f43439c8ba4d9d9cb2376e134f91ac477800433d3fdc035a84ad557ce8f93d78
+  data.tar.gz: 266350c62103ab7c4d32cc25602bb7aa14499222f2ea085c1918e5e6952e8925
+SHA512:
+  metadata.gz: 3942cd5d98be5cc13ebdb26fa7c155788466e2ab0f5051677aa18553e20230325bb8eda2cc2983c472f745addded4d0d356627d6dad09abd5704bd51e0d0b932
+  data.tar.gz: 7f19953b673e3e571f2c6a997d8ab6c6a771f099b176238775f276223912668917f7cb78877daeb23e6dee47217250f0f0007fcfe1835e84fe8343396375cf80

data/AUTHORS

@@ -0,0 +1 @@
+* Gregg Kellogg <gregg@greggkellogg.net>

data/README.md

@@ -0,0 +1,57 @@
+# RDF::OrderedRepo
+
+An order-preserving repository for RDF.rb.
+
+[![Gem Version](https://badge.fury.io/rb/rdf-ordered-repo.png)](https://badge.fury.io/rb/rdf-ordered-repo)
+[![Build Status](https://travis-ci.org/ruby-rdf/rdf-ordered-repo.png?branch=master)](https://travis-ci.org/ruby-rdf/rdf-ordered-repo)
+
+## Description
+
+An in-memory implementation of RDF::Repository using native Ruby Hashes having insert-order preserving properties.
+
+## Examples
+
+    require 'rdf/ordered_repo'
+    require 'rdf/nquads'
+    repo = RDF::OrderedRepo.load("https://ruby-rdf.github.com/rdf/etc/doap.nq")
+
+## Dependencies
+
+* [Ruby](https://ruby-lang.org/) (>= 2.4)
+* [RDF.rb][] (~> 3.1)
+
+## Mailing List
+
+* <https://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Author
+
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
+
+## Contributing
+This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+  Before committing, run `git diff --check` to make sure of this.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec` or `VERSION` files. If you need to change them,
+  do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the
+  corresponding list in the the `README`. Alphabetical order applies.
+* Don't touch the `AUTHORS` file. If your contributions are significant
+  enough, be assured we will eventually add you in there.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you.
+
+## License
+
+This is free and unencumbered public domain software. For more information,
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[RDF.rb]:           https://ruby-rdf.github.com/
+[YARD]:             https://yardoc.org/
+[YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:              https://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

data/VERSION

@@ -0,0 +1 @@
+3.1.0

data/etc/doap.ttl

@@ -0,0 +1,30 @@
+@base         <https://rubygems.org/gems/rdf-ordered-repo> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix dc:   <http://purl.org/dc/terms/> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+@prefix ex:   <http://example.org/> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+
+<> a doap:Project ;
+  doap:name          "RDF::N3" ;
+  doap:homepage      <https://github.com/ruby-rdf/rdf-ordered-repo> ;
+  doap:license       <https://unlicense.org/1.0/> ;
+  doap:shortdesc     "An order-preserving repository for RDF.rb."@en ;
+  doap:description   "An in-memory implementation of RDF::Repository using native Ruby Hashes having insert-order preserving properties."@en ;
+  doap:created       "2020-09-22"^^xsd:date;
+  doap:programming-language "Ruby" ;
+  doap:implements    <http://www.w3.org/TR/rdf11-concepts/> ;
+  doap:category      <http://dbpedia.org/resource/Resource_Description_Framework>,
+                     <http://dbpedia.org/resource/Ruby_(programming_language)> ;
+  doap:download-page <> ;
+  doap:mailing-list  <https://lists.w3.org/Archives/Public/public-rdf-ruby/> ;
+  doap:bug-database  <https://github.com/ruby-rdf/rdf-ordered-repo/issues> ;
+  doap:blog          <https://greggkellogg.net/> ;
+  doap:developer     <https://greggkellogg.net/foaf#me> ;
+  doap:helper        <http://njh.me/> ;
+  doap:maintainer    <https://greggkellogg.net/foaf#me> ;
+  doap:documenter    <https://greggkellogg.net/foaf#me> ;
+  foaf:maker         <https://greggkellogg.net/foaf#me> ;
+  dc:creator         <https://greggkellogg.net/foaf#me> .

data/lib/rdf/ordered_repo.rb

@@ -0,0 +1,310 @@
+require 'rdf'
+
+module RDF
+  ##
+  # Sub-class of RDF::Repository with order-preserving properties.
+  class OrderedRepo < RDF::Repository
+    DEFAULT_GRAPH = false
+
+    ##
+    # Initializes this repository instance.
+    #
+    # @param [URI, #to_s]    uri (nil)
+    # @param [String, #to_s] title (nil)
+    # @param [Hash{Symbol => Object}] options
+    # @option options [Boolean]   :with_graph_name (true)
+    #   Indicates that the repository supports named graphs, otherwise,
+    #   only the default graph is supported.
+    # @option options [Boolean]   :with_validity (true)
+    #   Indicates that the repository supports named validation.
+    # @option options [Boolean]   :transaction_class (DEFAULT_TX_CLASS)
+    #   Specifies the RDF::Transaction implementation to use in this Repository.
+    # @yield  [repository]
+    # @yieldparam [Repository] repository
+    def initialize(uri: nil, title: nil, **options, &block)
+      @data = options.delete(:data) || {}
+      super do
+        if block_given?
+          case block.arity
+            when 1 then block.call(self)
+            else instance_eval(&block)
+          end
+        end
+      end
+    end
+
+    ##
+    # Returns `true` if this respository supports the given `feature`.
+    #
+    # This repository supports list_terms.
+    def supports?(feature)
+      case feature.to_sym
+      when :rdfstar          then true
+      when :snapshots        then false
+      else super
+      end
+    end
+
+    ##
+    # Creates a query from the statements in this repository, turning blank nodes into non-distinguished variables. This can be used to determine if this repository is logically a subset of another repository.
+    #
+    # @return [RDF::Query]
+    def to_query
+      RDF::Query.new do |query|
+        each do |statement|
+          query.pattern RDF::Query::Pattern.from(statement, ndvars: true)
+        end
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Countable#count
+    def count
+      count = 0
+      @data.each do |_, ss|
+        ss.each do |_, ps|
+          ps.each { |_, os| count += os.size }
+        end
+      end
+      count
+    end
+    
+    ##
+    # @private
+    # @see RDF::Enumerable#has_graph?      
+    def has_graph?(graph)
+      @data.has_key?(graph)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_graph
+    def graph_names(options = nil, &block)        
+      @data.keys.reject { |g| g == DEFAULT_GRAPH }.to_a
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_graph
+    def each_graph(&block)
+      if block_given?
+        @data.each_key do |gn|
+          yield RDF::Graph.new(graph_name: (gn == DEFAULT_GRAPH ? nil : gn), data: self)
+        end
+      end
+      enum_graph
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#has_statement?
+    def has_statement?(statement)
+      has_statement_in?(@data, statement)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_statement
+    def each_statement(&block)
+      if block_given?
+        @data.each do |g, ss|
+          ss.each do |s, ps|
+            ps.each do |p, os|
+              os.each do |o, object_options|
+                yield RDF::Statement.new(s, p, o, object_options.merge(graph_name: g.equal?(DEFAULT_GRAPH) ? nil : g))
+              end
+            end
+          end
+        end
+      end
+      enum_statement
+    end
+    alias_method :each, :each_statement
+
+    ##
+    # @see Mutable#apply_changeset
+    def apply_changeset(changeset)
+      data = @data
+      changeset.deletes.each do |del|
+        if del.constant?
+          data = delete_from(data, del)
+        else
+          # we need this condition to handle wildcard statements
+          query_pattern(del) { |stmt| data = delete_from(data, stmt) }
+        end
+      end
+      changeset.inserts.each { |ins| data = insert_to(data, ins) }
+      @data = data
+    end
+
+    ##
+    # @see RDF::Dataset#isolation_level
+    def isolation_level
+      :serializable
+    end
+
+    protected
+
+    ##
+    # Match elements with `eql?`, not `==`
+    #
+    # `graph_name` of `false` matches default graph. Unbound variable matches
+    # non-false graph name.
+    #
+    # Matches terms which are native lists.
+    #
+    # @private
+    # @see RDF::Queryable#query_pattern
+    def query_pattern(pattern, **options, &block)
+      if block_given?
+        graph_name  = pattern.graph_name
+        subject     = pattern.subject
+        predicate   = pattern.predicate
+        object      = pattern.object
+
+        cs = @data.has_key?(graph_name) ? { graph_name => @data[graph_name] } : @data
+
+        cs.each do |c, ss|
+          next unless graph_name.nil? ||
+                      graph_name == DEFAULT_GRAPH && !c ||
+                      graph_name.eql?(c)
+
+          ss = if subject.nil? || subject.is_a?(RDF::Query::Variable)
+            ss
+          elsif subject.is_a?(RDF::Query::Pattern)
+            # Match subjects which are statements matching this pattern
+            ss.keys.select {|s| s.statement? && subject.eql?(s)}.inject({}) do |memo, st|
+              memo.merge(st => ss[st])
+            end
+          elsif ss.has_key?(subject)
+            { subject => ss[subject] }
+          else
+            []
+          end
+          ss.each do |s, ps|
+            ps = if predicate.nil? || predicate.is_a?(RDF::Query::Variable)
+              ps
+            elsif ps.has_key?(predicate)
+              { predicate => ps[predicate] }
+            else
+              []
+            end
+            ps.each do |p, os|
+              os.each do |o, object_options|
+                next unless object.nil? || object.eql?(o)
+                yield RDF::Statement.new(s, p, o, object_options.merge(graph_name: c.equal?(DEFAULT_GRAPH) ? nil : c))
+              end
+            end
+          end
+        end
+      else
+        enum_for(:query_pattern, pattern, **options)
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#insert
+    def insert_statement(statement)
+      @data = insert_to(@data, statement)
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#delete
+    def delete_statement(statement)
+      @data = delete_from(@data, statement)
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#clear
+    def clear_statements
+      @data = @data.clear
+    end
+
+    ##
+    # @private
+    # @return [Hash]
+    def data
+      @data
+    end
+
+    ##
+    # @private
+    # @return [Hash]
+    def data=(hash)
+      @data = hash
+    end
+
+    private
+
+    ##
+    # @private
+    # @see #has_statement
+    def has_statement_in?(data, statement)
+      s, p, o, g = statement.to_quad
+      g ||= DEFAULT_GRAPH
+
+      data.has_key?(g) &&
+        data[g].has_key?(s) &&
+        data[g][s].has_key?(p) &&
+        data[g][s][p].has_key?(o)
+    end
+
+    ##
+    # @private
+    # @return [Hash] a new, updated hash 
+    def insert_to(data, statement)
+      raise ArgumentError, "Statement #{statement.inspect} is incomplete" if statement.incomplete?
+
+      unless has_statement_in?(data, statement)
+        s, p, o, c = statement.to_quad
+        c ||= DEFAULT_GRAPH
+
+        data          = data.has_key?(c)       ? data.dup       : data.merge(c => {})
+        data[c]       = data[c].has_key?(s)    ? data[c].dup    : data[c].merge(s => {})
+        data[c][s]    = data[c][s].has_key?(p) ? data[c][s].dup : data[c][s].merge(p => {})
+        data[c][s][p] = data[c][s][p].merge(o => statement.options)
+      end
+      data
+    end
+    
+    ##
+    # @private
+    # @return [Hash] a new, updated hash 
+    def delete_from(data, statement)
+      if has_statement_in?(data, statement)
+        s, p, o, g = statement.to_quad
+        g = DEFAULT_GRAPH unless supports?(:graph_name)
+        g ||= DEFAULT_GRAPH
+
+        os   = data[g][s][p].dup.delete(o)
+        ps   = os.empty? ? data[g][s].dup.delete_if {|k,v| k == p} : data[g][s].merge(p => os)
+        ss   = ps.empty? ? data[g].dup.delete_if    {|k,v| k == s} : data[g].merge(s => ps)
+        return ss.empty? ? data.dup.delete_if       {|k,v| k == g} : data.merge(g => ss)
+      end
+      data
+    end
+
+    module VERSION
+      VERSION_FILE = File.expand_path("../../../VERSION", __FILE__)
+      MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+      STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+      ##
+      # @return [String]
+      def self.to_s()   STRING end
+
+      ##
+      # @return [String]
+      def self.to_str() STRING end
+
+      ##
+      # @return [Array(Integer, Integer, Integer)]
+      def self.to_a() STRING.split(".") end
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: rdf-ordered-repo
+version: !ruby/object:Gem::Version
+  version: 3.1.0
+platform: ruby
+authors:
+- Gregg Kellogg
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+description: An in-memory implementation of RDF::Repository using native Ruby Hashes
+  having insert-order preserving properties.
+email: public-rdf-ruby@w3.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- README.md
+- UNLICENSE
+- VERSION
+- etc/doap.ttl
+- lib/rdf/ordered_repo.rb
+homepage: https://github.com/ruby-rdf/rdf-ordered-repo
+licenses:
+- Unlicense
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.3
+signing_key:
+specification_version: 4
+summary: An order-preserving repository for RDF.rb.
+test_files: []