slender_t 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Richards
+
+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,29 @@
+= slender_t
+
+SlenderT is a triples store  It is simple for the simple jobs.  I decided to replace a recommendation engine with a set of triples and some simple query tools, and this is the result.  I didn't want to break out the bigger tools for something that will only have hundreds of triples.
+
+The ideas started with of "Programming the Semantic Web" by Toby Segaran et al.  Toby's code was in Python, and of course this is a Ruby version.  I've made quite a few changes with the query tools and using my Ruby idioms, but this is still a very simple gem.
+
+== Usage
+
+From the command line:
+
+slender_t
+>> ...
+
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 David Richards. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "slender_t"
+    gem.summary = %Q{Simple triples storage}
+    gem.description = %Q{Simple triples storage for projects too small to install an RDF database.}
+    gem.email = "david@fleetventures.com"
+    gem.homepage = "http://github.com/davidrichards/slender_t"
+    gem.authors = ["David Richards"]
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "slender_t #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/slender_t

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby -wKU
+require 'yaml'
+
+version = File.read(File.join(File.dirname(__FILE__), %w(.. VERSION)))
+st_file = File.join(File.dirname(__FILE__), %w(.. lib slender_t))
+
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+options = { :irb => irb, :without_stored_procedures => false }
+OptionParser.new do |opt|
+  opt.banner = "Usage: console [environment] [options]"
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion -r #{st_file}"
+
+puts "Loading SlenderT version: #{version}"
+
+exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/slender_t.rb

@@ -0,0 +1,161 @@
+class SlenderT
+  
+  require 'rubygems'
+  require 'open-uri'
+  require 'fastercsv'
+  
+  class << self
+    def load(source, opts={})
+      SlenderT.new(source, opts)
+    end
+  end
+  
+  attr_reader :spo, :pos, :osp
+  
+  def initialize(contents=nil, opts={})
+    @spo, @pos, @osp = {}, {}, {}
+    self.load(contents, opts) if contents
+  end
+  
+  # Expects CSV, a filename, or a URL with triples in it
+  # If there is a header in the file, use load(contents, :header => true)
+  # so that we can ignore the first line
+  # If there are special converters needed for FasterCSV to work, include them
+  # in the options as well.
+  def load(contents, opts={})
+    table = infer_csv_contents(contents, opts)
+    return nil unless contents
+    table.each do |row|
+      self.add(*row)
+    end
+  end
+  
+  def save(filename)
+    File.open(filename, 'wb') {|f| f.write self.to_csv}
+  end
+  
+  def add(subject, predicate, object)
+    add_to_index(self.spo, subject, predicate, object)
+    add_to_index(self.pos, predicate, object, subject)
+    add_to_index(self.osp, object, subject, predicate)
+    [subject, predicate, object]
+  end
+  
+  def remove(subject, predicate, object)
+    triples = find(subject, predicate, object)
+    return true unless triples
+    for s, p, o in triples do
+      self.remove_from_index(self.spo, s, p, o)
+      self.remove_from_index(self.pos, p, o, s)
+      self.remove_from_index(self.osp, o, s, p)
+    end
+    [subject, predicate, object]
+  end
+  
+  def find(subject=nil, predicate=nil, object=nil)
+    begin
+      if subject and predicate and object
+        if self.spo[subject] and self.spo[subject][predicate] and self.spo[subject][predicate].include?(object)
+          return [[subject, predicate, object]]
+        else
+          return []
+        end
+      elsif subject and predicate and object.nil?
+        return self.spo[subject][predicate].map {|o| [subject, predicate, o]}
+      elsif subject and predicate.nil? and object
+        return self.osp[object][subject].map {|p| [subject, p, object]}
+      elsif subject and predicate.nil? and object.nil?
+        return self.spo[subject].inject([]) do |list, h|
+          p, objects = h.first, h.last
+          objects.each {|o| list << [subject, p, o]}
+          list
+        end
+      elsif subject.nil? and predicate and object
+        return self.pos[predicate][object].map {|s| [s, predicate, object]}
+      elsif subject.nil? and predicate and object.nil?
+        return self.pos[predicate].inject([]) do |list, h|
+          o, subjects = h.first, h.last
+          subjects.each {|s| list << [s, predicate, o]}
+          list
+        end
+      elsif subject.nil? and predicate.nil? and object
+        self.osp[object].inject([]) do |list, h|
+          s, predicates = h.first, h.last
+          predicates.each {|p| list << [s, p, object]}
+          list
+        end
+      elsif subject.nil? and predicate.nil? and object.nil?
+        list = []
+        self.spo.each do |s, predicates|
+          predicates.each do |p, objects|
+            objects.each {|o| list << [s, p, o]}
+          end
+        end
+        list
+      end
+    rescue
+      []
+    end
+  end
+
+  def inspect
+    self.spo.keys.size > 20 ? "#{self.class}: #{self.spo.keys.size} unique subjects" : "#{self.class}: #{self.spo.keys.inspect}"
+  end
+  
+  # Just very basic for now
+  def to_csv
+    self.find.map {|row| row.join(',')}.join("\n")
+  end
+  
+  def value(subject=nil, predicate=nil, object=nil)
+    s, p, o = find(subject, predicate, object).first
+    return s unless subject
+    return p unless predicate
+    return o unless object
+    nil
+  end
+  
+  protected
+    def add_to_index(index, a, b, c)
+      if index.keys.include?(a) and index[a].keys.include?(b)
+        # TODO: May not be efficient enough
+        index[a][b] = index[a][b] | [c]
+      elsif index.keys.include?(a)
+        index[a][b] = [c]
+      else
+        index[a] = {}
+        index[a][b] = [c]
+      end
+    end
+    
+    def remove_from_index(index, a, b, c)
+      bs = index[a]
+      cset = bs[b] if bs
+      cset.delete(c) if cset
+      bs.delete(b) if cset and cset.empty?
+      index.delete(a) if bs and bs.empty?
+      true
+    end
+    
+    def infer_csv_contents(obj, opts={})
+      begin
+        contents = File.read(obj) if File.exist?(obj)
+        open(obj) {|f| contents = f.read} unless contents
+      rescue
+        nil
+      end
+      contents ||= obj if obj.is_a?(String)
+      return nil unless contents
+      table = FCSV.parse(contents, default_csv_opts.merge(opts))
+      labels = opts.fetch(:headers, false) ? table.shift : []
+      while table.last.empty?
+        table.pop
+      end
+      table
+    end
+    
+    def default_csv_opts; {:converters => :all}; end
+
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/slender_t/*.rb").each { |file| require file }