activeobject 0.0.3

data/lib/active_object/associations.rb

@@ -0,0 +1,200 @@
+module ActiveObject
+
+	module Associations
+		def self.included(base)
+			base.send :include, HasOneAssociation
+			base.send :include, HasManyAssociation
+		end
+
+		module HasOneAssociation
+			def self.included(base)
+				base.extend ClassMethods
+			end
+
+			module ClassMethods
+
+				#  has_one用于指明两个对象之间的关联。
+	      #
+	      #  一旦使用has_one，下列方法将被添加:
+	      #
+	      # [association]
+	      #   返回关联对象. 如果没有找到则返回+nil+。
+	      # [association=(associate)]
+	      #   对关联对象赋值。
+	      # [association.nil?]
+	      #   如果没有关联对象，则返回+true+。
+	      #
+	      # (用第一个参数替换+association+,例如：
+	      # <tt>has_one :manager</tt> 将添加 <tt>manager.nil?</tt>.)
+	      #
+	      # === 示例
+	      #
+	      # Account类定义了<tt>has_one :beneficiary</tt>,将添加:
+	      # * <tt>Account#beneficiary</tt>
+	      # * <tt>Account#beneficiary=(beneficiary)</tt>
+	      # * <tt>Account#beneficiary.nil?</tt>
+	      #
+	      # === 选项
+	      #
+	      # 通过hash选项指定关联的行为
+	      #
+	      # 选项:
+	      # [:class_name]
+	      #   指定关联的类名。默认情况类名是有关联推断出来的，如果无法推断则需要显性指定。
+				#
+				# 选项示例:
+				# 	has_one :icon,:class_name=>"Photo"
+				#
+				def has_one(association, options = {})
+
+					class_name = options.delete(:class_name) || association.to_s.camelize
+					write_inheritable_attribute "#{association}_class",class_name   # 保存关联的类名
+					attr_accessor "#{association}"
+					merge_attributes "#{association}_id"                            # 将关联id作为持久化属性
+
+					define_method("#{association}_id") do
+						self.instance_variable_get("@#{association}") ? self.instance_variable_get("@#{association}").id : nil
+					end
+
+					define_method("#{association}_id=") do |value|
+						self.instance_variable_set("@#{association}",self.class.read_inheritable_attribute("#{association}_class").constantize.find(value))
+					end
+				end
+
+			end
+		end
+
+		module HasManyAssociation
+			def self.included(base)
+				base.extend ClassMethods
+			end
+
+			class Collection
+				def initialize()
+					@objects = []
+				end
+				# 遍历关联对象集合
+				def each
+					@objects.each do |object|
+						yield object
+					end
+				end
+
+				def each_with_index
+					@objects.each_with_index do |object,index|
+						yield object,index
+					end
+				end
+
+				# 添加一个关联对象
+				def append(object)
+					@objects << object
+				end
+
+				# 插入一个关联对象
+				def insert(index,object)
+					@objects.insert(index,object)
+				end
+
+				# 删除一个关联对象
+				def delete(object)
+					@objects.delete(object)
+				end
+
+				def size
+					@objects.size
+				end
+
+				def clear
+					@objects.clear
+				end
+
+				def empty?
+					@objects.empty?
+				end
+
+				def object_ids
+					@objects.collect{|object| object.id}
+				end
+
+				def objects
+					@objects
+				end
+			end
+
+			module ClassMethods
+
+				#  has_many用于指明两个对象之间的关联。
+	      #
+	      #  一旦使用has_many，下列方法将被添加:
+	      # [associations.each]
+	      #   遍历对象集合
+	      # [associations]
+	      #   返回关联的对象集合. 如果没有找到则返回空数组。
+	      # [associations.append(object)]
+	      #   添加一个关联对象。
+	      # [associations.insert(object,index)]
+	      #   插入一个关联对象。
+	      # [associations.delete(object)]
+	      #   删除一个关联对象。
+	      # [associations.clear]
+	      #   清除所有关联对象。
+	      # [associations.size]
+	      #   关联对象的数量。
+	      # [association.empty?]
+	      #   如果没有关联对象，则返回+true+。
+	      #
+	      # (用第一个参数替换+associations+,例如：
+	      # <tt>has_many :managers</tt> 将添加 <tt>managers.empty?</tt>.)
+	      #
+	      # === 示例
+	      #
+	      # Account类定义了<tt>has_many :friends</tt>,将添加:
+	      # * <tt>Account#friends</tt>
+	      # * <tt>Account#friends.append(user)</tt>
+	      # * <tt>Account#friends.delete(user)</tt>
+	      # * <tt>Account#friends.clear</tt>
+	      # * <tt>Account#friends.size</tt>
+	      # * <tt>Account#friends.empty?</tt>
+	      #
+	      # === 选项
+	      #
+	      # 通过hash选项指定关联的行为
+	      #
+	      # 选项:
+	      # [:class_name]
+	      #   指定关联的类名。默认情况类名是有关联推断出来的，如果无法推断则需要显性指定。
+				#
+				# 选项示例:
+				# 	has_many :friends,:class_name=>"User"
+				#
+				def has_many(associations, options = {})
+
+					class_name = options.delete(:class_name) || associations.to_s.singularize.camelize
+					write_inheritable_attribute "#{associations}_class",class_name   # 保存关联的类名
+					merge_attributes "#{associations}_ids"                            # 将关联ids作为持久化属性
+
+					define_method("#{associations}_ids") do
+						self.instance_variable_get("@#{associations}") ? self.instance_variable_get("@#{associations}").object_ids : []
+					end
+
+					define_method("#{associations}_ids=") do |value|
+						self.instance_variable_set("@#{associations}",Collection.new)
+						value.each do |object_id|
+							self.instance_variable_get("@#{associations}").append(self.class.read_inheritable_attribute("#{associations}_class").constantize.find(object_id))
+						end
+					end
+
+					define_method("#{associations}") do
+					  self.instance_variable_set("@#{associations}",Collection.new) unless self.instance_variable_get("@#{associations}")
+					  self.instance_variable_get("@#{associations}")
+					end
+
+				end
+
+			end
+		end
+
+	end
+
+end

