cockroach 0.0.0

data/lib/cockroach/base/node_structure.rb

@@ -0,0 +1,11 @@
+module Cockroach
+  module Base
+    # Simple idea. After that the nodes will be available as
+    #   Cockroach::FactoryGirl::Node['top_node']['sub_mode']['sub_sub_node']
+    module NodeStructure
+      def [](name)
+        (@nodes ||= {})[name.to_s]
+      end
+    end
+  end
+end

data/lib/cockroach/config.rb

@@ -0,0 +1,54 @@
+module Cockroach
+  class Config
+    extend ActiveSupport::Autoload
+    
+    autoload :Loader
+    autoload :ConfigNotExistsError, 'cockroach/config/loader'
+
+    class MissingRootPathError < Exception; end
+
+    class << self
+      attr_writer :root
+      attr_accessor :fixturer, :config_path, :fixtures_path
+
+      # Returns root folder for the project, of if one is missing it tries to return
+      # Rails.root, if Rails is not defined it will raise an error.
+      def root
+        @root ||= begin
+          if defined?(Rails)
+            File.join Rails.root
+          else
+            "./"
+          end
+        end
+      end
+    end
+
+    attr_reader :profile, :options, :fixtures_path
+    
+    def initialize path_to_config
+      @config_path = File.expand_path path_to_config, self.class.root
+      @profile, @options = Cockroach::Config::Loader.parse(@config_path)
+      @fixturer_def = get_option('fixturer') || self.class.fixturer || 'factory_girl'
+      @fixtures_path = self.class.fixtures_path if self.class.fixtures_path
+    end
+
+    def fixturer
+      @fixturer ||= @fixturer_def.to_s.camelize.to_sym
+    end
+
+    def profiler
+      @profiler ||= begin
+        Cockroach.const_get(fixturer)::Profiler.new
+      end
+    end
+
+    protected
+
+    # Options might not be specified at all. In that case @options will be nil
+    # This method will return nil, if option unavailable
+    def get_option option
+      @options[option.to_s] rescue nil
+    end
+  end
+end

data/lib/cockroach/config/loader.rb

@@ -0,0 +1,35 @@
+require "psych"
+require "yaml"
+
+module Cockroach
+  class Config
+    # Loader class just returns a structured and ready to use information
+    # parsed from faker project yaml file.
+    class ConfigNotExistsError < Exception; end
+
+    class Loader
+      CONSTRAINTS = %w(fixture_gem fixtures_path).freeze
+
+      class << self
+        # Load the file from the provided path, and return the contents as
+        # an Array, with the following structure:
+        #
+        #   [
+        #     { * Hash containg the amounts },
+        #     { * Hash containing any other options or settings }
+        #   ]
+        #
+        def parse path_to_config
+          raise ConfigNotExistsError.new("File under the path \"#{path_to_config}\", does not exists.") unless File.exists?(path_to_config)
+          contents = YAML.load_file path_to_config
+
+          options = contents.extract!(*CONSTRAINTS)
+          options.delete_if {|key, value| value == nil }
+          options = nil if options.blank?
+
+          [contents, options]
+        end
+      end
+    end
+  end
+end

data/lib/cockroach/fixtures/factory_girl.rb

@@ -0,0 +1,4 @@
+require "factory_girl"
+require "cockroach/fixtures/factory_girl/loader"
+require "cockroach/fixtures/factory_girl/profiler"
+require "cockroach/fixtures/factory_girl/node"

data/lib/cockroach/fixtures/factory_girl/loader.rb

@@ -0,0 +1,43 @@
+module Cockroach
+  module FactoryGirl
+
+    class NoExistingPathError < Exception; end
+
+    # Loader class is designed to load the FactoryGirl fixtures, defined
+    # in the project.
+    class Loader
+      class << self
+        def load
+          if factory_items.blank?
+            old_paths = ::FactoryGirl.definition_file_paths
+            if Cockroach.config.fixtures_path
+              ::FactoryGirl.definition_file_paths = [Cockroach.config.fixtures_path]
+            else
+              ::FactoryGirl.definition_file_paths = old_paths.collect { |path| File.join(Cockroach::Config.root, path) }
+            end
+
+            # Italiano spagetti
+            unless ::FactoryGirl.definition_file_paths.inject(false) { |valid, path| valid || File.exists?("#{path}.rb") || File.directory?(path) }
+              raise NoExistingPathError.new("Neither of the paths are valid: #{::FactoryGirl.definition_file_paths.inspect}")
+            end
+        
+            ::FactoryGirl.find_definitions
+            ::FactoryGirl.definition_file_paths = old_paths
+          end
+        end
+
+        def load!
+          factory_items.clear
+          load
+        end
+
+        protected
+
+        def factory_items
+          ::FactoryGirl.factories.instance_variable_get(:@items)
+        end
+      end
+
+    end
+  end
+end

