rdf-sparql 0.0.2

data/UNLICENSE

@@ -0,0 +1,25 @@
+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, contact Alex Serebryakov [serebryakov@gmail.com]
+or visit <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/lib/common.rb

@@ -0,0 +1,106 @@
+module RDF
+  module SPARQL
+    module Common
+
+      ##
+      # Yields each statement of SPARQL query
+      # @yield  [statement]
+      # @yieldparam [Statement]
+      # @return [Reader]
+      ##
+      def each_statement(&block)
+        @graph.each_statement { |statement| block.call(statement) }
+        self
+      end
+
+      ##
+      # Yields each triple of SPARQL query
+      # @yield  [triple]
+      # @yieldparam [Array(Value)]
+      # @return [Reader]
+      ##
+      def each_triple(&block)
+        @graph.each_triple { |*triple| block.call(*triple) }
+        self
+      end
+
+      ##
+      # Yields each target variable in SPARQL query
+      # @yield  [variable]
+      # @yieldparam [Variable]
+      # @return [Reader]
+      ##
+      def each_target(&block)
+        @targets.each { |target| block.call(target) }
+        self
+      end
+
+      ##
+      # Yields each variable in SPARQL query
+      # @yield  [variable]
+      # @yieldparam [Variable]
+      # @return [Reader]
+      ##
+      def each_variable(&block)
+        variables.each { |variable| block.call(variable) }
+        self
+      end
+
+      ##
+      # [-]
+      ##
+      def targets
+        @targets
+      end
+      
+      ##
+      # [-]
+      ##
+      def statements
+        @graph.statements
+      end
+
+      ##
+      # [-]
+      ##
+      def triples
+        @graph.triples
+      end
+
+      ##
+      # [-]
+      ##
+      def variables
+        Hash[@graph.map { |pattern|
+          pattern.variables.values
+        }.flatten.uniq.map { |variable|
+          [variable.name, variable]
+        }]
+      end
+
+      ##
+      # [-]
+      ##
+      def type
+        @type || @options[:type]
+      end
+      
+      ##
+      # Check whether `distinct` flag was specified
+      # @return [Boolean]
+      ##
+      def distinct?
+        @options[:distinct] == true
+      end
+
+      ##
+      # Check whether `reduced` flag was specified
+      # @return [Boolean]
+      ##
+      def reduced?
+        @options[:reduced] == true
+      end
+
+    end # Common
+  end # SPARQL
+end # RDF

data/lib/lib/extensions/variable.rb

@@ -0,0 +1,69 @@
+class RDF::Query
+  class Variable
+    
+    attr_reader :modifier
+
+    def initialize(name = nil, value = nil)
+      name = 'v%s' % rand(100000) if name.nil?    
+      @name, @values = name.to_sym, []
+      @strict = true
+      bind(value) unless value.nil?
+    end
+    
+    def unbound?
+      @values.empty?
+    end
+    
+    def literal?
+      value.class == String && values.length == 1 && modifier == "="
+    end
+    
+    def value
+      @values.first.nil? ? nil : @values.first.last
+    end
+    
+    def values
+      @values.dup
+    end
+    
+    def bind(value, modifier = "=", strict = true)
+      value = if value.respond_to?(:object)
+        value.object
+      else
+        value
+      end
+
+      @modifier = case modifier
+        when :eq then "="
+        when :nq then "!="
+        when :lt then "<"
+        when :lte then "<="
+        when :gt then ">"
+        when :gte then ">="
+        else modifier
+      end
+      
+      @strict = strict
+      add(value, modifier)
+    end
+    
+    def strict?
+      @strict
+    end
+
+    def to_s
+      unbound? ? "?#{name}" : "#{name}#{modifier}#{value}"
+    end
+    
+    private
+    
+    def add(value, modifier)
+      new_value = [modifier, value]
+      unless @values.include?(new_value)
+        @values << new_value
+      end
+      @values.last
+    end
+    
+  end
+end

