tsukasaoishi-miyazakiresistance 0.0.2 → 0.0.3

data/Manifest.txt

@@ -3,3 +3,7 @@ Manifest.txt
 README.rdoc
 Rakefile
 lib/miyazakiresistance.rb
+lib/miyazaki_resistance/base.rb
+lib/miyazaki_resistance/error.rb
+lib/miyazaki_resistance/miyazaki_logger.rb
+lib/miyazaki_resistance/tokyo_connection.rb

data/README.rdoc

@@ -10,13 +10,13 @@ MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.
 
   require 'miyazaki_resistance'
   class Example < MiyazakiResistance::Base
-    host_and_port "localhost", 1975
-    host_and_port "slave", 1975, :readonly
-    set_timeout 5
-    set_column :name, :string
+    set_server "localhost", 1975, :write
+    set_server "slave", 1975, :standby
+    set_timeout 60
+    set_column :name, :string, :index
     set_column :age, :integer
     set_column :birthday, :date
-    set_column :created_at, :datetime
+    set_column :created_at, :datetime, :index
   end
 
 == REQUIREMENTS:

data/lib/miyazaki_resistance/base.rb

@@ -0,0 +1,256 @@
+module MiyazakiResistance
+  class Base
+    attr_accessor :id
+
+    def initialize(args = nil)
+      args ||= {}
+      self.id = nil
+      args.each do |key, value|
+        if key.empty?
+          key = :id
+          value = value.to_i
+        else
+          case self.class.all_columns[key.to_s]
+          when :integer
+            value = value.to_i
+          when :string
+            value = value.to_s
+          when :datetime
+            value = Time.at(value.to_i) unless value.is_a?(Time)
+          when :date
+            unless value.is_a?(Date)
+              time = Time.at(value.to_i)
+              value = Date.new(time.year, time.month, time.day)
+            end
+          end
+        end
+        
+        self.__send__("#{key}=", value)
+      end
+    end
+
+    def save
+      time_column_check
+      con = write_connection
+      self.id = kaeru_timeout{con.genuid.to_i} if new_record?
+      kaeru_timeout {con.put(self.id, raw_attributes)}
+    rescue TimeoutError
+      remove_pool(con)
+      retry
+    end
+
+
+    def update_attributes(args)
+      raise NewRecordError if new_record?
+      attributes = args
+      save
+    end
+
+    def destroy
+      raise NewRecordError if new_record?
+      con = write_connection
+      kaeru_timeout{con.out(self.id)}
+    rescue TimeoutError
+      remove_pool(con)
+      retry
+    end
+
+    def attributes
+      hash = {}
+      self.class.all_columns.keys.each{|key| hash.update(key => self.__send__(key))}
+      hash
+    end
+
+    def attributes=(args)
+      args.each {|key, value| self.__send__("#{key}=", value)}
+    end
+
+    def new_record?
+      self.id.nil?
+    end
+
+    class << self
+      def find(first, args={})
+        case first.class.name
+        when "Fixnum"
+          find_by_id(first)
+        when "Array"
+          find_by_ids(first)
+        when "Symbol"
+          find_by_query(first, args)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def find_by_query(mode, args={})
+        con = read_connection
+        query = TokyoTyrant::RDBQRY.new(con)
+
+        limit = (mode == :first ? 1 : args[:limit])
+        query = make_limit(query, limit, args[:offset])
+        query = make_order(query, args[:order])
+        query = make_conditions(query, args[:conditions])
+        
+        now = Time.now
+        results = kaeru_timeout{query.searchget}.map{|r| self.new(r)}
+        limit.to_i == 1 ? results.first : results
+      rescue TimeoutError
+        remove_pool(con)
+        retry
+      end
+
+      def find_by_id(target)
+        find_by_ids([target])
+      end
+
+      def count(args = {})
+        con = read_connection
+        if args.empty?
+          kaeru_timeout{con.rnum}
+        else
+          query = TokyoTyrant::RDBQRY.new(con)
+          query = make_conditions(query, args[:conditions])
+          kaeru_timeout{query.search}.size
+        end
+      rescue TimeoutError
+        remove_pool(con)
+        retry
+      end
+
+      def create(args)
+        inst = self.new(args)
+        inst.save
+        inst
+      end
+    end
+
+    private
+
+    def raw_attributes
+      hash = {}
+      self.class.all_columns.each do |col, type|
+        value = self.__send__(col)
+        value = self.class.convert_date_to_i(value, type)
+        hash.update(col.to_s => value)
+      end
+      hash
+    end
+
+    def time_column_check
+      time_columns = ["updated"]
+      time_columns << "created" if new_record?
+      time_columns.each do |col|
+        %w|at on|.each do |type|
+          if self.class.all_columns.keys.include?("#{col}_#{type}")
+            now = Time.now
+            now = Date.new(now.year, now.month, now.day) if type == "on"
+            self.__send__("#{col}_#{type}=", now) if self.__send__("#{col}_#{type}").nil? || col == "updated"
+          end
+        end
+      end
+    end
+
+    def self.type_upcase(type)
+      case type
+      when :integer, :datetime, :date
+        "NUM"
+      when :string
+        "STR"
+      end
+    end
+
+    def self.find_by_ids(targets)
+      ret = Hash[*targets.map{|t| [t, nil]}.flatten]
+      con = read_connection
+      kaeru_timeout{con.mget(ret)}
+      
+      ret.map do |r|
+        inst = self.new(r.last)
+        inst.id = r.first.to_i
+        inst
+      end
+    rescue TimeoutError
+      remove_pool(con)
+      retry
+    end
+
+    def self.make_limit(query, limit, offset)
+      query.setlimit(limit, offset) if limit
+      query
+    end
+
+    def self.make_order(query, order)
+      if order
+        target, order_type = order.split
+        if target == "id" || self.all_columns.keys.include?(target)
+          type = (target == "id" ? :integer : self.all_columns[target])
+          target = "" if target == "id"
+          order_type ||= "asc"
+          eval(%Q|query.setorder(target, TokyoTyrant::RDBQRY::QO#{type_upcase(type)}#{order_type.upcase})|)
+        end
+      end
+      query
+    end
+
+    def self.make_conditions(query, conditions)
+      if conditions
+        cond = conditions.first
+        param = conditions[1..-1]
+
+        col, ope, exp, type = nil, nil, nil, nil
+        not_flag = false
+        cond.split.each do |item|
+          next if %w|AND and|.include?(item)
+
+          if self.all_columns.keys.include?(item)
+            col = item
+            type = self.all_columns[item]
+          elsif item == "id"
+            col = ""
+            type = :integer
+          elsif OPERATIONS.keys.include?(item)
+            raise QueryError if col.nil? || type.nil?
+            work = type
+            work = :integer if DATE_TYPE.include?(work)
+            ope = OPERATIONS[item][work]
+            if not_flag
+              raise QueryError unless NOT_OPERATIONS.include?(item)
+              ope = ~ope
+              not_flag = false
+            end
+          elsif %w|NOT not|.include?(item)
+            not_flag = true
+          else
+            raise QueryError if col.nil? || type.nil? || ope.nil?
+            exp = (item == "?" ? param.shift : item)
+            if exp.is_a?(Array)
+              exp = exp.map{|e| plastic_data(e, type)}.join(" ")
+            else
+              exp = plastic_data(exp, type)
+            end
+          end
+
+          if col && type && ope && exp
+            query.addcond(col, ope, exp)
+            col, ope, exp, type = nil, nil, nil, nil
+            not_flag = false
+          end
+        end
+      end
+      query
+    end
+
+    def self.plastic_data(value, type)
+      ret = case type
+      when :datetime
+        value.to_i
+      when :date
+        Time.local(value.year, value.month, value.day).to_i
+      else
+        value
+      end
+      ret.to_s
+    end
+  end
+end

data/lib/miyazaki_resistance/error.rb

@@ -0,0 +1,9 @@
+module MiyazakiResistance
+  class MiyazakiResistanceError < StandardError; end
+  class TokyoTyrantConnectError < MiyazakiResistanceError; end
+  class NewRecordError < MiyazakiResistanceError; end
+  class QueryError < MiyazakiResistanceError; end
+  class MasterDropError < MiyazakiResistanceError; end
+  class AllTimeoutORConnectionPoolEmpty < MiyazakiResistanceError; end
+end
+

data/lib/miyazaki_resistance/miyazaki_logger.rb

@@ -0,0 +1,27 @@
+module MiyazakiResistance
+  module MiyazakiLogger
+    def self.included(base)
+      base.class_eval do
+        @@logger = nil
+      end
+      base.extend ClassMethods
+      base.__send__(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      def logger
+        @@logger ||= Logger.new("miyazakiresistance.log")
+      end
+
+      def logger=(target)
+        @@logger = target
+      end
+    end
+
+    module InstanceMethods
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end

data/lib/miyazaki_resistance/tokyo_connection.rb

@@ -0,0 +1,129 @@
+module MiyazakiResistance
+  module TokyoConnection
+    def self.included(base)
+      base.extend ClassMethods
+      base.__send__(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :connection_pool
+      attr_accessor :all_columns
+      attr_accessor :all_indexes
+      attr_accessor :timeout_time
+
+      DEFAULT_TIMEOUT = 60
+
+      def set_server(host, port, target = :readonly)
+        logger.debug "set_server host : #{host} port : #{port} target : #{target}"
+
+        self.connection_pool ||= {:read => [], :write => nil, :standby => nil}
+        rdb = TokyoTyrant::RDBTBL.new
+        unless rdb.open(host, port)
+          logger.error "TokyoTyrantConnectError host : #{host} port : #{port} target : #{target}"
+          raise TokyoTyrantConnectError
+        end
+
+        self.connection_pool[:read] << rdb
+        self.connection_pool[:write] = rdb if target == :write
+        self.connection_pool[:standby] = rdb if target == :standby
+      end
+
+      def set_timeout(seconds)
+        self.timeout_time = seconds.to_i
+      end
+
+      def set_column(name, type, index = :no_index)
+        self.all_indexes ||= []
+        self.all_columns ||= {}
+        name = name.to_s
+        self.__send__(:attr_accessor, name)
+        self.all_columns.update(name => type)
+
+        set_index(name, type) if index == :index
+      end
+
+      def read_connection
+        check_pool
+        self.connection_pool[:read].sort_by{rand}.first
+      end
+
+      def write_connection
+        self.connection_pool[:write]
+      end
+
+      def remove_pool(rdb)
+        self.connection_pool[:read].delete_if{|pool| pool == rdb}
+        check_pool
+        fail_over if rdb == self.connection_pool[:write]
+      end
+
+      def kaeru_timeout(&block)
+        ret = nil
+        thread = Thread.new{ret = yield}
+        raise TimeoutError unless thread.join(self.timeout_time || DEFAULT_TIMEOUT)
+        ret
+      end
+
+      private
+
+      def all_connections
+        [self.connection_pool[:read], self.connection_pool[:write], self.connection_pool[:standby]].flatten.compact.uniq
+      end
+
+      def check_pool
+        return if self.connection_pool[:read] && !self.connection_pool[:read].empty?
+        logger.error "AllTimeoutORConnectionPoolEmpty"
+        raise AllTimeoutORConnectionPoolEmpty
+      end
+
+      def fail_over
+        unless self.connection_pool[:standby]
+          logger.error "MasterDropError"
+          raise MasterDropError
+        end
+
+        logger.info "master server failover"
+        self.connection_pool[:write] = self.connection_pool[:standby]
+        self.connection_pool[:standby] = nil
+      end
+
+      def set_index(name, type)
+        index_type = case type
+          when :integer, :datetime, :date
+            TokyoTyrant::RDBTBL::ITDECIMAL
+          when :string
+            TokyoTyrant::RDBTBL::ITLEXICAL
+          end
+
+        self.all_indexes << name
+        all_connections.each do |con|
+          begin
+            con.setindex(name, index_type)
+            con.setindex(name, TokyoTyrant::RDBTBL::ITOPT)
+          rescue TimeoutError
+            remove_pool(con)
+            retry
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def read_connection
+        self.class.read_connection
+      end
+
+      def write_connection
+        self.class.write_connection
+      end
+
+      def remove_pool(rdb)
+        self.class.remove_pool(rdb)
+      end
+
+      def kaeru_timeout(&block)
+        self.class.kaeru_timeout(&block)
+      end
+    end
+  end
+end

data/lib/miyazakiresistance.rb

@@ -4,435 +4,37 @@ $:.unshift(File.dirname(__FILE__)) unless
 require 'tokyotyrant'
 require 'timeout'
 require 'logger'
+require 'miyazaki_resistance/tokyo_connection'
+require 'miyazaki_resistance/miyazaki_logger'
+require 'miyazaki_resistance/base'
+require 'miyazaki_resistance/error'
 
 module MiyazakiResistance
-  VERSION = '0.0.2'
-
-  class MiyazakiResistanceError < StandardError; end
-  class TokyoTyrantConnectError < MiyazakiResistanceError; end
-  class NewRecordError < MiyazakiResistanceError; end
-  class QueryError < MiyazakiResistanceError; end
-  class MasterDropError < MiyazakiResistanceError; end
-  class AllTimeoutORConnectionPoolEmpty < MiyazakiResistanceError; end
-
-  module TokyoConnection
-    def self.included(base)
-      base.extend ClassMethods
-      base.__send__(:include, InstanceMethods)
-    end
-
-    module ClassMethods
-      attr_accessor :connection_pool
-      attr_accessor :all_columns
-      attr_accessor :all_indexes
-      attr_accessor :timeout_time
-
-      def set_server(host, port, target = :readonly)
-        logger.debug "set_server host : #{host} port : #{port} target : #{target}"
-
-        self.connection_pool ||= {:read => [], :write => nil, :standby => nil}
-        rdb = TokyoTyrant::RDBTBL.new
-        unless rdb.open(host, port)
-          logger.error "TokyoTyrantConnectError host : #{host} port : #{port} target : #{target}"
-          raise TokyoTyrantConnectError
-        end
-
-        self.connection_pool[:read] << rdb
-        self.connection_pool[:write] = rdb if target == :write
-        self.connection_pool[:standby] = rdb if target == :standby
-      end
-
-      def set_timeout(seconds)
-        self.timeout_time = seconds.to_i
-      end
-
-      def set_column(name, type, index = :no_index)
-        self.all_indexes ||= []
-        self.all_columns ||= {}
-        name = name.to_s
-        self.__send__(:attr_accessor, name)
-        self.all_columns.update(name => type)
-
-        set_index(name, type) if index == :index
-      end
-
-      def read_connection
-        check_pool
-        self.connection_pool[:read].sort_by{rand}.first
-      end
-
-      def write_connection
-        self.connection_pool[:write]
-      end
-
-      def remove_pool(rdb)
-        self.connection_pool[:read].delete_if{|pool| pool == rdb}
-        check_pool
-        fail_over if rdb == self.connection_pool[:write]
-      end
-
-      def kaeru_timeout(&block)
-        ret = nil
-        thread = Thread.new{ret = yield}
-        raise TimeoutError unless thread.join(self.timeout_time)
-        ret
-      end
-
-      private
-
-      def all_connections
-        [self.connection_pool[:read], self.connection_pool[:write], self.connection_pool[:standby]].flatten.compact.uniq
-      end
-
-      def check_pool
-        return if self.connection_pool[:read] && !self.connection_pool[:read].empty?
-        logger.error "AllTimeoutORConnectionPoolEmpty"
-        raise AllTimeoutORConnectionPoolEmpty
-      end
-
-      def fail_over
-        unless self.connection_pool[:standby]
-          logger.error "MasterDropError"
-          raise MasterDropError
-        end
-
-        logger.info "master server failover"
-        self.connection_pool[:write] = self.connection_pool[:standby]
-        self.connection_pool[:standby] = nil
-      end
-
-      def set_index(name, type)
-        index_type = case type
-          when :integer, :datetime, :date
-            TokyoTyrant::RDBTBL::ITDECIMAL
-          when :string
-            TokyoTyrant::RDBTBL::ITLEXICAL
-          end
-
-        self.all_indexes << name
-        all_connections.each do |con|
-          begin
-            con.setindex(name, index_type)
-          rescue TimeoutError
-            remove_pool(con)
-            retry
-          end
-        end
-      end
-    end
-
-    module InstanceMethods
-      def read_connection
-        self.class.read_connection
-      end
-
-      def write_connection
-        self.class.write_connection
-      end
-
-      def remove_pool(rdb)
-        self.class.remove_pool(rdb)
-      end
-
-      def kaeru_timeout(&block)
-        self.class.kaeru_timeout(&block)
-      end
-    end
-  end
-
-  module MiyazakiLogger
-    def self.included(base)
-      base.class_eval do
-        @@logger = nil
-      end
-      base.extend ClassMethods
-      base.__send__(:include, InstanceMethods)
-    end
-
-    module ClassMethods
-      def logger
-        @@logger ||= Logger.new("miyazakiresistance.log")
-      end
-
-      def logger=(target)
-        @@logger = target
-      end
-    end
-
-    module InstanceMethods
-      def logger
-        self.class.logger
-      end
-    end
-  end
-
-  class Base
-    include TokyoConnection
-    include MiyazakiLogger
-
-    OPERATIONS = {
-      "=" => {:string => TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNUMEQ},
-      "!=" => {:string => ~TokyoTyrant::RDBQRY::QCSTREQ, :integer => ~TokyoTyrant::RDBQRY::QCNUMEQ},
-      "<>" => {:string => ~TokyoTyrant::RDBQRY::QCSTREQ, :integer => ~TokyoTyrant::RDBQRY::QCNUMEQ},
-      "include" => {:string => TokyoTyrant::RDBQRY::QCSTRINC},
-      "begin" => {:string => TokyoTyrant::RDBQRY::QCSTRBW},
-      "end" => {:string => TokyoTyrant::RDBQRY::QCSTREW},
-      "allinclude" => {:string => TokyoTyrant::RDBQRY::QCSTRAND},
-      "anyinclude" => {:string => TokyoTyrant::RDBQRY::QCSTROR},
-      "in" => {:string => TokyoTyrant::RDBQRY::QCSTROREQ, :integer => TokyoTyrant::RDBQRY::QCNUMOREQ},
-      "=~" => {:string => TokyoTyrant::RDBQRY::QCSTRRX},
-      "!~" => {:string => ~TokyoTyrant::RDBQRY::QCSTRRX},
-      ">" => {:integer => TokyoTyrant::RDBQRY::QCNUMGT},
-      ">=" => {:integer => TokyoTyrant::RDBQRY::QCNUMGE},
-      "<" => {:integer => TokyoTyrant::RDBQRY::QCNUMLT},
-      "<=" => {:integer => TokyoTyrant::RDBQRY::QCNUMLE},
-      "between" => {:integer => TokyoTyrant::RDBQRY::QCNUMBT}
-    }
-    NOT_OPERATIONS = %w|include begin end allinclude anyinclude in between|
-    DATE_TYPE = [:datetime, :date]
-
-    attr_accessor :id
-
-    def initialize(args = nil)
-      args ||= {}
-      self.id = nil
-      args.each do |key, value|
-        case self.class.all_columns[key.to_s]
-        when :integer
-          value = value.to_i
-        when :string
-          value = value.to_s
-        when :datetime
-          value = Time.at(value.to_i) unless value.is_a?(Time)
-        when :date
-          unless value.is_a?(Date)
-            time = Time.at(value.to_i)
-            value = Date.new(time.year, time.month, time.day)
-          end
-        end
-        
-        self.__send__("#{key}=", value)
-      end
-    end
-
-    def save
-      time_column_check
-      con = write_connection
-      self.id = kaeru_timeout{con.genuid.to_i} if new_record?
-      kaeru_timeout {con.put(self.id, raw_attributes)}
-    rescue TimeoutError
-      remove_pool(con)
-      retry
-    end
-
-
-    def update_attributes(args)
-      raise NewRecordError if new_record?
-      attributes = args
-      save
-    end
-
-    def destroy
-      raise NewRecordError if new_record?
-      con = write_connection
-      kaeru_timeout{con.out(self.id)}
-    rescue TimeoutError
-      remove_pool(con)
-      retry
-    end
-
-    def attributes
-      hash = {}
-      self.class.all_columns.keys.each{|key| hash.update(key => self.__send__(key))}
-      hash
-    end
-
-    def attributes=(args)
-      args.each {|key, value| self.__send__("#{key}=", value)}
-    end
-
-    def new_record?
-      self.id.nil?
-    end
-
-    class << self
-      def find(first, args={})
-        case first.class.name
-        when "Fixnum"
-          find_by_id(first)
-        when "Array"
-          find_by_ids(first)
-        when "Symbol"
-          find_by_query(first, args)
-        else
-          raise ArgumentError
-        end
-      end
-
-      def find_by_query(mode, args={})
-        con = read_connection
-        query = TokyoTyrant::RDBQRY.new(con)
-
-        limit = (mode == :first ? 1 : args[:limit])
-        query = make_limit(query, limit, args[:offset])
-        query = make_order(query, args[:order])
-        query = make_conditions(query, args[:conditions])
-        
-        ids = kaeru_timeout{query.search}
-        ret = find_by_ids(ids)
-        ret = ret.first if limit.to_i == 1
-        ret
-      rescue TimeoutError
-        remove_pool(con)
-        retry
-      end
-
-      def find_by_id(target)
-        find_by_ids([target])
-      end
-
-      def count(args = {})
-        con = read_connection
-        if args.empty?
-          kaeru_timeout{con.rnum}
-        else
-          query = TokyoTyrant::RDBQRY.new(con)
-          query = make_conditions(query, args[:conditions])
-          kaeru_timeout{query.search}.size
-        end
-      rescue TimeoutError
-        remove_pool(con)
-        retry
-      end
-
-      def create(args)
-        inst = self.new(args)
-        inst.save
-        inst
-      end
-    end
-
-    private
-
-    def raw_attributes
-      hash = {}
-      self.class.all_columns.each do |col, type|
-        value = self.__send__(col)
-        value = self.class.convert_date_to_i(value, type)
-        hash.update(col.to_s => value)
-      end
-      hash
-    end
-
-    def time_column_check
-      time_columns = ["updated"]
-      time_columns << "created" if new_record?
-      time_columns.each do |col|
-        %w|at on|.each do |type|
-          if self.class.all_columns.keys.include?("#{col}_#{type}")
-            now = Time.now
-            now = Date.new(now.year, now.month, now.day) if type == "on"
-            self.__send__("#{col}_#{type}=", now) if self.__send__("#{col}_#{type}").nil? || col == "updated"
-          end
-        end
-      end
-    end
-
-    def self.type_upcase(type)
-      case type
-      when :integer, :datetime, :date
-        "NUM"
-      when :string
-        "STR"
-      end
-    end
-
-    def self.find_by_ids(targets)
-      targets.map do |key|
-        begin
-          con = read_connection
-          data = kaeru_timeout{con.get(key)}
-          inst = self.new(data)
-          inst.id = key.to_i
-          inst
-        rescue TimeoutError
-          remove_pool(con)
-          retry
-        end
-      end
-    end
-
-    def self.make_limit(query, limit, offset)
-      query.setlimit(limit, offset) if limit
-      query
-    end
-
-    def self.make_order(query, order)
-      if order
-        target, order_type = order.split
-        if target == "id" || self.all_columns.keys.include?(target)
-          type = (target == "id" ? :integer : self.all_columns[target])
-          target = "" if target == "id"
-          order_type ||= "asc"
-          eval(%Q|query.setorder(target, TokyoTyrant::RDBQRY::QO#{type_upcase(type)}#{order_type.upcase})|)
-        end
-      end
-      query
-    end
-
-    def self.make_conditions(query, conditions)
-      if conditions
-        cond = conditions.first
-        param = conditions[1..-1]
-
-        col, ope, exp, type = nil, nil, nil, nil
-        not_flag = false
-        cond.split.each do |item|
-          next if %w|AND and|.include?(item)
-
-          if self.all_columns.keys.include?(item)
-            col = item
-            type = self.all_columns[item]
-          elsif item == "id"
-            col = ""
-            type = :integer
-          elsif OPERATIONS.keys.include?(item)
-            raise QueryError if col.nil? || type.nil?
-            work = type
-            work = :integer if DATE_TYPE.include?(work)
-            ope = OPERATIONS[item][work]
-            if not_flag
-              raise QueryError unless NOT_OPERATIONS.include?(item)
-              ope = ~ope
-              not_flag = false
-            end
-          elsif %w|NOT not|.include?(item)
-            not_flag = true
-          else
-            raise QueryError if col.nil? || type.nil? || ope.nil?
-            exp = (item == "?" ? param.shift : item)
-            exp = convert_date_to_i(exp, type)
-          end
-
-          if col && type && ope && exp
-            query.addcond(col, ope, exp.to_s)
-            col, ope, exp, type = nil, nil, nil, nil
-            not_flag = false
-          end
-        end
-      end
-      query
-    end
+  VERSION = '0.0.3'
+end
 
-    def self.convert_date_to_i(value, type)
-      case type
-      when :datetime
-        value.to_i
-      when :date
-        Time.local(value.year, value.month, value.day).to_i
-      else
-        value
-      end
-    end
-  end
+MiyazakiResistance::Base.class_eval do
+  include MiyazakiResistance::TokyoConnection
+  include MiyazakiResistance::MiyazakiLogger
+
+  OPERATIONS = {
+    "=" => {:string => TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNUMEQ},
+    "!=" => {:string => ~TokyoTyrant::RDBQRY::QCSTREQ, :integer => ~TokyoTyrant::RDBQRY::QCNUMEQ},
+    "<>" => {:string => ~TokyoTyrant::RDBQRY::QCSTREQ, :integer => ~TokyoTyrant::RDBQRY::QCNUMEQ},
+    "include" => {:string => TokyoTyrant::RDBQRY::QCSTRINC},
+    "begin" => {:string => TokyoTyrant::RDBQRY::QCSTRBW},
+    "end" => {:string => TokyoTyrant::RDBQRY::QCSTREW},
+    "allinclude" => {:string => TokyoTyrant::RDBQRY::QCSTRAND},
+    "anyinclude" => {:string => TokyoTyrant::RDBQRY::QCSTROR},
+    "in" => {:string => TokyoTyrant::RDBQRY::QCSTROREQ, :integer => TokyoTyrant::RDBQRY::QCNUMOREQ},
+    "=~" => {:string => TokyoTyrant::RDBQRY::QCSTRRX},
+    "!~" => {:string => ~TokyoTyrant::RDBQRY::QCSTRRX},
+    ">" => {:integer => TokyoTyrant::RDBQRY::QCNUMGT},
+    ">=" => {:integer => TokyoTyrant::RDBQRY::QCNUMGE},
+    "<" => {:integer => TokyoTyrant::RDBQRY::QCNUMLT},
+    "<=" => {:integer => TokyoTyrant::RDBQRY::QCNUMLE},
+    "between" => {:integer => TokyoTyrant::RDBQRY::QCNUMBT}
+  }
+  NOT_OPERATIONS = %w|include begin end allinclude anyinclude in between|
+  DATE_TYPE = [:datetime, :date]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tsukasaoishi-miyazakiresistance
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Tsukasa OISHI
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-25 00:00:00 -07:00
+date: 2009-03-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,10 @@ files:
 - README.rdoc
 - Rakefile
 - lib/miyazakiresistance.rb
+- lib/miyazaki_resistance/base.rb
+- lib/miyazaki_resistance/error.rb
+- lib/miyazaki_resistance/miyazaki_logger.rb
+- lib/miyazaki_resistance/tokyo_connection.rb
 has_rdoc: true
 homepage: http://www.kaeruspoon.net/keywords/MiyazakiResistance
 post_install_message: PostInstall.txt