flextures 3.0.1 → 3.1.0

data/lib/flextures/flextures_loader.rb

@@ -10,11 +10,9 @@ require 'flextures/flextures_factory'
 
 module Flextures
   # data loader
-  module Loader
+  class Loader
     PARENT = Flextures
 
-    @@option_cache = {}
-
     # column set default value
     COMPLETER = {
       binary:->{ 0 },
@@ -82,6 +80,79 @@ module Flextures
       },
     }
 
+    def initialize(*_)
+      # 読み込み状態を持っておく
+      @options = {}
+      @already_loaded_fixtures = {}
+    end
+
+    def loads(*fixtures)
+      # キャッシュが有効 ∧ 呼んだ事無いファイル
+      load_list = self.class.parse_flextures_options( @options, *fixtures)
+      load_list.sort(&self.class.loading_order).each do |params|
+        load(params)
+      end
+    end
+
+    def load(params)
+      return if cashable?(params) and loaded?(params)
+      @already_loaded_fixtures[params[:table]] = params
+      self.class.load(params)
+    end
+
+    def cashable?(params)
+      !!params[:cache]
+    end
+
+    def loaded?(params)
+      equal_table_data?(@already_loaded_fixtures[params[:table]], params)
+    end
+
+    # compare
+    def equal_table_data?(src,dst)
+      return false unless src.is_a?(Hash)
+      return false unless dst.is_a?(Hash)
+      (src.to_a - dst.to_a).empty?
+    end
+
+    # called by Rspec or Should
+    # set options
+    # @params [Hash] options exmple : { cashe: true, dir: "models/users" }
+    def set_options( options )
+      @options.merge!(options)
+      @options
+    end
+
+    # called by Rspec or Should after filter
+    # reflesh options
+    def delete_options
+      @options = {}
+    end
+
+    # return current option status
+    # @return [Hash] current option status
+    def flextures_options
+      @options
+    end
+
+    # parse flextures function arguments
+    # @params [Hash] fixtures function arguments
+    # @return [Array] formatted load options
+    def self.parse_flextures_options( base_options, *fixtures )
+      options = {}
+      options = fixtures.shift if fixtures.size > 1 and fixtures.first.is_a?(Hash)
+
+      options[:dir] = self.parse_controller_option( options ) if options[:controller]
+      options[:dir] = self.parse_model_options( options )     if options[:model]
+
+      # :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.reduce({}){ |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(base_options).merge(options) }
+    end
+
     # load fixture datas
     #
     # example:
@@ -90,9 +161,9 @@ module Flextures
     # 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 }
+    def self.flextures( *fixtures )
+      loader = Flextures::Loader::Instance.new
+      loader.loads(*fixtures)
     end
 
     # @return [Proc] order rule block (user Array#sort methd)
@@ -104,31 +175,11 @@ module Flextures
       }
     end
 
-    # 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
-
-    # called by Rspec or Should after filter
-    # reflesh options
-    def self.delete_options
-      @@option_cache = {}
-    end
-
-    # return current option status
-    # @return [Hash] current option status
-    def self.flextures_options
-      @@option_cache
-    end
-
     # 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
+    def self.load( format )
+      file_name, method = file_exist(format)
       if method
         send(method, format)
       else
@@ -138,46 +189,46 @@ module Flextures
 
     # load CSV data
     # @params [Hash] format file load format(table name, file name, options...)
-    def self.csv format
+    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
+      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
 
     # load YAML data
     # @params [Hash] format file load format( table: name, file: name, options...)
-    def self.yml format
+    def self.yml( format )
       type = :yml
-      file_name, ext = file_exist format, [type]
+      file_name, ext = file_exist( format, [type] )
 
-      return unless self.file_loadable? format, file_name
+      return unless self.file_loadable?( format, file_name )
 
-      klass, filter = self.create_model_filter format, file_name, type
-      self.load_yml format, klass, filter, file_name
+      klass, filter = self.create_model_filter( format, file_name, type )
+      self.load_yml( format, klass, filter, file_name )
     end
 
-    def self.load_csv format, klass, filter, file_name
-      attributes = klass.columns.map &:name
+    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]
+        warning( "CSV", attributes, keys ) unless format[:silent]
         csv.each do |values|
           h = values.extend(Extensions::Array).to_hash(keys)
-          filter.call h
+          filter.call(h)
         end
       end
       file_name
     end
 
-    def self.load_yml format, klass, filter, file_name
-      yaml = YAML.load File.open(file_name)
+    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
+      attributes = klass.columns.map(&:name)
       yaml.each do |k,h|
-        warning "YAML", attributes, h.keys unless format[:silent]
-        filter.call h
+        warning( "YAML", attributes, h.keys ) unless format[:silent]
+        filter.call(h)
       end
       file_name
     end
@@ -186,7 +237,7 @@ module Flextures
     # load directroy is change
     # spec/fixtures/:controller_name/:action_name/
     # @return [String] directory path
-    def self.parse_controller_option options
+    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]
@@ -197,38 +248,20 @@ module Flextures
     # load directroy is change
     # spec/fixtures/:model_name/:method_name/
     # @return [String] directory path
-    def self.parse_model_options options
+    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)
-
-      options[:dir] = self.parse_controller_option( options ) if options[:controller]
-      options[:dir] = self.parse_model_options( options )     if options[:model]
-
-      # :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
-
     # example:
     # self.create_stair_list("foo/bar/baz")
     # return ["foo/bar/baz","foo/bar","foo",""]
