flextures 2.1.0 → 3.0.0

data/lib/flextures/flextures_base_config.rb

@@ -1,16 +1,27 @@
 # encoding: utf-8
 
-# 基本設定を記述する
+# base configurations
+# if you want to change setting, create 'config/flextures.config.rb', and overwrite setting
+#
+# example:
+# module Flextures
+#  # load and dump directroy setting change "spec/fixtures/" to "test/fixtures/"
+#  Config.fixture_load_directory = "test/fixtures/"
+#  Config.fixture_dump_directory = "test/fixtures/"
+# end
+#
 module Flextures
   module Config
     @@read_onlys=[]
     @@configs={
-      fixture_load_directory: "spec/fixtures/",
-      fixture_dump_directory: "spec/fixtures/",
-      init_all_tables: false,  # 実行後に全テーブルの初期化を行うか？falseにするとそのぶん高速化できる
-      ignore_tables: ["schema_migrations"],
+      ignore_tables: ["schema_migrations"], # 'ignore_tables' table data is not deleted by flextures delete_all method
+      fixture_load_directory: "spec/fixtures/", # base load directory
+      fixture_dump_directory: "spec/fixtures/", # dump load directory
+      init_all_tables: false,  # if this option is 'true', when start unit test, all table data is delete
+      options: {}, # options(example { unfilter: true })
+      table_load_order: [], # set load options
     }
-    # ハッシュをsetter、getterに変換
+    # hash key change to getter and setter
     class<< self
       @@configs.each do |setting_key, setting_value|
         define_method(setting_key){ @@configs[setting_key] }

data/lib/flextures/flextures_command.rb

@@ -15,49 +15,47 @@ module Flextures
         Flextures::init_load
         table_names = Flextures::ARGS.parse
         puts "dumping..."
-        if ["yml","yaml"].member? ENV["FORMAT"]
+        case ENV["FORMAT"].to_s.to_sym
+        when :yml,:yaml
           table_names.map { |fmt| Flextures::Dumper::yml(fmt) }
+        when :csv
+          table_names.map { |fmt| Flextures::Dumper::csv(fmt) }
         else
           table_names.map { |fmt| Flextures::Dumper::csv(fmt) }
         end
       end
 
-      def self.csvdump
-        Flextures::init_load
-        puts "dumping..."
-        table_names = Flextures::ARGS.parse
-        table_names.map { |fmt| Flextures::Dumper::csv(fmt) }
-      end
-
-      def self.ymldump
-        Flextures::init_load
-        puts "dumping..."
-        table_names = Flextures::ARGS.parse
-        table_names.map { |fmt| Flextures::Dumper::yml(fmt) }
-      end
-
       def self.load
         Flextures::init_load
         table_names = Flextures::ARGS.parse
         Flextures::init_tables unless ENV["T"] or ENV["TABLE"] or ENV["M"] or ENV["MODEL"] or ENV["F"] or ENV["FIXTUES"]
+        file_format = ENV["FORMAT"]
         puts "loading..."
-        table_names.map { |fmt| Flextures::Loader::load(fmt) }
+        case file_format.to_s.to_sym
+        when :csv
+          table_names.map { |fmt| Flextures::Loader::csv(fmt) }
+        when :yml
+          table_names.map { |fmt| Flextures::Loader::yml(fmt) }
+        else
+          table_names.map { |fmt| Flextures::Loader::load(fmt) }
+        end
       end
 
-      def self.csvload
+      # load and dump data
+      def self.generate
         Flextures::init_load
         table_names = Flextures::ARGS.parse
         Flextures::init_tables unless ENV["T"] or ENV["TABLE"] or ENV["M"] or ENV["MODEL"] or ENV["F"] or ENV["FIXTUES"]
