dummy_data 0.9

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 0.9 (August 10, 2010)
+
+Features:
+  - generating data for Rails 3 applications by using dummy (functionality split up from old project)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Gonçalo Silva
+
+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.md

@@ -0,0 +1,70 @@
+# Dummy data
+
+"Dummy data" uses dummy[http://github.com/goncalossilva/dummy] to generate clever data for your Rails 3 application; it also allows you to import it to the database.
+
+## Description
+
+Check dummy's[http://github.com/goncalossilva/dummy] description for a better notion of what exactly is dummy data. This gem uses dummy to generate this data for your models and stores it in YAML files. It also provides a rake task for you to import it to the database.
+
+## Installation
+
+$ gem install dummy_data
+
+## Usage
+
+Add the following to the Gemfile of your Rails 3 application:
+    gem "dummy_data"
+    
+Now you have access to the generator:
+    rails generate dummy:data
+    
+You can change the base amount of records and the growth ratio (what these mean exactly is explained latter on):
+    rails generate dummy:data --base-amount 5 --growth-ratio 1.5
+    
+Also, you can manually define the amount of records to generate for each model (or just accept the defaults):
+    rails generate dummy:data --manual-amounts
+    
+And you can manually set the output folder for the dummy data (which defaults to test/dummy):
+    rails generate dummy:data --output-folder test/awesome_dummy
+
+The files will be placed under _output-folder_/data.
+    
+Feel free to mix all of these options.
+    
+The fixtures are stored in _test/dummy/data_ (by default) while a rake file is placed in _lib/tasks/dummy\_data.rake_. It allows you to import the generated data into the database:
+    RAILS_ENV="dummy" rake dummy:data:import
+
+Don't forget to change RAILS_ENV to whatever is appropriate for you (and is configured under databases.yml). Your database doesn't need to be empty.
+
+## More information
+
+### Smart data
+
+"Dummy data" tells dummy to try to understand your database columns and generate data accordingly, instead of dumping "Lorem ipsum" all over the place.
+
+For instance, if you have a field called _company\_name_, it will generate a company name. If you have a field called _awesome\_postal\_code_, it will generate a valid ZIP Code. If you have a field called _longitude_, it will generate a valid longitude, and so on. You get the picture.
+
+Dummy cares about associations. It will create random associations between the automatically generated records, so you don't have to worry about that.
+
+### Smart amounts of data
+
+"Dummy data" is aware that the amount of records that each model has in real world applications is different. For this reason, it will analyze your model associations to try to make a somewhat accurate estimation of the expected amount of records.
+
+To illustrate this, consider an application with models for _Child_, _Parent_ and _GrandParent_. If the base amount is 10, the growth ratio is 2.0, and the models look like the following:
+
+    class GrandParent < ActiveRecord::Base  
+      has_many :parents
+    end
+    
+    class Parent < ActiveRecord::Base
+      belongs_to :grand_parent
+      has_many :children
+    end
+    
+    class Child < ActiveRecord::Base
+        belongs_to :parent
+    end`
+
+The generator will create dummy data for 10 _GrandParents_, 20 _Parents_ and 40 _Children_.
+
+Copyright (c) 2010 Gonçalo Silva

data/lib/dummy_data.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "dummy"
+require "generators/common"
+require "generators/data/data_generator"

data/lib/generators/common.rb

@@ -0,0 +1,82 @@
+module Dummy
+  module Generators
+    # Methods used by other dummy-related gems are grouped here
+    # Other generators will just "include Dummy::Generators::Common"
+    module Common
+      def gather_associations
+        @models.each_key do |model|
+          model_symbol = model.to_s.underscore.pluralize.to_sym
+          associations = model.reflect_on_all_associations(:belongs_to)
+          
+          associations.each do |assoc|
+            assoc_name = assoc.name.to_s.camelcase
+            assoc_options = assoc.options
+
+            if assoc_options.empty?
+              @models[model][:associations].push({
+                :model  => assoc_name.constantize,
+                :foreign_key => "#{assoc_name.underscore}_id"
+              })
+            elsif assoc_options.has_key?(:class_name) and assoc_options.has_key?(:foreign_key)
+              @models[model][:associations].push({
+                :model => assoc_options[:class_name].constantize, # TODO: handle class_name
+                :foreign_key => assoc_options[:foreign_key]
+              })
+            else
+              next
+            end
+
+            assoc_model = @models[model][:associations].last[:model]
+            assoc_reflections = assoc_model.reflect_on_all_associations(:has_one)
+            @models[model][:associations].pop if assoc_reflections.map(&:name).include?(model_symbol)
+          end
+        end
+      end
+      
+      def generate_record_data(name, info, column, fixtures=true)
+        column_name = String.new(column.name) # this shouldn't be needed, ruby bug?
+        if(column_name =~ /_at$/ and column.type == :datetime) or column_name == "id"
+          return
+        end
+
+        associated_model = associated_class_name(info, column_name)
+
+        if associated_model
+          if fixtures
+            val = generate_association_data(associated_model)
+            column_name.gsub!(/_id$/, "")
+          else
+            val = Fixtures.identify(generate_association_data(associated_model))
+          end
+        else
+	        val = generate_regular_data(column)
+        end
+
+        {column_name => val}
+      end
+      
+      def associated_class_name(info, name)
+        info[:associations].each do |assoc|
+          return assoc[:model] if assoc[:foreign_key] == name
+        end
+        false
+      end
+      
+      def generate_association_data(associated_model)
+        random_record_num = rand(@models[associated_model][:record_amount])
+        "#{associated_model.to_s.underscore}_#{random_record_num}"
+      end
+
+      def generate_regular_data(column)
+        val = Dummy.magic_data(column.name, column.type)
+        
+        if val
+          val
+        else
+          say_status :failed, "data generation for '#{column.name}' with type '#{column.type.to_s.downcase}'", :red
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/generators/data/data_generator.rb

@@ -0,0 +1,145 @@
+require "yaml"
+require "active_support"
+require "active_support/core_ext/string/inflections"
+require "active_record"
+require "active_record/fixtures"
+require "rails/generators"
+
+module Dummy
+  module Generators
+    class DataGenerator < Rails::Generators::Base  
+      include Dummy::Generators::Common
+              
+      def self.source_root
+        @source_root ||= File.expand_path("../templates", __FILE__)
+      end
+      
+      class_option :base_amount, :type => :numeric, :default => 10,
+                  :desc => "The base amount of records to generate for each model."
+      class_option :growth_ratio, :type => :numeric, :default => 2.0,
+                  :desc => "The growth ratio of each model, according to its associations."
+      class_option :manual_amounts, :type => :boolean, :default => false,
+                  :desc => "Manually set the amount of records for each model."
+      class_option :output_folder, :type => :string, :default => "test/dummy",
+                  :desc => "Dummy output folder, data/ will be used when storing the resulting YAML files."
+
+      def install_dummy_data
+        initialize_application
+        generate_dummy_data
+        copy_rake_file
+        create_dummyfile
+      end
+
+    private
+    
+      def initialize_application
+        require File.expand_path("#{Rails.root}/config/environment.rb")
+        say_status :successful, "initialize Rails application"
+      end
+
+      def generate_dummy_data
+        get_table_names
+        gather_associations
+        predict_record_amounts
+        generate_and_write_data
+      end
+
+      def get_table_names
+        @models = Hash.new
+        Dir["app/models/*.rb"].each do |full_path|
+          model = File.basename(full_path).chomp(File.extname(full_path)).camelcase.constantize
+          @models.merge!({model => {
+            :record_amount => 0, :associations => []
+          }}) if model.respond_to?(:columns)
+        end
+      end
+
+      def predict_record_amounts
+        models = @models.dup
+        models.each do |model, info|
+          predict_record_amount(model, info, models, [])
+        end
+      end
+
+      def predict_record_amount(model, info, models, stacked_models)
+        info[:associations].each do |assoc|
+          next if stacked_models.include?(assoc[:model])
+
+          if model != assoc[:model]
+            stacked_models << assoc[:model]
+            predict_record_amount(assoc[:model], @models[assoc[:model]], models, stacked_models)
+          end
+        end
+
+        amount = options.base_amount
+        if not info[:associations].empty?
+          amount = info[:associations].map do |assoc|
+            @models[assoc[:model]][:record_amount]
+          end.max * options.growth_ratio # **info[:associations].size
+        end
+        
+        if options.manual_amounts
+          user_defined = ask("Number of records for #{model} (default: #{amount}): ")
+          amount = user_defined unless user_defined.empty?
+        end
+
+        @models[model][:record_amount] = amount.to_i
+        stacked_models.delete(model)
+        models.delete(model)
+      end
+
+      def generate_and_write_data
+        empty_directory "#{options.output_folder}/data"
+        data = Hash.new
+
+        @models.each do |model, info|
+          name = model.to_s.underscore
+          
+          (0..info[:record_amount]-1).each do |num|
+            key_value = Hash.new
+            fixture_data = Hash.new
+
+            model.columns.each do |column|
+              key_value = generate_record_data(name, info, column)
+              fixture_data.merge!(key_value) unless key_value.nil?
+            end
+            
+            data[model.table_name] = Hash.new if data[model.table_name].nil?
+            data[model.table_name].merge!({ "#{name}_#{num}" => fixture_data })
+          end
+
+          say_status :successful, "generate #{info[:record_amount]} records for '#{name}'"
+        end
+        
+        data.each do |name, fixtures|
+          content = "# '#{name}' data generated automatically by dummy at #{Time.now.strftime("%H:%M %m/%d/%Y")} (#{fixtures.size} records).\n"
+          
+          content << YAML.dump(fixtures)
+          
+          create_file "#{options.output_folder}/data/#{name}.yml", content
+        end
+        say_status :successful, "store fixtures"
+      end 
+
+      def copy_rake_file
+        template "dummy_data.rake", "lib/tasks/dummy_data.rake"
+      end
+      
+      def create_dummyfile
+        data = Hash.new
+        dummyfile_path = "#{options.output_folder}/Dummyfile"
+        
+        @models.each do |model, info|
+          data[model.to_s.underscore.pluralize] = {:records => info[:record_amount]}
+        end
+        
+        content = "# This file was automatically generated by Dummy. Do NOT change it.\n"        
+        content << YAML.dump(data)
+        
+        remove_file dummyfile_path, :verbose => false if File.exists?(dummyfile_path)
+        create_file dummyfile_path, content
+      end
+    end
+  end
+end
+

data/lib/generators/data/templates/dummy_data.rake

@@ -0,0 +1,13 @@
+require "active_record/fixtures"
+
+namespace :dummy do
+  namespace :data do
+    desc "Load the generated dummy data into the current environment's database."
+    task :import => :environment do
+      Fixtures.reset_cache
+      fixtures_folder = File.join(Rails.root, "<%= options.output_folder %>/data")
+      fixtures = Dir[File.join(fixtures_folder, '*.yml')].map {|f| File.basename(f, '.yml') }
+      Fixtures.create_fixtures(fixtures_folder, fixtures)
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: dummy_data
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  version: "0.9"
+platform: ruby
+authors: 
+- "Gon\xC3\xA7alo Silva"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dummy
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta
+        version: 3.0.0.beta
+  type: :runtime
+  version_requirements: *id002
+description: Uses dummy to generate consistent fake data for your models (including associations) and provides a rake task to import it into the database
+email: 
+- goncalossilva@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/generators/data/data_generator.rb
+- lib/generators/common.rb
+- lib/dummy_data.rb
+- lib/generators/data/templates/dummy_data.rake
+- LICENSE
+- README.md
+- CHANGELOG.md
+has_rdoc: true
+homepage: http://github.com/goncalossilva/dummy_data
+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: 
+      - 1
+      - 3
+      - 7
+      version: 1.3.7
+requirements: []
+
+rubyforge_project: dummy_data
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Uses dummy to generate data for your models and allows you to import it
+test_files: []
+