gardener 1.0.0

data/README.rdoc

@@ -0,0 +1,44 @@
+=Gardener
+==A Simple Rails Plugin to help you create seed data
+Easy transfer of individual records in a Rails app between environments via yaml dumps. 
+
+But you don't need to know that.
+
+All you care about is 
+
+==Usage
+Put 
+	gem 'gardener'
+in your gemfile and gardener gets right to work.
+
+He's there behind the scenes and you can call on him in several ways.
+
+==Class Methods
+
+===sow
+	User.sow 
+for example, would render all the users down into a yaml file, which you could then commit into your source control,
+and deploy to staging or production.
+
+Once deployed you could write a rake task :P
+or just go into the rails console :D 
+and call 
+	User.reap
+to pull the records up out of the file and into your database.
+===reap
+"[...] whatsoever a man soweth, that shall he also reap" - Galatians 6:7-8
+For reaping the fruits of your labor.  
+
+==Instance Methods
+
+===plant_seed
+	User.find(1)
+	User.plant_seed
+Would put only the one user in a file to be reconstituted later.  This is the use case that I wrote this for, 
+I found myself making lots of copy changes to databased content for websites, and needed a simple way to move those things
+from one environment (development --> staging or staging --> production) to another.  I didn't want to copy over entire tables
+because there were some records that didn't need to come over, so existing tools like Taps http://adam.heroku.com/past/2009/2/11/taps_for_easy_database_transfers/
+weren't a perfect fit for me.  
+
+
+

data/lib/gardener.rb

@@ -0,0 +1,157 @@
+module Gardener
+	def self.included(base)
+		base.extend(ClassMethods)
+	end
+	
+	module ClassMethods
+		
+		attr_accessor :infinite_choice
+		
+
+		# Dump every instance of a class (every record in the database for a model) into a file 
+		# to be reconstituted later.
+		def sow
+			c = self.to_s.underscore.pluralize
+			dir = File.join [Rails.root, 'db', 'garden']
+			Dir.mkdir(dir) unless File.exists?(dir)
+
+			File.open(File.join([Rails.root, 'db', 'garden', "#{c}.yml"] ), 'w') do |file|		
+				self.find_each{ |x| file << x.to_yaml }
+			end
+		end
+			
+
+		# Take the things that were dumped to a file and put them in the database.
+		def reap
+			c = self.to_s.underscore.pluralize
+			str = ''
+		  File.open(File.join([Rails.root, 'db', 'garden', "#{c}.yml"] ), 'r').each_line do |line|
+				if line.match /^---.*/
+					sprout(str)
+					str = ''
+				end
+				str << line
+			end
+			sprout(str) unless str.blank?
+		end
+		
+		
+		# Helper function to reconstitute a record from it's yaml representation.
+		def sprout(str)
+			return false if str.blank?
+#			puts str.inspect
+			
+			foo = YAML.load(str)
+			return unless foo # YAML.load('') == false 
+			bob = self.new(foo.attributes)
+			bob.id = foo.id
+
+			# Grr, have to check to see if anything in the inheritance hierarchy has the id.
+			base_class = self.base_class 
+			scott = base_class.find_by_id(bob.id)
+			
+			if scott
+				puts "\n\n#{bob.class.name} already exists, differences are"
+				bar = scott.diff(bob)
+				if bar.blank?
+					puts "\tActually, there are no differences, even the ids are the same #{bob.id} == #{scott.id}.\n\tLooks like you're trying to bring in the exact same object that already exists in the db."
+				else
+					pp bar
+				end
+				
+				if @infinite_choice
+					res = @infinite_choice
+				else
+					print "\n\nAdd a 'z' to your selection to apply it to everything\nOverwrite (y), do nothing (n), give a new ID (i), or abort (a) ?  "
+					res = gets
+					@infinite_choice = res if res.match(/z/i)
+				end
+				
+				if res.match(/y/i)
+					scott = bob
+					scott.save
+				elsif res.match(/a/i)
+					raise "User Salted the earth.  Nothing will grow here for some time ..." 
+				elsif res.match(/i/i)
+					bob.id = nil
+					bob.save
+				else
+					puts "#{bob.class.name} with id #{bob.id} already exists, doing nothing."					
+				end
+			else
+				bob.save
+			end
+		end
+
+	end  # End ClassMethods
+
+
+
+
+##### Instance Methods #####
+
+	def diff(obj)
+		buff = {}
+		self.attributes.each do |k, v|
+			tmp = obj.send(k) if obj.respond_to?(k)
+			if tmp.eql?(v)
+				# they're the same, do nothing
+			else
+				buff[k] = {:original => v, :new => tmp} 
+			end
+		end # end self.attributes.each
+		buff
+	end
+
+
+	# Called on an particular instance of a class to render it down into a file, from which it can be 
+	# _reaped_ later.
+	def plant_seed(options = {})
+		c = self.class.to_s.underscore.pluralize
+		# Code to render down associated items exists, but nothing has been done to pull those objects back out.
+		# Not automatically at least, but of course reaping the correct model will pull them up no problem.  
+		
+		
+		# TODO
+		# need to load the file up and see if the thing i'm trying to add is in it
+		# or just overwrite the whole file every time.
+		# Do something to prevent duplicates from slipping in. 
+		dir = File.join [Rails.root, 'db', 'garden']
+		Dir.mkdir(dir) unless File.exists?(dir)
+		
+		
+		File.open(File.join([Rails.root, 'db', 'garden', "#{c}.yml"] ), 'a') do |file|
+			file << self.to_yaml
+		end		
+		
+		includes = things_to_include(options)
+		puts includes
+		includes.each do |k, v|
+			tom = self.send(k) if self.respond_to?(k)
+			[*tom].each{|y| y.plant_seed({:include => v})}
+		end		
+
+	end
+	
+	
+	def things_to_include(options)
+		# [*THING] is so that THING can be an array or a single instance of a class.  
+		# .each will blow up if THING is just an instance, not an array, unless we explode and re-array it.
+		return [] unless options[:include]
+		case options[:include]
+		when Hash
+			options[:include].inject({}){|memo, v| memo[v[0]] = v[1] if self.respond_to?(v[0]); memo}
+		else
+			[*options[:include]]
+		end
+	end
+
+	def to_fixture
+		{"#{self.class.to_s.underscore}_#{self.id}" => self.attributes}.to_yaml
+	end
+
+	
+	
+end
+
+ActiveRecord::Base.class_eval{ include Gardener }

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: gardener
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Bob Larrick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-08 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A Ruby on Rails Plugin to help you create seed data.  Useful when you want to move just a few pieces of data 		from one environment to another.  To my knowledge there is no other gem that will help you move a few records from your development or staging 		environment to your production environment.
+email: larrick@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/gardener.rb
+- README.rdoc
+has_rdoc: true
+homepage: https://github.com/deathbob/Gardener
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple Seed Data Creation for Ruby on Rails.
+test_files: []
+