shanna-dm-tokyo-adapter 0.2.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+test/tc/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 "Shane Hanna"
+
+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,86 @@
+= DataMapper Tokyo Cabinet/Tyrant Table Store Adapter
+
+* http://github.com/shanna/dm-tokyo-adapter/tree/master
+
+== Description
+
+A DataMapper Tokyo Cabinet/Tyrant table store adapter.
+
+=== Table Store
+
+http://tokyocabinet.sourceforge.net/spex-en.html#features_tctdb
+
+The Tokyo Cabinet table storage engine doesn't require a predefined schema and as such properties in your resource are
+only used for by the adapter for typecasting. There is no need to migrate your resource when you create, update or
+delete properties.
+
+== Dependencies
+
+Ruby::
+* dm-core     ~> 0.10.0
+* rufus-tokyo ~> 0.1.12
+
+== Install
+
+* Via gem:
+
+    gem install shanna-dm-tokyo-adapter -s http://gems.github.com
+
+* Via git:
+
+    git clone git://github.com/shanna/dm-tokyo-adapter.git
+    rake install
+
+== Synopsis
+
+  # Tokyo Cabinet DB files will be located in #{path}/#{database}/#{resource}.tdb
+  DataMapper.setup(:default,
+    :adapter  => 'tokyo_cabinet',
+    :database => 'tc',
+    :path     => File.dirname(__FILE__)
+  )
+
+  # Tokyo Tyrant connection.
+  DataMapper.setup(:default,
+    :adapter  => 'tokyo_tyrant',
+    :host     => 'localhost',
+    :port     => '1978',
+  )
+
+  # Define your DataMapper resource and start saving:
+  class User
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+    property :age, Integer
+  end
+
+  # No need to (auto_)migrate!
+  User.create(:name => 'Fred', :age => '25')
+
+  # Conditions:
+  users = User.all(:age.gte => 10, :limit => 20, :order => [:age.asc])
+
+== TODO
+
+* Documentation. It's undocumented at the moment.
+* Give access to the <tt>Rufus::Tokyo::Table</tt> object through the adapter. Handy if you want to add indexes and
+  other things that can't be done through the DataMapper API.
+* Better tests. I haven't really tested all the DM primitives and query operators yet.
+* Better typecasting. DataTime and Time should typecast to Integer so that they can be searched using the numeric
+  operators.
+
+Ideally in the future I'd like to contribute to these broader goals:
+
+* All the TokyoCabinet stores equally supported in DM.
+* DataMapper define a public/semipublic API for key => value and search stores through Moneta (memcachedb, memcacheq,
+  couchdb, mtokyo cabinet bdb, etc.)
+* DataMapper per adapter query operators. You can't always shoehorn everything into an SQL mindset.
+
+== Contributing
+
+Go nuts. Just send me a pull request (github or otherwise) when you are happy with your code.
+
+== Copyright
+
+Copyright (c) 2009 "Shane Hanna". See LICENSE for details.

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name     = 'dm-tokyo-adapter'
+    gem.summary  = %Q{TODO}
+    gem.email    = 'shane.hanna@gmail.com'
+    gem.homepage = 'http://github.com/shanna/dm-tokyo-adapter'
+    gem.authors  = ['Shane Hanna']
+    gem.files.reject!{|f| f =~ /\.tdb$/}
+    gem.add_dependency 'dm-core', '~> 0.10.0'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'dm-tokyo-cabinet-adapter'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 2
+:patch: 1
+:major: 0

