kyoto_record 0.0.1

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'directory_watcher'
+gem 'rev'
+gem 'rspec'

data/kyoto_record.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name                     = "kyoto_record"
+  s.version                  = "0.0.1"
+  s.summary                  = "Persist your classes in Kyoto Cabinet."
+  s.description              = "\"KyotoRecord\": Kyoto Cabinet wrapper for Ruby binding.  Scannable. Indexable. A programming interface made for babies."
+  s.homepage                 = "http://github.com/thirdreplicator/kyoto_record"
+  s.authors                  = ["David Beckwith"]
+  s.email                    = "thirdreplicator@gmail.com"
+  s.require_paths            = ["."] 
+  s.files                    = ["kyoto_record.rb", "kyoto_record_spec.rb", "Gemfile", "watch.rb", "kyoto_record.gemspec"]
+  s.rubyforge_project        = "nowarning"
+end

data/kyoto_record.rb

@@ -0,0 +1,218 @@
+require 'kyotocabinet'
+
+module KyotoRecord
+
+  # Refactored out this module so that it can be reused in the class 'Index'
+  #  as well as the module ClassMethds, which is directly enhancing the
+  #  user-defined data model class.
+
+  module Cabinet
+    include KyotoCabinet
+
+    def find(id)
+      value = @db.get(id)
+      if value
+        obj = Marshal.load( @db.get(id) ) 
+        obj.id = id
+        obj
+      end
+    end
+
+    def scan(start_key=nil, limit=1/0.0, &block)
+      cur = @db.cursor
+      i = 0 
+      cur.jump(start_key)
+
+      while (rec = cur.get(true)) && i < limit
+        key = rec[0]
+        if key != 'last_id'
+          i += 1
+          value = Marshal.load(rec[1])
+          block.call(value)
+        end
+      end
+      cur.disable
+    end
+
+    def scan_page(page, per_page=100, &block)
+      @recs_per_page ||= per_page
+      start_key = (page-1)*per_page + 1
+      limit = per_page
+      scan(start_key, limit, &block)
+    end
+
+    def get_attr(attr)
+      value = Marshal.load( @db.get( attr ) ) if kc.get(attr)
+      if value
+        return value
+      else
+        STDERR.printf("get error: %s\n", kc.error)
+        raise "Couldn't find value for attribute: #{attr}"
+      end
+    end
+
+    # Utilities
+    def open_db(base_name)
+      Dir.mkdir('data') if !Dir.exists?('data')
+      db = DB::new
+      unless db.open("./data/#{base_name}.kch", DB::OWRITER | DB::OCREATE)
+        STDERR.printf("open error: %s\n", db.error)
+      end
+      db
+    end
+
+    def close_db(base_name)
+      unless @db.close
+        STDERR.printf("close error: %s\n", db.error)
+      end
+    end
+    
+    # Utilities
+
+    def set(k,v)
+      @db.set(k, Marshal.dump(v))
+    end
+
+    def get(k)
+      val = @db.get(k)
+      Marshal.load(val) if val
+    end
+
+    def set_raw(k,v)
+      @db.set(k,v)
+    end
+
+    def get_raw(k)
+      @db.get(k)
+    end
+
+    def last_id
+      get_raw(:last_id).to_i
+    end
+
+    def last_id=(i)
+      set_raw(:last_id, i)
+    end
+ 
+    def class_name
+      @class_name ||= self.to_s
+    end
+  end # Cabinet
+
+  # Reuse the Cabinet module to make indexes of attributes.
+  #  Each index is a Kyoto Cabinet index.  value -> id
+  #  E.g. "David" -> 1
+  # For a "username" attribute on the class User, the index would be in
+  #  ./data/User_username.kch
+  class Index
+    include Cabinet
+    attr_reader :klass, :attr, :base_name, :db
+
+    def initialize(klass, attribute)
+      @klass = klass
+      @attr = attribute
+      @base_name = klass.to_s + "_" + attribute.to_s
+      @db = open_db(@base_name) 
+    end
+  end # class Index
+
+  module ClassMethods
+    # This is where attr_kyoto and index_kyoto go.
+    include Cabinet
+
+    def attr_kyoto( *attrs )
+      @db = open_db(class_name)
+
+      @attrs ||= {}
+      @indices ||= {} 
+
+      # Don't redefine it if it was already defined.
+      if !self.respond_to?(:id)
+        # a general setter
+        define_method :set_attr do |k, v|
+          @values[k] = v
+        end
+  
+        # a general getter
+        define_method :get_attr do |k|
+          @values[k]
+        end 
+       
+        def define_getter_and_setter(attr)
+          define_method :"#{attr}".to_s do
+            @values[attr]
+          end
+    
+          define_method :"#{attr}=".to_s do |val|
+            set_attr(attr, val)
+          end
+        end 
+
+        define_getter_and_setter(:id)
+      end # if
+
+      # In case multiple attributes were passed in, let's loop over each one.
+      attrs.each do |attr|
+        define_getter_and_setter(attr)
+      end
+    end # attr_kyoto
+
+    def index_kyoto( *attrs )
+      attrs.each do |attr|
+        @indices[attr] = Index.new(self, attr)
+        singleton = class << self; self; end
+        singleton.class_eval <<-EOM
+
+          def find_by_#{attr}(val)
+            self.find( @indices[\"#{attr}\".to_sym].get(val) )
+          end
+EOM
+      end
+    end
+
+    def indices
+      @indices
+    end
+  end # ClassMethods
+
+  ###  Instance Methods  ###
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end  
+ 
+  def initialize
+    @values ||= {}
+    super
+  end
+
+  def save
+    if !id
+      # TODO: use KyotoCabinet::DB#increment
+      id = self.class.last_id + 1
+      self.class.last_id = id
+    end
+
+    write_indices(id)
+    write_to_kyoto(id, self)
+  end
+
+  def write_indices(id)
+    self.class.indices.each do |attr, index|
+      index.set(@values[attr], id)
+    end
+  end
+
+  def write_to_kyoto(k, v)
+    set_error(k,v) unless self.class.set(k, v)
+  end
+
+  private
+
+  def set_error(k,v)
+    STDERR.printf("set error for (k,v)=(%s, %s): %s\n", k, v, kc.error)
+  end
+
+end
+
+

data/kyoto_record_spec.rb

@@ -0,0 +1,179 @@
+$: << File.dirname(__FILE__)
+
+require 'rspec'
+require 'kyoto_record'
+
+describe 'KyotoRecord module' do
+  before(:each) do
+    class A
+      include KyotoRecord
+      attr_kyoto :x
+    end
+  end
+
+  after(:each) do
+    `rm -rf ./data`
+  end
+
+  it "should have a database even if no instances were saved" do
+    File.exist?('./data/A.kch').should be_true
+  end
+
+  it "should retrieve 3 if 3 was saved into a kyoto attribute" do
+    @a = A.new
+    @a.x = 3
+    @a.save
+    A.find(1).should be_an_instance_of(A)
+  end
+
+  it "should retrieve 3 if 3 was saved into a kyoto attribute" do
+    @a = A.new
+    @a.x = 3
+    @a.save
+    A.find(1).x.should == 3
+  end
+
+  it "should retrieve a symbol :abc if the symbol :abc was saved" do
+    @a = A.new
+    @a.x = :abc
+    @a.save
+    A.find(1).x.should == :abc
+  end
+
+  it "should be able to save arbitrary objects" do
+    @a = A.new
+    @a.x = Time.now
+    @a.save
+    A.find(1).x.should be_an_instance_of( Time )
+  end
+
+  it "should have a last_id of nil if nothing has been saved yet." do
+    A.last_id.should == 0
+  end
+
+  it "should have a last_id of 1 if something has been saved." do
+    @a = A.new
+    @a.x = 1
+    @a.save
+    A.last_id.should == 1
+  end
+
+  it "should be able to set a particular value" do
+    A.set_raw(:xyz, 999)
+    A.get_raw(:xyz).should == "999" # Kyoto Cabinet only returns String or binary literals
+  end
+
+  it "should be able to find an instance by id" do
+    # Create two instances, set x, then save them.
+    
+    @a = A.new
+    @a.x = 100
+    @a.save  
+
+    @b = A.new
+    @b.x = 200
+    @b.save
+
+    A.find(1).x.should == 100
+    A.find(2).x.should == 200 
+  end
+
+  it "should be able to set multiple KC attributes at once." do
+    class B
+      include KyotoRecord
+      attr_kyoto :x, :y, :z
+    end
+    b= B.new
+    b.should respond_to(:x)
+    b.should respond_to(:y)
+    b.should respond_to(:z)
+  end
+
+  it "should be able to set those variables just like normal" do
+    class B
+      include KyotoRecord
+      attr_kyoto :x, :y, :z
+    end
+    b= B.new
+    b = B.new
+    b.x = 5
+    b.y = :abc
+    b.z = "duck"
+    b.save
+
+    B.find(1).x.should == 5
+    B.find(1).y.should == :abc 
+    B.find(1).z.should == "duck" 
+  end
+
+  describe "Iterating over the records." do
+    before(:each) do
+      # Insert 100 records
+      10.times do |i|
+        a = A.new
+        a.x = i+1
+        a.save 
+      end 
+    end
+
+    it "should be able to return a list of serialized objects" do
+      word = ""
+      A.scan do |z|
+        word += z.x.to_s
+      end
+      word.should == "12345678910"
+    end
+
+    it "should be able to start from the 2nd record" do
+      word = ""
+      A.scan(5) do |z|
+        word += z.x.to_s
+      end
+      word.should == "5678910"
+    end
+
+    it "should be able to stop after a given limit" do
+      word = ""
+      A.scan(2, 3) do |z|
+        word += z.x.to_s
+      end
+      word.should == "234"
+    end
+
+    it "should be able to scan by page" do
+      word = ""
+      A.scan_page(3, 2) do |z|
+        word += z.x.to_s
+      end
+      word.should == "56"
+    end
+  end
+  describe "Indexing of attributes." do
+    before(:each) do
+      class A
+        attr_kyoto :username
+        index_kyoto :username
+      end
+    end
+
+    it "should create a new database called './data/A_name.kch'" do
+      File.exist?('./data/A_username.kch').should be_true
+    end
+ 
+    it "should be able to look up a record by attribute value" do
+      a = A.new
+      a.username = "David"
+      a.save
+      A.indices[:username].should be_a_kind_of(::KyotoRecord::Index)
+      A.find_by_username("David").should be_a_kind_of( ::KyotoRecord )
+      A.find_by_username("David").id.should == 1
+      A.find_by_username("David").username.should == "David"
+    end
+  end
+
+  describe "Auxilliary functions" do
+    it "should be able to know it's own name as a string" do
+      A.class_name
+    end
+  end
+end

data/watch.rb

@@ -0,0 +1,20 @@
+$: << File.dirname(__FILE__)
+
+require 'directory_watcher'
+
+command = 'rspec -c *_spec.rb'
+
+dw = DirectoryWatcher.new '.', :pre_load => true, :scanner => :rev
+dw.glob = '**/*.rb'
+dw.reset true
+dw.interval = 1.0
+dw.stable = 1.0
+dw.add_observer do |*args|
+  args.each do |event|
+    system(command) if event.to_s =~ /stable/
+  end
+end
+dw.start
+gets      # when the user hits "enter" the script will terminate
+dw.stop
+

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: kyoto_record
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- David Beckwith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-02 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: "\"KyotoRecord\": Kyoto Cabinet wrapper for Ruby binding.  Scannable. Indexable. A programming interface made for babies."
+email: thirdreplicator@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- kyoto_record.rb
+- kyoto_record_spec.rb
+- Gemfile
+- watch.rb
+- kyoto_record.gemspec
+has_rdoc: true
+homepage: http://github.com/thirdreplicator/kyoto_record
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: nowarning
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Persist your classes in Kyoto Cabinet.
+test_files: []
+