data/lib/cockroach/fixtures/factory_girl/node.rb

@@ -0,0 +1,51 @@
+module Cockroach
+  module FactoryGirl
+    # Node deals only with a specific records class. It makes sure that
+    # fixtures are created specific amount of time and will make sure that
+    # the associations are correctly assigned.
+    class Node < ::Cockroach::Base::Node
+      def after_initialize
+        @factory = ::FactoryGirl.factory_by_name(@name)
+      end
+
+      def load! factory_opts = nil
+        if factory_opts
+          normalised_opts = factory_opts.dup
+          @aliases.each_pair { |k,v| normalised_opts[k] = normalised_opts.delete(v) } if @aliases
+          normalised_opts.keep_if {|k,v| allowed_options.include? k }
+        end
+
+        amount.times do
+          current_factory = generate_current_factory(normalised_opts)
+          ids << current_factory.id
+          unless nodes.blank?
+            load_nodes! (factory_opts || {}).merge({ node_name => current_factory})
+          end
+        end
+      end
+
+      protected
+      
+      def generate_current_factory options
+        if @source
+          ret = @source.sample
+          ret.update_attributes(options) unless options.blank?
+          ret
+        else
+          options.blank? ?
+            ::FactoryGirl.create(name) :
+            ::FactoryGirl.create(name, options)
+        end
+      end
+
+      def allowed_options
+        @allowed_options ||= @factory.send(:evaluator_class).attribute_list.names.map(&:to_s)
+      end
+
+      # Returns class deducted from factory
+      def orm_class
+        @factory.send(:class_name)
+      end
+    end
+  end
+end

data/lib/cockroach/fixtures/factory_girl/profiler.rb

@@ -0,0 +1,34 @@
+require "cockroach/base/node_structure"
+
+module Cockroach
+  module FactoryGirl
+    # Profiler does all the routine to fill the database.
+    class Profiler
+      include Cockroach::Base::LoadNodes
+      include Cockroach::Base::NodeStructure
+      
+      def initialize config = Cockroach.config
+        @source = config.profile
+        @base_models = @source.keys
+      end
+
+      # This method will load all the mentioned records into database
+      def load
+        unless @loaded
+          Cockroach::FactoryGirl::Loader.load
+          @source.each_pair do |name, structure|
+            node = Cockroach::FactoryGirl::Node.new(name, structure)
+            nodes[node.node_name] = node
+          end
+          @loaded = true
+        end
+      end
+
+      # This method will load all the mentioned records into database
+      def load!
+        load unless @loaded
+        nodes.each_value(&:load!)
+      end
+    end
+  end
+end

data/lib/cockroach/railtie.rb

@@ -0,0 +1,7 @@
+module Cockroach
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../../tasks/faker.rake', __FILE__)
+    end
+  end
+end

data/lib/cockroach/source.rb

@@ -0,0 +1,40 @@
+module Cockroach
+  module Source
+    autoload :Node, 'cockroach/source/node'
+    autoload :Model, 'cockroach/source/model'
+
+    class << self
+      def get_source source_refs
+        if source_refs.is_a?(Hash) && source_refs.keys.include?('model')
+          get_model source_refs
+        else
+          get_node source_refs
+        end
+      end
+
+      protected
+
+      def get_model source_refs
+        model_name = source_refs.delete('model')
+        Cockroach::Source::Model.new model_name.to_s.constantize, source_refs
+      end
+
+      def get_node source_refs
+        return unless source_refs
+        if source_refs.is_a?(String)
+          source_path = [source_refs]
+        else
+          source_path = source_refs.flatten
+          while source_path.last.is_a? Hash
+            source_path << source_path.pop.flatten
+          end
+        end
+        source_path.flatten!
+        node = source_path.inject(::Cockroach.profiler) do |node_keeper, node_name|
+          node_keeper[node_name]
+        end
+        Cockroach::Source::Node.new node
+      end
+    end
+  end
+end

