dataset 1.3.1

data/lib/dataset/record/model.rb

@@ -0,0 +1,50 @@
+module Dataset
+  module Record # :nodoc:
+    
+    class Model # :nodoc:
+      attr_reader :attributes, :model, :meta, :symbolic_name, :session_binding
+      
+      def initialize(meta, attributes, symbolic_name, session_binding)
+        @meta            = meta
+        @attributes      = attributes.stringify_keys
+        @symbolic_name   = symbolic_name || object_id
+        @session_binding = session_binding
+      end
+      
+      def record_class
+        meta.record_class
+      end
+      
+      def id
+        model.id
+      end
+      
+      def create
+        model = to_model
+        model.save!
+        model
+      end
+      
+      def to_hash
+        to_model.attributes
+      end
+      
+      def to_model
+        @model ||= begin
+          m = meta.record_class.new
+          attributes.each do |k,v|
+            if reflection = record_class.reflect_on_association(k.to_sym)
+              case v
+              when Symbol
+                v = session_binding.find_model(reflection.klass, v)
+              end
+            end
+            m.send "#{k}=", v
+          end
+          m
+        end
+      end
+    end
+    
+  end
+end

data/lib/dataset/resolver.rb

@@ -0,0 +1,110 @@
+module Dataset
+  # An error raised when a dataset class cannot be found.
+  #
+  class DatasetNotFound < StandardError
+  end
+  
+  # A dataset may be referenced as a class or as a name. A Dataset::Resolver
+  # will take an identifier, whether a class or a name, and return the class.
+  #
+  class Resolver
+    cattr_accessor :default
+    
+    def identifiers
+      @identifiers ||= {}
+    end
+    
+    # Attempt to convert a name to a constant. With the identifier :people, it
+    # will search for 'PeopleDataset', then 'People'.
+    #
+    def resolve(identifier)
+      return identifier if identifier.is_a?(Class)
+      if constant = identifiers[identifier]
+        return constant
+      end
+
+      constant = resolve_class(identifier)
+      unless constant
+        constant = resolve_identifier(identifier)
+      end
+      identifiers[identifier] = constant
+    end
+    
+    protected
+      def resolve_identifier(identifier) # :nodoc:
+        constant = resolve_class(identifier)
+        unless constant
+          raise Dataset::DatasetNotFound, "Could not find a dataset '#{identifier.to_s.camelize}' or '#{identifier.to_s.camelize + suffix}'."
+        end
+        constant
+      end
+      
+      def resolve_class(identifier)
+        names = [identifier.to_s.camelize, identifier.to_s.camelize + suffix]
+        constant = resolve_these(names.reverse)
+        if constant && constant.superclass != ::Dataset::Base
+          raise Dataset::DatasetNotFound, "Found a class '#{constant.name}', but it does not subclass 'Dataset::Base'."
+        end
+        constant
+      end
+      
+      def resolve_these(names) # :nodoc:
+        names.each do |name|
+          constant = name.constantize rescue nil
+          return constant if constant && constant.is_a?(Class)
+        end
+        nil
+      end
+      
+      def suffix # :nodoc:
+        @suffix ||= 'Dataset'
+      end
+  end
+  
+  # Resolves a dataset by looking for a file in the provided directory path
+  # that has a name matching the identifier. Of course, should the identifier
+  # be a class already, it is simply returned.
+  #
+  class DirectoryResolver < Resolver
+    def initialize(*paths)
+      @paths = paths
+    end
+    
+    def <<(path)
+      @paths << path
+    end
+    
+    protected
+      def resolve_identifier(identifier) # :nodoc:
+        @paths.each do |path|
+          file = File.join(path, identifier.to_s)
+          unless File.exists?(file + '.rb')
+            file = file + '_' + file_suffix
+            next unless File.exists?(file + '.rb')
+          end
+          require file
+          begin
+            return super
+          rescue Dataset::DatasetNotFound => dnf
+            if dnf.message =~ /\ACould not find/
+              raise Dataset::DatasetNotFound, "Found the dataset file '#{file + '.rb'}', but it did not define #{dnf.message.sub('Could not find ', '')}"
+            else
+              raise Dataset::DatasetNotFound, "Found the dataset file '#{file + '.rb'}' and a class #{dnf.message.sub('Found a class ', '')}"
+            end
+          end
+        end
+        raise DatasetNotFound, "Could not find a dataset file in #{@paths.inspect} having the name '#{identifier}.rb' or '#{identifier}_#{file_suffix}.rb'."
+      end
+      
+      def file_suffix # :nodoc:
+        @file_suffix ||= suffix.downcase
+      end
+  end
+  
+  # The default resolver, used by the Dataset::Sessions that aren't given a
+  # different instance. You can set this to something else in your
+  # test/spec_helper.
+  #
+  Resolver.default = Resolver.new
+  
+end

