zeng 0.0.1

data/lib/cute_kv/document.rb

@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+require 'yaml'
+require 'uuid'
+require 'json'
+require 'json/add/core'
+
+module CuteKV
+  class CuteKVError < StandardError;end
+  class ObjectNotSaved < CuteKVError; end
+
+  #  CuteKV's built-in attribute id is the <t>key</t> to access <t>value</t>, and id is formated by uuid.
+  #  ==
+  #  CuteKV provide a Document module to persistence class's attributes, when a class include Document module,
+  #  then it can <t>assign</t> attributes needed to persistence.
+  #
+  #    class User
+  #      include CuteKV::Document
+  #      assign :name,:age=>25,:gender=>"male"
+  #    end
+  #
+  #    User have three persistence attributes: "name", "age"(default value is 25) and "gender"(default male)
+  #    @jim = User.new(:name=>"jim")
+  #    @jim.name               #=> "jim"
+  #    @jim.age                #=> 25
+  #    @jim.gender             #=> "male"
+  #
+  #  Every object has a default +id+, if you want to set primary key, you can use <t>primary_key</t> to set up.
+  #
+  #    class Account < ActiveObject::Base
+  #      include CuteKV::Document
+  #      assign :name,:email,:encrypt_password
+  #      primary_key :email
+  #    end
+  #
+  #  == New
+  #     Use hash params to create a new object, example:
+  #   user = User.new(:name => "David", :occupation => "Code Artist")
+  #   user.name # => "David"
+  #
+  #     you can initialize object by using block
+  #   user = User.new {|u| u.name = "David"; u.occupation = "Code Artist"}
+  #
+  #     Also，you can first create a bare object then assign values to it
+  #   user = User.new
+  #   user.name = "David"
+  #   user.occupation = "Code Artist"
+  #
+  #  == Create
+  #
+  #  == Update
+  #
+  #  == Destroy
+  #
+  #     ==== params
+  #
+  # * +object+ is what you want to destroy
+  #
+  #     ==== example
+  #     jim = User.create(:name=>"jim")
+  #   User.Destroy(jim)
+  #   if Account.destroy(jim) will return nil, because jim is not a instance object of Account.
+
+
+  module Document
+
+    def self.included(base)
+      base.extend ClassMethods
+      # select serializers, exmaple "json", ",marshal", default is "json"
+      base.select_serializer(:json)
+      base.send :include, InstanceMethods
+      base.send :include, Serialization
+      base.send :include, Timestamp
+      add_client(base) unless clients.include?(base)
+    end
+
+    module InstanceMethods
+      attr_reader :id
+
+      def initialize(attributes={}, new_id=true)
+        if new_id
+          @id = UUID.new.generate
+          assigned_attrs = self.class.read_assigned_attributes_with_default_values
+          attributes.each_key {|key| assigned_attrs.delete(key)}
+          attributes.merge!(assigned_attrs)
+        end
+        attributes.each {|attr, value| self.send "#{attr}=", value if self.respond_to? "#{attr}=" }
+        yield self if block_given?
+      end
+
+      # we protect class's backend from instance objects
+      def save
+        self.class.save(self)
+      end
+
+      def serialized_attributes
+        seri_attrs = assigned_attributes.inject({}){|h,attr|
+          h[attr] = self.send attr if self.respond_to? attr
+          h
+        }
+        #
+        #don't use :id, or you will get @id=nil when you use marshal to serialize object's attributes
+        seri_attrs["id"] = @id
+        self.class.serialize seri_attrs
+      end
+
+      def assigned_attributes
+        self.class.assigned_attributes
+      end
+
+      # update object's attributes
+      # <tt>attributes</tt>are the attributes needed to be updated
+      def update(attributes={})
+        self.class.update(self, attributes)
+      end
+
+
+
+      # reload object from database
+      def reload
+        self.class.reload(self)
+      end
+
+      # destroy self from database
+      def destroy
+        self.class.destroy(self)
+      end
+
+      def assigned_attributes_values
+        self.assigned_attributes.inject({}){|h,attr| h[attr] = self.send attr; h  }
+      end
+
+    end
+
+    module ClassMethods
+
+      # Assigning attributs needed to persistence
+      #  Example:
+      #    class User
+      #      include CuteKV::Document
+      #      assign :name, :country=>"China", :gender=>"male"
+      #    end
+      def assign(*attributes)
+        attrs = attributes.inject({}){ |h,attr|
+          if attr.is_a? Hash
+            attr.each {|k, v| attr_accessor k; h[k.to_sym] = v }
+          else
+            attr_accessor attr
+            h[attr.to_sym] = nil
+          end
+          h
+        }
+        write_assigned_attributes_with_default_values(attrs)
+      end
+
+      def write_assigned_attributes_with_default_values(attributes={})
+        (@assigned_attributes_with_default_values ||={}).merge!(attributes)
+      end
+
+      def read_assigned_attributes_with_default_values
+        @assigned_attributes_with_default_values.dup
+      end
+
+      def assigned_attributes
+        @assigned_attributes_with_default_values.keys
+      end
+
+      def backend
+        @backend
+      end
+
+
+      #empty database
+      def clear
+        @backend.clear
+      end
+
+
+      # Configure CuteKV's Back-end database,now support LightCloud/TokyoTyrant/TokyoCabinet.
+      #   +adapter+ specify what database to use
+      #     :TC => TokyoCabinet (few to use :TC in our practice projects)
+      #     :TT => TokyoTyrant
+      #     :LC => LightCloud
+      #
+      #  +config+ is the config infos about back-end
+      #           when +adapter+ is specified to :TT, +config+ coulde be a String or Hash
+      #     String:
+      #       User.backend_configure :TT, "127.0.0.1:1985"
+      #     or Hash:
+      #       User.backend_configure :TT, :host=>'127.0.0.1', :port=>1985
+      #
+      #
+      #Back-end database,now we support tokyotyrant, lightcloud
+      def backend_configure(adapter, config)
+        @backend = Connector.new(adapter,config)
+      end
+
+
+      # 返回当前对象的数据库和索引配置信息
+      def backend_configurations
+        @backend.infos
+      end
+
+
+      #
+      # find object by it's +id+
+      # ==== Example
+      #   User.find('aaron@nonobo.com') return an User's instance object
+      #   if User's backend has this id or return nil
+      def find(id)
+        return if id.nil?
+        raw_value = @backend.get(id)
+        return if raw_value.nil?
+        value = deserialize raw_value
+        active(value)
+      end
+
+      # Active sleeped value so we'll get a live object :-)
+      # It's should not generate a new id, because this value has included a id
+      def active(value, new_id=false)
+        id = value.delete("id")
+        new(value, new_id) {|obj| obj.instance_variable_set(:@id, id)}
+      end
+
+      def all
+      end
+
+      # Create one or more objects and save them to database
+      # return objects you have created
+      # parameters +attributes+ is Hash or hash Array
+      #
+      # ==== Example
+      #   # create single object
+      #   User.create(:first_name => 'Jamie')
+      #
+      #   # create more objects
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
+      #
+      #   # create an object, and assign values to attributes through block
+      #   User.create(:first_name => 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      def create(attributes = {}, &block)
+        object = new(attributes)
+        yield(object) if block_given?
+        object.save
+        object
+      end
+
+      def save(object)
+        object.is_a?(self) ? @backend.put(object.id, object.serialized_attributes) : nil
+      end
+
+      def update(object, attributes={})
+        object.is_a?(self) ? attributes.each{|key,value|
+          object.send("#{key}=",value) if object.respond_to? "#{key}="
+        } : nil
+      end
+
+      def reload(object)
+        return unless object.is_a?(self)
+        raw_value = @backend.get(object.id)
+        return if raw_value.nil?
+        value = deserialize raw_value
+        update(object, value)
+      end
+
+
+      # destroy object who is an instance of Actors # and execute all callback and filt actions
+      # ==== Example
+      #   aaron = User.create(:name=>"aaron")
+      #   User.destroy(aaron)
+      def destroy(object)
+        object.is_a?(self) ? @backend.delete(object.id) : nil
+      end
+
+      Serializers ={
+        :json => {:ser=> lambda{|value| JSON.generate(value)},
+          :desr=>lambda{|raw| JSON.parse(raw)},
+          :type=>"json"
+        },
+        :marshal => {:ser=> lambda{|value| Marshal.dump(value)},
+          :desr=>lambda{|raw| Marshal.load(raw)},
+          :type => "marshal"
+        }
+      }
+
+      def select_serializer(type=:json)
+        @serializer = Serializers[type]
+      end
+
+      def serializer_type
+        @serializer[:type]
+      end
+
+      def serialize(value)
+        @serializer[:ser].call(value)
+      end
+
+      def deserialize(raw_value)
+        @serializer[:desr].call(raw_value)
+      end
+
+    end
+
+    class << self
+      def backend_configure(klass,adapter, host_port )
+      end
+
+      # docking external mod, so that expanding Document's functions
+      # and class who has included Document will hold the exteranl mod's methods.
+      def docking(mod)
+        @clients.each {|client| client.send :include, mod }
+      end
+
+      def add_client(client)
+        (@clients ||= []) << client if client.is_a? Class
+      end
+
+      def clients
+        (@clients ||= []).dup
+      end
+
+    end
+
+  end
+
+end