-        puts "loading..."
-        table_names.map { |fmt| Flextures::Loader::csv(fmt) }
-      end
-
-      def self.ymlload
-        Flextures::init_load
-        table_names = Flextures::ARGS::parse
-        Flextures::init_tables unless ENV["T"] or ENV["TABLE"] or ENV["M"] or ENV["MODEL"] or ENV["F"] or ENV["FIXTUES"]
-        puts "loading..."
-        table_names.map { |fmt| Flextures::Loader::yml(fmt) }
+        file_format = ENV["FORMAT"]
+        puts "generating..."
+        case file_format.to_s.to_sym
+        when :yml
+          table_names.map { |fmt| Flextures::Loader::yml(fmt); Flextures::Dumper::yml(fmt) }
+        when :csv
+          table_names.map { |fmt| Flextures::Loader::csv(fmt); Flextures::Dumper::csv(fmt) }
+        else
+          table_names.map { |fmt| Flextures::Loader::csv(fmt); Flextures::Dumper::csv(fmt) }
+        end
       end
     end
   end

data/lib/flextures/flextures_dumper.rb

@@ -1,14 +1,16 @@
 # encoding: utf-8
 
+require "fileutils"
+
 module Flextures
-  # データを吐き出す処理をまとめる
+  # defined data dump methods
   module Dumper
     PARENT = Flextures
     # procに機能追加、関数合成のためのメソッドを追加する
     class Proc < ::Proc
       def *(other)
         if self.lambda? and other.lambda?
-          lambda {|*x| other.call(self.call(*x)) }
+          lambda { |*x| other.call(self.call(*x)) }
         elsif not self.lambda? and not other.lambda?
           Proc.new {|*x| other.call(self.call(*x)) }
         else
@@ -21,8 +23,9 @@ module Flextures
       Proc.new(&b)
     end
 
+    # create data translater
     def self.translate_creater( val, rules )