data/lib/dataset/session.rb

@@ -0,0 +1,51 @@
+module Dataset
+  class Session # :nodoc:
+    attr_accessor :dataset_resolver
+    
+    def initialize(database, dataset_resolver = Resolver.default)
+      @database = database
+      @dataset_resolver = dataset_resolver
+      @datasets = Hash.new
+      @load_stack = []
+    end
+    
+    def add_dataset(test_class, dataset_identifier)
+      dataset = dataset_resolver.resolve(dataset_identifier)
+      if dataset.used_datasets
+        dataset.used_datasets.each { |used_dataset| self.add_dataset(test_class, used_dataset) }
+      end
+      datasets_for(test_class) << dataset
+    end
+    
+    def datasets_for(test_class)
+      if test_class.superclass
+        @datasets[test_class] ||= Collection.new(datasets_for(test_class.superclass) || [])
+      end
+    end
+    
+    def load_datasets_for(test_class)
+      datasets = datasets_for(test_class)
+      if last_load = @load_stack.last
+        if last_load.datasets == datasets
+          current_load = Reload.new(last_load)
+        elsif last_load.datasets.subset?(datasets)
+          @database.capture(last_load.datasets)
+          current_load = Load.new(datasets, last_load.dataset_binding)
+          current_load.execute(last_load.datasets, @dataset_resolver)
+          @load_stack.push(current_load)
+        else
+          @load_stack.pop
+          last_load = @load_stack.last
+          @database.restore(last_load.datasets) if last_load
+          current_load = load_datasets_for(test_class)
+        end
+      else
+        @database.clear
+        current_load = Load.new(datasets, @database)
+        current_load.execute([], @dataset_resolver)
+        @load_stack.push(current_load)
+      end
+      current_load
+    end
+  end
+end

data/lib/dataset/session_binding.rb

