radiant 0.6.9 → 0.7.0

data/vendor/plugins/dataset/lib/dataset/session_binding.rb

@@ -0,0 +1,299 @@
+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
+  #
+  # This is a TODO for Dataset. For now, you will have to use the finder of the base class:
+  #
+  #    class Person < ActiveRecord::Base; end
+  #    class User < Person; end
+  #
+  #    create_record :user, :bobby, :name => 'Bobby'
+  #
+  #    people(:bobby)
+  #
+  module ModelFinders
+    def create_finder(record_class) # :nodoc:
+      record_loader_base_name = record_class.name.underscore
+      define_method record_loader_base_name.pluralize do |*symbolic_names|
+        names = Array(symbolic_names)
+        models = names.inject([]) do |c,n|
+          c << dataset_session_binding.find_model(record_class, n); c
+        end
+        names.size == 1 ? models.first : models
+      end
+      define_method "#{record_loader_base_name}_id" do |*symbolic_names|
+        names = Array(symbolic_names)
+        ids = names.inject([]) do |c,n|
+          c << dataset_session_binding.find_id(record_class, n); c
+        end
+        names.size == 1 ? ids.first : ids
+      end
+    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 'BObama'  => :b_obama
+    # 
+    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)
+      @symbolic_names_to_ids = 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, symbolic_name)
+      record_class = resolve_record_class record_type
+      if local_id = @symbolic_names_to_ids[record_class][symbolic_name]
+        local_id
+      elsif !parent_binding.nil?
+        parent_binding.find_id record_type, symbolic_name
+      else
+        raise RecordNotFound.new(record_type, symbolic_name)
+      end
+    end
+    
+    def find_model(record_type, symbolic_name)
+      record_class = resolve_record_class record_type
+      if local_id = @symbolic_names_to_ids[record_class][symbolic_name]
+        record_class.find local_id
+      elsif !parent_binding.nil?
+        parent_binding.find_model record_type, symbolic_name
+      else
+        raise RecordNotFound.new(record_type, 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_class = record.class.base_class
+      @model_finders.create_finder(record_class) unless @symbolic_names_to_ids.has_key?(record_class)
+      @symbolic_names_to_ids[record_class][symbolic_name] = record.id
+      record
+    end
+    
+    def name_to_sym(name)
+      return nil if name.nil?
+      name.to_s.underscore.gsub("'", "").gsub("\"", "").gsub(" ", "_").to_sym
+    end
+    
+    protected
+      def insert(dataset_record_class, record_type, *args)
+        symbolic_name, attributes = extract_creation_arguments args
+        record_class = resolve_record_class record_type
+        record_meta  = database.record_meta record_class
+        record       = dataset_record_class.new(record_meta, attributes, symbolic_name)
+        @model_finders.create_finder(record.record_class) unless @symbolic_names_to_ids.has_key?(record.record_class)
+        return_value = nil
+        ActiveRecord::Base.silence do
+          return_value = record.create
+          @symbolic_names_to_ids[record.record_class][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

data/vendor/plugins/dataset/lib/dataset/version.rb

@@ -0,0 +1,9 @@
+module Dataset
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/vendor/plugins/dataset/spec/dataset/database/base_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../spec_helper'
+
+describe Dataset::Database::Base do
+  before do
+    @database = Dataset::Database::Base.new
+  end
+  
+  it 'should clear the tables of all AR classes' do
+    Place.create!
+    Thing.create!
+    @database.clear
+    Place.count.should be(0)
+    Thing.count.should be(0)
+  end
+  
+  it 'should not clear the "schema_migrations" table' do
+    ActiveRecord::Base.connection.insert("INSERT INTO schema_migrations (version) VALUES ('testing123')")
+    @database.clear
+    ActiveRecord::Base.connection.select_one("SELECT version FROM schema_migrations WHERE version = 'testing123'").should_not be_blank
+  end
+end

data/vendor/plugins/dataset/spec/dataset/resolver_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../spec_helper'
+
+ResolveThis = Class.new(Dataset::Base)
+ResolveDataset = Class.new(Dataset::Base)
+SomeModelNotDs = Class.new
+SomeModelNotDsDataset = Class.new(Dataset::Base)
+NotADataset = Class.new
+TheModule = Module.new
+TheModuleDataset = Class.new(Dataset::Base)
+
+describe Dataset::Resolver do
+  before do
+    @resolver = Dataset::Resolver.new
+  end
+  
+  it 'should skip modules' do
+    @resolver.resolve(:the_module).should == TheModuleDataset
+  end
+  
+  it 'should find simply classified' do
+    @resolver.resolve(:resolve_this).should == ResolveThis
+  end
+  
+  it 'should find ending with Dataset' do
+    @resolver.resolve(:resolve).should == ResolveDataset
+  end
+  
+  it 'should keep looking if first try is not a dataset' do
+    dataset = @resolver.resolve(:some_model_not_ds)
+    dataset.should_not be(SomeModelNotDs)
+    dataset.should == SomeModelNotDsDataset
+  end
+  
+  it 'should indicate when found class is not a dataset' do
+    lambda do
+      @resolver.resolve(:not_a_dataset)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Found a class 'NotADataset', but it does not subclass 'Dataset::Base'."
+    )
+  end
+  
+  it 'should indicate that it could not find a dataset' do
+    lambda do
+      @resolver.resolve(:undefined)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Could not find a dataset 'Undefined' or 'UndefinedDataset'."
+    )
+  end
+end
+
+describe Dataset::DirectoryResolver do
+  before do
+    @resolver = Dataset::DirectoryResolver.new(SPEC_ROOT + '/fixtures/datasets')
+  end
+  
+  it 'should not look for a file if the constant is already defined' do
+    @resolver.resolve(:resolve).should be(ResolveDataset)
+  end
+  
+  it 'should find file with exact name match' do
+    defined?(ExactName).should be_nil
+    dataset = @resolver.resolve(:exact_name)
+    defined?(ExactName).should == 'constant'
+    dataset.should == ExactName
+  end
+  
+  it 'should find file with name ending in _dataset' do
+    defined?(EndingWithDataset).should be_nil
+    dataset = @resolver.resolve(:ending_with)
+    defined?(EndingWithDataset).should == 'constant'
+    dataset.should == EndingWithDataset
+  end
+  
+  it 'should indicate that it could not find a dataset file' do
+    lambda do
+      @resolver.resolve(:undefined)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      %(Could not find a dataset file in ["#{SPEC_ROOT + '/fixtures/datasets'}"] having the name 'undefined.rb' or 'undefined_dataset.rb'.)
+    )
+  end
+  
+  it 'should indicate when it finds a file, but the constant is not defined after loading the file' do
+    lambda do
+      @resolver.resolve(:constant_not_defined)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Found the dataset file '#{SPEC_ROOT + '/fixtures/datasets/constant_not_defined.rb'}', but it did not define a dataset 'ConstantNotDefined' or 'ConstantNotDefinedDataset'."
+    )
+  end
+  
+  it 'should indicate when it finds a file, but the constant defined is not a subclass of Dataset::Base' do
+    lambda do
+      @resolver.resolve(:not_a_dataset_base)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Found the dataset file '#{SPEC_ROOT + '/fixtures/datasets/not_a_dataset_base.rb'}' and a class 'NotADatasetBase', but it does not subclass 'Dataset::Base'."
+    )
+  end
+  
+  it 'should support adding multiple directories' do
+    @resolver << (SPEC_ROOT + '/fixtures/more_datasets')
+    defined?(InAnotherDirectoryDataset).should be_nil
+    dataset = @resolver.resolve(:in_another_directory)
+    defined?(InAnotherDirectoryDataset).should == 'constant'
+    dataset.should == InAnotherDirectoryDataset
+  end
+end