-      rule_map ={
+      rule_map = {
         nullstr: proc { |d|
           return "null" if d.nil?
           d
@@ -77,6 +80,7 @@ module Flextures
       procs.call(val)
     end
 
+    # data translaters
     TRANSLATER = {
       binary:->( d, format ){
         procs = (format == :yml)?
@@ -144,84 +148,107 @@ module Flextures
           [proc { |d| d.to_s }]
         self.translate_creater d, procs
       },
+      # use null only value
+      null:->( d, format ){
+        format==:yml ? "null" : ""
+      },
     }
 
-    # 適切な型に変換
+    # translate data
+    # @params [Object] value
+    # @params [Symbol] type datatype
+    # @params [Symbol] format data type (:yml or :csv)
+    # @return translated value
     def self.trans( v, type, format )
       trans = TRANSLATER[type]
       return trans.call( v, format ) if trans
       v
     end
 
-    # csv で fixtures を dump
+    # dump attributes data
+    # @params klass dump table Model
+    # @params [Hash] options dump options
+    # @return [Array] columns format information
+    def self.dump_attributes klass, options
+      columns = klass.columns.map { |column| { name: column.name, type: column.type } }
+      # option[:minus] colum is delete columns
+      columns.reject! { |column| options[:minus].include?(column[:name]) } if options[:minus]
+      # option[:plus] colum is new columns
+      # values is all nil
+      plus = options[:plus].to_a.map { |colname| { name: colname, type: :null } }
+      columns + plus
+    end
+
+    # filter is translate value safe YAML or CSV string
+    # @params [Class] klass ActiveRecord class
+    # @params [String] table_name table name
+    # @params [Hash] options options
+    # @params [Symbol] type format type (:yml or :csv)
+    # @return [Proc] filter function
+    def self.create_filter attr_type, format, type
+      filter = DumpFilter[format[:table].to_s.to_sym] || {}
+      ->(row) {
+        attr_type.map do |h|
+          v = filter[h[:name].to_sym] ? filter[h[:name].to_sym].call(row[h[:name]]) : trans(row[h[:name]], h[:type], type)
+          [h[:name],v]
+        end
+      }
+    end
+
+    # data dump to csv format
+    # @params [Hash] format file format data
+    # @params [Hash] options dump format options
     def self.csv format
+      klass = PARENT.create_model(format[:table])
+      attr_type = self.dump_attributes klass, format
+      filter = self.create_filter attr_type, format, :csv
+      self.dump_csv klass, attr_type, filter, format
+    end
+
+    # dump csv format data
+    def self.dump_csv klass, attr_type, values_filter, format
+      # TODO: 拡張子は指定してもしなくても良いようにする
       file_name = format[:file] || format[:table]
-      dir_name = format[:dir] || DUMP_DIR
-      # 指定されたディレクトリを作成
-      recursive_mkdir(dir_name)
+      dir_name = File.join( Flextures::Config.fixture_dump_directory, format[:dir].to_s )
+      FileUtils.mkdir_p(dir_name)
       outfile = File.join(dir_name, "#{file_name}.csv")
-      table_name = format[:table]
-      klass = PARENT.create_model(table_name)
-      attributes = klass.columns.map { |column| column.name }
-      filter = DumpFilter[table_name]
       CSV.open(outfile,'w') do |csv|
-        attr_type = klass.columns.map { |column| { name: column.name, type: column.type } }
-        csv<< attributes
+        # dump column names
+        csv<< attr_type.map { |h| h[:name].to_s }
+        # dump column datas
         klass.all.each do |row|
-          csv<< attr_type.map do |h|
-            if (filter && filter[h[:name].to_sym])
-              filter[h[:name].to_sym].call(row[h[:name]])
-            else
-              trans(row[h[:name]], h[:type], :csv)
-            end
-          end
+          csv<< values_filter.call(row).map(&:last)
         end
       end
       outfile
     end
 
-    # yaml で fixtures を dump
+    # data dump to yaml format
+    # @params [Hash] format file format data
+    # @params [Hash] options dump format options
     def self.yml format
+      klass = PARENT::create_model(format[:table])
+      attr_type = self.dump_attributes klass, format
+      filter = self.create_filter attr_type, format, :yml
+      self.dump_yml klass, filter, format
+    end
+
+    # dump yml format data
+    def self.dump_yml klass, values_filter, format
+      # TODO: 拡張子は指定してもしなくても良いようにする
+      table_name = format[:table]
       file_name = format[:file] || format[:table]
-      dir_name = format[:dir] || DUMP_DIR
-      # 指定されたディレクトリを作成
-      recursive_mkdir(dir_name)
+      dir_name = File.join( Flextures::Config.fixture_dump_directory, format[:dir].to_s )
+      FileUtils.mkdir_p(dir_name)
       outfile = File.join(dir_name, "#{file_name}.yml")
-      table_name = format[:table]
-      klass = PARENT::create_model(table_name)
-      attributes = klass.columns.map { |colum| colum.name }
-      columns = klass.columns
-      # テーブルからカラム情報を取り出し
-      column_hash = {}
-      columns.each { |col| column_hash[col.name] = col }
-      # 自動補完が必要なはずのカラム
-      lack_columns = columns.select { |c| !c.null and !c.default }.map{ |o| o.name.to_sym }
-      not_nullable_columns = columns.select { |c| !c.null }.map &:name
-
-      filter = DumpFilter[table_name]
       File.open(outfile,"w") do |f|
-        klass.all.each_with_index do |row,idx|
-          f<< "#{table_name}_#{idx}:\n" +
-            klass.columns.map { |column|
-              colname, coltype = column.name, column.type
-              if (filter && filter[colname.to_sym])
-                v = filter[colname.to_sym].call(row[colname.to_sym])
-              else
-                v = trans(row[colname], coltype, :yml)
-              end
-              "  #{colname}: #{v}\n"
-            }.join
+        klass.all.each.with_index do |row,idx|
+          values = values_filter.call(row).map { |k,v| "  #{k}: #{v}\n" }.join
+          f<< "#{table_name}_#{idx}:\n" + values
         end
       end
       outfile
     end
-
-    def self.recursive_mkdir(path)
-      return if FileTest.exist?(path)
-      dir = File.dirname(path)
-      recursive_mkdir(dir)
-      Dir.mkdir(path)
-    end
   end
 end
 

data/lib/flextures/flextures_extension_modules.rb

@@ -3,25 +3,29 @@
 require 'ostruct'
 
 module Flextures
-  # Plug-in 内部拡張
+  # OpenStruct hack in flextures Plug-in
   class OpenStruct < ::OpenStruct
-    # hashに変化させる
+    # Struct Data translate to Hash
     def to_hash
-      h={}
       (self.methods - ::OpenStruct.new.methods)
         .select{ |name| name.to_s.match(/\w+=/) }
         .map{ |name| name.to_s.gsub(/=/,'').to_sym }
-        .each{ |k| h[k]=self.send(k) }
-      h
+        .inject({}){ |k,h| h[k]=self.send(k); h }
     end
   end
 
   module Extensions
     module Array
+      # use Object#extend
+      # @params [Array] keys hash keys
+      # @return [Hash] tanslated Hash data
+      # example:
+      # hash = array.extend(Extensions::Array).to_hash(keys)
       def to_hash keys
-        h = {}
-        [keys,self].transpose.each{ |k,v| h[k]=v }
-        h
+        values = self
+        values = values[0..keys.size-1]               if keys.size < values.size
+        values = values+[nil]*(keys.size-values.size) if keys.size > values.size
+        [keys,values].transpose.inject({}){ |h,pair| k,v=pair; h[k]=v; h }
       end
     end
   end

data/lib/flextures/flextures_factory.rb

@@ -1,16 +1,15 @@
 # encoding: utf-8
 
 module Flextures
-  # ロードするデータを必要に応じて加工する
+  # Flextures FactoryFilter is program to translate ActiveRecord data
   class LoadFilter
-    # 設置ファイルから取得した Factoryの一覧を取得
+    # FactoryFilter data
     FACTORIES={}
 
-    # Factory を定義
-    # @params table_name
-    # @params options
-    # @params block
-    # @return Flextures::Factory
+    # set FactoryFilter
+    # @params [String] table_name
+    # @params [Array] options arguments ActiveRecord Model
+    # @params [Proc] block FactoryFilter
     def self.define table_name, *options, &block
       h={ block: block }
       options.each do |o|
@@ -22,18 +21,21 @@ module Flextures
       FACTORIES[table_name.to_sym]=h
     end
 
-    # Factoryを取得
+    # get FactoryFilter
+    # @params [String|Symbol] table_name
+    # @return [Proc] filter block
     def self.get table_name
       f = FACTORIES[table_name.to_sym]
       f && f[:block]
     end
     def self.[](table_name); self.get(table_name); end
   end
+
   class DumpFilter
-    # 設置ファイルから取得した Factoryの一覧を取得
+    # FactoryDumpFilter data
     FACTORIES={}
 
-    # Factory を定義
+    # set FactoryFilter
     # @params table_name
     # @params options
     # @params block
@@ -42,7 +44,7 @@ module Flextures
       FACTORIES[table_name.to_sym]=hash
     end
 
-    # Factoryを取得
+    # get FactoryFilter
     def self.get table_name
       FACTORIES[table_name.to_sym]
     end

data/lib/flextures/flextures_loader.rb

@@ -9,11 +9,11 @@ require 'flextures/flextures'
 require 'flextures/flextures_factory'
 
 module Flextures
-  # Dumperと違ってデータの吐き出し処理をまとめたクラス
+  # data loader
   module Loader 
     PARENT = Flextures
 
-    @@table_cache = {}
+    @@option_cache = {}
 
     # column set default value
     COMPLETER = {
@@ -38,7 +38,7 @@ module Flextures
       },
       boolean:->(d){
         return d if d.nil?
-        (0==d || ""==d || !d) ? false : true
+        !(0==d || ""==d || !d)
       },
       date:->(d){
         return d   if d.nil?
@@ -51,27 +51,23 @@ module Flextures
         DateTime.parse(d.to_s)
       },
       decimal:->(d){
-        return d   if d.nil?
+        return d if d.nil?
         d.to_i
       },
       float:->(d){
-        return d   if d.nil?
+        return d if d.nil?
         d.to_f
       },
       integer:->(d){
-        return d   if d.nil?
+        return d if d.nil?
         d.to_i
       },
       string:->(d){
-        return d if d.nil?
-        return d if d.is_a?(Hash)
-        return d if d.is_a?(Array)
+        return d if d.nil? or d.is_a?(Hash) or d.is_a?(Array)
         d.to_s
       },
       text:->(d){
-        return d if d.nil?
-        return d if d.is_a?(Hash)
-        return d if d.is_a?(Array)
+        return d if d.nil? or d.is_a?(Hash) or d.is_a?(Array)
         d.to_s
       },
       time:->(d){
@@ -86,163 +82,243 @@ module Flextures
       },
     }
 
-    # どのファイルが存在するかチェック
-    # @param [Hash] format ロードしたいファイルの情報
-    # @return 存在するファイルの種類(csv,yml)、どちも存在しないならnil
-    def self.file_exist format, type = [:csv,:yml]
-      table_name = format[:table].to_s
-      file_name = format[:file] || format[:table]
-      dir_name = format[:dir] || LOAD_DIR
-
-      ext=->{
-        if    type.member?(:csv) and File.exist? "#{dir_name}#{file_name}.csv"
-          :csv
-        elsif type.member?(:yml) and File.exist? "#{dir_name}#{file_name}.yml"
-          :yml
-        else
-          nil
-        end
-      }.call
-
-      [table_name, "#{dir_name}#{file_name}",ext]
-    end
-    
-    # flextures関数の引数をパースして
-    # 単純な読み込み向け形式に変換します
+    # load fixture datas
     #
-    # @params [Hash] 読み込むテーブルとファイル名のペア
-    # @return [Array] 読み込テーブルごとに切り分けられた設定のハッシュを格納
-    def self.parse_flextures_options *fixtures
-      options = {}
-      options = fixtures.shift if fixtures.size > 1 and fixtures.first.is_a?(Hash)
+    # example:
+    # flextures :all # load all table data
+    # flextures :users, :items # load table data, received arguments
+    # flextures :users => :users2 # :table_name => :file_name
+    #
+    # @params [Hash] fixtures load table data
+    def self.flextures *fixtures
+      load_list = parse_flextures_options(*fixtures)
+      load_list.sort(&self.loading_order).each{ |params| Loader::load params }
+    end
 
-      # :allですべてのfixtureを反映
-      fixtures = Flextures::deletable_tables if fixtures.size== 1 and :all == fixtures.first
+    # @return [Proc] order rule block (user Array#sort methd)
+    def self.loading_order
+      ->(a,b){
+        a = Flextures::Config.table_load_order.index(a) || -1
+        b = Flextures::Config.table_load_order.index(b) || -1
+        b <=> a
+      }
+    end
 
-      last_hash = {}
-      last_hash = fixtures.pop if fixtures.last.is_a? Hash
+    # called by Rspec or Should
+    # set options
+    # @params [Hash] options exmple : { cashe: true, dir: "models/users" }
+    def self.set_options options
+      @@option_cache ||= {}
+      @@option_cache.merge!(options)
+    end
 
-      load_hash = fixtures.inject({}){ |h,name| h[name.to_sym] = name; h }
-      load_hash.merge!(last_hash)
-      load_hash = load_hash.map { |k,v| { table: k, file: v, loader: :fun } }
-      [load_hash, options]
+    # called by Rspec or Should after filter
+    # reflesh options
+    def self.delete_options
+      @@option_cache = {}
     end
 
-    # fixturesをまとめてロード、主にテストtest/unit, rspec で使用する
-    #
-    # 全テーブルが対象
-    # flextures :all
-    # テーブル名で一覧する
-    # flextures :users, :items
-    # ハッシュで指定
-    # flextures :users => :users2
-    #
-    # @params [Hash] 読み込むテーブルとファイル名のペア
-    def self.flextures *fixtures
-      load_hash, options = parse_flextures_options(*fixtures)
-      load_hash.each{ |params| Loader::load params }
+    # return current option status
+    # @return [Hash] current option status
+    def self.flextures_options
+      @@option_cache
     end
 
-    # csv 優先で存在している fixtures をロード
-    def self.load format, options = {}
-      table_name, file_name, method = file_exist format
+    # load fixture data
+    # fixture file prefer YAML to CSV
+    # @params [Hash] format file load format(table name, file name, options...)
+    def self.load format
+      file_name, method = file_exist format
       if method
-        send(method, format, options)
+        send(method, format)
       else
-        # ファイルが存在しない時
-        print "Warning: #{file_name}  is not exist!\n" 
+        puts "Warning: #{file_name} is not exist!" unless format[:silent]
       end
     end
 
-    # CSVのデータをロードする
-    def self.csv format, options={}
-      table_name, file_name, ext = file_exist format, [:csv]
+    # load CSV data
+    # @params [Hash] format file load format(table name, file name, options...)
+    def self.csv format
+      type = :csv
+      file_name, ext = file_exist format, [type]
+      return unless self.file_loadable? format, file_name
+      klass, filter = self.create_model_filter format, file_name, type
+      self.load_csv format, klass, filter, file_name
+    end
 
-      # キャッシュ利用可能ならそれをそのまま使う
-      return if options[:cache] and @@table_cache[table_name.to_sym] and @@table_cache[table_name.to_sym] == file_name
-      @@table_cache[table_name.to_sym] = file_name
+    # load YAML data
+    # @params [Hash] format file load format( table: name, file: name, options...)
+    def self.yml format
+      type = :yml
+      file_name, ext = file_exist format, [type]
 
-      print "try loading #{file_name}.csv\n" unless [:fun].include? format[:loader]
-      return nil unless File.exist? "#{file_name}.csv"
+      return unless self.file_loadable? format, file_name
 
-      klass = PARENT::create_model table_name
-      attributes = klass.columns.map &:name
-      filter = create_filter klass, LoadFilter[table_name], file_name, :csv
-      # rails3_acts_as_paranoid がdelete_allで物理削除しないことの対策
-      klass.send( klass.respond_to?(:delete_all!) ? :delete_all! : :delete_all )
+      klass, filter = self.create_model_filter format, file_name, type
+      self.load_yml format, klass, filter, file_name
+    end
 
-      CSV.open( "#{file_name}.csv" ) do |csv|
-        keys = csv.shift # keyの設定
-        warning "CSV", attributes, keys
+    def self.load_csv format, klass, filter, file_name
+      attributes = klass.columns.map &:name
+      CSV.open( file_name ) do |csv|
+        keys = csv.shift # active record column names
+        warning "CSV", attributes, keys unless format[:silent]
         csv.each do |values|
           h = values.extend(Extensions::Array).to_hash(keys)
-          o = filter.call h
-          o.save( validate: false )
+          filter.call h
         end
       end
-      "#{file_name}.csv"
+      file_name
     end
 
-    # YAML形式でデータをロードする
-    def self.yml format, options={}
-      table_name, file_name, ext = file_exist format, [:yml]
+    def self.load_yml format, klass, filter, file_name
+      yaml = YAML.load File.open(file_name)
+      return false unless yaml # if file is empty
+      attributes = klass.columns.map &:name
+      yaml.each do |k,h|
+        warning "YAML", attributes, h.keys unless format[:silent]
+        filter.call h
+      end
+      file_name
+    end
+
+    # if parameter include controller, action value
+    # load directroy is change
+    # spec/fixtures/:controller_name/:action_name/
+    # @return [String] directory path
+    def self.parse_controller_option options
+      controller_dir = ["controllers"]
+      controller_dir<< options[:controller] if options[:controller]
+      controller_dir<< options[:action]     if options[:controller] and options[:action]
+      File.join(*controller_dir)
+    end
+
+    # if parameter include controller, action value
+    # load directroy is change
+    # spec/fixtures/:model_name/:method_name/
+    # @return [String] directory path
+    def self.parse_model_options options
+      model_dir = ["models"]
+      model_dir<< options[:model]  if options[:model]
+      model_dir<< options[:method] if options[:model] and options[:method]
+      File.join(*model_dir)
+    end
+
+    # parse flextures function arguments
+    # @params [Hash] fixtures function arguments
+    # @return [Array] formatted load options
+    def self.parse_flextures_options *fixtures
+      options = {}
+      options = fixtures.shift if fixtures.size > 1 and fixtures.first.is_a?(Hash)
 
-      # キャッシュ利用可能ならそれをそのまま使う
-      return if options[:cache] and @@table_cache[table_name.to_sym] and @@table_cache[table_name.to_sym] == file_name
-      @@table_cache[table_name.to_sym] = file_name
+      options[:dir] = self.parse_controller_option( options ) if options[:controller]
+      options[:dir] = self.parse_model_options( options )     if options[:model]
 
-      print "try loading #{file_name}.yml\n" unless [:fun].include? format[:loader]
-      return nil unless File.exist? "#{file_name}.yml"
+      # :all value load all loadable fixtures
+      fixtures = Flextures::deletable_tables if fixtures.size==1 and :all == fixtures.first
+      last_hash = fixtures.last.is_a?(Hash) ? fixtures.pop : {}
+      load_hash = fixtures.inject({}){ |h,name| h[name.to_sym] = name.to_s; h } # if name is string is buged
+      load_hash.merge!(last_hash)
+      load_hash.map { |k,v| { table: k, file: v, loader: :fun }.merge(@@option_cache).merge(options) }
+    end
 
-      attributes, filter = ->{
-        klass = PARENT::create_model table_name
-        # rails3_acts_as_paranoid がdelete_allで物理削除しないことの対策
-        klass.send( klass.respond_to?(:delete_all!) ? :delete_all! : :delete_all )
-        attributes = klass.columns.map &:name
-        filter = create_filter klass, LoadFilter[table_name], file_name, :yml
-        [attributes, filter]
-      }.call
+    # example:
+    # self.create_stair_list("foo/bar/baz")
+    # return ["foo/bar/baz","foo/bar","foo",""]
+    def self.stair_list dir, stair=true
+      return [dir.to_s] unless stair
+      l = []
+      dir.to_s.split("/").inject([]){ |a,d| a<< d; l.unshift(a.join("/")); a }
+      l<< ""
+      l
+    end
 
-      yaml = YAML.load(File.open("#{file_name}.yml"))
-      return false unless yaml # ファイルの中身が空の場合
-      yaml.each do |k,h|
-        warning "YAML", attributes, h.keys
-        o = filter.call h
-        o.save( validate: false )
+    # parse format option and return load file info
+    # @param [Hash] format load file format informations
+    # @return [Array] [file_name, filt_type(:csv or :yml)]
+    def self.file_exist format, type = [:csv,:yml]
+      table_name = format[:table].to_s
+      file_name = (format[:file] || format[:table]).to_s
+      base_dir_name = Flextures::Config.fixture_load_directory
+      self.stair_list(format[:dir], format[:stair]).each do |dir|
+        file_path = File.join( base_dir_name, dir, file_name )
+        return ["#{file_path}.csv", :csv] if type.member?(:csv) and File.exist? "#{file_path}.csv"
+        return ["#{file_path}.yml", :yml] if type.member?(:yml) and File.exist? "#{file_path}.yml"
       end
-      "#{file_name}.yml"
+
+      [ File.join(base_dir_name, "#{file_name}.csv"), nil ]
+    end
+
+    # file load check
+    # @return [Bool] lodable is 'true'
+    def self.file_loadable? format, file_name
+      return unless File.exist? file_name
+      puts "try loading #{file_name}" if !format[:silent] and ![:fun].include?(format[:loader])
+      true
     end
 
-    # 欠けたカラムを検知してメッセージを出しておく
+    # print warinig message that lack or not exist colum names
     def self.warning format, attributes, keys
-      (attributes-keys).each { |name| print "Warning: #{format} colum is missing! [#{name}]\n" }
-      (keys-attributes).each { |name| print "Warning: #{format} colum is left over! [#{name}]\n" }
+      (attributes-keys).each { |name| puts "Warning: #{format} colum is missing! [#{name}]" }
+      (keys-attributes).each { |name| puts "Warning: #{format} colum is left over! [#{name}]" }
     end
 
-    # フィクスチャから取り出した値を、加工して欲しいデータにするフィルタを作成して返す
-    def self.create_filter klass, factory, filename, ext
+    # create filter and table info
+    def self.create_model_filter format, file_name, type
+      table_name = format[:table].to_s
+      klass = PARENT::create_model table_name
+      # if you use 'rails3_acts_as_paranoid' gem, that is not delete data 'delete_all' method
+      klass.send (klass.respond_to?(:delete_all!) ? :delete_all! : :delete_all)
+
+      filter = ->(h){
+        filter = create_filter klass, LoadFilter[table_name.to_sym], file_name, type, format
+        o = klass.new
+        o = filter.call o, h
+        o.save( validate: false )
+        o
+      }
+      [klass, filter]
+    end
+
+    # return flextures data translate filter
+    # translate filter is some functions
+    # 1. column value is fill, if colum is not nullable
+    # 2. factory filter
+    # @params [ActiveRecord::Base] klass ActiveRecord model data
+    # @params [Proc] factory FactoryFilter
+    # @params [String] filename
+    # @params [Symbol] ext file type (:csv or :yml)
+    # @params [Hash] options other options
+    # @return [Proc] translate filter
+    def self.create_filter klass, factory, filename, ext, options
       columns = klass.columns
-      # テーブルからカラム情報を取り出し
-      column_hash = {}
-      columns.each { |col| column_hash[col.name] = col }
-      # 自動補完が必要なはずのカラム
-      lack_columns = columns.select { |c| !c.null and !c.default }.map{ |o| o.name.to_sym }
-      not_nullable_columns = columns.select { |c| !c.null }.map &:name
-      # ハッシュを受け取って、必要な値に加工してからハッシュで返すラムダを返す
-      return->(h){
-        # テーブルに存在しないキーが定義されているときは削除
+      # data translat array to hash
+      column_hash = columns.inject({}) { |h,col| h[col.name] = col; h }
+      lack_columns = columns.reject { |c| c.null and c.default }.map{ |o| o.name.to_sym }
+      # default value shound not be null columns
+      not_nullable_columns = columns.reject(&:null).map &:name
+      strict_filter=->(o,h){
+        # if value is not 'nil', value translate suitable form
+        h.each{ |k,v| v.nil? || o[k] = (TRANSLATER[column_hash[k].type] && TRANSLATER[column_hash[k].type].call(v)) }
+        # call FactoryFilter
+        factory.call(*[o, filename, ext][0,factory.arity]) if factory and !options[:unfilter]
+        o
+      }
+      # receives hased data and translate ActiveRecord Model data
+      # loose filter correct error values
+      # strict filter don't correct errora values and raise error
+      loose_filter=->(o,h){
+        h.reject! { |k,v| options[:minus].include?(k) } if options[:minus]
+        # if column name is not include database table columns, those names delete
         h.select! { |k,v| column_hash[k] }
-        o = klass.new 
-        # 値がnilでないなら型をDBで適切なものに変更
-        h.each{ |k,v| nil==v || o[k] = (TRANSLATER[column_hash[k].type] ? TRANSLATER[column_hash[k].type].call(v) : nil) }
-        # FactoryFilterを動作させる
-        factory.call(*[o, :load, filename, ext][0,factory.arity]) if factory
-        # 値がnilの列にデフォルト値を補間
-        not_nullable_columns.each{ |k| o[k]==nil && o[k] = (COMPLETER[column_hash[k].type] ? COMPLETER[column_hash[k].type].call : nil) }
-        # 列ごと抜けているデータを保管
-        lack_columns.each { |k| nil==o[k] && o[k] = COMPLETER[column_hash[k].type].call }
+        strict_filter.call(o,h)
+        # set default value if value is 'nil'
+        not_nullable_columns.each{ |k| o[k].nil? && o[k] = (column_hash[k] && COMPLETER[column_hash[k].type] && COMPLETER[column_hash[k].type].call) }
+        # fill span values if column is not exist
+        lack_columns.each { |k| o[k].nil? && o[k] = (column_hash[k] && COMPLETER[column_hash[k].type] && COMPLETER[column_hash[k].type].call) }
         o
       }
+      (options[:strict]==true) ? strict_filter : loose_filter
     end
   end
 end