zeng 0.0.1 → 0.0.2

data/lib/cute_kv/connector.rb

@@ -1,27 +0,0 @@
-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

data/lib/cute_kv/ext/string.rb

@@ -1,34 +0,0 @@
-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

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

data/lib/cute_kv/serialization.rb

@@ -1,95 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

data/lib/cute_kv/serializers/xml_serializer.rb

@@ -1,325 +0,0 @@
-module CuteKV#:nodoc:
-  module Serialization
-    # Builds an XML document to represent the model. Some configuration is
-    # available through +options+. However more complicated cases should
-    # override ActiveObject::Base#to_xml.
-    #
-    # By default the generated XML document will include the processing
-    # instruction and all the object's attributes. For example:
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <id type="integer">1</id>
-    #     <approved type="boolean">false</approved>
-    #     <replies-count type="integer">0</replies-count>
-    #     <bonus-time type="datetime">2000-01-01T08:28:00+12:00</bonus-time>
-    #     <written-on type="datetime">2003-07-16T09:28:00+1200</written-on>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # This behavior can be controlled with <tt>:only</tt>, <tt>:except</tt>,
-    # <tt>:skip_instruct</tt>, <tt>:skip_types</tt> and <tt>:dasherize</tt>.
-    # The <tt>:only</tt> and <tt>:except</tt> options are the same as for the
-    # +attributes+ method. The default is to dasherize all column names, but you
-    # can disable this setting <tt>:dasherize</tt> to +false+. To not have the
-    # column type included in the XML output set <tt>:skip_types</tt> to +true+.
-    #
-    # For instance:
-    #
-    #   topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ])
-    #
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <approved type="boolean">false</approved>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # To include first level associations use <tt>:include</tt>:
-    #
-    #   firm.to_xml :include => [ :account, :clients ]
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # To include deeper levels of associations pass a hash like this:
-    #
-    #   firm.to_xml :include => {:account => {}, :clients => {:include => :address}}
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # To include any methods on the model being called use <tt>:methods</tt>:
-    #
-    #   firm.to_xml :methods => [ :calculated_earnings, :real_earnings ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <calculated-earnings>100000000000000000</calculated-earnings>
-    #     <real-earnings>5</real-earnings>
-    #   </firm>
-    #
-    # To call any additional Procs use <tt>:procs</tt>. The Procs are passed a
-    # modified version of the options hash that was given to +to_xml+:
-    #
-    #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
-    #   firm.to_xml :procs => [ proc ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <abc>def</abc>
-    #   </firm>
-    #
-    # Alternatively, you can yield the builder object as part of the +to_xml+ call:
-    #
-    #   firm.to_xml do |xml|
-    #     xml.creator do
-    #       xml.first_name "David"
-    #       xml.last_name "Heinemeier Hansson"
-    #     end
-    #   end
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <creator>
-    #       <first_name>David</first_name>
-    #       <last_name>Heinemeier Hansson</last_name>
-    #     </creator>
-    #   </firm>
-    #
-    # As noted above, you may override +to_xml+ in your ActiveObject::Base
-    # subclasses to have complete control about what's generated. The general
-    # form of doing this is:
-    #
-    #   class IHaveMyOwnXML < ActiveObject::Base
-    #     def to_xml(options = {})
-    #       options[:indent] ||= 2
-    #       xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-    #       xml.instruct! unless options[:skip_instruct]
-    #       xml.level_one do
-    #         xml.tag!(:second_level, 'content')
-    #       end
-    #     end
-    #   end
-    def to_xml(options = {}, &block)
-      serializer = XmlSerializer.new(self, options)
-      block_given? ? serializer.to_s(&block) : serializer.to_s
-    end
-
-  end
-
-  class XmlSerializer < CuteKV::Serialization::Serializer #:nodoc:
-    def builder
-      @builder ||= begin
-        options[:indent] ||= 2
-        builder = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-        unless options[:skip_instruct]
-          builder.instruct!
-          options[:skip_instruct] = true
-        end
-
-        builder
-      end
-    end
-
-    def root
-      root = (options[:root] || @object.class.to_s.underscore).to_s
-      dasherize? ? root.dasherize : root
-    end
-
-    def dasherize?
-      !options.has_key?(:dasherize) || options[:dasherize]
-    end
-
-    def serializable_attributes
-      serializable_attribute_names.collect { |name| Attribute.new(name.to_s, @object) }
-    end
-
-    def serializable_method_attributes
-      Array(options[:methods]).inject([]) do |method_attributes, name|
-        method_attributes << MethodAttribute.new(name.to_s, @object) if @object.respond_to?(name.to_s)
-        method_attributes
-      end
-    end
-
-    def add_attributes
-      (serializable_attributes + serializable_method_attributes).each do |attribute|
-        add_tag(attribute)
-      end
-    end
-
-    def add_procs
-      if procs = options.delete(:procs)
-        [ *procs ].each do |proc|
-          proc.call(options)
-        end
-      end
-    end
-
-    def add_tag(attribute)
-      builder.tag!(
-        dasherize? ? attribute.name.dasherize : attribute.name,
-        attribute.value.to_s,
-        attribute.decorations(!options[:skip_types])
-      )
-    end
-
-    def add_associations(association, objects, opts)
-      if objects.is_a?(Enumerable)
-        tag = association.to_s
-        tag = tag.dasherize if dasherize?
-        if objects.empty?
-          builder.tag!(tag, :type => :array)
-        else
-          builder.tag!(tag, :type => :array) do
-            association_name = association.to_s.singularize
-            objects.each do |object|
-              object.to_xml opts.merge(
-                :root => association_name,
-                :type => (object.class.to_s.underscore == association_name ? nil : object.class.name)
-              )
-            end
-          end
-        end
-      else
-        if object = @object.send(association)
-          object.to_xml(opts.merge(:root => association))
-        end
-      end
-    end
-
-    def serialize
-      args = [root]
-      if options[:namespace]
-        args << {:xmlns=>options[:namespace]}
-      end
-
-      if options[:type]
-        args << {:type=>options[:type]}
-      end
-
-      builder.tag!(*args) do
-        add_attributes
-        procs = options.delete(:procs)
-        add_includes { |association, objects, opts| add_associations(association, objects, opts) }
-        options[:procs] = procs
-        add_procs
-        yield builder if block_given?
-      end
-    end
-
-    class Attribute #:nodoc:
-      attr_reader :name, :value, :type
-
-      def initialize(name, object)
-        @name, @object = name, object
-
-        @type  = compute_type
-        @value = compute_value
-      end
-
-      # There is a significant speed improvement if the value
-      # does not need to be escaped, as <tt>tag!</tt> escapes all values
-      # to ensure that valid XML is generated. For known binary
-      # values, it is at least an order of magnitude faster to
-      # Base64 encode binary values and directly put them in the
-      # output XML than to pass the original value or the Base64
-      # encoded value to the <tt>tag!</tt> method. It definitely makes
-      # no sense to Base64 encode the value and then give it to
-      # <tt>tag!</tt>, since that just adds additional overhead.
-      def needs_encoding?
-        ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
-      end
-
-      def decorations(include_types = true)
-        decorations = {}
-
-        if type == :binary
-          decorations[:encoding] = 'base64'
-        end
-
-        if include_types && type != :string
-          decorations[:type] = type
-        end
-
-        if value.nil?
-          decorations[:nil] = true
-        end
-
-        decorations
-      end
-
-      protected
-        def compute_type
-          type = @object.send(name).class
-        end
-
-        def compute_value
-          value = @object.send(name)
-
-          if formatter = Hash::XML_FORMATTING[type.to_s]
-            value ? formatter.call(value) : nil
-          else
-            value
-          end
-        end
-    end
-
-    class MethodAttribute < Attribute #:nodoc:
-      protected
-        def compute_type
-          Hash::XML_TYPE_NAMES[@object.send(name).class.name] || :string
-        end
-    end
-  end
-end