amigo 0.1.0

data/History.rdoc

@@ -0,0 +1,3 @@
+=== 0.1.0 / 2010-05-14
+
+* Initial version

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Simon Harris
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.rdoc

@@ -0,0 +1,20 @@
+= Amigo - In-memory triple store
+
+  GitHub:     http://github.com/harukizaemon/amigo
+  Gemcutter:  http://gemcutter/gems/amigo
+  email:      haruki.zaemon@gmail.com
+  IRC:        #haruki_zaemon on freenode
+
+== Introduction
+
+== Installation
+
+Amigo is distributed as a gem via gemcutter (http://gemcutter.org/gems/amigo) or as source via GitHub (http://github.com/harukizaemon/amigo).
+
+Installation via the gem is easy:
+
+  > gem install amigo
+
+Once installed, all that remains is to make the classes available in your code:
+
+  require 'amigo'

data/Rakefile

@@ -0,0 +1,5 @@
+Dir[File.expand_path("tasks/**/*.rb")].each do |task_file|
+  require task_file
+end
+
+task :default => [ :spec ]

data/lib/amigo.rb

@@ -0,0 +1,4 @@
+require 'amigo/triple'
+require 'amigo/store'
+require 'amigo/select'
+require 'amigo/version'

data/lib/amigo/core_ext.rb

@@ -0,0 +1 @@
+require 'amigo/core_ext/object'

data/lib/amigo/core_ext/object.rb

@@ -0,0 +1,21 @@
+module Amigo
+
+  module CoreExt
+
+    module Object
+
+      def to_ntriple
+        inspect
+      end
+
+    end
+
+  end
+
+end
+
+class Object
+
+  include Amigo::CoreExt::Object
+
+end

data/lib/amigo/initial_result.rb

@@ -0,0 +1,31 @@
+require 'hamster/immutable'
+require 'hamster/set'
+require 'hamster/hash'
+
+require 'amigo/solution'
+require 'amigo/join_result'
+
+module Amigo
+
+  class InitialResult
+
+    include Hamster::Immutable
+
+    SOLUTIONS = Hamster.set(Solution.new(Hamster.set, Hamster.hash))
+
+    def initialize(variables, triples)
+      @variables = variables
+      @triples = triples
+    end
+
+    def add(where)
+      JoinResult.new(@variables, @triples, where.select(@triples))
+    end
+
+    def solutions
+      SOLUTIONS
+    end
+
+  end
+
+end

data/lib/amigo/join_result.rb

@@ -0,0 +1,27 @@
+require 'hamster/immutable'
+
+require 'amigo/solution'
+
+module Amigo
+
+  class JoinResult
+
+    include Hamster::Immutable
+
+    def initialize(variables, triples, rows)
+      @variables = variables
+      @triples = triples
+      @rows = rows
+    end
+
+    def add(where)
+      transform { @rows = where.join(@triples, @rows) }
+    end
+
+    def solutions
+      @rows.map { |row| Solution.new(@variables, row) }
+    end
+
+  end
+
+end

data/lib/amigo/select.rb

@@ -0,0 +1,55 @@
+require 'hamster/immutable'
+require 'hamster/list'
+
+require 'amigo/variables'
+require 'amigo/where'
+require 'amigo/initial_result'
+require 'amigo/join_result'
+require 'amigo/solution'
+
+module Amigo
+
+  class Select
+
+    include Hamster::Immutable
+
+    def initialize(first_variable, *other_variables)
+      @variables = Variables.new(first_variable, *other_variables)
+      @where_clauses = Hamster.list
+    end
+
+    def where(subject, predicate, object)
+      transform {
+        @where_clauses = @where_clauses.cons(Where.new(subject, predicate, object))
+      }
+    end
+
+    def from(store)
+      store.execute(self)
+    end
+
+    def execute(triples)
+      @where_clauses.
+        reduce(InitialResult.new(@variables, triples), &:add).
+        solutions
+    end
+
+    def to_sparql
+      "SELECT #{@variables.to_sparql} WHERE {#{@where_clauses.reverse.map(&:to_sparql).join(" ")}}"
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      other.class.equal?(self.class) &&
+        @variables.eql?(other.instance_variable_get(:@variables)) &&
+        @where_clauses.eql?(other.instance_variable_get(:@where_clauses))
+    end
+    alias_method :==, :eql?
+
+    def hash
+      @variables.hash ^ @where_clauses.hash
+    end
+
+  end
+
+end

data/lib/amigo/solution.rb

@@ -0,0 +1,44 @@
+require 'hamster/immutable'
+
+module Amigo
+
+  class Solution
+
+    include Hamster::Immutable
+
+    def initialize(variables, row)
+      @variables = variables
+      @row = row
+    end
+
+    def include?(name)
+      @variables.include?(name)
+    end
+
+    def [](name)
+      return @row[name] if include?(name)
+      raise NameError, "#{name} not found"
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      other.class.equal?(self.class) &&
+        @variables.eql?(other.instance_variable_get(:@variables)) &&
+        @row.eql?(other.instance_variable_get(:@row))
+    end
+    alias_method :==, :eql?
+
+    def hash
+      @variables.hash ^ @row.hash
+    end
+
+    private
+
+    def method_missing(name, *args, &block)
+      return self[name] if args.empty? && !block_given?
+      super
+    end
+
+  end
+
+end

data/lib/amigo/store.rb

@@ -0,0 +1,44 @@
+require 'hamster/immutable'
+require 'hamster/set'
+require 'amigo/triple'
+
+module Amigo
+
+  def self.store
+    EmptyStore
+  end
+
+  class Store
+
+    include Hamster::Immutable
+
+    def initialize
+      @triples = Hamster.set
+    end
+
+    def add(subject, predicate, object)
+      triple = Triple.new(subject, predicate, object)
+      return self if @triples.include?(triple)
+      transform { @triples = @triples.add(triple) }
+    end
+
+    def execute(query)
+      query.execute(@triples)
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      other.class.equal?(self.class) &&
+        @triples.eql?(other.instance_variable_get(:@triples))
+    end
+    alias_method :==,:eql?
+
+    def hash
+      @triples.hash
+    end
+
+  end
+
+  EmptyStore = Store.new
+
+end

data/lib/amigo/term.rb

@@ -0,0 +1,44 @@
+require 'hamster/immutable'
+
+module Amigo
+
+  class Term
+
+    include Hamster::Immutable
+
+    def initialize(component, value)
+      @component = component
+      @value = value
+    end
+
+    def select?(statement)
+      @value === statement.send(@component)
+    end
+
+    def bind(statement, row)
+      row
+    end
+
+    def join?(statement, row)
+      true
+    end
+
+    def to_sparql
+      @value.inspect
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      other.class.equal?(self.class) &&
+        @component.eql?(other.instance_variable_get(:@component)) &&
+        @value.eql?(other.instance_variable_get(:@value))
+    end
+    alias_method :==, :eql?
+
+    def hash
+      @component.hash ^ @value.hash
+    end
+
+  end
+
+end

data/lib/amigo/triple.rb

@@ -0,0 +1,45 @@
+require 'hamster/immutable'
+require 'amigo/core_ext'
+
+module Amigo
+
+  class Triple
+
+    include Hamster::Immutable
+
+    attr_reader :subject, :predicate, :object
+
+    def initialize(subject, predicate, object)
+      @subject = subject
+      @predicate = predicate
+      @object = object
+    end
+
+    def to_ntriple
+      "#{[@subject, @predicate, @object].map(&:to_ntriple).join(" ")} ."
+    end
+
+    def inspect
+      to_ntriple
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      return other.class.equal?(self.class) &&
+        other.subject == self.subject &&
+        other.predicate == self.predicate &&
+        other.object == self.object
+    end
+    alias_method :==, :eql?
+
+    def hash
+      subject.hash ^ predicate.hash ^ object.hash
+    end
+
+    def <=>(other)
+      [subject, predicate, object] <=> [other.subject, other.predicate, other.object]
+    end
+
+  end
+
+end

data/lib/amigo/uri.rb

@@ -0,0 +1,38 @@
+require 'hamster/immutable'
+
+module Amigo
+
+  class URI
+
+    include Hamster::Immutable
+
+    class << self
+      alias_method :parse, :new
+    end
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def to_sparql
+      to_ntriple
+    end
+
+    def to_ntriple
+      "<#{@uri}>"
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      other.class.equal?(self.class) &&
+        @uri.eql?(other.instance_variable_get(:@uri))
+    end
+    alias_method :==, :eql?
+
+    def hash
+      @uri.hash
+    end
+
+  end
+
+end

data/lib/amigo/variable.rb

@@ -0,0 +1,45 @@
+require 'hamster/immutable'
+
+module Amigo
+
+  class Variable
+
+    include Hamster::Immutable
+
+    def initialize(component, name)
+      @component = component
+      @name = name
+    end
+
+    def select?(statement)
+      true
+    end
+
+    def bind(statement, row)
+      row.put(@name, statement.send(@component))
+    end
+
+    def join?(statement, row)
+      return true unless row.has_key?(@name)
+      statement.send(@component) == row[@name]
+    end
+
+    def to_sparql
+      "?#{@name}"
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      other.class.equal?(self.class) &&
+        @component.eql?(other.instance_variable_get(:@component)) &&
+        @name.eql?(other.instance_variable_get(:@name))
+    end
+    alias_method :==, :eql?
+
+    def hash
+      @component.hash ^ @name.hash
+    end
+
+  end
+
+end