@@ -0,0 +1,317 @@
+module Dataset
+  # An error that will be raised when an attempt is made to load a named model
+  # that doesn't exist. For example, if you do people(:jenny), and yet no
+  # record was ever created with the symbolic name :jenny, this error will be
+  # raised.
+  #
+  class RecordNotFound < StandardError
+    def initialize(record_type, symbolic_name)
+      super "There is no '#{record_type.name}' found for the symbolic name ':#{symbolic_name}'."
+    end
+  end
+  
+  # Whenever you use Dataset::RecordMethods, you will get finder methods in
+  # your tests that help you load instances of the records you have created
+  # (or named models).
+  #
+  #    create_record :person, :jimmy, :name => 'Jimmy'
+  #    person_id(:jimmy)  => The id was captured from create_record
+  #    people(:jimmy)     => The same as Jimmy.find(person_id(:jimmy))
+  #
+  # The methods will not exist in a test unless it utilizes a dataset (or
+  # defines one itself through the block technique) that creates a record for
+  # the type.
+  #
+  # You may also pass multiple names to these methods, which will have them
+  # return an array of values.
+  #
+  #    people(:jimmy, :jane, :jeff)     => [<# Person :name => 'Jimmy'>, <# Person :name => 'Jane'>, <# Person :name => 'Jeff'>]
+  #    person_id(:jimmy, :jane, :jeff)  => [1, 2, 3]
+  #
+  # NOTE the plurality of the instance finder, versus the singularity of the
+  # id finder.
+  #
+  # == Single Table Inheritence
+  #
+  #    class Person < ActiveRecord::Base; end
+  #    class User < Person; end
+  #
+  #    create_record :user, :bobby, :name => 'Bobby'
+  #
+  #    people(:bobby) OR users(:bobby)
+  #
+  module ModelFinders
+    def create_finder(record_meta) # :nodoc:
+      @finders_generated ||= []
+      
+      return if @finders_generated.include?(record_meta)
+      
+      record_meta.model_finder_names.each do |finder_name|
+        unless instance_methods.include?(finder_name)
+          define_method finder_name do |*symbolic_names|
+            names = Array(symbolic_names)
+            models = names.inject([]) do |c,n|
+              c << dataset_session_binding.find_model(record_meta, n); c
+            end
+            names.size == 1 ? models.first : models
+          end
+        end
+      end
+      
+      record_meta.id_finder_names.each do |finder_name|
+        unless instance_methods.include?(finder_name)
+          define_method finder_name do |*symbolic_names|
+            names = Array(symbolic_names)
+            ids = names.inject([]) do |c,n|
+              c << dataset_session_binding.find_id(record_meta, n); c
+            end
+            names.size == 1 ? ids.first : ids
+          end
+        end
+      end
+      
+      @finders_generated << record_meta
+    end
+  end
+  
+  # Any Dataset::Base subclass, dataset block, or test method in a
+  # dataset-using test context (including setup/teardown/before/after) may
+  # create and access models through these methods. Note that you should use
+  # Dataset::ModelFinders if you can for finding your created data.
+  #
+  module RecordMethods
+    
+    # Similar to old fashioned fixtures, this will do a direct database
+    # insert, without running any validations or preventing you from writing
+    # attr_protected attributes. Very nice for speed, but kind of a pain if
+    # you have complex structures or hard to keep right validations.
+    #
+    #     create_record :type, :symbolic_name, :attr1 => 'value', :attr2 => 'value', :etc => 'etc'
+    #
+    # The _symbolic_name_ is an optional parameter. You may replace _type_
+    # with an ActiveRecord::Base subclass or anything that works with:
+    #
+    #    to_s.classify.constantize
+    #
+    # The id of the model will be a hash of the symbolic name.
+    #
+    def create_record(*args)
+      dataset_session_binding.create_record(*args)
+    end
+    
+    # This will instantiate your model class and assign each attribute WITHOUT
+    # using mass assignment. Validations will be run. Very nice for complex
+    # structures or hard to keep right validations, but potentially a bit
+    # slower, since it runs through all that ActiveRecord code.
+    #
+    #     create_model :type, :symbolic_name, :attr1 => 'value', :attr2 => 'value', :etc => 'etc'
+    #
+    # The _symbolic_name_ is an optional parameter. You may replace _type_
+    # with an ActiveRecord::Base subclass or anything that works with:
+    #
+    #    to_s.classify.constantize
+    #
+    # The id of the record will be kept from the instance that is saved.
+    #
+    def create_model(*args)
+      dataset_session_binding.create_model(*args)
+    end
+    
+    # Dataset will track each of the records it creates by symbolic name to
+    # id. When you need the id of a record, there is no need to go to the
+    # database.
+    #
+    #    find_id :person, :bobby    => 23425234
+    #
+    # You may pass one name or many, with many returning an Array of ids.
+    #
+    def find_id(*args)
+      dataset_session_binding.find_id(*args)
+    end
+    
+    # Dataset will track each of the records it creates by symbolic name to
+    # id. When you need an instance of a record, the stored id will be used to
+    # do the fastest lookup possible: Person.find(23425234).
+    #
+    #    find_model :person, :bobby    => <#Person :id => 23425234, :name => 'Bobby'>
+    #
+    # You may pass one name or many, with many returning an Array of
+    # instances.
+    #
+    def find_model(*args)
+      dataset_session_binding.find_model(*args)
+    end
+    
+    # This is a great help when you want to create records in a custom helper
+    # method, then make it and maybe things associated to it available to
+    # tests through the Dataset::ModelFinders.
+    #
+    #    thingy = create_very_complex_thingy_and_stuff
+    #    name_model thingy, :thingy_bob
+    #    name_model thingy.part, :thingy_part
+    #
+    # In tests:
+    #
+    #    thingies(:thingy_bob)
+    #    parts(:thingy_part)
+    #
+    def name_model(*args)
+      dataset_session_binding.name_model(*args)
+    end
+    
+    # Converts string names into symbols for use in naming models
+    # 
+    #     name_to_sym 'my name' => :my_name
+    #     name_to_sym 'RPaul'  => :r_paul
+    # 
+    def name_to_sym(name)
+      dataset_session_binding.name_to_sym(name)
+    end
+  end
+  
+  class SessionBinding # :nodoc:
+    attr_reader :database, :parent_binding
+    attr_reader :model_finders, :record_methods
+    attr_reader :block_variables
+    
+    def initialize(database_or_parent_binding)
+      @id_cache = Hash.new {|h,k| h[k] = {}}
+      @record_methods = new_record_methods_module
+      @model_finders = new_model_finders_module
+      @block_variables = Hash.new
+      
+      case database_or_parent_binding
+      when Dataset::SessionBinding
+        @parent_binding = database_or_parent_binding
+        @database = parent_binding.database
+        @model_finders.module_eval { include database_or_parent_binding.model_finders }
+        @block_variables.update(database_or_parent_binding.block_variables)
+      else 
+        @database = database_or_parent_binding
+      end
+    end
+    
+    def copy_block_variables(dataset_block)
+      dataset_block.instance_variables.each do |name|
+        self.block_variables[name] = dataset_block.instance_variable_get(name)
+      end
+    end
+    
+    def create_model(record_type, *args)
+      insert(Dataset::Record::Model, record_type, *args)
+    end
+    
+    def create_record(record_type, *args)
+      insert(Dataset::Record::Fixture, record_type, *args)
+    end
+    
+    def find_id(record_type_or_meta, symbolic_name)
+      record_meta = record_meta_for_type(record_type_or_meta)
+      if local_id = @id_cache[record_meta.id_cache_key][symbolic_name]
+        local_id
+      elsif !parent_binding.nil?
+        parent_binding.find_id record_meta, symbolic_name
+      else
+        raise RecordNotFound.new(record_meta, symbolic_name)
+      end
+    end
+    
+    def find_model(record_type_or_meta, symbolic_name)
+      record_meta = record_meta_for_type(record_type_or_meta)
+      if local_id = @id_cache[record_meta.id_cache_key][symbolic_name]
+        record_meta.record_class.find local_id
+      elsif !parent_binding.nil?
+        parent_binding.find_model record_meta, symbolic_name
+      else
+        raise RecordNotFound.new(record_meta, symbolic_name)
+      end
+    end
+    
+    def install_block_variables(target)
+      block_variables.each do |k,v|
+        target.instance_variable_set(k,v)
+      end
+    end
+    
+    def name_model(record, symbolic_name)
+      record_meta = database.record_meta(record.class)
+      @model_finders.create_finder(record_meta)
+      @id_cache[record_meta.id_cache_key][symbolic_name] = record.id
+      record
+    end
+    
+    def record_meta_for_type(record_type)
+      record_type.is_a?(Record::Meta) ? record_type : begin
+        record_class = resolve_record_class(record_type)
+        database.record_meta(record_class)
+      end
+    end
+    
+    def name_to_sym(name)
+      name.to_s.underscore.gsub("'", "").gsub("\"", "").gsub(" ", "_").to_sym if name
+    end
+    
+    protected
+      def insert(dataset_record_class, record_type, *args)
+        symbolic_name, attributes = extract_creation_arguments args
+        record_meta  = record_meta_for_type(record_type)
+        record       = dataset_record_class.new(record_meta, attributes, symbolic_name, self)
+        return_value = nil
+        
+        @model_finders.create_finder(record_meta)
+        ActiveRecord::Base.silence do
+          return_value = record.create
+          @id_cache[record_meta.id_cache_key][symbolic_name] = record.id
+        end
+        return_value
+      end
+      
+      def extract_creation_arguments(arguments)
+        if arguments.size == 2 && arguments.last.kind_of?(Hash)
+          arguments
+        elsif arguments.size == 1 && arguments.last.kind_of?(Hash)
+          [nil, arguments.last]
+        elsif arguments.size == 1 && arguments.last.kind_of?(Symbol)
+          [arguments.last, Hash.new]
+        else
+          [nil, Hash.new]
+        end
+      end
+      
+      def new_model_finders_module
+        mod = Module.new
+        dataset_binding = self
+        mod.module_eval do
+          define_method :dataset_session_binding do
+            dataset_binding
+          end
+        end
+        mod.extend ModelFinders
+        mod
+      end
+      
+      def new_record_methods_module
+        mod = Module.new do
+          include RecordMethods
+        end
+        dataset_binding = self
+        mod.module_eval do
+          define_method :dataset_session_binding do
+            dataset_binding
+          end
+        end
+        mod
+      end
+      
+      def resolve_record_class(record_type)
+        case record_type
+        when Symbol
+          resolve_record_class record_type.to_s.singularize.camelize
+        when Class
+          record_type
+        when String
+          record_type.constantize
+        end
+      end
+  end
+end