zeng 0.0.1

data/CHANGE

@@ -0,0 +1,3 @@
+2010-1-20 add docking method for CuteKV::Document, enhance it's scalability
+2010-1-20 add CuteKV::Timestamp module supporting timestamp function
+2010-1-24 add CuteKV::Validations module supporting validate

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Aaron
+
+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,89 @@
+= CuteKV -- based at Ruby for object-key/value map
+
+
+== Main features
+* Independent Object Storage
+
+  Through backend_configure to appoint storage location
+	class User < ActiveObject::Base
+		backend_configure :TT,"127.0.0.1:1987"
+	end
+
+* Customize define persistent properties
+  you can assign persitent properties by <t>assign</t> method,and set default value for 
+  each property.
+
+	class User 
+    include CuteKV::Document
+		backend_configure :TT,"127.0.0.1:1987"
+		assign :name,:email, :gender=>'male', :age=>25
+	end
+
+ ==Object's associations
+
+  Using CuteKV::associations module, we can description associations between objects
+  
+
+	class User
+    include CuteKV::Document
+		backend_configure :TT,"127.0.0.1:1987"
+		assign :name,:email, :gender=>'male', :age=>25
+	end
+
+  CuteKV::associations::map(User=>:icon, Icon=>:user)  #=>user has one icon and icon belongs to one user
+  CuteKV::associations::map(User=>:friends)            #=>user has many friends
+
+	class Icon < ActiveObject::Base
+    include CuteKV::Document
+		backend_configure :TT,"127.0.0.1:1987"
+		assign :content
+	end
+
+ ==Validations
+  now CuteKV support validations by a simple method <t>validate</t> from CuteKV::Validations module
+  I just keep it simple or i will improve it to approach activerecord's validations
+  class User
+    include CuteKV::Document	
+		incude CuteKV::Validations
+		backend_configure :TT,"127.0.0.1:1987"
+		assign :name,:email, :gender=>'male', :age=>25
+		validate :name_presence_valid
+
+	  def name_presence_valid	
+		  errors.add(:name, "name should not blank") if self.name.blank?
+		end
+  end
+
+	@jim = User.create()
+	@jim.save                             #=>nil
+	User.find(@jim.id)                    #=>nil
+	@jim.errors_message_on(:name)         #=>"name should not blank"
+
+
+ ==Index
+	class User 
+    include CuteKV::Document
+		backend_configure :TT,"127.0.0.1:1987"
+		assign :name,:email, :gender=>'male', :age=>25
+	end
+  @jim = User.create(:name=>"jim", :email=>"jim@nonobo.com")
+  @aaron = User.create(:name=>"aaron", :email=>"aaron@nonobo.com")
+  @jack= User.create(:name=>"jack", :email=>"jack@nonbo.com")
+  @lucy = User.create(:name=>"lucy", :email=>"lucy@nonobo.com")
+  Useing CuteKV::Indexer module, you can build index for object, just like:
+   CuteKV::Indexer::map(User=>[:name, :email, :age])
+   then, 
+     User.indexes << @jim
+     User.indexes << @aaron
+     User.indexes << @lucy
+   User.find_all_by_name("jim")   #=>@jim
+   User.find_all_by_age(25)   #=>@jim, @aaron, @lucy, @jack
+
+ == Supoort multiple database
+	CuteKV using adapter to connect database.now backend support：TokyoCabinet/TokyoTyrant/LightCloud。
+
+
+== Using in rails
+  in environment.rb, you will add
+		require 'cutekv'
+

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+task :default=>:test
+
+task :test do 
+	Dir['spec/case/**/*'].each {|test|
+   sh "ruby #{test}" if test =~ /(_test\.rb)$/
+	}
+end
+
+desc "start test for given file"
+task :test_file, [:file] do |t, args|
+  sh "ruby spec/case/#{args.file}_test.rb"
+end
+
+desc "创建gemspec文件"
+task :gemspec do
+	spec = Gem::Specification.new do |s|
+		s.name = %{zeng}
+		s.version = '0.0.1'
+                s.summary = 'A chinese fishing tool'
+		s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+		s.email = ["kayak.jiang@gmail.com"]
+		s.authors = "Guimin Jiang"
+		s.files = Dir["./**/*"].delete_if {|path| path =~ /.gem$/}
+		s.require_paths = ["lib"]
+		s.required_ruby_version = Gem::Requirement.new(">= 1.8.6")
+		s.rubygems_version = %q{1.3.4}
+		s.add_dependency(%q<ffi>)
+	end
+
+	File.open("zeng.gemspec", "w") {|f| f << spec.to_ruby }
+end
+

