rubysouth-tokyo_model 0.0.2

data/History.txt

@@ -0,0 +1,9 @@
+== 0.0.2 2009-04-17
+
+* 1 major enhancement:
+  * Added adapters for TDB files and Tokyo Tyrant.
+
+== 0.0.1 2009-04-15
+
+* 1 major enhancement:
+  * Project set up on Github

data/Manifest.txt

@@ -0,0 +1,18 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/tokyo_model.rb
+lib/tokyo_model/adapters/abstract_adapter.rb
+lib/tokyo_model/adapters/file.rb
+lib/tokyo_model/adapters/tyrant.rb
+lib/tokyo_model/persistable.rb
+script/console
+script/destroy
+script/generate
+test/contest.rb
+test/fixtures/post.rb
+test/test_basic_model.rb
+test/test_file_adapter.rb
+test/test_helper.rb
+tokyo_model.gemspec

data/README.rdoc

@@ -0,0 +1,32 @@
+= TokyoModel
+
+TokyoModel is a lightweight ORM that uses TokyoCabinet's table databases (TDB)
+as a storage backend. TDB has tables but no schemas, which allows for some
+interesting possibilities in an ORM.
+
+Our first public release is planned for some time in late April 2009. At the
+moment almost ALMOST NOTHING is implemented. It wouldn't even be fair to
+describe this as pre-alpha. DO NOT USE THIS.
+
+== LICENSE:
+
+Copyright (c) 2009 Adrian Mugnolo and Norman Clarke
+
+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/Rakefile

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'newgem'
+require File.dirname(__FILE__) + '/lib/tokyo_model'
+
+$hoe = Hoe.new('tokyo_model', TokyoModel::VERSION) do |p|
+  p.developer('Adrian Mugnolo', 'adrian@mugnolo.com')
+  p.developer('Norman Clarke', 'norman@randomba.org')
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name = "tokyo-model"
+  p.url = "http://github.com/rubysouth/tokyo_model"
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+end
+
+require 'newgem/tasks'

data/lib/tokyo_model/adapters/abstract_adapter.rb

@@ -0,0 +1,44 @@
+module TokyoModel
+  module Adapters
+
+    # This class exists almost exclusively to indicate the methods that all
+    # adapters must implement. The default implementation simply delegates
+    # everything to the underlying database file or connection.
+    class AbstractAdapter
+
+      attr :db
+
+      # Delete the record identified by +pkey+.
+      def out(pkey)
+        @db.out(pkey)
+      end
+      alias_method :delete, :out
+
+      # Generate a new primary key to use as an identifier for a new record.
+      def genuid
+        @db.genuid
+      end
+
+      # Fetch the record identified by +pkey+.
+      def get(pkey)
+        @db.get(pkey)
+      end
+
+      # Insert or update the record identified by +pkey+.
+      def put(pkey, hash)
+        @db.put(pkey, hash)
+      end
+
+      # Perform a query.
+      def query(*args)
+        raise NotImplementedError.new
+      end
+
+      # Delegate any unknown method calls to the underlying @db.
+      def method_missing(symbol, *args)
+        @db.send(symbol, *args)
+      end
+
+    end
+  end
+end

data/lib/tokyo_model/adapters/file.rb

@@ -0,0 +1,50 @@
+require 'tokyocabinet'
+
+module TokyoModel
+  module Adapters
+
+    # This adapter provides access to TokyoCabinet TDB files.
+    class File < AbstractAdapter
+
+
+      # Permitted open modes for accessing TDB files: +:read+, +:write+,
+      # +:create+, +:truncate+, +:nolock+, +:lock_noblock+ and +:sync+
+      OPEN_MODES = {
+        :read         => TokyoCabinet::TDB::OREADER,
+        :write        => TokyoCabinet::TDB::OWRITER,
+        :create       => TokyoCabinet::TDB::OCREAT,
+        :truncate     => TokyoCabinet::TDB::OTRUNC,
+        :nolock       => TokyoCabinet::TDB::ONOLCK,
+        :lock_noblock => TokyoCabinet::TDB::OLCKNB,
+        :sync         => TokyoCabinet::TDB::OTSYNC
+      }.freeze
+
+      # Open the TDB file. Accepts a URI and list of open modes:
+      #
+      #   db = TokyoModel::Adapters::File.new("file:///tmp/database.tdb", :read,
+      #     :write, :create, :trunc)
+      def initialize(uri, *args)
+        @db = TokyoCabinet::TDB::new
+        @db.open(uri.path, args.empty? ? File.default_open_mode : File.open_mode(*args))
+      end
+
+      class << self
+
+        # The default open mode is read/write.
+        def default_open_mode
+          open_mode(:read, :write)
+        end
+
+        # Takes an array of open mode symbols and returns the mode number:
+        #
+        #   open_mode(:read, :write, :sync) # 3
+        #   open_mode(:read, :write, :sync) # 67
+        def open_mode(*modes)
+          modes.inject(0) { |memo, obj| memo | OPEN_MODES[obj.to_sym].to_i }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/tokyo_model/adapters/tyrant.rb

