miyazakiresistance 0.1.3

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-03-21
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+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
+lib/miyazaki_resistance/enhance.rb
+initializers/rdb.rb

data/README.rdoc

@@ -0,0 +1,95 @@
+= miyazakiresistance
+
+* http://www.kaeruspoon.net/keywords/MiyazakiResistance
+
+== DESCRIPTION:
+
+MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.
+
+== SYNOPSIS:
+
+  require 'miyazakiresistance'
+  class Example < MiyazakiResistance::Base
+    set_server "localhost", 1975, :write
+    set_server "slave", 1975, :standby
+    set_timeout 60
+    set_column :name, :string
+    set_column :age, :integer
+    set_column :birthday, :date
+    set_column :created_at, :datetime
+  end
+
+  work = Example.new
+  work.name = "tsukasa"
+  work.age = 34
+  work.birthday => Date.today
+  work.save
+
+  Example.create(:name => "oishi", :age => 14, :birthday => Date.today)
+
+  Example.count
+  Example.count(:conditions => ["name = ?", "oishi"])
+
+  Example.find(1)
+  Example.find([1,2])
+  Example.find(:first)
+  Example.find(:all)
+  Example.find(:all, :conditions => ["name = ? age = ?", "tsukasa", 34], :order => "created_at DESC", :offset => 1, :limit => 1)
+  Example.find_by_name("tsukasa")
+  Example.find_all_by_name_and_age("tsukasa", 34)
+
+
+  * You can write in config file
+
+  require 'miyazakiresistance'
+  class Example < MiyazakiResistance::Base
+    server_config Rails.env, "log/miyazakiresistance.yml"
+    set_timeout 60
+    set_column :name, :string
+    set_column :age, :integer
+    set_column :birthday, :date
+    set_column :created_at, :datetime
+  end
+
+  'in log/miyazakiresistance.log'
+  developemnt:
+    set_server:
+      - server: localhost
+        port: 1975
+	role: write
+      - server: localhost
+        port: 1978
+	role: readonly
+
+== REQUIREMENTS:
+
+Tokyo Tyrant
+
+== INSTALL:
+
+* sudo gem install miyazakiresistance
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Tsukasa OISHI
+
+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/Rakefile