data/lib/cute_kv/ext/string.rb

@@ -0,0 +1,34 @@
+class String
+
+	def plural?
+		(Dic::PLU_WORDS.include?(self) || self.pluralize == self) && !Dic::SIN_WORDS.include?(self) 
+	end
+
+	def singular?
+		(Dic::SIN_WORDS.include?(self) || self.singularize == self) && !Dic::PLU_WORDS.include?(self)
+	end
+
+end
+
+module WordAct
+	def add(words)
+    if words.is_a? Array
+			words.each {|w| self.add(w.to_s)}
+		else
+			self << words.to_s
+			Dic::Mirror[self].delete(words.to_s)
+			self.uniq!
+		end
+	end
+
+	def hash
+		self.object_id
+	end
+end
+
+module Dic
+	(SIN_WORDS = []).extend(WordAct)
+	(PLU_WORDS = []).extend(WordAct)
+	Mirror = {SIN_WORDS=>PLU_WORDS, PLU_WORDS=>SIN_WORDS}
+end
+

data/lib/cute_kv/ext/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+	def plural?
+		self.to_s.plural?
+	end
+
+	def singular?
+		self.to_s.singular?
+	end
+end

data/lib/cute_kv/indexer.rb

@@ -0,0 +1,102 @@
+module CuteKV
+  module Indexer
+    Map = Class.new
+    Collection = Class.new(Array)
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      attr_reader :key, :values
+      attr_accessor :index_attrs
+
+
+      def initialize(key, value)
+        @key = key
+        @values = JSON.parse value
+      end
+
+      def save
+        self.class.save(self)
+      end
+
+      def objects
+        map = self
+        index_attrs = self.index_attrs
+        Collection.class_eval {
+          define_method(:<<){|obj|
+            old = map.values.assoc(obj.id)
+            map.values.delete(old)
+            index = index_attrs.inject({}){
+              |h, attr| h[attr] = obj.send(attr) if obj.respond_to?(attr)
+              h
+            }
+            index.merge!(:id=>obj.id)
+            map.values << [obj.id,index]
+            map.save
+
+          }
+        }
+        values = Collection.new.replace(self.values)
+      end
+
+    end
+
+    module ClassMethods
+      def connect(klass)
+        @backend = klass.backend
+      end
+
+      def find(key)
+        new(key, @backend[key]) if @backend[key]
+      end
+
+      def create(key, values=[])
+        value = JSON.generate values
+        @backend[key] = value
+        new(key, value)
+      end
+
+      def save(map)
+        @backend[map.key] = JSON.generate map.values
+      end
+
+      def find_or_create(key)
+        find(key) || create(key)
+      end
+
+    end
+
+
+    class << self
+
+      def map(class_attrs={})
+        c = class_attrs.keys[0]
+        attrs = class_attrs.values.flatten
+        key = "#{c}-index-#{attrs.join('-')}"
+        index_map = Map.send(:include, self)
+        index_map.connect(c)
+        klass = class << c; self; end
+        klass.instance_eval {
+          define_method(:indexes){
+            map = index_map.find_or_create(key)
+            map.index_attrs = attrs
+            map.objects
+          }
+          attrs.each {|attr|
+            define_method("find_all_by_#{attr}"){|value|
+              c.indexes.map {|index|
+                c.find(index[-1]['id']) if index[-1][attr.to_s] == value
+              }.compact
+            }
+          }
+        }
+        true
+      end
+
+    end
+
+  end
+end

