yaml_seeder 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Paul Fedory
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,54 @@
+= YamlSeeder
+Seeds your ActiveRecord models from Foxy Fixture-like YAML files
+
+== YAML seed files
+YamlSeeder works upon seed files which are very similar to fixtures - the foxy-fixtures introduced in Rails 2.0. For example, consider a Company model and an Employee model, where an employee belongs to a company:
+
+=== companies.yml
+  dunder:
+    name: Dunder Mifflin
+
+=== employees.yml
+  michael:
+    name: Michael Scott
+    company: dunder
+
+It's a good idea to put these seed files in their own directory, say "db/seeds".
+
+For more information, google "foxy fixtures" or see http://ryandaigle.com/articles/2007/10/26/what-s-new-in-edge-rails-fixtures-just-got-a-whole-lot-easier
+  
+== Installation
+
+  gem install yaml_seeder
+  
+== Usage
+
+Use YamlSeeder to seed your Rails database. If you're using Rails 2.3.4 or later, add the following to your "db/seeds.rb" file (don't forget to require 'yaml_seeder'!)
+
+===db/seeds.rb
+
+  require 'yaml_seeder'
+  Dir.glob(RAILS_ROOT + '/db/seeds/*.yml').each do |file|
+    YamlSeeder.seed('db/seeds', File.basename(file, '.*'))
+  end
+
+Alternatively, or if you're using an earlier version of Rails, you can create a rake task (eg. called "db:yaml_seed"):
+
+===lib/tasks/seed.rake
+
+  require 'yaml_seeder'
+  namespace :db do
+    desc "Load seed files (from db/seeds) into the current environment's database." 
+    task :yaml_seed => :environment do
+      Dir.glob(RAILS_ROOT + '/db/seeds/*.yml').each do |file|
+        YamlSeeder.seed('db/seeds', File.basename(file, '.*'))
+      end
+    end
+  end
+
+== Notes
+  * If ID's are not specified in the YAML seed files, then they will be assigned by the normal creation of saving an ActiveRecord (ie. the next ID available).
+  * Currently, YamlSeeder only supports belong-to associations.
+
+
+Copyright (c) 2010 Paul Fedory, released under the MIT license

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the yaml_seeder plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the yaml_seeder plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'YamlSeeder'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/yaml_seeder.rb