@@ -0,0 +1,27 @@
+require 'tokyotyrant'
+
+module TokyoModel
+  module Adapters
+
+    # This adapter provides access to TokyoTyrant TDB databases.
+    class Tyrant < AbstractAdapter
+
+      DEFAULT_PORT = 1978
+
+      # Open the TDB file. Accepts a URI and discards any extra arguments
+      # passed in.
+      #
+      #   db = TokyoModel::Adapters::Tyrant.new("tyrant://localhost:1978")
+      #   db = TokyoModel::Adapters::Tyrant.new("unix://host/var/sock/tyrant.sock")
+      def initialize(uri, *args)
+        @db = TokyoTyrant::RDBTBL::new
+        if uri.scheme == "unix"
+          @db.open(uri.path, 0)
+        else
+          @db.open(uri.host, uri.port || DEFAULT_PORT)
+        end
+      end
+
+    end
+  end
+end

data/lib/tokyo_model/persistable.rb

@@ -0,0 +1,65 @@
+module TokyoModel
+
+  module Persistable
+
+    def self.included(base)
+      base.class_eval { extend TokyoModel::Persistable::ClassMethods }
+    end
+
+    module ClassMethods
+
+      def  connect(uri, *args)
+        @db = TokyoModel.open(uri, *args)
+      end
+
+      def db
+        @db ||= TokyoModel::DATABASES.first
+      end
+
+      def get(id)
+        obj = new
+        if record = db.get(id)
+          record.each { |k, v| obj.send("#{k}=".to_sym, v) }
+          obj.id = id
+        end
+        obj
+      end
+      alias_method :find, :get
+
+      def setter_methods
+        instance_methods.select {|m| m =~ /[^=]$/ && instance_methods.include?("#{m}=") && !%w(taguri).include?(m) }
+      end
+
+    end
+
+    def ==(obj)
+      self.class == obj.class && id == obj.id
+    end
+
+    def attributes
+      self.class.setter_methods.inject({}) do |m, o|
+        v = send(o.to_sym)
+        m[o] = v if v
+        m
+      end
+    end
+
+    def db
+      self.class.db
+    end
+
+    def id
+      @id ||= db.genuid
+    end
+
+    def id=(id)
+      @id = id
+    end
+
+    def put
+      db.put(id, attributes)
+    end
+    alias_method :save, :put
+
+  end
+end

data/lib/tokyo_model.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'uri'
+require 'tokyo_model/persistable'
+require 'tokyo_model/adapters/abstract_adapter'
+
+module TokyoModel
+
+  VERSION = '0.0.2'
+  ADAPTERS = [:file, :tyrant].freeze
+  DATABASES = []
+
+  # Connect to the database. Accepts a uri and optional list of open modes:
+  #
+  #   TokyoModel.connect("file:/tmp/database.tdb", :read, :write, :create, :truncate)
+  #   TokyoModel.connect("tyrant://localhost:1978")
+  #   TokyoModel.connect("unix://host/var/sock/tyrant.sock")
+  #
+  # The permitted URI schemas are: +file+, +tyrant+ and +unix+.
+  def self.open(*args)
+    uri = URI::parse(args.shift)
+    DATABASES << adapter(uri.scheme).new(uri, *args)
+  end
+
+  def self.close
+    DATABASES.each { |d| d.close }
+  end
+
+  private
+
+  def self.adapter(scheme)
+    class_name = scheme == "unix" ? "tyrant" : scheme
+    require "tokyo_model/adapters/#{class_name}"
+    TokyoModel::Adapters.const_get(class_name.titleize.to_sym)
+  end
+
+end
+
+class String
+  def titleize
+    self.gsub(/\b([a-z])/) { |x| x[-1..-1].upcase }
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+libs << " -r rubygems"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/tokyo_model.rb'}"
+
+puts "Loading tokyo_model gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/contest.rb