-    def self.stair_list dir, stair=true
+    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 }
+      dir.to_s.split("/").reduce([]){ |a,d| a<< d; l.unshift(a.join("/")); a }
       l<< ""
       l
     end
@@ -236,43 +269,43 @@ module Flextures
     # 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]
+    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"
+        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.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
+    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
+    def self.warning( format, attributes, keys )
       (attributes-keys).each { |name| puts "Warning: #{format} colum is missing! [#{name}]" }
       (keys-attributes).each { |name| puts "Warning: #{format} colum is left over! [#{name}]" }
     end
 
     # create filter and table info
-    def self.create_model_filter format, file_name, type
+    def self.create_model_filter( format, file_name, type )
       table_name = format[:table].to_s
-      klass = PARENT::create_model table_name
+      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)
+      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
+        filter = create_filter( klass, LoadFilter[table_name.to_sym], file_name, type, format )
         o = klass.new
-        o = filter.call o, h
+        o = filter.call( o, h )
         o.save( validate: false )
         o
       }
@@ -289,13 +322,13 @@ module Flextures
     # @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
+    def self.create_filter( klass, factory, filename, ext, options )
       columns = klass.columns
       # data translat array to hash
-      column_hash = columns.inject({}) { |h,col| h[col.name] = col; h }
+      column_hash = columns.reduce({}) { |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
+      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)) }
@@ -312,7 +345,7 @@ module Flextures
         h.select! { |k,v| column_hash[k] }
         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) }
+        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
@@ -321,4 +354,3 @@ module Flextures
     end
   end
 end
-

data/lib/flextures/rspec_flextures_support.rb

@@ -1,33 +1,63 @@
 # encoding: utf-8
 
+
+module RSpec
+  module Rails
+    module SetupAndTeardownAdapter
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def flextures_prepend_before(&block)
+          prepend_before(&block)
+        end
+
+        def flextures_before(&block)
+          before(&block)
+        end
+      end
+    end
+  end
+end
+
 # flextures function use like fixtures method in RSpec
 module RSpec
   module Core
     module Hooks
       # load fixtture data
       # @params [Array] _ fixture file names
-      def flextures *_
-        before { Flextures::Loader::flextures *_ }
+      def flextures( *_ )
+        flextures_loader = create_or_get_flextures_loader(__method__)
+        flextures_before do
+          flextures_loader.loads( *_ )
+        end
+      end
+
+      # flexturesの読み出し
+      def create_or_get_flextures_loader(*_)
+        @@flextures_loader ||= Flextures::Loader.new(*_)
+      end
+
+      def flextures_get_options
+        @@flextures_loader
       end
 
       # delete table data
       # @params [Array] _ table names
-      def flextures_delete *_
-        before {
+      def flextures_delete( *_ )
+        flextures_loader = create_or_get_flextures_loader(__method__)
+        flextures_before do
           if _.empty?
             Flextures::init_tables
           else
-            Flextures::delete_tables *_
+            Flextures::delete_tables( *_ )
           end
-        }
+        end
       end
 
-      def flextures_set_options options
-        before do
-          Flextures::Loader::set_options options
-        end
-        after do
-          Flextures::Loader::delete_options
+      def flextures_set_options( options )
+        flextures_loader = create_or_get_flextures_loader(__method__)
+        flextures_prepend_before do
+          flextures_loader.set_options( options )
         end
       end
     end
@@ -53,6 +83,13 @@ module ActiveRecord
     def setup_fixtures
       Flextures::init_load
       setup_fixtures_bkup
+      set_transactional_filter_params
+    end
+
+    # nilで無い時は値をtransactional_filterが有効　
+    def set_transactional_filter_params
+      return if Flextures::Config.use_transactional_fixtures.nil?
+      self.use_transactional_fixtures = Flextures::Config.use_transactional_fixtures
     end
 
     alias :teardown_fixtures_bkup :teardown_fixtures
@@ -61,4 +98,3 @@ module ActiveRecord
     end
   end
 end
-

data/lib/flextures/testunit_flextures_support.rb

@@ -4,32 +4,40 @@
 module Shoulda
   module Context
     module ClassMethods
-      def flextures *_
+      def create_or_get_flextures_loader
+        @flextures_loader ||= Flextures::Loader.new
+      end
+
+      def flextures( *_ )
+        flextures_loader = create_or_get_flextures_loader
+
         context = Shoulda::Context.current_context
-        context.setup_blocks<< ->{ Flextures::Loader::flextures *_ }
+        context.setup_blocks<< ->{ flextures_loader.flextures(*_) }
       end
 
-      def flextures_delete *_
+      def flextures_delete( *_ )
         context = Shoulda::Context.current_context
+
         context.setup_blocks<< -> {
           if _.empty?
             Flextures::init_tables
           else
-            Flextures::delete_tables *_
+            Flextures::delete_tables(*_)
           end
         }
       end
 
-      def flextures_set_options options={}
+      def flextures_set_options( options={} )
+        flextures_loader = create_or_get_flextures_loader
+
         context = Shoulda::Context.current_context
         context.setup_blocks<< -> {
-          Flextures::Loader::set_options options
+          flextures_loader.set_options(options)
         }
         context.teardown_blocks<< -> {
-          Flextures::Loader::delete_options
+          flextures_loader.delete_options
         }
       end
     end
   end
 end
-