data/lib/cute_kv/serialization.rb

@@ -0,0 +1,95 @@
+module CuteKV#:nodoc:
+  module Serialization
+    class Serializer #:nodoc:
+      attr_reader :options
+
+      def initialize(object, options = {})
+        @object, @options = object, options.dup
+      end
+
+      # To replicate the behavior in ActiveObject#attributes,
+      # <tt>:except</tt> takes precedence over <tt>:only</tt>.  If <tt>:only</tt> is not set
+      # for a N level model but is set for the N+1 level models,
+      # then because <tt>:except</tt> is set to a default value, the second
+      # level model can have both <tt>:except</tt> and <tt>:only</tt> set.  So if
+      # <tt>:only</tt> is set, always delete <tt>:except</tt>.
+      def serializable_attribute_names
+        attribute_names = @object.assigned_attributes.collect {|n| n.to_s} << "id"
+
+        if options[:only]
+          options.delete(:except)
+          attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
+        else
+          options[:except] = Array(options[:except])
+          attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
+        end
+
+        attribute_names
+      end
+
+      def serializable_method_names
+        Array(options[:methods]).inject([]) do |method_attributes, name|
+          method_attributes << name if @object.respond_to?(name.to_s)
+          method_attributes
+        end
+      end
+
+      def serializable_names
+        serializable_attribute_names + serializable_method_names
+      end
+
+      # Add associations specified via the <tt>:includes</tt> option.
+      # Expects a block that takes as arguments:
+      #   +association+ - name of the association
+      #   +objects+     - the association object(s) to be serialized
+      #   +opts+        - options for the association objects
+      def add_includes(&block)
+        if include_associations = options.delete(:include)
+          base_only_or_except = { :except => options[:except],
+                                  :only => options[:only] }
+
+          include_has_options = include_associations.is_a?(Hash)
+          associations = include_has_options ? include_associations.keys : Array(include_associations)
+
+          for association in associations
+            objects = @object.send association
+
+            unless objects.nil?
+              association_options = include_has_options ? include_associations[association] : base_only_or_except
+              opts = options.merge(association_options)
+              yield(association, objects, opts)
+            end
+          end
+
+          options[:include] = include_associations
+        end
+      end
+
+      def serializable_object
+        returning(serializable_object = {}) do
+          serializable_names.each { |name| serializable_object[name] = @object.send(name) }
+
+          add_includes do |association, objects, opts|
+            if objects.is_a?(Enumerable)
+              serializable_object[association] = objects.collect { |r| self.class.new(r, opts).serializable_object }
+            else
+              serializable_object[association] = self.class.new(objects, opts).serializable_object
+            end
+
+          end
+        end
+      end
+
+      def serialize
+        # overwrite to implement
+      end
+
+      def to_s(&block)
+        serialize(&block)
+      end
+    end
+  end
+end
+
+require 'cute_kv/serializers/xml_serializer'
+require 'cute_kv/serializers/json_serializer'

