flextures 3.1.3 → 4.0.0

data/lib/flextures/flextures_extension_modules.rb

@@ -1,19 +1,6 @@
-# encoding: utf-8
-
 require 'ostruct'
 
 module Flextures
-  # OpenStruct hack in flextures Plug-in
-  class OpenStruct < ::OpenStruct
-    # Struct Data translate to Hash
-    def to_hash
-      (self.methods - ::OpenStruct.new.methods)
-        .select{ |name| name.to_s.match(/\w+=/) }
-        .map{ |name| name.to_s.gsub(/=/,'').to_sym }
-        .reduce({}){ |k,h| h[k]=self.send(k); h }
-    end
-  end
-
   module Extensions
     module Array
       # use Object#extend
@@ -21,7 +8,7 @@ module Flextures
       # @return [Hash] tanslated Hash data
       # example:
       # hash = array.extend(Extensions::Array).to_hash(keys)
-      def to_hash( keys )
+      def to_hash(keys)
         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

data/lib/flextures/flextures_factory.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Flextures
   # Flextures FactoryFilter is program to translate ActiveRecord data
   class LoadFilter
@@ -10,7 +8,7 @@ module Flextures
     # @params [String] table_name
     # @params [Array] options arguments ActiveRecord Model
     # @params [Proc] block FactoryFilter
-    def self.define( table_name, *options, &block )
+    def self.define(table_name, *options, &block)
       h={ block: block }
       options.each do |o|
         begin
@@ -40,12 +38,12 @@ module Flextures
     # @params options
     # @params block
     # @return Flextures::Factory
-    def self.define( table_name, hash )
+    def self.define(table_name, hash)
       FACTORIES[table_name.to_sym]=hash
     end
 
     # get FactoryFilter
-    def self.get( table_name )
+    def self.get(table_name)
       FACTORIES[table_name.to_sym]
     end
     def self.[](table_name); self.get(table_name); end

data/lib/flextures/flextures_loader.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'ostruct'
 require 'csv'
 
@@ -88,28 +86,28 @@ module Flextures
 
     def loads(*fixtures)
       # キャッシュが有効 ∧ 呼んだ事無いファイル
-      load_list = self.class.parse_flextures_options( @options, *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]
+    def self.cache?(params)
+      if params.first.is_a?(Hash)
+        param = params.first
+        param[:cache] == true
+      end
     end
 
-    def loaded?(params)
-      equal_table_data?(@already_loaded_fixtures[params[:table]], params)
+    def reset_cache
     end
 
     # compare
-    def equal_table_data?(src,dst)
+    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?
@@ -118,9 +116,8 @@ module Flextures
     # called by Rspec or Should
     # set options
     # @params [Hash] options exmple : { cashe: true, dir: "models/users" }
-    def set_options( options )
+    def set_options(options)
       @options.merge!(options)
-      @options
     end
 
     # called by Rspec or Should after filter
@@ -138,12 +135,12 @@ module Flextures
     # parse flextures function arguments
     # @params [Hash] fixtures function arguments
     # @return [Array] formatted load options
-    def self.parse_flextures_options( base_options, *fixtures )
+    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]
+      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
@@ -161,7 +158,7 @@ module Flextures
     # flextures :users => :users2 # :table_name => :file_name
     #
     # @params [Hash] fixtures load table data
-    def self.flextures( *fixtures )
+    def self.flextures(*fixtures)
       loader = Flextures::Loader::Instance.new
       loader.loads(*fixtures)
     end
@@ -178,7 +175,7 @@ module Flextures
     # load fixture data
     # fixture file prefer YAML to CSV
     # @params [Hash] format file load format(table name, file name, options...)
-    def self.load( format )
+    def self.load(format)
       file_name, method = file_exist(format)
       if method
         send(method, format)
@@ -189,31 +186,31 @@ 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 )
+    def self.load_csv(format, klass, filter, file_name)
       attributes = klass.columns.map(&:name)
-      CSV.open( file_name ) do |csv|
+      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)
@@ -222,12 +219,12 @@ module Flextures
       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)
       yaml.each do |k,h|
-        warning( "YAML", attributes, h.keys ) unless format[:silent]
+        warning("YAML", attributes, h.keys) unless format[:silent]
         filter.call(h)
       end
       file_name
@@ -237,7 +234,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]
@@ -248,7 +245,7 @@ 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]
@@ -258,7 +255,7 @@ module Flextures
     # 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("/").reduce([]){ |a,d| a<< d; l.unshift(a.join("/")); a }
@@ -269,12 +266,12 @@ 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
+      base_dir_name = Flextures::Configuration.load_directory
       self.stair_list(format[:dir], format[:stair]).each do |dir|
-        file_path = File.join( base_dir_name, dir, file_name )
+        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
@@ -283,8 +280,8 @@ module Flextures
 
     # 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
@@ -296,17 +293,18 @@ module Flextures
     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)
+      # binding.pry
       # 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.save( validate: false )
+        o = filter.call(o, h)
+        o.save(validate: false)
         o
       }
       [klass, filter]
@@ -322,24 +320,24 @@ 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.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)
-      strict_filter=->(o,h){
+      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]
+        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){
+      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] }

data/lib/flextures/flextures_railtie.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Flextures
   class Railtie < Rails::Railtie
     rake_tasks do

data/lib/flextures/rspec_flextures_support.rb

@@ -1,100 +1,154 @@
-# encoding: utf-8
-
-
+# flextures function use like fixtures method in RSpec
 module RSpec
   module Rails