data/lib/cockroach/source/model.rb

@@ -0,0 +1,33 @@
+module Cockroach
+  module Source
+    class Model
+      attr_reader :model
+
+      def initialize model, options = {}
+        @model = model
+        @options = options
+      end
+
+      # Returns a random record, among generated.
+      def sample
+        if @options.blank?
+          model.order('RAND()').first
+        else
+          if @options.has_key?("id")
+            find @options["id"]
+          elsif @options.has_key?("conditions")
+            model.order('RAND()').where(@options["conditions"]).first
+          end
+        end
+      end
+
+      protected
+
+      # Find among the record generated by this node.
+      # Returns ORM instance object
+      def find id
+        model.find id
+      end
+    end
+  end
+end

data/lib/cockroach/source/node.rb

@@ -0,0 +1,27 @@
+module Cockroach
+  module Source
+    class Node
+      attr_reader :node
+
+      def initialize node
+        @node = node
+      end
+
+      # Returns a random record, among generated.
+      def sample
+        return nil if node.ids.empty?
+        id = node.ids.sample
+        find id
+      end
+
+      protected
+
+      # Find among the record generated by this node.
+      # Returns ORM instance object
+      def find id
+        return nil if node.ids.empty?
+        node.send(:orm_class).find id
+      end
+    end
+  end
+end

data/lib/cockroach/version.rb

@@ -0,0 +1,3 @@
+module Cockroach
+  VERSION = File.read(File.expand_path("./../../VERSION", __FILE__))
+end

data/lib/generators/cockroach/install_generator.rb

@@ -0,0 +1,20 @@
+#require 'rails/generators/generated_attribute'
+
+module Cockroach
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Copy Faker config file into projects configuration folder"
+
+      # all public methods in here will be run in order
+      def copy_config
+        template "faker.yml", "config/faker.yml"
+      end
+
+      def copy_initializer
+        template "cockroach.rb", "config/initializers/cockroach.rb"
+      end
+    end
+  end
+end

data/lib/generators/cockroach/templates/cockroach.rb

@@ -0,0 +1,8 @@
+#Cockroach.setup do |c|
+#  c.root = Rails.root
+#  c.config_path = "config/faker.yml"
+#  c.fixtures_path = File.expand_path(File.join('../../../', 'test', 'factories'), __FILE__)
+#
+#  #the only available fixturer now is factory girl
+#  #c.fixturer = "factory_girl"
+#end

data/lib/generators/cockroach/templates/faker.yml

@@ -0,0 +1,16 @@
+# This file contains all the information, required for Cockroach to
+# configure the amount of the generated records for fake database.
+# It just keep the amount of the records that is required to generate, hierarhy
+# and some other details conserning the generation way.
+
+user_amount: 1000
+
+feeds_ratio: 1000
+
+cities:
+  amount: 1000
+  places:
+    ratio:
+      lower_limit: 100
+      upper_limit: 1000
+    address_amount: 1

data/lib/tasks/faker.rake

@@ -0,0 +1,35 @@
+namespace :cockroach do
+  desc "Validate your Cockroach config before load it."
+  task :validate, [:config_path] => [:environment] do |task, args|
+    if Cockroach.config && args[:config_path]
+      Cockroach.config.config_path = args[:config_path]
+    elsif args[:config_path]
+      Cockroach.setup do |c|
+        c.config_path = args[:config_path]
+      end
+    end
+
+    puts "Considering factory location as: #{Cockroach.config.fixtures_path || Cockroach::Config.root}"
+
+    Cockroach.profiler.load
+    puts "Config file is valid!"
+  end
+
+  desc "Run Cockroach generator"
+  task :generate, [:config_path] => [:environment] do |task, args|
+    Rake::Task["cockroach:validate"].invoke(args[:config_path])
+
+    Cockroach.profiler.load!
+  end
+
+  desc "Trancate the database, load seeds and run Cockroach generator"
+  task :reload, [:config_path] => [:environment] do |task, args|
+    args.with_defaults(:config_path => 'config/faker.yml')
+
+    Rake::Task["db:drop"].invoke
+    Rake::Task["db:create"].invoke
+    Rake::Task["db:migrate"].invoke
+    Rake::Task["db:seed"].invoke
+    Rake::Task["cockroach:generate"].invoke(args[:config_path])
+  end
+end