data/lib/lib/format.rb

@@ -0,0 +1,11 @@
+module RDF::SPARQL
+
+  class Format < RDF::Format
+    content_type     'application/sparql', :extension => :sparql
+    content_encoding 'utf-8'
+
+    reader { RDF::SPARQL::Reader }
+    writer { RDF::SPARQL::Writer }
+
+  end
+end

data/lib/lib/reader.rb

@@ -0,0 +1,291 @@
+module RDF::SPARQL
+  class Reader < RDF::Reader
+
+    include RDF::SPARQL::Common
+    format RDF::SPARQL::Format
+    
+    ##
+    # @param  [IO, File, String] input
+    # @yield  [reader]
+    # @yieldparam [Reader] reader
+    ##
+    def initialize(input = $stdin, options = {}, &block)
+      @line = input.respond_to?(:read) ? input.read : input
+      @graph = RDF::Graph.new
+      @type = nil
+      @prefixes = {}
+      @variables = {}
+      @targets = []
+      @options = {}
+      read_query
+      block.call(self) if block_given?
+    end
+    
+    private
+    
+      
+    ##
+    # Reads prologue of SPARQL query (prefixes and targets)
+    ##
+    def read_prologue
+      while (read_prefix || read_target); end
+    end
+    
+    ##
+    # Reads next `PREFIX`
+    ##
+    def read_prefix
+      full, ns, uri = match(/\s*PREFIX\s+([a-z]+):\s+<([^>]+)>/)
+      full.nil? ? nil : add_prefix(ns, uri)
+    end
+    
+    ##
+    # Reads targets of SPARQL query
+    ##
+    def read_target
+      read_select_target || read_describe_target || read_construct_target || read_ask_target
+    end
+    
+    ##
+    # Reads targets of a `SELECT` query
+    ##
+    def read_select_target
+      full, flag = match(/\s*SELECT\s+(DISTINCT|REDUCED|)\s*/)
+      return nil if full.nil?
+      case flag
+        when 'DISTINCT' then @options[:distinct] = true
+        when 'REDUCED'  then @options[:reduced] = true
+      end
+      @type = :select
+      while 
+        var = read_variable
+        var.nil? ? break : add_target(var)
+      end
+    end
+    
+    ##
+    # Reads targets of a `DESCRIBE` query
+    ##
+    def read_describe_target
+      return nil if match(/\s*DESCRIBE\s+/).nil?
+      @type = :describe
+      while
+        var = (read_variable || read_uri)
+        var.nil? ? break : add_target(var)
+      end
+    end
+    
+    ##
+    # Reads targets of a `CONSTRUCT` query
+    ##
+    def read_construct_target
+      return nil
+      @type = :construct
+    end
+    
+    ##
+    # Reads targets of an `ASK` query
+    ##
+    def read_ask_target
+      return nil
+      @type = :ask
+    end
+    
+    ##
+    # Reads all triples & filters of a query
+    ##
+    def read_where
+      full = match(/(WHERE|)\s*\{/)
+      return nil if full.nil?
+      while (read_triple || read_filter); end
+    end
+    
+    ##
+    # Main parser loop: reads prologue, conditions and epilogue
+    ##
+    def read_query #nodoc
+      while (read_prologue || read_where || read_epilogue); end
+    end
+    
+    ##
+    # Reads a triple
+    ##
+    def read_triple
+      shortcut =    read_triple_ending
+      @subject =    (read_variable || read_uri)   if shortcut == '.'
+      @predicate =  (read_variable || read_uri)   if shortcut != ','
+      @object =     (read_variable || read_uri || read_literal)
+      return nil if @subject.nil?
+      add_triple(@subject, @predicate, @object)
+    end
+    
+    ##
+    # Finds any formatting shortcuts (a comma, a semicolon)
+    ##
+    def read_triple_ending
+      full, symbol = match(/\s*([\.|,|;])\s*/)
+      full.nil? ? '.' : (symbol.empty? ? '.' : symbol)
+    end
+
+    ##
+    # Reads a filter
+    ##
+    def read_filter
+      full = match(/FILTER\s*\(\s*/)
+      return nil if full.nil?
+      while (read_filter_condition || read_filter_ending); end
+    end
+    
+    ##
+    # Reads next condition specified in a filter
+    ##
+    def read_filter_condition
+      modifier =    read_filter_modifier
+      variable =    read_variable
+      comparison =  read_comparison_operator
+      value =       (read_variable || read_literal || read_numeric)
+      return nil if variable.nil?
+      variable.bind(value, comparison, (modifier != "||"))
+    end
+    
+    ##
+    # Returns filter modifier (|| or &&)
+    ##
+    def read_filter_modifier
+      full, symbols = match(/\s*(\|{2}|&{2})+\s*/)
+      full.nil? ? nil : symbols
+    end
+    
+    ##
+    # Moves pointer to the end of `FILTER` expression
+    ##
+    def read_filter_ending
+      match(/\s*\)\s*/)
+    end
+    
+    ##
+    # Returns comparison operator (> < != =)
+    ##
+    def read_comparison_operator
+      full, symbol = match(/\s*([!=|>|<|=])\s*/)
+      full.nil? ? nil : symbol
+    end
+    
+    ##
+    # Reads query epilogue (order, limit, group)
+    ##
+    def read_epilogue
+      nil
+    end
+    
+    ##
+    # Reads next `PREFIX`
+    ##
+    def read_prefix
+      full, ns, uri = match(/\s*PREFIX\s+([a-z]+):\s+<([^>]+)>/)
+      full.nil? ? nil : add_prefix(ns, uri)
+    end
+
+    ##
+    # Reads an URI (as a full URI, namespaced or RDF type shortcut)
+    ##
+    def read_uri
+      read_full_uri || read_type_shortcut || read_ns_uri
+    end
+    
+    ##
+    # Returns RDF.type if URI is an RDF type shortcut
+    ##
+    def read_type_shortcut
+      full, symbol = match(/\s*(a)\s*/)
+      full.nil? ? nil : (symbol == 'a' ? RDF.type : nil)
+    end
+    
+    ##
+    # Returns URI if this is a non-abridged URI (no shortcuts or namespaces)
+    ##
+    def read_full_uri
+      full, uri = match(/^<([^>]+)>/)
+      full.nil? ? nil : RDF::URI.new(uri)
+    end
+    
+    ##
+    # Returns URI that was namespaced in prefixes
+    ##
+    def read_ns_uri
+      full, ns, uri = match(/([a-zA-Z]+):([a-zA-Z]+)/)
+      full.nil? ? nil : RDF::URI.new(@prefixes[ns].to_s + uri)
+    end
+    
+    ##
+    # Reads a variable
+    ##
+    def read_variable
+      full, name = match(/\?([A-Za-z0-9_]+)\s*/)
+      full.nil? ? nil : add_variable(name)
+    end
+    
+    ##
+    # Reads a literal value
+    ##
+    def read_literal
+      full, string = match(/\s*"([^"]*)"/)
+      return nil if full.nil?
+      full, language = match(/@([a-z]+[\-a-z0-9]*)/)
+      if language
+        RDF::Literal.new(string, :language => language)
+      elsif match(/(\^\^)/)
+        RDF::Literal.new(string, :datatype => read_uri)
+      else
+        RDF::Literal.new(string)
+      end
+    end
+    
+    ##
+    # Reads a numeric value
+    ##
+    def read_numeric
+      full = match(/\d+/)
+      full.nil? ? nil : full.first
+    end
+
+    ##
+    # Registers a triple
+    ##
+    def add_triple(subject, predicate, object)
+      @graph << RDF::Query::Pattern.new(subject, predicate, object)
+    end
+
+    ##
+    # Registers a prefix
+    ##
+    def add_prefix(ns, uri)
+      @prefixes[ns] = uri
+    end
+    
+    ##
+    # Registers a variable
+    ##
+    def add_variable(name)
+      @variables[name] ||= RDF::Query::Variable.new(name)
+    end
+
+    ##
+    # Registers a target
+    ##
+    def add_target(var)
+      @targets << var
+    end
+    
+    ##
+    # Returns a match array
+    ##
+    def match(pattern)
+      if (@line =~ pattern) == 0
+        @line = $'.lstrip
+        Regexp.last_match.to_a
+      end
+    end
+    
+  end
+end