@@ -0,0 +1,28 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/miyazakiresistance'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('miyazakiresistance', MiyazakiResistance::VERSION) do |p|
+  p.developer('Tsukasa OISHI', 'tsukasa.oishi@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/initializers/rdb.rb

@@ -0,0 +1,13 @@
+module TokyoTyrant
+  class RDB
+    attr_accessor :host, :port
+
+    def open_with_save_params(host, port = 0)
+      @host = host
+      @port = port
+      open_without_save_params(host, port)
+    end
+    alias_method :open_without_save_params, :open
+    alias_method :open, :open_with_save_params
+  end
+end

data/lib/miyazaki_resistance/base.rb

@@ -0,0 +1,261 @@
+module MiyazakiResistance
+  class Base
+    attr_accessor :id
+
+    def initialize(args = nil)
+      args ||= {}
+      self.id = nil
+      args.each do |key, value|
+        if key.is_a?(String) && 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)}
+      self
+    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])
+        
+        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]).first
+      end
+
+      def find_and_update(first, args={})
+        list = self.find(first, args)
+        list = [list] unless list.is_a?(Array)
+        list.each {|inst| yield(inst) and inst.save}
+      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.count}
+        end
+      rescue TimeoutError
+        remove_pool(con)
+        retry
+      end
+
+      def create(args)
+        self.new(args).save
+      end
+    end
+
+    private
+
+    def raw_attributes
+      hash = {}
+      self.class.all_columns.each do |col, type|
+        value = self.__send__(col)
+        value = self.class.plastic_data(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
+        add_cond_list = []
+        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 = TokyoTyrant::RDBQRY::QCNEGATE | 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
+            add_cond_list << [col, ope, exp]
+            col, ope, exp, type = nil, nil, nil, nil
+            not_flag = false
+          end
+        end
+        add_cond_list.reverse.each{|acl| query.addcond(*acl)}
+      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/enhance.rb

@@ -0,0 +1,43 @@
+module MiyazakiResistance
+  module Enhance
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def method_missing(name, *arguments, &block)
+        if match = finder_attribute_names(name)
+          finder = match[:finder]
+          conditions = match[:cols].map{|col| "#{col} = ?"}.join(" ")
+
+          self.class_eval %Q|
+            def self.#{name}(*args)
+              options = args.last.is_a?(::Hash) ? pop : {}
+              options.update(:conditions => ["#{conditions}", args].flatten)
+              self.find(:#{finder}, options)
+            end
+          |
+
+          __send__(name, *arguments)
+        else
+          super
+        end
+      end
+
+      private
+
+      def finder_attribute_names(name)
+        ret = {:finder => :first, :cols => nil}
+        if name.to_s =~ /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+          ret[:finder] = :all if $1 == "all_by"
+          if cols = $2
+            cols = cols.split("_and_")
+            all_cols = self.all_columns.keys
+            ret[:cols] = cols  if cols.all?{|col| all_cols.include?(col)}
+          end
+        end
+        (ret[:cols].nil? || ret[:cols].empty?) ? nil : ret
+      end
+    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,57 @@
+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
+        class_variable_get("@@logger") || (logger = Logger.new(default_log_file_path))
+      end
+
+      def logger=(target)
+        class_variable_set("@@logger", target)
+      end
+
+      %w|fatal error warn info debug|.each do|level|
+        self.class_eval %Q|
+          def logger_#{level}(str)
+            put_log(str, "#{level}")
+          end
+        |
+      end
+
+      private
+
+      def put_log(str, level)
+        logger.__send__(level, log_msg(str))
+      end
+
+      def log_msg(str)
+        "[#{Time.now.strftime("%Y/%m/%d %H:%M:%S")}] #{str}"
+      end
+
+      def default_log_file_path
+        File.directory?("log") ? "log/miyazakiresistance.log" : "miyazakiresistance.log"
+      end
+    end
+
+    module InstanceMethods
+      def logger
+        self.class.logger
+      end
+
+      %w|fatal error warn info debug|.each do|level|
+        self.class_eval %Q|
+          def logger_#{level}(str)
+            self.class.logger_#{level}g(str)
+          end
+        |
+      end
+    end
+  end
+end

data/lib/miyazaki_resistance/tokyo_connection.rb

@@ -0,0 +1,137 @@
+require 'yaml'
+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 :timeout_time
+
+      DEFAULT = {
+        :timeout => 60,
+        :config => "miyazakiresistance.yml",
+        :port => 1978,
+        :role => :readonly
+      }
+
+      def server_config(env, file = DEFAULT[:config])
+        env = env.to_s
+        conf = YAML.load_file(file)
+
+        if (config = conf[env]).nil?
+          logger_fatal "specified environment(#{env}) is not found in conig file(#{file})"
+          return
+        end
+
+        config["set_server"].each do |work|
+          set_server work["server"], work["port"], work["role"]
+        end
+      rescue Errno::ENOENT => e
+        logger_fatal "config file is not found : #{file}"
+      end
+
+      def set_server(host, port = DEFAULT[:port], role = DEFAULT[:role])
+        self.connection_pool ||= {:read => [], :write => nil, :standby => nil}
+        rdb = TokyoTyrant::RDBTBL.new
+        logger_info "set server host : #{host} port : #{port} role : #{role}"
+
+        unless rdb.open(host.to_s, port)
+          logger_fatal "TokyoTyrantConnectError host : #{host} port : #{port} role : #{role}"
+          raise TokyoTyrantConnectError
+        end
+
+        self.connection_pool[:read] << rdb
+        self.connection_pool[:write] = rdb if role.to_sym == :write
+        self.connection_pool[:standby] = rdb if role.to_sym == :standby
+      end
+
+      def set_timeout(seconds)
+        self.timeout_time = seconds.to_i
+      end
+
+      def set_column(name, type, index = :no_index)
+        self.all_columns ||= {}
+        name = name.to_s
+        self.__send__(:attr_accessor, name)
+        self.all_columns.update(name => type)
+      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}
+
+        host, port = rdb.host, rdb.port
+        new_rdb = TokyoTyrant::RDBTBL.new
+        if new_rdb.open(host, port)
+          self.connection_pool[:read] << new_rdb
+          self.connection_pool[:write] = new_rdb if rdb == self.connection_pool[:write]
+        else
+          logger_fatal "remove pool : host #{host} port : #{port}"
+          check_pool
+          fail_over if rdb == self.connection_pool[:write]
+        end
+        rdb.close
+      end
+
+      def kaeru_timeout(&block)
+        ret = nil
+        thread = Thread.new{ret = yield}
+        raise TimeoutError, "tokyo tyrant server response error" 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_fatal "AllTimeoutORConnectionPoolEmpty"
+        raise AllTimeoutORConnectionPoolEmpty
+      end
+
+      def fail_over
+        unless self.connection_pool[:standby]
+          logger_fatal "MasterDropError"
+          raise MasterDropError
+        end
+
+        logger_fatal "master server failover"
+        self.connection_pool[:write] = self.connection_pool[:standby]
+        self.connection_pool[:standby] = nil
+      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

@@ -0,0 +1,40 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'logger'
+require 'timeout'
+require 'tokyotyrant'
+
+Dir.glob("#{File.join(File.dirname(__FILE__), "../initializers")}/*.rb").each{|path| require path}
+Dir.glob("#{File.join(File.dirname(__FILE__), "miyazaki_resistance")}/*.rb").each{|path| require path}
+
+module MiyazakiResistance
+  VERSION = '0.1.3'
+end
+
+MiyazakiResistance::Base.class_eval do
+  include MiyazakiResistance::TokyoConnection
+  include MiyazakiResistance::Enhance
+  include MiyazakiResistance::MiyazakiLogger
+
+  OPERATIONS = {
+    "=" => {:string => TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNUMEQ},
+    "!=" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCNUMEQ},
+    "<>" => {:string => TokyoTyrant::RDBQRY::QCNEGATE | TokyoTyrant::RDBQRY::QCSTREQ, :integer => TokyoTyrant::RDBQRY::QCNEGATE | 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::QCNEGATE | 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

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: miyazakiresistance
+version: !ruby/object:Gem::Version 
+  version: 0.1.3
+platform: ruby
+authors: 
+- Tsukasa OISHI
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-16 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.
+email: 
+- tsukasa.oishi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- 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
+- lib/miyazaki_resistance/enhance.rb
+- initializers/rdb.rb
+has_rdoc: true
+homepage: http://www.kaeruspoon.net/keywords/MiyazakiResistance
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: miyazakiresistance
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.
+test_files: []
+