data/test/config/config_test.rb

@@ -0,0 +1,129 @@
+require "test_helper"
+
+module Cockroach
+  class ConfigTest < Test::Unit::TestCase
+    setup do
+      Cockroach::Config.root = File.expand_path("../../support/data/dummy_structure", __FILE__)
+    end
+    
+    context "Config path assumptions" do
+      should "have predefined root path" do
+        assert_equal File.expand_path("../../support/data/dummy_structure", __FILE__), Cockroach::Config.root
+      end
+
+      should "assume rails root is defined" do
+        Cockroach::Config.root = nil
+        Rails.stubs(:root).returns("/some/fancy/path")
+
+        assert_equal "/some/fancy/path", Cockroach::Config.root
+      end
+      
+      #      should "assume rails root is not defined" do
+      #        Cockroach::Config.root = nil
+      #
+      #        Object.stubs(:defined?).with(Rails).returns(false)
+      #
+      #        assert_raise Cockroach::Config::MissingRootPathError do
+      #          Cockroach::Config.root
+      #        end
+      #      end
+
+      should "deduct root path from relative path" do
+        config = Cockroach::Config.new "../correct_with_option.yml"
+
+        assert config
+      end
+
+      should "deduct root path from absolute path" do
+        config = Cockroach::Config.new File.expand_path("../correct_with_option.yml", Cockroach::Config.root)
+
+        assert config
+      end     
+    end
+
+    context "Fixturers" do
+      context "FactoryGirl" do
+        should "be default" do
+          config = Cockroach::Config.new "../correct_with_option.yml"
+
+          assert_equal :FactoryGirl, config.fixturer
+        end
+      end
+    end
+
+    context "Profiler" do
+      setup do
+        Cockroach.setup {|config|}
+      end
+
+      should "be delegated" do
+        assert_instance_of Cockroach::FactoryGirl::Profiler, Cockroach.profiler
+      end
+      
+      should "create and keep new profiler" do
+        assert_instance_of Cockroach::FactoryGirl::Profiler, Cockroach.config.profiler
+      end
+
+      should "hit profiler once" do
+        ::Cockroach::FactoryGirl::Profiler.expects(:new).once.returns(true)
+
+        Cockroach.config.profiler
+        Cockroach.config.profiler
+      end
+    end
+  end
+
+  class SetupTest < Test::Unit::TestCase
+    context "Config class" do
+      def setup 
+        @old = Cockroach::Config.dup
+      end
+
+      def teardown
+        silence_warnings { Cockroach.const_set('Config', @old) }
+      end
+      
+      should "set root" do
+        Cockroach.setup do |c|
+          c.root = File.expand_path("../../support/data/dummy_structure", __FILE__)
+        end
+
+        assert_equal File.expand_path("../../support/data/dummy_structure", __FILE__), Cockroach::Config.root
+
+      end
+
+      should "set config_path" do
+        Cockroach.setup do |c|
+          c.root = File.expand_path("../../support/data/", __FILE__)
+          c.config_path = "./correct_with_option.yml"
+        end
+
+        assert_equal File.expand_path("../../support/data/correct_with_option.yml", __FILE__), Cockroach.config.instance_variable_get(:@config_path)
+      end
+
+      should "set fixtures_path" do
+        Cockroach.setup do |c|
+          c.root = File.expand_path("../../support/data/", __FILE__)
+          c.config_path = "./correct_with_option.yml"
+          c.fixtures_path = "some path to fixtures"
+        end
+
+        assert_equal "some path to fixtures", Cockroach.config.instance_variable_get(:@fixtures_path)
+      end
+
+      should "set fixturer" do
+        Object.const_set('FactoryBoy', mock('factory-boy'))
+        Cockroach.setup do |c|
+          c.root = File.expand_path("../../support/data/dummy_structure", __FILE__)
+          c.fixturer = :factory_boy
+        end
+
+        config = Cockroach.config
+
+        assert_equal :FactoryBoy, config.fixturer
+        Object.__send__(:remove_const,'FactoryBoy')
+      end
+    end
+
+  end
+end