rdf-aggregate-repo 0.0.1

data/AUTHORS

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

data/README.md

@@ -0,0 +1,66 @@
+# RDF::AggregateRepo
+
+An aggregate RDF::Repository supporting a subset of named graphs and zero or more named graphs mapped to the default graph.
+
+[![Gem Version](https://badge.fury.io/rb/rdf-aggregate-repo.png)](http://badge.fury.io/rb/rdf-aggregate-repo)
+[![Build Status](https://travis-ci.org/ruby-rdf/rdf-aggregate-repo.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-aggregate-repo)
+
+## Description
+
+Maps named graphs from one or more `RDF::Queryable` instances into a single object, allowing a specific set of _named graphs_ to be seen, as well as a _default graph_ made up from one or more _named graphs_. This is used to implement [SPARQL Datasets][].
+
+## Examples
+
+    require 'rdf'
+    require 'rdf/nquads'
+    repo = RDF::Repository.load("http://ruby-rdf.github.com/rdf/etc/doap.nq")
+    
+    # Instantiate a new aggregate repo based on an existing repo
+    aggregate = RDF::AggregateRepo.new(repo)
+    
+    # Use the default graph from the repo as the default graph of the aggregate
+    aggregate.add_default(false)
+    
+    # Use a single named graph
+    aggregate.add_named(RDF::URI("http://greggkellogg.net/foaf#me"))
+
+    # Retrieve all contexts
+    aggreggate.contexts.to_a #=> [RDF::URI("http://greggkellogg.net/foaf#me")]
+
+## Dependencies
+
+* [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
+* [RDF.rb][] (>= 1.0)
+
+## Mailing List
+
+* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Author
+
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://kellogg-assoc.com/>
+
+## Contributing
+
+* 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 <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[RDF.rb]:           http://ruby-rdf.github.com/
+[SPARQL Datasets]:  http://www.w3.org/TR/sparql11-query/#rdfDataset

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 <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/etc/doap.ttl

@@ -0,0 +1,33 @@
+@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 earl: <http://www.w3.org/ns/earl#> .
+@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#> .
+
+<http://rubygems.org/gems/rdf-turtle> a doap:Project, earl:Software ;
+  doap:name          "RDF::AggregateRepo" ;
+  doap:homepage      <http://ruby-rdf.github.com/rdf-aggregate-repo> ;
+  doap:license       <http://creativecommons.org/licenses/publicdomain/> ;
+  doap:shortdesc     "An aggregate RDF::Repository supporting a subset of named graphs and zero or more named graphs mapped to the default graph."@en ;
+  doap:description   "A gem extending RDF.rb with SPARQL dataset construction semantics."@en ;
+  doap:created       "2013-04-26"^^xsd:date ;
+  doap:programming-language "Ruby" ;
+  doap:implements    <http://www.w3.org/TR/sparql11-query/#specifyingDataset> ;
+  doap:category      <http://dbpedia.org/resource/Resource_Description_Framework>,
+                     <http://dbpedia.org/resource/Ruby_(programming_language)> ;
+  doap:download-page <http://rubygems.org/gems/rdf-aggregate-repo> ;
+  doap:mailing-list  <http://lists.w3.org/Archives/Public/public-rdf-ruby/> ;
+  doap:bug-database  <http://github.com/ruby-rdf/rdf-aggregate-repo/issues> ;
+  doap:blog          <http://greggkellogg.net/> ;
+  doap:developer     <http://greggkellogg.net/foaf#me> ;
+  doap:maintainer    <http://greggkellogg.net/foaf#me> ;
+  doap:documenter    <http://greggkellogg.net/foaf#me> ;
+  foaf:maker         <http://greggkellogg.net/foaf#me> ;
+  dc:title           "RDF::AggregateRepo" ;
+  dc:description     "A gem extending RDF.rb with SPARQL dataset construction semantics."@en ;
+  dc:date            "2013-04-26"^^xsd:date ;
+  dc:creator         <http://greggkellogg.net/foaf#me> ;
+  dc:isPartOf        <http://rubygems.org/gems/rdf> .

data/lib/rdf/aggregate_repo.rb

@@ -0,0 +1,244 @@
+require 'rdf'
+
+module RDF
+  autoload :MergeGraph, 'rdf/aggregate_repo/merge_graph'
+  autoload :VERSION, 'rdf/aggregate_repo/version'
+
+  ##
+  # An aggregated RDF repository.
+  #
+  # Aggregates the default and named graphs from one or more instances
+  # implementing RDF::Queryable. By default, the aggregate projects
+  # no default or named graphs, which must be added explicitly.
+  #
+  # Adding the existing default graph (identified with the name `false`)
+  # adds the merge of all default graphs from the specified `queryable`
+  # instances.
+  #
+  # Adding a named graph, adds the last graph found having that name
+  # from the specified `queryable` instances.
+  #
+  # Updating a previously non-existing named graph, appends to the last source. Updating the default graph updates to the merge of the graphs.
+  #
+  # @example Constructing an aggregate with arguments
+  #   aggregate = RDF::AggregateRepo.new(repo1, repo2)
+  #
+  # @example Constructing an aggregate with closure
+  #   aggregate = RDF::AggregateRepo.new do
+  #     source repo1
+  #     source repo2
+  #     default false
+  #     named   RDF::URI("http://example/")
+  #     named   RDF::URI("http://other/")
+  #   end
+  #
+  # @todo Allow graph names to reassigned with queryable
+  class AggregateRepo < RDF::Repository
+    ##
+    # The set of aggregated `queryable` instances included in this aggregate
+    #
+    # @return [Array<RDF::Queryable>]
+    attr_reader :sources
+
+    ##
+    # Names of the named graphs making up the default graph, or
+    # false, if it is made up from the merger of all default
+    # graphs
+    #
+    # @return [Array<RDF::URI, false>]
+    attr_reader :defaults
+
+    ##
+    # Create a new aggregation instance.
+    #
+    # @overload initialize(queryable = [], options = {})
+    #   @param [Array<RDF::Queryable>] queryable ([])
+    #   @param [Hash{Symbol => Object}] options ({})
+    #   @yield aggregation
+    #   @yieldparam [RDF::AggregateRepo] aggregation
+    #   @yieldreturn [void] ignored
+    def initialize(*queryable, &block)
+      @options = queryable.last.is_a?(Hash) ? queryable.last.dup : {}
+      
+      @sources = queryable
+      @defaults = []
+      @contexts = []
+
+      if block_given?
+        case block.arity
+        when 1 then block.call(self)
+        else instance_eval(&block)
+        end
+      end
+    end
+
+    ##
+    # Add a queryable to the set of constituent queryable instances
+    #
+    # @param [RDF::Queryable] queryable
+    # @return [RDF::AggregateRepo] self
+    def source(queryable)
+      @sources << queryable
+      @default_graph = nil
+      self
+    end
+    alias_method :add, :source
+
+    ##
+    # Set the default graph based on zero or more
+    # named graphs, or the merge of all default graphs if `false`
+    #
+    # @param [Array<RDF::Resource>, false] names
+    # @return [RDF::AggregateRepo] self
+    def default(*names)
+      if names.any? {|n| n == false} && names.length > 1
+        raise ArgumentError, "If using merge of default graphs, there can be only one"
+      end
+      @default_graph = nil
+      @defaults = names
+    end
+
+    ##
+    # Add a named graph projection. Dynamically binds to the
+    # last `queryable` having a matching context.
+    #
+    # @param [RDF::Resource] name
+    # @return [RDF::AggregateRepo] self
+    def named(name)
+      raise ArgumentError, "name must be an RDF::Resource: #{name.inspect}" unless name.is_a?(RDF::Resource)
+      raise ArgumentError, "name does not exist in loaded sources" unless sources.any?{|s| s.has_context?(name)}
+      @contexts << name
+    end
+
+    # Repository overrides
+
+    ##
+    # Not writable
+    #
+    # @return [false]
+    def writable?; false; end
+
+    ##
+    # @private
+    # @see RDF::Durable#durable?
+    def durable?
+      sources.all?(&:durable?)
+    end
+
+    ##
+    # @private
+    # @see RDF::Countable#empty?
+    def empty?
+      count == 0
+    end
+
+    ##
+    # @private
+    # @see RDF::Countable#count
+    def count
+      each_graph.to_a.reduce(0) {|memo, g| memo += g.count}
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#has_statement?
+    def has_statement?(statement)
+      each_graph.to_a.any? {|g| g.has_statement?(statement)}
+    end
+
+    ##
+    # @private
+    # @see RDF::Repository#each_statement
+    # @see RDF::Enumerable#each_statement
+    def each_statement(&block)
+      if block_given?
+        # Invoke {#each} in the containing class:
+        each(&block)
+      end
+      enum_statement
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each
+    def each(&block)
+      if block_given?
+        each_graph {|g| g.each(&block)}
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#has_context?
+    def has_context?(value)
+      @contexts.include?(value)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_context
+    def each_context(&block)
+      if block_given?
+        @contexts.each(&block)
+      end
+      enum_context
+    end
+
+
+    ##
+    # Iterate over each graph, in order, finding named graphs from the most recently added `source`.
+    #
+    # @see RDF::Enumerable#each_graph
+    def each_graph(&block)
+      if block_given?
+        block.call(default_graph)
+
+        # Send context from appropriate source
+        each_context do |context|
+          source  = sources.reverse.detect {|s| s.has_context?(context)}
+          block.call(RDF::Graph.new(context, :data => source))
+        end
+      end
+      enum_graph
+    end
+
+  protected
+
+    ##
+    def query_pattern(pattern, &block)
+    end
+
+    ##
+    # Default graph of this aggregate, either a projection of the source
+    # default graph (if `false`), a particular named graph from the
+    # last source in which it appears, or a MergeGraph composed of the
+    # graphs which compose it.
+    #
+    # @return [RDF::Graph]
+    def default_graph
+      @default_graph ||= begin
+        case
+        when sources.length == 0 || defaults.length == 0
+          RDF::Graph.new
+        when defaults.length == 1 && sources.length == 1
+          RDF::Graph.new((defaults.first || nil), :data => sources.first)
+        else
+          # Otherwise, create a MergeGraph from the set of pairs of source and context
+          RDF::MergeGraph.new(:name => nil) do
+            if defaults == [false]
+              sources.each do |s|
+                # Add default graph from each source
+                source s, false
+              end
+            else
+              each_context do |context|
+                # add the named graph
+                source sources.reverse.detect {|s| s.has_context?(context)}, context
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdf/aggregate_repo/merge_graph.rb

@@ -0,0 +1,196 @@
+require 'rdf'
+
+module RDF
+  ##
+  # A Merged graph.
+  #
+  # Implements a merged graph, containing statements from one or more source graphs. This is done through lazy evaluation of the sources, so that a copy of each source isn't required.
+  #
+  # This class can also be used to change the context (graph name) of triples from the name used in the source.
+  #
+  # @example Constructing a merge with arguments
+  #   aggregate = RDF::AggregateRepo.new(repo1, repo2)
+  #
+  # @example Constructing an aggregate with closure
+  #   aggregate = RDF::MergeGraph.new do
+  #     source graph1, context1
+  #     source graph2, context2
+  #     name false
+  #   end
+  #
+  # @see http://www.w3.org/TR/rdf11-mt/#dfn-merge
+  class MergeGraph
+    include RDF::Value
+    include RDF::Countable
+    include RDF::Enumerable
+    include RDF::Queryable
+
+    ##
+    # The set of aggregated `queryable` instances included in this aggregate
+    #
+    # @return [Array<Array<(RDF::Queryable, RDF::Resource)>>]
+    attr_reader :sources
+
+    ##
+    # Name of this graph, used for setting the context on returned `Statements`.
+    #
+    # @return [Array<RDF::URI, false>]
+    attr_reader :context
+
+    ##
+    # Create a new aggregation instance.
+    #
+    # @overload initialize(queryable = [], options = {})
+    #   @param [Hash{Symbol => Object}] options ({})
+    #   @option options [RDF::Resource] :context
+    #   @option options [RDF::Resource] :name alias for :context
+    #   @yield merger
+    #   @yieldparam [RDF::MergeGraph] self
+    #   @yieldreturn [void] ignored
+    def initialize(options = {}, &block)
+      @sources = []
+      @context = options[:context] || options[:name]
+
+      if block_given?
+        case block.arity
+        when 1 then block.call(self)
+        else instance_eval(&block)
+        end
+      end
+    end
+
+
+    ##
+    # Returns `true` to indicate that this is a graph.
+    #
+    # @return [Boolean]
+    def graph?
+      true
+    end
+
+    ##
+    # Returns `true` if this is a named graph.
+    #
+    # @return [Boolean]
+    # @note The next release, graphs will not be named, this will return false
+    def named?
+      !unnamed?
+    end
+
+    ##
+    # Returns `true` if this is a unnamed graph.
+    #
+    # @return [Boolean]
+    # @note The next release, graphs will not be named, this will return true
+    def unnamed?
+      @context.nil?
+    end
+
+    ##
+    # MergeGraph is writable if any source is writable. Updates go to the last writable source.
+    #
+    # @return [Boolean]
+    def writable?; sources.any?(&:writable?); end
+
+    ##
+    # Add a queryable to the set of constituent queryable instances
+    #
+    # @param [RDF::Queryable] queryable
+    # @return [RDF::MergeGraph] self
+    def source(queryable, context)
+      @sources << [queryable, context]
+      self
+    end
+    alias_method :add, :source
+
+    ##
+    # Set the context for statements in this graph
+    #
+    # @param [RDF::Resource, false] name
+    # @return [RDF::MergeGraph] self
+    def name(name)
+      @context = name
+      self
+    end
+
+    # Repository overrides
+
+    ##
+    # @private
+    # @see RDF::Durable#durable?
+    def durable?
+      sources.all?(&:durable?)
+    end
+
+    ##
+    # @private
+    # @see RDF::Countable#empty?
+    def empty?
+      count == 0
+    end
+
+    ##
+    # @private
+    # @see RDF::Countable#count
+    def count
+      each_statement.to_a.length
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#has_statement?
+    def has_statement?(statement)
+      sources.any? do |(source, ctx)|
+        statement = statement.dup
+        statement.context = ctx
+        source.has_statement?(statement)
+      end
+    end
+
+    ##
+    # @see RDF::Enumerable#each_statement
+    def each(&block)
+      # Add everything to a new graph for de-duplication
+      tmp = RDF::Graph.new(@context)
+      sources.each do |(source, ctx)|
+        tmp << RDF::Graph.new(ctx || nil, :data => source)
+      end
+      tmp.each(&block)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#has_context?
+    def has_context?(value)
+      @context == value
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_context
+    def each_context(&block)
+      if block_given?
+        block.call(context) if context
+      end
+      enum_context
+    end
+
+
+    ##
+    # Iterate over each graph, in order, finding named graphs from the most recently added `source`.
+    #
+    # @see RDF::Enumerable#each_graph
+    def each_graph(&block)
+      if block_given?
+        block.call(self)
+      end
+      enum_graph
+    end
+
+  protected
+
+    ##
+    def query_pattern(pattern, &block)
+    end
+  end
+end

data/lib/rdf/aggregate_repo/version.rb

@@ -0,0 +1,18 @@
+module RDF::Turtle::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  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

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: rdf-aggregate-repo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gregg Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: A gem extending RDF.rb with SPARQL dataset construction semantics.
+email: public-rdf-ruby@w3.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- README.md
+- UNLICENSE
+- VERSION
+- etc/doap.ttl
+- lib/rdf/aggregate_repo/merge_graph.rb
+- lib/rdf/aggregate_repo/version.rb
+- lib/rdf/aggregate_repo.rb
+homepage: http://ruby-rdf.github.com/rdf-aggregate-repo
+licenses:
+- Public Domain
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2958421905290465049
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: An aggregate RDF::Repository supporting a subset of named graphs and zero
+  or more named graphs mapped to the default graph.
+test_files: []
+has_rdoc: false