@@ -0,0 +1,179 @@
+# YamlSeeder
+require 'yaml'
+require 'erb'
+
+class YamlSeeder < Hash
+  DEFAULT_FILTER_RE = /\.ya?ml$/
+  
+  @@record_cache = Hash.new
+  @@yaml_cache = Hash.new
+  @@seedfile_directory = ""
+  
+  # The main entry point of YamlSeeder
+  # * seedfile_directory: the directory containing the YAML seed files (eg. db/seeds)
+  # * table_names: an array of strings containing the names of the models you wish to seed
+  def self.seed(seedfile_directory, table_names, class_names = {})
+    @@seedfile_directory = seedfile_directory
+    table_names = [table_names].flatten.map { |n| n.to_s }
+
+    # deletes the table name from the fetching list if it's cached already:
+    table_names_to_fetch = table_names.reject { |table_name| model_is_cached?(table_name) }
+    
+    unless table_names_to_fetch.empty?
+      yaml_rows_map = {}
+
+      yaml_rows = table_names_to_fetch.map do |table_name|
+        yaml_rows_map[table_name] = YamlSeeder.new(File.split(table_name.to_s).last, class_names[table_name.to_sym], File.join(seedfile_directory, table_name.to_s))
+      end
+      
+      @@yaml_cache.update(yaml_rows_map)
+      
+      yaml_rows.each do |row| 
+        row.insert_records
+      end
+
+    end    
+  end
+  
+  def initialize(table_name, class_name, seedfile_path, file_filter = DEFAULT_FILTER_RE)
+    @table_name, @seedfile_path, @file_filter = table_name, seedfile_path, file_filter
+    @name = table_name # preserve seed base name
+    
+    @class_name = class_name ||
+                  (ActiveRecord::Base.pluralize_table_names ? @table_name.singularize.camelize : @table_name.camelize)
+    @table_name = "#{ActiveRecord::Base.table_name_prefix}#{@table_name}#{ActiveRecord::Base.table_name_suffix}"
+    @table_name = class_name.table_name if class_name.respond_to?(:table_name)
+    
+    read_yaml_seed_files
+  end
+  
+  def insert_records
+    each do |label, row|
+
+      if model_class && model_class < ActiveRecord::Base
+
+        # If STI is used, find the correct subclass for association reflection
+        reflection_class =
+          if row.include?(inheritance_column_name)
+            row[inheritance_column_name].constantize rescue model_class
+          else
+            model_class
+          end
+
+        reflection_class.reflect_on_all_associations.each do |association|
+          case association.macro
+          when :belongs_to
+            
+            # if there's a belong-to association, find the id of the foreign key in the loaded associations.
+            # if it's not in the loaded associations, then load it. get it's id, and set the foreign key to it.
+            
+            # Do not replace association name with association foreign key if they are named the same
+            fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
+
+            if association.name.to_s != fk_name && value = row.delete(association.name.to_s)
+              if association.options[:polymorphic]
+                if value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
+                  target_type = $1
+                  target_type_name = (association.options[:foreign_type] || "#{association.name}_type").to_s
+
+                  # support polymorphic belongs_to as "label (Type)"
+                  row[target_type_name] = target_type
+                end
+              end
+              
+              if @@record_cache.has_key?(association.name.to_s.pluralize)
+                # load the appropriate association
+                assoc_records = @@record_cache[association.name.to_s.pluralize]
+                row[fk_name] = assoc_records[value].id
+              else
+                # they aren't loaded yet, so do the recursive thing, loading it.
+                YamlSeeder.seed(@@seedfile_directory, association.name.to_s.pluralize)
+                
+                # the record cache will now contain what we need
+                assoc_records = @@record_cache[association.name.to_s.pluralize]
+                row[fk_name] = assoc_records[value].id
+              end
+            end
+          end
+        end
+      end
+
+      @myobject = model_class.create (row)      
+      records_in_table = @@record_cache.has_key?(@table_name) ? @@record_cache[@table_name] : Hash.new
+      records_in_table[label] = @myobject
+      @@record_cache[@table_name] = records_in_table
+      
+    end
+  end
+  
+  private
+  def self.model_is_cached?(table_name)
+    @@record_cache.has_key?(table_name)
+  end
+  
+  def read_yaml_seed_files
+    yaml_string = ""
+    Dir["#{@seedfile_path}/**/*.yml"].select { |f| test(?f, f) }.each do |subseed_path|
+      yaml_string << IO.read(subseed_path)
+    end
+    yaml_string << IO.read(yaml_file_path)
+
+    if yaml = parse_yaml_string(yaml_string)
+      # If the file is an ordered map, extract its children.
+      yaml_value =
+        if yaml.respond_to?(:type_id) && yaml.respond_to?(:value)
+          yaml.value
+        else
+          [yaml]
+        end
+
+      yaml_value.each do |seed|
+        raise YamlSeeder::FormatError, "Bad data for #{@class_name} seed named #{seed}" unless seed.respond_to?(:each)
+        seed.each do |name, data|
+          unless data
+            raise YamlSeeder::FormatError, "Bad data for #{@class_name} seed named #{name} (nil)"
+          end
+
+          self[name] = data
+        end
+      end
+    end
+  end
+  
+  class YamlSeederError < StandardError #:nodoc:
+  end
+
+  class FormatError < YamlSeederError #:nodoc:
+  end
+  
+  def parse_yaml_string(seed_content)
+    YAML::load(erb_render(seed_content))
+  rescue => error
+    raise YamlSeeder::FormatError, "a YAML error occurred parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}"
+  end
+  
+  def yaml_file_path
+    "#{@seedfile_path}.yml"
+  end
+  
+  def inheritance_column_name
+    @inheritance_column_name ||= model_class && model_class.inheritance_column
+  end
+
+  def erb_render(seed_content)
+    ERB.new(seed_content).result
+  end
+  
+  def model_class
+    unless defined?(@model_class)
+      @model_class =
+        if @class_name.nil? || @class_name.is_a?(Class)
+          @class_name
+        else
+          @class_name.constantize rescue nil
+        end
+    end
+
+    @model_class
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: yaml_seeder
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Fedory
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-21 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Seeds your ActiveRecord models from YAML files, when the YAML files are formatted like test fixtures.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+files: 
+- lib/yaml_seeder.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/paulfedory/yaml_seeder
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Seeds your ActiveRecord models from YAML files
+test_files: []
+