@@ -0,0 +1,99 @@
+# The "Contest" library was taken from: http://github.com/citrusbyte/contest/
+#
+# Copyright (c) 2009 Damian Janowski and Michel Martens for Citrusbyte
+#
+# 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.
+
+require "test/unit"
+
+# Test::Unit loads a default test if the suite is empty, whose purpose is to
+# fail. Since having empty contexts is a common practice, we decided to
+# overwrite TestSuite#empty? in order to allow them. Having a failure when no
+# tests have been defined seems counter-intuitive.
+class Test::Unit::TestSuite
+  def empty?
+    false
+  end
+end
+
+# Contest adds +setup+, +teardown+, +test+ and +context+ as class methods, and
+# the instance methods +setup+ and +teardown+ now iterate on the corresponding
+# blocks. Note that all setup and teardown blocks must be defined with the
+# block syntax. Adding setup or teardown instance methods defeats the purpose
+# of this library.
+class Test::Unit::TestCase
+  def self.setup(&block)
+    setup_blocks << block
+  end
+
+  def self.teardown(&block)
+    teardown_blocks << block
+  end
+
+  def setup
+    self.class.setup_blocks.each do |block|
+      instance_eval(&block)
+    end
+  end
+
+  def teardown
+    self.class.teardown_blocks.each do |block|
+      instance_eval(&block)
+    end
+  end
+
+  def self.context(name, &block)
+    subclass = Class.new(self.superclass)
+    subclass.setup_blocks.unshift(*setup_blocks)
+    subclass.teardown_blocks.unshift(*teardown_blocks)
+    subclass.class_eval(&block)
+    const_set(context_name(name), subclass)
+  end
+
+  def self.test(name, &block)
+    define_method(test_name(name), &block)
+  end
+
+  class << self
+    alias_method :should, :test
+    alias_method :describe, :context
+  end
+
+private
+
+  def self.setup_blocks
+    @setup_blocks ||= []
+  end
+
+  def self.teardown_blocks
+    @teardown_blocks ||= []
+  end
+
+  def self.context_name(name)
+    "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
+  end
+
+  def self.test_name(name)
+    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
+  end
+
+  def self.sanitize_name(name)
+    name.gsub(/\W+/, ' ').strip
+  end
+end

data/test/fixtures/post.rb

@@ -0,0 +1,4 @@
+class Post
+  include TokyoModel::Persistable
+  attr_accessor :title, :body, :author, :permalink
+end

data/test/test_basic_model.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require File.dirname(__FILE__) + "/fixtures/post.rb"
+
+class TestBasicModel < Test::Unit::TestCase
+
+  setup do
+    TokyoModel.open("file:#{dbpath}", :write, :read, :create, :truncate)
+    @post = Post.new
+    @post.title = "First post!"
+    @post.body = "Lorem ipsum dolor sit amet, consectetur adipisicing elit"
+    @post.author = "John Doe"
+    @post.permalink = "http://example.org/posts/1"
+    @post.put
+  end
+
+  teardown do
+    TokyoModel.close
+    FileUtils.rm_f dbpath
+  end
+
+  context "a model" do
+
+    should "have a db connection" do
+      assert_not_nil Post.db
+    end
+
+    should "be gettable" do
+      post2 = Post.get(@post.id)
+      assert_equal @post.title, post2.title
+      assert_equal 1, TokyoModel::DATABASES.first.rnum
+    end
+
+    should "generate an id when persisted" do
+      post = Post.new
+      post.title = "test"
+      post.put
+      assert_not_nil post.id
+    end
+
+  end
+
+  context "a model instance" do
+    should "be equal to another instance of the same class with the same id" do
+      assert_equal @post, Post.get(@post.id)
+    end
+  end
+
+end

data/test/test_file_adapter.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestFileAdapter < Test::Unit::TestCase
+
+  test "default open mode should be read/write" do
+    assert_equal 3, TokyoModel::Adapters::File.default_open_mode
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+$VERBOSE = false
+require 'rubygems'
+require 'fileutils'
+require 'test/unit'
+require 'contest'
+
+require File.dirname(__FILE__) + '/../lib/tokyo_model'
+
+def tmpdir
+  @tmpdir ||= File.join(File.dirname(File.expand_path(__FILE__)), "tmp")
+end
+
+def dbpath
+  "#{tmpdir}/test.tdb"
+end
+
+FileUtils.mkdir_p tmpdir

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: rubysouth-tokyo_model
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Adrian Mugnolo
+- Norman Clarke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-17 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: ""
+email: 
+- adrian@mugnolo.com
+- norman@randomba.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/tokyo_model.rb
+- lib/tokyo_model/adapters/abstract_adapter.rb
+- lib/tokyo_model/adapters/file.rb
+- lib/tokyo_model/adapters/tyrant.rb
+- lib/tokyo_model/persistable.rb
+- script/console
+- script/destroy
+- script/generate
+- test/contest.rb
+- test/fixtures/post.rb
+- test/test_basic_model.rb
+- test/test_file_adapter.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/rubysouth/tokyo_model
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: tokyo-model
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- test/test_basic_model.rb
+- test/test_file_adapter.rb
+- test/test_helper.rb