-    module SetupAndTeardownAdapter
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def flextures_prepend_before(&block)
-          prepend_before(&block)
-        end
+    module FlextureSupport
+      @@once_included = false
+      def self.included(m)
+        init_tables
+      end
 
-        def flextures_before(&block)
-          before(&block)
+      def self.init_tables
+        unless @@once_included
+          Flextures::init_tables
+          @@once_included = true
         end
       end
     end
   end
+
+  RSpec.configure do |c|
+    c.include RSpec::Rails::FlextureSupport
+  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( *_ )
-        flextures_loader = create_or_get_flextures_loader(__method__)
-        flextures_before do
-          flextures_loader.loads( *_ )
+# override setup_fixtures function
+module ActiveRecord
+  module TestFixtures
+    PARENT = self
+    @@flextures_loader = Flextures::Loader.new
+    @@all_cached_flextures = {}
+    @@already_loaded_flextures = {}
+
+    alias :setup_fixtures_bkup :setup_fixtures
+    def setup_fixtures
+      Flextures::load_configurations
+      setup_fixtures_bkup
+    end
+
+    alias :teardown_fixtures_bkup :teardown_fixtures
+    def teardown_fixtures
+      teardown_fixtures_bkup
+    end
+
+    # load initial fixtures
+    # There is fixtures load before start rspec
+    def self.init_load_should_cache_fixtures(table_load_settings)
+      table_load_settings.each do |load_setting|
+        if should_cache_setting?(load_setting) and !cached_table?(load_setting)
+          @@flextures_loader.load(load_setting)
+          set_cached_settng_list(load_setting)
+        end
+      end
+    end
+
+    # Usually, fixture is cached when is exist under "spec/fixture/" directly.
+    def self.should_cache_setting?(load_setting)
+      load_setting.keys.sort == %i[table file loader].sort &&
+      load_setting[:file].to_s == load_setting[:table].to_s &&
+      load_setting[:loader] == :fun
+    end
+
+    # check: same data is exist in DB.
+    def self.cached_table?(load_setting)
+      flextures_cached?(load_setting) || fixture_cached?(load_setting)
+    end
+
+    def self.flextures_cached?(load_setting)
+      config = @@all_cached_flextures[load_setting[:table]]
+      config && config == load_setting
+    end
+
+    # flextures check fixture function already loaded data.
+    def self.fixture_cached?(load_setting)
+      default_file_path = File.join(Flextures::Configuration.load_directory, "#{load_setting[:table]}.yml")
+
+      load_setting[:file] == default_file_path &&
+      yml_fixture_cached?(load_setting[:table])
+    end
+
+    def self.yml_fixture_cached?(table_name)
+      connection = ActiveRecord::Base.connection
+      !!ActiveRecord::FixtureSet.fixture_is_cached?(connection, table_name)
+    end
+
+    def self.set_cached_settng_list(load_setting)
+      @@all_cached_flextures[load_setting[:table]] = load_setting
+    end
+
+    def load_not_cached_fixtures(table_load_settings)
+      table_load_settings.each do |load_setting|
+        if PARENT.cached_table?(load_setting) and load_setting[:cache] != false
+          next
+        else
+          @@flextures_loader.load(load_setting)
         end
       end
+    end
+
+    def load_all_fixtures(table_load_settings)
+      table_load_settings.each do |load_setting|
+        @@flextures_loader.load(load_setting)
+      end
+    end
+
+    module ClassMethods
+      def get_or_initialize_flextures_loader_options
+        @flextures_loader_options ||= {}
+      end
+
+      def flextures_loader_options
+        get_or_initialize_flextures_loader_options
+      end
+
+      def flextures_loader
+        PARENT.class_variable_get(:@@flextures_loader)
+      end
 
-      # flexturesの読み出し
-      def create_or_get_flextures_loader(*_)
-        @@flextures_loader ||= Flextures::Loader.new(*_)
+      def flextures(*fixtures)
+        loads_use_cache_fixtures(*fixtures)
       end
 
-      def flextures_get_options
-        @@flextures_loader
+      def loads_use_cache_fixtures(*fixtures)
+        table_load_settings = Flextures::Loader.parse_flextures_options(flextures_loader_options, *fixtures)
+
+        if use_transactional_fixtures
+          PARENT.init_load_should_cache_fixtures(table_load_settings)
+          before do
+            load_not_cached_fixtures(table_load_settings)
+          end
+        else
+          before do
+            load_all_fixtures(table_load_settings)
+          end
+        end
       end
 
       # delete table data
       # @params [Array] _ table names
-      def flextures_delete( *_ )
-        flextures_loader = create_or_get_flextures_loader(__method__)
-        flextures_before do
+      def flextures_delete(*_)
+        before do
           if _.empty?
             Flextures::init_tables
           else
-            Flextures::delete_tables( *_ )
+            Flextures::delete_tables(*_)
           end
         end
       end
 
-      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
-  end
-
-  module Rails
-    module FlextureSupport
-      def self.included(m)
-        Flextures::init_tables
+      def flextures_set_options(options)
+        @flextures_loader_options = get_or_initialize_flextures_loader_options
+        @flextures_loader_options = @flextures_loader_options.merge(options)
       end
     end
   end
-
-  RSpec.configure do |c|
-    c.include RSpec::Rails::FlextureSupport
-  end
-end
-
-# override setup_fixtures function
-module ActiveRecord
-  module TestFixtures
-    alias :setup_fixtures_bkup :setup_fixtures
-    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
-    def teardown_fixtures
-      teardown_fixtures_bkup
-    end
-  end
 end