data/TODOLIST

@@ -0,0 +1,5 @@
+like activerecord i will add 
+1. validate
+  
+
+

data/init.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cutekv'

data/lib/cute_kv/adapters/light_cloud.rb

@@ -0,0 +1,22 @@
+# 访问LightCloud的加载模块
+require 'lightcloud'
+module CuteKV 
+	module Adapters
+		module TokyoCloud
+			def put(key, value)
+				@db.set(key, value)
+			end
+
+			def get(key)
+				@db.get(key)
+			end
+
+		private
+			def establish(conf)
+				conf = YAML.load_file(conf) if conf.is_a?(String)
+				lookup_nodes, storage_nodes = LightCloud.generate_nodes(conf)
+			  	@db = LightCloud.new(lookup_nodes, storage_nodes)
+			end
+		end
+	end
+end

data/lib/cute_kv/adapters/tokyo_cabinet.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# 访问TokyoCabinet的加载模块
+require 'rufus/tokyo'
+module CuteKV
+  module Adapters
+    module TokyoCabinet
+      def put(key, value)
+        @db[key] = value
+      end
+
+      def get(key)
+        @db[key]
+      end
+
+      def delete(key)
+        @db.delete(key)
+      end
+
+      def infos
+        {:adapter=>@adapter, :host=>@host, :port=>@port}
+      end
+
+      def method_missing(method, *args)
+        @db.send method, *args
+      end
+
+      private
+      def establish(conf)
+        @db = Rufus::Tokyo::Cabinet.new(conf)
+      end
+    end
+  end
+end

data/lib/cute_kv/adapters/tokyo_tyrant.rb

@@ -0,0 +1,22 @@
+# 访问TokyoTyrant的加载模块
+require 'rufus/tokyo'
+require 'cute_kv/adapters/tokyo_cabinet'
+module CuteKV
+	module Adapters
+		module TokyoTyrant
+			include CuteKV::Adapters::TokyoCabinet
+			private
+				def establish(conf)
+					if conf.is_a? Hash
+						@host = conf[:host] || conf["host"]
+						@port = (conf[:port] || conf["port"]).to_i
+					else
+						conf = conf.split(':')
+						@host = conf[0]
+						@port = conf[1].to_i
+					end
+					@db = Rufus::Tokyo::Tyrant.new(@host, @port)
+				end
+		end
+	end
+end

data/lib/cute_kv/associations.rb