data/dm-tokyo-adapter.gemspec

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dm-tokyo-adapter}
+  s.version = "0.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Shane Hanna"]
+  s.date = %q{2009-06-01}
+  s.email = %q{shane.hanna@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "dm-tokyo-adapter.gemspec",
+     "lib/dm-tokyo-adapter.rb",
+     "lib/dm-tokyo-adapter/cabinet.rb",
+     "lib/dm-tokyo-adapter/query.rb",
+     "lib/dm-tokyo-adapter/tyrant.rb",
+     "test/helper.rb",
+     "test/test_cabinet.rb",
+     "test/test_query.rb",
+     "test/test_tyrant.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/shanna/dm-tokyo-adapter}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{TODO}
+  s.test_files = [
+    "test/test_cabinet.rb",
+     "test/test_tyrant.rb",
+     "test/helper.rb",
+     "test/test_query.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<dm-core>, ["~> 0.10.0"])
+    else
+      s.add_dependency(%q<dm-core>, ["~> 0.10.0"])
+    end
+  else
+    s.add_dependency(%q<dm-core>, ["~> 0.10.0"])
+  end
+end

data/lib/dm-tokyo-adapter/cabinet.rb

@@ -0,0 +1,95 @@
+require 'dm-core'
+require 'fileutils'
+require 'rufus-tokyo'
+
+module DataMapper
+  module Adapters
+    module Tokyo
+
+      # A DataMapper Tokyo Cabinet table store adapter.
+      #
+      # http://tokyocabinet.sourceforge.net/spex-en.html#features_tctdb
+      #
+      # The Tokyo Cabinet table storage engine doesn't require a predefined schema and as such properties in your
+      # resource are only used by the adapter for typecasting. There is no need to migrate your resource when you
+      # create, update or delete properties.
+      #
+      # == See
+      #
+      # DataMapper::Adapters::Tokyo::Query:: Table Query.
+      class CabinetAdapter < AbstractAdapter
+        def create(resources)
+          resources.map do |resource|
+            model          = resource.model
+            identity_field = model.identity_field
+
+            with_connection(resource.model) do |connection|
+              initialize_identity_field(resource, connection.generate_unique_id) if identity_field
+              connection[key(resource)] = attributes(resource, :field)
+            end
+          end.size
+        end
+
+        def read(query)
+          with_connection(query.model) do |connection|
+            Tokyo::Query.new(connection, query).read
+          end
+        end
+
+        def update(attributes, collection)
+          with_connection(collection.query.model) do |connection|
+            collection.each do |record|
+              connection[key(record)] = attributes(record, :field)
+            end.size
+          end
+        end
+
+        def delete(collection)
+          with_connection(collection.query.model) do |connection|
+            collection.each do |record|
+              connection.delete(key(record))
+            end.size
+          end
+        end
+
+        protected
+          def create_connection(model)
+            @tdb_path ||= FileUtils.mkdir_p(
+              File.join(*[@options[:path], (@options[:host] || @options[:database])].compact)
+            ).first
+            tdb = File.join(@tdb_path, "#{model.base_model.storage_name(name)}.tdb")
+            Rufus::Tokyo::Table.new(tdb)
+          end
+
+          def close_connection(connection)
+            connection.close
+          end
+
+        private
+          def key(resource)
+            key = resource.key
+            (key.size > 1 ? key.join(':') : key.first).to_s
+          end
+
+          def attributes(resource, key_on = :name)
+            resource.attributes(key_on).map{|k, v| [k, v.to_s]}.to_hash
+          end
+
+          def with_connection(model)
+            begin
+              connection = create_connection(model)
+              return yield(connection)
+            rescue => error
+              DataMapper.logger.error(error.to_s)
+              raise error
+            ensure
+              close_connection(connection) if connection
+            end
+          end
+      end # CabinetAdapter
+    end # Tokyo
+
+    TokyoCabinetAdapter = Tokyo::CabinetAdapter
+    const_added(:TokyoCabinetAdapter)
+  end # Adapters
+end # DataMapper

data/lib/dm-tokyo-adapter/query.rb

@@ -0,0 +1,109 @@
+require 'dm-core'
+require 'rufus-tokyo'
+
+module DataMapper
+  module Adapters
+    module Tokyo
+
+      # Query a Tokyo Cabinet table store with a DataMapper query.
+      #
+      # == Notes
+      #
+      # Query conditions not supported natively by TC's table query will fall back to DM's in-memory query
+      # filtering. This may impact performance.
+      class Query
+        include Extlib::Assertions
+        include DataMapper::Query::Conditions
+
+        def initialize(connection, query)
+          assert_kind_of 'connection', connection, Rufus::Tokyo::Table
+          assert_kind_of 'query', query, DataMapper::Query
+          @connection, @query, @native = connection, query, true
+        end
+
+        #--
+        # TODO: Log when a query cannot be performed natively by TC.
+        # TODO: Use native sorting if there is only a single order condition.
+        # TODO: connection[] if I have everything I need to fetch by the primary key.
+        def read
+          records = @connection.query do |statements|
+            if @query.conditions.kind_of?(OrOperation)
+              @native = false
+            else
+              @query.conditions.each do |condition|
+                condition_statement(statements, condition)
+              end
+            end
+
+            statements.no_pk
+            if @native
+              statements.limit(@query.limit) if @query.limit
+              # TODO: Native sorting when only one order field.
+            end
+          end
+
+          # Typecast return values.
+          records.each do |record|
+            @query.fields.each do |property|
+              field = property.field
+              record[field] = property.typecast(record[field])
+            end
+          end
+
+          @query.filter_records(records)
+        end
+
+        private
+          def condition_statement(statements, conditions, affirmative = true)
+            case conditions
+              when AbstractOperation  then operation_statement(statements, conditions, affrimative)
+              when AbstractComparison then comparison_statement(statements, conditions, affirmative)
+            end
+          end
+
+          def operation_statement(statements, operation, affirmative = true)
+            case operation
+              when OrOperation  then @native = false
+              when NotOperation then condition_statement(statements, operation.first, !affirmative)
+              when AndOperation then operation.each{|op| condition_statement(statements, op, affirmative)}
+            end
+          end
+
+          def comparison_statement(statements, comparison, affirmative = true)
+            value     = comparison.value
+            primitive = comparison.property.primitive
+
+            if value.kind_of?(Range) && value.exclude_end?
+              operation = BooleanOperation.new(:and,
+                Comparison.new(:gte, comparison.property, value.first),
+                Comparison.new(:lt, comparison.property, value.last)
+              )
+              operation_statement(statements, operation, affirmative)
+              return
+            end
+
+            operator = case comparison
+              when EqualToComparison              then primitive == Integer ? :numeq : :eq
+              when InclusionComparison            then primitive == Integer ? :numoreq : nil
+              when RegexpComparison               then :regex
+              when LikeComparison                 then :regex
+              when GreaterThanComparison          then :gt
+              when LessThanComparison             then :lt
+              when GreaterThanOrEqualToComparison then :gte
+              when LessThanOrEqualToComparison    then :lte
+            end
+
+            unless operator
+              @native = false
+              return
+            end
+            statements.add(comparison.property.field, operator, quote_value(value), affirmative)
+          end
+
+          def quote_value(value)
+            "#{value}"
+          end
+      end # Query
+    end # Tokyo
+  end # Adapters
+end # DataMapper

data/lib/dm-tokyo-adapter/tyrant.rb

@@ -0,0 +1,35 @@
+require 'dm-tokyo-adapter/cabinet'
+
+module DataMapper
+  module Adapters
+    module Tokyo
+
+      # A DataMapper Tokyo Tyrant table store adapter.
+      #
+      # http://tokyocabinet.sourceforge.net/tyrantdoc/
+      # http://tokyocabinet.sourceforge.net/spex-en.html#features_tctdb
+      #
+      # The Tokyo Cabinet table storage engine doesn't require a predefined schema and as such properties in your
+      # resource are only used by the adapter for typecasting. There is no need to migrate your resource when you
+      # create, update or delete properties.
+      #
+      # == See
+      #
+      # DataMapper::Adapters::Tokyo::Query:: Table Query.
+      class TyrantAdapter < Tokyo::CabinetAdapter
+        protected
+
+          #--
+          # TODO: Default port to 1978?
+          def create_connection(model)
+            credentials = [@options[:socket] || @options.values_at(:host, :port)]
+            Rufus::Tokyo::TyrantTable.new(*credentials.flatten)
+          end
+      end # TyrantAdapter
+    end # Tokyo
+
+    TokyoTyrantAdapter = Tokyo::TyrantAdapter
+    const_added(:TokyoTyrantAdapter)
+  end # Adapters
+end
+

data/lib/dm-tokyo-adapter.rb

@@ -0,0 +1,3 @@
+require 'dm-tokyo-adapter/query'
+require 'dm-tokyo-adapter/cabinet'
+require 'dm-tokyo-adapter/tyrant'

data/test/helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'dm-tokyo-adapter'
+
+class Test::Unit::TestCase
+end
+
+DataMapper.setup(:default, {
+  :adapter  => 'tokyo_cabinet',
+  :database => 'tc',
+  :path     => File.dirname(__FILE__)
+})
+
+class Test::Unit::TestCase
+  include Extlib::Hook
+
+  # after :teardown do
+  def teardown
+    descendants = DataMapper::Model.descendants.dup.to_a
+    while model = descendants.shift
+      descendants.concat(model.descendants) if model.respond_to?(:descendants)
+      Object.send(:remove_const, model.name.to_sym)
+      DataMapper::Model.descendants.delete(model)
+    end
+  end
+end
+

data/test/test_cabinet.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class AdapterTest < Test::Unit::TestCase
+  context DataMapper::Adapters::TokyoCabinetAdapter do
+    context 'Serial key resource' do
+      setup do
+        class ::User
+          include DataMapper::Resource
+          property :id, Serial
+          property :name, String
+          property :age, Integer
+        end
+
+        @user = User.create(:name => 'Joe', :age => 22)
+      end
+
+      teardown do
+        User.all.destroy
+      end
+
+      should 'assign id to attributes' do
+        item = User.create
+        assert_kind_of User, item
+        assert_not_nil item.id
+      end
+
+      should 'get an item' do
+        assert_equal @user, User.get(@user.id)
+      end
+
+      should 'get items' do
+        assert_equal 1, User.all.size
+      end
+
+      should 'destroy item' do
+        assert @user.destroy
+        assert_equal 0, User.all.size
+      end
+
+      should 'update item' do
+        @user.name = 'Woot'
+        assert @user.save
+        assert_equal 'Woot', User.get(@user.id).name
+      end
+    end
+
+    context 'Compound key resource' do
+      setup do
+        class ::User
+          include DataMapper::Resource
+          property :name, String, :key => true
+          property :age, Integer, :key => true
+        end
+
+        @user = User.create(:name => 'Joe', :age => 22)
+      end
+
+      teardown do
+        User.all.destroy
+      end
+
+      should 'get an item' do
+        assert_equal @user, User.get(*@user.key)
+      end
+    end
+  end
+end

data/test/test_query.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class QueryTest < Test::Unit::TestCase
+  context 'Resource' do
+    setup do
+      class ::User
+        include DataMapper::Resource
+        property :id, Serial
+        property :name, String
+        property :age, Integer
+      end
+
+      @joe   = User.create(:name => 'Joe',  :age => 11)
+      @jack  = User.create(:name => 'Jack', :age => 22)
+      @john  = User.create(:name => 'John', :age => 33)
+    end
+
+    teardown do
+      User.all.destroy
+    end
+
+    should 'get items' do
+      assert_equal 3, User.all.size
+    end
+
+    should 'get items with sring conditions' do
+      User.create(:name => 'John', :age => 44)
+      assert_equal 2, User.all(:name => 'John').size
+    end
+
+    should 'get items with integer equality conditions' do
+      User.create(:name => 'Fred', :age => 33)
+      assert_equal 2, User.all(:age => 33).size
+    end
+
+    should 'get items with integer range conditions' do
+      User.create(:name => 'Fred', :age => 33)
+      assert_equal 3, User.all(:age.gte => 22, :age.lte => 34).size
+    end
+
+    should 'order items by string' do
+      users = [@jack, @joe, @john]
+      assert_equal users, User.all(:order => [:name.asc])
+      assert_equal users.reverse, User.all(:order => [:name.desc])
+    end
+
+    should 'order items by integer' do
+      users = [@joe, @jack, @john]
+      assert_equal users, User.all(:order => [:age.asc])
+      assert_equal users.reverse, User.all(:order => [:age.desc])
+    end
+
+    should 'limit items' do
+      assert_equal 2, User.all(:limit => 2).size
+    end
+  end
+end # QueryTest
+

data/test/test_tyrant.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class AdapterTest < Test::Unit::TestCase
+  context DataMapper::Adapters::TokyoTyrantAdapter do
+    should 'behave like DM::A::TokyoCabinetAdapter'
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: shanna-dm-tokyo-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Shane Hanna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-01 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+description: 
+email: shane.hanna@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- dm-tokyo-adapter.gemspec
+- lib/dm-tokyo-adapter.rb
+- lib/dm-tokyo-adapter/cabinet.rb
+- lib/dm-tokyo-adapter/query.rb
+- lib/dm-tokyo-adapter/tyrant.rb
+- test/helper.rb
+- test/test_cabinet.rb
+- test/test_query.rb
+- test/test_tyrant.rb
+has_rdoc: true
+homepage: http://github.com/shanna/dm-tokyo-adapter
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/test_cabinet.rb
+- test/test_tyrant.rb
+- test/helper.rb
+- test/test_query.rb