data/lib/lib/version.rb

@@ -0,0 +1,25 @@
+module RDF
+  module SPARQL
+    module VERSION
+      MAJOR = 0
+      MINOR = 0
+      TINY  = 2
+      EXTRA = nil
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+      STRING << "-#{EXTRA}" if EXTRA
+
+      ##
+      # @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() [MAJOR, MINOR, TINY] end
+    end
+  end
+end

data/lib/lib/writer.rb

@@ -0,0 +1,250 @@
+module RDF::SPARQL
+  class Writer < RDF::Writer
+    
+    include RDF::SPARQL::Common
+    format RDF::SPARQL::Format
+
+    ##
+    # @param  [IO, File] output
+    # @yield  [writer]
+    # @yieldparam [Writer] writer
+    ##
+    def initialize(output = $stdout, options = {}, &block)
+      @output, @options = output, options
+      @graph = RDF::Graph.new
+      @targets = []
+      if block_given?
+        block.call(self)
+        write_query
+      end
+    end
+    
+    
+    ##
+    # Stores the SPARQL representation of a triple.
+    #
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Value]    object
+    # @return [void]
+    ##
+    def write_triple(subject, predicate, object)
+      @graph << RDF::Query::Pattern.new(subject, predicate, object)
+    end
+    
+    ##
+    # @param  [Array<Array(Value)>] triples
+    def write_triples(triples)
+      triples.each { |triple| write_triple(*triple) }
+    end
+    
+    ##
+    # [-]
+    ##
+    def new_target(name_or_uri = nil)
+      @targets << case name_or_uri
+        when String     then RDF::Query::Variable.new(name_or_uri)
+        when RDF::URI   then name_or_uri
+        else            RDF::Query::Variable.new('v%s' % rand(10000))
+      end
+      @targets.last
+    end
+    
+    ##
+    # [-]
+    ##
+    def write_query
+      puts format_prologue
+      puts format_where
+      puts write_epilogue
+    end
+
+    private
+    
+    ##
+    # [-]
+    ##
+    def format_prologue
+      format_prefix
+      case type
+        when :select    then write_select_target
+        when :describe  then write_describe_target
+        when :construct then write_construct_target
+        when :ask       then write_ask_target
+      end
+    end
+    
+    ##
+    # [-]
+    ##
+    def format_prefix
+      ""
+    end
+    
+    ##
+    # [-]
+    ##
+    def write_select_target
+      "SELECT %s %s %s \n" % [
+        distinct? ? "DISTINCT" : "",
+        reduced? ? "REDUCED" : "",
+        write_targets ]
+    end
+    
+    ##
+    # [-]
+    ##
+    def write_describe_target
+      "DESCRIBE %s \n" % [
+        write_targets ]
+    end
+    
+    ##
+    # [-]
+    ##
+    def write_construct_target
+      raise NotImplementedError, '`CONSTRUCT` queries are not yet supported'
+    end
+    
+    ##
+    # [-]
+    ##
+    def write_ask_target
+      raise NotImplementedError, '`ASK` queries are not yet supported'
+    end
+    
+    ##
+    # [-]
+    ##
+    def write_targets
+      @targets.map { |target| format_value(target) }.join(' ')
+    end
+    
+    ##
+    # [-]
+    ##
+    def format_where
+      "WHERE { %s %s }" % [
+        triples.map { |triple| format_triple(*triple) }.join("\n"),
+        variables.map { |variable| format_filter(variable) }.join("\n") ]
+    end
+        
+    ##
+    # [-]
+    ##
+    def write_epilogue(options = {})
+      ""
+    end
+
+    ##
+    # Returns the SPARQL representation of a statement.
+    #
+    # @param  [RDF::Statement] statement
+    # @return [String]
+    ##
+    def format_statement(statement)
+      format_triple(*statement.to_triple)
+    end
+
+    ##
+    # Returns the SPARQL representation of a triple.
+    #
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Value]    object
+    # @return [String]
+    ##
+    def format_triple(subject, predicate, object)
+      "%s %s %s ." % [subject, predicate, object].map { |value| format_value(value) }
+    end
+
+    ##
+    # Returns the SPARQL representation of a URI reference.
+    #
+    # @param  [RDF::URI] literal
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    ##
+    def format_uri(uri, options = {})
+      "<%s>" % uri_for(uri)
+    end
+
+    ##
+    # Returns the SPARQL representation of a blank node.
+    #
+    # @param  [RDF::Node] node
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    ##
+    def format_node(node, options = {})
+      "_:%s" % node.id
+    end
+    
+    ##
+    # Returns the SPARQL representation of a variable.
+    #
+    # @param  [RDF::Variable] node
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    ##
+    def format_variable(variable, options = {})
+      if variable.literal?
+        '"%s"' % variable.value
+      else
+        "?%s" % variable.name
+      end
+    end
+    
+    ##
+    # Returns the N-Triples representation of a blank node.
+    #
+    # @param  [RDF::Node] node
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    ##
+    def format_filter(variable, options = {})
+#      "FILTER(%s %s %s)" % [format_variable(variable), variable.comparison, variable.value]
+      ""
+    end
+    
+    ##
+    # @param  [Value] value
+    # @return [String]
+    ##
+    def format_value(value, options = {})
+      case value
+        when String
+          format_literal(value, options)
+        when RDF::Literal
+          format_literal(value, options)
+        when RDF::URI
+          format_uri(value, options)
+        when RDF::Node
+          format_node(value, options)
+        when RDF::Query::Variable
+          format_variable(value, options)
+        else nil
+      end
+    end
+    
+    ##
+    # Returns the N-Triples representation of a literal.
+    #
+    # @param  [RDF::Literal, String, #to_s] literal
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    ##
+    def format_literal(literal, options = {})
+      case literal
+        when RDF::Literal
+          text = quoted(escaped(literal.value))
+          text << "@#{literal.language}" if literal.has_language?
+          text << "^^<#{uri_for(literal.datatype)}>" if literal.has_datatype?
+          text
+        else
+          quoted(escaped(literal.to_s))
+      end
+    end
+    
+  end
+end

data/lib/rdf-sparql.rb

@@ -0,0 +1,13 @@
+require 'rdf'
+
+module RDF
+  module SPARQL
+    require 'lib/format'
+    require 'lib/common'
+    require 'lib/reader'
+    require 'lib/writer'
+    require 'lib/version'
+    require 'lib/extensions/variable'
+  end
+end
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-sparql
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Alex Serebryakov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id002
+description: RDF.rb plugin for parsing / writing SPARQL queries
+email: serebryakov@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- UNLICENSE
+- VERSION
+- lib/lib/common.rb
+- lib/lib/extensions/variable.rb
+- lib/lib/format.rb
+- lib/lib/reader.rb
+- lib/lib/version.rb
+- lib/lib/writer.rb
+- lib/rdf-sparql.rb
+has_rdoc: true
+homepage: http://github.com/42cities/rdf-sparql/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rdf-sparql
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: RDF.rb plugin for parsing / writing SPARQL queries
+test_files: []
+