@@ -0,0 +1,285 @@
+module CuteKV
+  module Associations
+
+    Map = Class.new
+    Collection = Class.new(Array) {
+      def to_json(options={})
+        "[#{self.map{|c| c.to_json(options)}.join(',')}]"
+      end
+    }
+
+    class Symmetry
+
+      def initialize(asso={})
+        @asso_string = parse(asso)
+        @assos = @asso_string.split("#")
+      end
+
+      def mirror(object)
+        m_o = @assos[@assos.size - 1 - @assos.index(object.to_s)]
+        m_o = m_o.constantize if object.is_a? Class
+        m_o = m_o.to_sym if object.is_a? Symbol
+        m_o
+      end
+
+      def each
+        asso =  [[@assos[0].constantize, @assos[1].to_sym ],[@assos[-1].constantize, @assos[-2].to_sym]].uniq
+        asso.each {|a| yield a[0], a[-1]}
+      end
+
+      private
+      def parse(asso={})
+        keys = asso.keys
+        values = asso.values.flatten
+        "#{keys[0]}##{values[0]}##{values[-1]}##{keys[-1]}"
+      end
+
+    end
+
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+
+      def initialize(key, ids)
+        @key_infos = key.split('#')
+        @klass = @key_infos[-1].constantize
+        @key = key
+        @ids = deserialize ids
+      end
+
+      def ids
+        @ids
+      end
+
+      def relex(object)
+        r_k = @key_infos[0]
+        r_v = @key_infos[1]
+        k = @key_infos[-1]
+        v = @key_infos[-2]
+        key = "#{k}##{v}##{object.id}#relations##{r_v}##{r_k}"
+        map = self.class.find(key) || self.class.create(key, [])
+      end
+
+
+      def objects
+        map = self
+        #it is very strange! when i use 'id', i can't use the method 'remove' correctly, so i use '_id'
+        _id = @key_infos[2]
+        _klass = @klass
+        _rv = @key_infos[1]
+        objs = Collection.new
+        objs.replace self.ids.collect {|id| @klass.find(id)}.compact
+        self.ids = objs.map(&:id) unless objs.size == self.ids.size
+        Collection.class_eval {
+          define_method(:<<){|object|
+            return unless object.is_a? _klass
+            if _rv.singular?
+              map.send(:ids=, [object.id])
+            else
+              map.ids << object.id
+            end
+            rel_map = map.relex(object)
+            rel_map.ids << _id
+            map.save
+            rel_map.save
+          }
+
+          define_method(:remove) {|object|
+            return unless object.is_a? _klass
+            map.ids.delete(object.id)
+            rel_map = map.relex(object)
+            rel_map.ids.delete(_id)
+            map.save
+            rel_map.save
+          }
+
+
+        }
+        objs
+      end
+
+      def save
+        self.class.backend[@key] = serialize @ids
+      end
+
+
+      private
+      def ids=(ids)
+        return unless ids.is_a? Array
+        @ids = ids
+      end
+
+      def serialize(ids)
+        self.class.send :serialize, ids
+      end
+
+      def deserialize(raw_ids)
+        self.class.send :deserialize, raw_ids
+      end
+
+    end
+
+
+    module ClassMethods
+
+      def connect(class_obj)
+        @backend = class_obj.backend
+        @class_obj = class_obj
+      end
+
+      def find(key)
+        new(key, @backend[key]) if @backend[key]
+      end
+
+      def create(key,ids=[])
+        ids = serialize ids
+        @backend[key] = ids
+        new(key, ids)
+      end
+
+      def backend
+        @backend
+      end
+
+      def find_or_create(key)
+        find(key) || create(key, [])
+      end
+
+      def gen_key(k, v, object, r_v, r_k)
+        key = "#{k}##{v}##{object.id}#relations##{r_v}##{r_k}"
+      end
+
+      def draw(k, v, object, r_v, r_k)
+        key = gen_key(k, v, object, r_v, r_k)
+        find_or_create(key)
+      end
+
+      private
+
+      def serialize(ids)
+        @class_obj.serialize(ids)
+      end
+
+      def deserialize(raw_ids)
+        @class_obj.deserialize(raw_ids)
+      end
+
+    end
+
+    class << self
+      # Although relations between real word's objects are complex, we abstract all relations to three
+      # type relations: # <tt>one_to_one</tt>, # <tt>one_to_many</tt>, # <tt>many_to_many</tt>
+      #
+      # == One_To_One
+      #   class User < ActiveObject::Base
+      #     assign :name, :gender=>"male"
+      #   end
+      #
+      #   class Icon < ActiveObject::Base
+      #     assign :path
+      #   end
+      #   @aaron = User.create(:name=>"aaron")
+      #   @icon = Icon.create(:path=>"/tmp/aaron.jpg")
+      #
+      #   Associations::map(User=>:icon, Icon=>:user)
+      #   User will add a instance method :icon
+      #   Icon will add a instance method :user
+      #   @aaron.icon = @icon
+      #   aaron = User.find(@aaron.id)
+      #   aaron.icon.path                      #=>"/tmp/aaron.jpg"
+      #   icon = Icon.find(@icon.id)
+      #   icon.user.name                       #=>"aaron"
+      #
+      #   Associations::map(User=>[:wife, :husband])
+      #   @rita = User.create(:name=>"rita", :gender=>'female')
+      #   @aaron.wife = @rita
+      #   @aaron.wife                         #=>@rita
+      #   @rita.husband                       #=>@aaron
+      #
+      # == One_To_Many
+      #   Associations::map(User=>:books, Book=>:owner)
+      #   @book_ruby = Book.create(:name=>"Ruby")
+      #   @book_java = Book.create(:name=>"Java")
+      #
+      # == Many_To_Many
+      #   Associations::map(User=>:projects, Project=>:members)
+      #   @aaron = User.create(:name=>"aaron")
+      #   @nonobo = Project.create(:name=>"nonobo")
+      #   @admin = Project.create(:name=>"admin")
+      #   @aaron.prjects << @nonobo
+      #   @aaron.prjects << @admin
+      #   @aaron.projects   #=>[@nonobo, @admin]
+      #   @nonobo.members   #=>[@aaron]
+      #   @aaron.projects.remove(@nonbo)
+      #   @nonbo.members   #=> []
+      #   @aaron.projects   #=> [@admin]
+      #
+      #
+      def map(asso)
+        if asso.is_a? String
+          #load classes's associations from yml file
+          assos = YAML::load(IO.read(asso))
+          assos.each {|asso| map(constantize_asso_keys(asso)) }
+        else
+          singus = Array(asso.delete(:singular)).compact
+          Dic::SIN_WORDS.add(singus) unless singus.empty?
+          pluras = Array(asso.delete(:plural)).compact
+          Dic::PLU_WORDS.add(pluras) unless pluras.empty?
+          symmetry = Symmetry.new(asso)
+          symmetry.each {|k,v|
+            r_k = symmetry.mirror(k)
+            r_v = symmetry.mirror(v)
+            asso_map = Map.send(:include, self)
+            asso_map.connect(k)
+            k.class_eval {
+              define_method(v) {
+                map = asso_map.draw(k,v,self,r_v,r_k)
+                if v.singular?
+                  obj = map.objects.last
+                  return if obj.nil?
+                  def obj.remove(object)
+                    Collection.new.replace([self]).remove(object)
+                  end
+                  obj
+                else
+                  map.objects
+                end
+              }
+
+              define_method("#{v}=") {|object|
+                return if object.nil?
+                map = asso_map.draw(k,v,self,r_v,r_k)
+                vo = self.send(v)
+                vo.send(r_v).remove(self) if vo
+                rvo = object.send(r_v)
+                rvo.send(v).remove(object) if r_v.singular? && rvo
+                map.objects << object
+              } if v.singular?
+
+            }
+          }
+        end
+
+      end
+
+      protected
+
+      def constantize_asso_keys(asso)
+        h = {}
+        plurs = asso.delete("plural").split(" ") if asso["plural"]
+        sins = asso.delete("singular").split(" ") if asso["singular"]
+        h[:plural] = plurs if plurs
+        h[:singular] = sins if sins
+        asso.each {|k,v| h[k.constantize] = v.split(' ') }
+        h
+      end
+
+    end
+
+  end
+
+
+end

data/lib/cute_kv/connector.rb

@@ -0,0 +1,27 @@
+module CuteKV
+  class Connector
+    def self.config(adapter)
+      case adapter.to_sym
+			  when :TC 
+						require 'cute_kv/adapters/tokyo_cabinet'
+						include CuteKV::Adapters::TokyoCabinet
+			  when :TT 
+						require 'cute_kv/adapters/tokyo_tyrant'
+						include CuteKV::Adapters::TokyoTyrant
+			  when :LC 
+						require 'cute_kv/adapters/light_cloud'
+						include CuteKV::Adapters::TokyoCloud
+			  else
+				  raise ConfigError,'没有指定数据库类型！'
+			  end
+	  end
+
+	  def initialize(adapter, conf)
+			@adapter = adapter
+		  self.class.config(adapter)
+		  establish(conf)
+	  end
+
+  end
+
+end