data/lib/active_object/base.rb

@@ -0,0 +1,415 @@
+require 'yaml'
+require 'uuid'
+require 'json'
+require 'active_object/adapters/light_cloud'
+require 'active_object/adapters/tokyo_cabinet'
+require 'active_object/adapters/tokyo_tyrant'
+
+
+# 实现访问LightCloud的通用方法
+module ActiveObject
+	class ActiveObjectError < StandardError;end
+
+	class ObjectNotFound < ActiveObjectError;end
+
+	class ObjectNotSaved < ActiveObjectError;end
+
+	class ConfigError < ActiveObjectError;end
+
+  #  ActiveObject内建id属性，采用uuid格式，对象的key由对象类和uuid组成，中间用下划线相连。通过attribute指定需要持久化的属性。
+  #
+  #  == 描述类
+  #  ActiveObject所有类都是从Base类派生的，在派生新类时需要指定持久化存储的属性.就像下面一样:
+  #
+  #    class User < ActiveObject::Base
+  #      attribute :name,:email,:encrypt_password
+  #    end
+  #
+  #  每个对象有默认的ID,如果想指定主关键字，可以通过primary_key指定
+  #
+  #    class User < ActiveObject::Base
+  #      primary_key :email
+  #      attribute :name,:email,:encrypt_password
+  #    end
+  #
+  #  == 新建
+  # 可以通过hash参数新建对象,例如：
+  #   user = User.new(:name => "David", :occupation => "Code Artist")
+  #   user.name # => "David"
+  #
+  # 也可以使用块初始化对象:
+  #
+  #   user = User.new do |u|
+  #     u.name = "David"
+  #     u.occupation = "Code Artist"
+  #   end
+  #
+  # 当然，也可以在新建后对特定的属性赋值：
+  #
+  #   user = User.new
+  #   user.name = "David"
+  #   user.occupation = "Code Artist"
+  #
+  # == 删除
+  # 删除主关键字与参数 +id+ 匹配的对象。
+  #
+  # ==== 参数
+  #
+  # * +id+ - 对象的主关键字.
+  #
+  # ==== 例子
+  #
+  #   User.delete('aaron@nonobo.com')
+
+
+	class Base
+		write_inheritable_attribute :attributes,[:id]
+		write_inheritable_attribute :primary_key,nil
+
+		@@configurations = nil
+		@@database_model = nil
+
+		@@connection = nil
+
+		class << self
+
+			# 定义需要持久化的属性
+			#  示例:
+			#    class User < ActiveObject::Base
+			#      attribute :email,:name,:password  # 表示email,name,password需要持久化存储
+			#    end
+			def attribute(*options)
+				options.each do |attribute|
+				  attr_accessor attribute
+				end
+				merge_attributes options
+			end
+
+			def attributes
+				read_inheritable_attribute(:attributes)
+			end
+
+			def primary_key(value=nil)
+				if value
+					write_inheritable_attribute :primary_key,value
+				else
+					read_inheritable_attribute(:primary_key)
+				end
+			end
+
+
+			# 配置ActiveObject访问的后台数据库支撑，目前支持LightCloud/TokyoTyrant/TokyoCabinet。
+			#  参数 +model+ 用于描述后台数据库的类型。
+			#     :TC => 表示TokyoCabinet
+			#     :TT => 表示TokyoTyrant
+			#     :LC => 表示LightCloud
+			#
+			#  参数 +config+ 用于接收后台数据库的配置信息。
+			#
+			#  	  当model指定为TokyoCabinet数据库时，config为指定的文件名，例如：
+			#        ActiveObject::Base.configure :TC, File.join(File.dirname(__FILE__),'act.tch')
+			#     这里需要注意的是指定的文件名后缀符合TokyoCabinet的约定规则。更多信息请参看:http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
+			#
+			#
+			#
+			#     当model指定为TokyoTyrant数据库时， config为指定的远程服务器地址，例如:
+			#        ActiveObject::Base.configure :TT, '127.0.0.1:54321'
+			#
+			#     当model指定为LightCloud数据库时， config可以接收符合配置规则的hash:
+			#        ActiveObject::Base.configure :LC, {'user'=>{'lookup_one'=>['127.0.0.1:30001','127.0.0.1:33001'],'storage_one'=>['127.0.0.1:20001','127.0.0.1:24001']}}
+			#     也可以是配置文件的文件名。
+			#        ActiveObject::Base.configure :LC, File.join(File.dirname(__FILE__),'config.yml')
+			#
+			def configure(model,config)
+				@@configurations = config
+				@@database_model = model
+				case @@database_model
+					when :TC
+						ActiveObject::Base.send :include,ActiveObjectTokyoCabinet
+					when :TT
+						ActiveObject::Base.send :include,ActiveObjectTokyoTyrant
+					when :LC
+						ActiveObject::Base.send :include,ActiveObjectLightCloud
+					else
+						raise ConfigError,'没有指定数据库类型！'
+				end
+			end
+
+			def configurations
+				@@configurations
+			end
+
+			# 返回当前所使用的数据库模型
+			#  :TC表示采用的是TokyoCabinet
+			#  :TT表示采用的是TokyoTyrant
+			#  :LC表示采用的是LightCloud
+			def database_model
+				@@database_model
+			end
+
+			# 通过主关键字查找对象
+			#
+			#   +id+ 参数表示需要找回的主关键字.
+			#
+			# ==== Example
+			#   User.find('aaron@nonobo.com')
+			#
+			def find(id)
+				return nil if id.blank?
+				record = load(id)
+				record ? instance(id,record) : nil
+			end
+
+			# 查找该类的所有对象
+			#  User.find_all => 取出所有的用户
+			#def find_all
+			#end
+
+      # 新建对象（或多个对象）并保存到数据库(假设都通过验证)
+      # 不管是否保存到数据库，都将返回对象.
+      #
+      # 参数 +attributes+ 可以是Hash或Hash数组.
+      #
+      # ==== 示例
+      #   # 创建单个新对象
+      #   User.create(:first_name => 'Jamie')
+      #
+      #   # 创建多个对象
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
+      #
+      #   # 创建对象，并通过块进行其它属性的赋值.
+      #   User.create(:first_name => 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # 创建多个对象，并通过块进行其它属性的赋值，每个对象都会执行块：
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def create(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, &block) }
+        else
+          object = new(attributes)
+          yield(object) if block_given?
+          object.save
+          object
+        end
+      end
+
+
+      # 删除主关键字与参数 +id+ 匹配的对象，并且在删除之前执行所有的回调和过滤。
+      #
+      # ==== 参数
+      #
+      # * +id+ - 对象的主关键字.
+      #
+      # ==== 示例
+      #   User.destroy('aaron@nonobo.com')
+      def destroy(id)
+      	find(id).destroy
+      end
+
+			# 在适配器中重写
+      #def delete(id)
+      #end
+
+      def base_class
+        class_of_active_object_descendant(self)
+      end
+
+      def self_and_descendents_from_active_object#nodoc:
+        klass = self
+        classes = [klass]
+        while klass != klass.base_class
+          classes << klass = klass.superclass
+        end
+        classes
+      rescue
+        [self]
+      end
+
+    	# 通过id转换成存取用的key
+			def id_to_key(id)
+				"#{self.to_s}_#{id}"
+			end
+
+			# 将key转换成id
+			def key_to_id(key)
+				key[key.index("_")+1..-1]
+			end
+
+			def deserialize_attributes(raw_record)
+				Marshal.load(raw_record)
+			end
+
+			def serialize_attributes(record)
+				Marshal.dump(record)
+			end
+
+			protected
+        def class_of_active_object_descendant(klass)
+          if klass.superclass == Base
+            klass
+          elsif klass.superclass.nil?
+            raise ActiveObjectError, "#{name} doesn't belong in a hierarchy descending from ActiveObject"
+          else
+            class_of_active_object_descendant(klass.superclass)
+          end
+        end
+
+				def configurations=(value)
+					@@configurations= value
+				end
+
+				def database_model=(value)
+					@@database_model = value
+				end
+
+				# 合并属性
+				def merge_attributes(options)
+					attrs = read_inheritable_attribute :attributes
+					attrs << options
+					write_inheritable_attribute :attributes, attrs.flatten.uniq
+				end
+
+      private
+				# 在设配器中重写
+				#def load(id)
+				#end
+
+      	# 构建一个对象实例
+        def instance(id,record)
+       	  object = new(record)
+       	  object.send "id=",id
+					object.instance_variable_set(:@new_record,false)
+					object
+       	end
+
+		end
+
+		def initialize(attributes = nil)
+			self.id = UUID.new.generate
+			@new_record = true
+			assign_attributes(attributes)
+      object = yield self if block_given?
+      object
+		end
+
+		def attributes
+			self.class.attributes
+		end
+
+		# id用来标识对象
+		# 为了能够通过前缀访问对象,在uuid之前加入对象的类名作为存取的key
+		def id=(value)
+			@key = self.class.id_to_key(value)
+		end
+
+		def id
+			self.class.key_to_id(@key)
+		end
+
+    # 如果对象没有被存储，表明对象还是新记录，返回true，否则返回false.
+    def new_record?
+      @new_record
+    end
+
+    # 如果对象已经被删除，返回true，否则返回false。
+    def destroyed?
+      @destroyed || false
+    end
+
+    # 从数据库中删除对象
+    # 不像 #destroy, 这个方法不运行 +before_delete+ 和 +after_delete+ 回调.
+    def delete
+      self.class.delete(id) unless new_record?
+      @destroyed = true
+    end
+
+    def destroy
+    	delete
+    end
+
+    # 从数据库中重新加载对象的属性
+    def reload
+			#raise "Object is deleted" if destroyed?
+			unless new_record?
+				begin
+					attributes = self.class.send :load, self.id
+					assign_attributes(attributes)
+					true
+				rescue
+					false
+				end
+			end
+    end
+
+    # :call-seq:
+    #   save(perform_validation = true)
+    #
+    # 保存对象.
+    #
+    # 如果对象是新对象，那么在数据库中创建。否则，如果对象是数据库中已经存在的对象，那么更新数据库
+    #
+    # 如果 +perform_validation+ 是true，将执行验证。如果验证失败，那么动作被取消，并且返回false。
+    #
+    # +save+ 相关联的一系列回调. 如果任何一个<tt>before_*</tt>回调返回 +false+，那么+save+动作被取消并返回 +false+.
+		def save
+			create_or_update
+		end
+
+    # 保存对象.
+    #
+		# 如果对象是新对象，那么在数据库中创建。否则，如果对象是数据库中已经存在的对象，那么更新数据库
+    #
+    # 执行<tt>save!</tt>时，验证总是被运行。只要有任意一个执行失败都将抛出 ActiveObject::ObjectInvalid异常。
+    #
+    # +save+ 相关联的一系列回调. 如果任何一个<tt>before_*</tt>回调返回 +false+，那么+save+动作被取消并返回 +false+，并且抛出ActiveObject::RecordNotSaved.
+    def save!
+      create_or_update || raise(ObjectNotSaved)
+    end
+
+
+		private
+      def attribute_present?(attribute)
+        value = read_attribute(attribute)
+        !value.blank?
+      end
+
+			def assign_attributes(attributes=nil)
+				attributes.each do |key,value|
+					self.send "#{key}=",value
+				end unless attributes.nil?
+			end
+
+			def create_or_update
+        result = new_record? ? create : update
+        @destroyed = false
+        @new_record = false
+        result != false
+			end
+
+			def serialize_attributes
+				record = {}
+				self.class.attributes.each do |attribute|
+				  record.merge!({attribute=>(self.send attribute)})
+				end
+				self.class.serialize_attributes(record)
+			end
+
+			def create
+				self.id = self.send self.class.primary_key if self.class.primary_key
+				set
+			end
+
+			def update
+				set
+			end
+
+			# 保存记录,在适配器中重写
+			#def set
+			#end
+	end
+
+end