data/lib/cute_kv/serializers/json_serializer.rb

@@ -0,0 +1,75 @@
+module CuteKV#:nodoc:
+	module Serialization
+		def self.included(base)
+			base.cattr_accessor :include_root_in_json, :instance_writer => false
+			base.extend ClassMethods
+		end
+
+		# Returns a JSON string representing the model. Some configuration is
+		# available through +options+.
+		#
+		# Without any +options+, the returned JSON string will include all
+		# the model's attributes. For example:
+		#
+		#   konata = User.find(1)
+		#   konata.to_json
+		#   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+		#         "created_at": "2006/08/01", "awesome": true}
+		#
+		# The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
+		# included, and work similar to the +attributes+ method. For example:
+		#
+		#   konata.to_json(:only => [ :id, :name ])
+		#   # => {"id": 1, "name": "Konata Izumi"}
+		#
+		#   konata.to_json(:except => [ :id, :created_at, :age ])
+		#   # => {"name": "Konata Izumi", "awesome": true}
+		#
+		# To include any methods on the model, use <tt>:methods</tt>.
+		#
+		#   konata.to_json(:methods => :permalink)
+		#   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+		#         "created_at": "2006/08/01", "awesome": true,
+		#         "permalink": "1-konata-izumi"}
+		#
+		# To include associations, use <tt>:include</tt>.
+		#
+		#   konata.to_json(:include => :posts)
+		#   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+		#         "created_at": "2006/08/01", "awesome": true,
+		#         "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
+		#                   {"id": 2, author_id: 1, "title": "So I was thinking"}]}
+		#
+		# 2nd level and higher order associations work as well:
+		#
+		#   konata.to_json(:include => { :posts => {
+		#                                  :include => { :comments => {
+		#                                                :only => :body } },
+		#                                  :only => :title } })
+		#   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+		#         "created_at": "2006/08/01", "awesome": true,
+		#         "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
+		#                    "title": "Welcome to the weblog"},
+		#                   {"comments": [{"body": "Don't think too hard"}],
+		#                    "title": "So I was thinking"}]}
+		def to_json(options = {})
+			if include_root_in_json
+				"{#{self.class.json_class_name}: #{JsonSerializer.new(self, options).to_s}}"
+			else
+				JsonSerializer.new(self, options).to_s
+			end
+		end
+
+		class JsonSerializer < CuteKV::Serialization::Serializer #:nodoc:
+			def serialize
+				serializable_object.to_json
+			end
+		end
+
+		module ClassMethods
+			def json_class_name
+				@json_class_name ||= name.demodulize.underscore.inspect
+			end
+		end
+	end
+end