data/vendor/plugins/dataset/spec/dataset/rspec_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../spec_helper'
+
+class Spec::Example::ExampleGroup
+  include Dataset
+end
+
+describe Spec::Example::ExampleGroup do
+  include SandboxedOptions
+  
+  it 'should have a dataset method' do
+    group = Class.new(Spec::Example::ExampleGroup)
+    group.should respond_to(:dataset)
+  end
+  
+  it 'should load the dataset when the group is run' do
+    load_count = 0
+    dataset = Class.new(Dataset::Base) do
+      define_method(:load) do
+        load_count += 1
+      end
+    end
+    
+    group = Class.new(Spec::Example::ExampleGroup) do
+      self.dataset(dataset)
+      it('one') {}
+      it('two') {}
+    end
+    
+    group.run
+    load_count.should be(1)
+  end
+  
+  it 'should load datasets in nested groups' do
+    dataset_one = Class.new(Dataset::Base) do
+      define_method(:load) do
+        Thing.create!
+      end
+    end
+    dataset_two = Class.new(Dataset::Base) do
+      define_method(:load) do
+        Place.create!
+      end
+    end
+    
+    group = Class.new(Spec::Example::ExampleGroup) do
+      dataset(dataset_one)
+      it('one') {}
+    end
+    group_child = Class.new(group) do
+      dataset(dataset_two)
+      it('two') {}
+    end
+    
+    group.run
+    Thing.count.should be(1)
+    Place.count.should be(0)
+    
+    group_child.run
+    Thing.count.should be(1)
+    Place.count.should be(1)
+  end
+  
+  it 'should expose data reading methods from dataset binding to the test methods through the group instances' do
+    created_model = nil
+    dataset = Class.new(Dataset::Base) do
+      define_method(:load) do
+        created_model = create_model(Thing, :dataset_thing)
+      end
+    end
+    
+    found_in_before_all, dataset_thing_in_example = nil
+    created_in_before_all, before_all_thing_in_example = nil
+    created_in_example = nil
+    group = Class.new(Spec::Example::ExampleGroup) do
+      self.dataset(dataset)
+      before(:all) do
+        found_in_before_all = things(:dataset_thing)
+        created_in_before_all = create_model(Thing, :before_all_thing)
+      end
+      it 'one' do
+        dataset_thing_in_example = things(:dataset_thing)
+        before_all_thing_in_example = things(:before_all_thing)
+        created_in_example = create_model(Thing)
+      end
+    end
+    
+    group.run
+    group.should_not respond_to(:things)
+    
+    dataset_thing_in_example.should_not be_nil
+    dataset_thing_in_example.should == created_model
+    
+    found_in_before_all.should_not be_nil
+    found_in_before_all.should == created_model
+    
+    created_in_before_all.should_not be_nil
+    before_all_thing_in_example.should == created_in_before_all
+    
+    created_in_example.should_not be_nil
+  end
+  
+  it 'should expose dataset helper methods to the test methods through the group instances' do
+    dataset_one = Class.new(Dataset::Base) do
+      helpers do
+        def helper_one; end
+      end
+      def load; end
+    end
+    dataset_two = Class.new(Dataset::Base) do
+      uses dataset_one
+      helpers do
+        def helper_two; end
+      end
+      def load; end
+    end
+    
+    group_before_all_instance, group_example_instance = nil
+    group = Class.new(Spec::Example::ExampleGroup) do
+      self.dataset(dataset_two)
+      before(:all) do
+        group_before_all_instance = self
+      end
+      it 'one' do
+        group_example_instance = self
+      end
+    end
+    
+    group.run
+    
+    group.should_not respond_to(:helper_one)
+    group.should_not respond_to(:helper_two)
+    group_before_all_instance.should respond_to(:helper_one)
+    group_before_all_instance.should respond_to(:helper_two)
+    group_example_instance.should respond_to(:helper_one)
+    group_example_instance.should respond_to(:helper_two)
+  end
+end