cockroach 0.0.0

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.3@artirix_faker

data/Gemfile

@@ -0,0 +1,28 @@
+source 'https://rubygems.org'
+
+gem "activerecord", :require => false
+gem "activesupport", :require => false
+gem "faker"
+
+group :development do
+  gem "yard", "~> 0.6.0"
+  gem "jeweler", "~> 1.6.4"
+end
+
+group :test do
+  gem "rails"
+  gem "test-unit"
+  gem 'shoulda-context'
+  gem "mocha"
+
+  gem "factory_girl"
+
+  gem "simplecov", "~> 0.6.4", :platform => :ruby_19
+  gem "rcov", "~> 1.0.0", :platform => :ruby_18
+
+  gem "debugger", "~> 1.1.3", :platform => :ruby_19
+  gem 'ruby-debug', :platform => :ruby_18
+
+  gem "database_cleaner", :group => :test
+  gem "sqlite3", :group => :test
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+MIT License
+
+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,124 @@
+# Cockroach
+
+Cockroach allows you to simplify faking the database, during development. Idea is simple:
+There are ready fixtures in your database. **YOU SHOULD REUSE THEM!**
+
+Well, one may say that you you should follow TDD/BDD, hence there is no need in this gem.
+But wait, what about designers? Shall they follow this approach as well? You want to spend your time
+explaining them the process? Sure, go ahead!
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cockroach'
+
+And then execute:
+
+    $ bundle
+
+Or install it as:
+
+    $ gem install cockroach
+
+# After instalation
+
+After the gem was installed, all the required files may now be generated with Rails generator:
+
+    $ bundle exec rails g cockroach:install
+
+That will create config/faker.yml
+
+# Rake tasks
+
+There are several rake tasks available:
+
+    rake cockroach:validate
+
+The task above will validate your config file after you edited it.
+
+    rake cockroach:generate
+
+After, you validated your file, you may now proceed to generation.
+
+    rake cockroach:reload
+
+In case you would like to to have a new and nice database, just run the task above.
+That will drop and create existing DB, apply all migrations, seed the database and generate fake data afterwards.
+
+# Usage
+
+Cockroach will try to find your fixtures first. Once it is done:
+There are several ways how to specify the required amount of the records:
+
+### First way is *simple*:
+
+Just specify the amount of the records that are require or provide the range:
+An example:
+
+    #a strict amount
+    users_amount: 1000 # what will generate 1000 records for user factory
+
+    #or a fuzzy way
+    feeds_ratio: 1000 # what will generate a random amount of users, in the range between 500 and 2000.
+
+**amount** - will just generate the strict amount of record. In the example above,
+           there will be 1000 users in the database.
+
+**ratio**  - will pick a random amount of Feed records, within a range a range.
+             By default, the limitations are obeying the following principle:
+             `(specified_number/2, specified_number*2)`
+             NB! It will **ALWAYS** be flored Integer.
+
+This method is helpful, once you are dealing with data structure you can consider as simple.
+So you need to create a specific amount of records, without any subsequential creation.
+
+### Next way is *simple subsequential*:
+
+You can specify the amount of records one level under the record type:
+An examples:
+
+    # a strict amount
+    business:
+      amount: 1000
+
+    # or fuzzy way:
+    users:
+      ratio: 1000
+
+    # or more fuzzy way:
+    users:
+      ratio:
+        lower_limit: 300
+        upper_limit: 10000
+
+**amount** and **ratio** have same meaning as in the previous example.
+In the last example, the amount will be a random number, within `(lower_limit..upper_limit)`
+
+### Next way is *complicated subsequential*:
+
+It is often required to generate a associated models, like in case when
+City'es may have many associated Place'es.
+A brief examples:
+
+    # simple case
+    cities:
+      amount: 1000
+      places_ratio: 300
+
+    # or a bit more complecated
+    cities:
+      amount: 1000
+      places:
+        ratio:
+          lower_limit: 100
+          upper_limit: 1000
+        address_amount: 1
+
+### Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "cockroach"
+  gem.homepage = "https://github.com/artirix/cockroach"
+  gem.license = "MIT"
+  gem.summary = %Q{This gem allows one to fake all the date for the Artirix project}
+  gem.description = %Q{In order to simplify the life of the Artirix developers, this gem was build.
+  It allows to generate the data, and fill teh database with fake records.}
+  gem.email = "max.zab@artirix.com"
+  gem.authors = ["E-Max"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/cockroach.gemspec

@@ -0,0 +1,96 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "cockroach"
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["E-Max"]
+  s.date = "2012-10-12"
+  s.description = "In order to simplify the life of the Artirix developers, this gem was build.\n  It allows to generate the data, and fill teh database with fake records."
+  s.email = "max.zab@artirix.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".rvmrc",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "cockroach.gemspec",
+    "lib/cockroach.rb",
+    "lib/cockroach/base/load_nodes.rb",
+    "lib/cockroach/base/node.rb",
+    "lib/cockroach/base/node_structure.rb",
+    "lib/cockroach/config.rb",
+    "lib/cockroach/config/loader.rb",
+    "lib/cockroach/fixtures/factory_girl.rb",
+    "lib/cockroach/fixtures/factory_girl/loader.rb",
+    "lib/cockroach/fixtures/factory_girl/node.rb",
+    "lib/cockroach/fixtures/factory_girl/profiler.rb",
+    "lib/cockroach/railtie.rb",
+    "lib/cockroach/source.rb",
+    "lib/cockroach/source/model.rb",
+    "lib/cockroach/source/node.rb",
+    "lib/cockroach/version.rb",
+    "lib/generators/cockroach/install_generator.rb",
+    "lib/generators/cockroach/templates/cockroach.rb",
+    "lib/generators/cockroach/templates/faker.yml",
+    "lib/tasks/faker.rake",
+    "test/config/config_test.rb",
+    "test/config/loader_test.rb",
+    "test/fixturers/factory_girl/aliasing_test.rb",
+    "test/fixturers/factory_girl/loading_test.rb",
+    "test/fixturers/factory_girl/node_test.rb",
+    "test/fixturers/factory_girl/profiler_test.rb",
+    "test/fixturers/source_test.rb",
+    "test/generators/install_generator_test.rb",
+    "test/support/active_record.rb",
+    "test/support/data/correct_with_option.yml",
+    "test/support/data/correct_without_option.yml",
+    "test/support/data/dummy_structure/config/faker.yml",
+    "test/support/data/dummy_structure/config/user_only.yml",
+    "test/support/data/dummy_structure/config/witness.yml",
+    "test/support/data/dummy_structure/test/factories/user_factory.rb",
+    "test/support/database_cleaner.rb",
+    "test/support/factory_girl_mocked.rb",
+    "test/support/models/user.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = "https://github.com/artirix/cockroach"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "This gem allows one to fake all the date for the Artirix project"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_runtime_dependency(%q<faker>, [">= 0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<faker>, [">= 0"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<faker>, [">= 0"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

data/lib/cockroach.rb

@@ -0,0 +1,43 @@
+require "active_support/dependencies/autoload"
+require "active_support/core_ext/module"
+require "cockroach/railtie" if defined?(Rails)
+
+module Cockroach
+  extend ActiveSupport::Autoload
+  
+  autoload :VERSION
+  autoload :Config
+
+  autoload :Source
+
+  module Base
+    autoload :Node, 'cockroach/base/node'
+    autoload :LoadNodes, 'cockroach/base/load_nodes'
+  end
+  
+  autoload_under 'fixtures' do
+    autoload :FactoryGirl
+  end
+
+  class InvalideStructureError < Exception; end
+  class MissingFixtureError < Exception; end
+
+  mattr_reader :config
+  
+  class << self
+    delegate :profiler, :to => :config
+    
+    def setup &block
+      block.yield(Cockroach::Config)
+      @@config = Cockroach::Config.new (Cockroach::Config.config_path || "config/faker.yml")
+      load_fixturer
+    end
+  
+    private
+
+    #
+    def load_fixturer
+      self.const_get(@@config.fixturer)
+    end
+  end
+end

data/lib/cockroach/base/load_nodes.rb

@@ -0,0 +1,38 @@
+require 'active_support/concern'
+
+module Cockroach
+  module Base
+    module LoadNodes
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :nodes
+
+        def load! *agrs
+          raise "Abstract method"
+        end
+
+        def nodes
+          @nodes ||= {}
+        end
+
+        protected
+
+        # Parse structure file and create a branch of sub nodes.
+        def load_nodes
+          @structure.each do |name, structure|
+            node = Cockroach::FactoryGirl::Node.new(name, structure, {:parrent => self})
+            nodes[node.node_name] = node
+          end
+        end
+
+        # Load all the sub nodes
+        def load_nodes! fixturer_opts = nil
+          nodes.each_value do |node|
+            node.load! fixturer_opts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cockroach/base/node.rb

@@ -0,0 +1,192 @@
+require "cockroach/base/node_structure"
+
+module Cockroach
+  module Base
+    # 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
+      include Cockroach::Base::LoadNodes
+      include Cockroach::Base::NodeStructure
+      
+      APPROACHES = %w(amount ratio).freeze
+
+      class << self
+        # Method validating structure for Node operations.
+        # It will only accepts a structure if it is a Hash object,
+        # with one key only.
+        # In any other case a _false_ value will be returned
+        def valid_structure? structure
+          structure.is_a?(Hash) && structure.keys.size == 1 ||
+            structure.is_a?(Array) && structure.size == 2
+        end
+
+        # Deduct the information from Node instance name:
+        # will try to get:
+        #   name: compulsary
+        #   approach: optional
+        # Returns array containing name and approach
+        #
+        # Example:
+        #
+        #   # no apprach
+        #   ["users", nil]
+        #
+        #   # ratio apprach
+        #   ["users", "ratio"]
+        def extract_info symbol_or_string
+          symbol_or_string = symbol_or_string.to_s
+          approach = (symbol_or_string.match(/_(#{APPROACHES.join('|')})$/)[1] rescue nil)
+          symbol_or_string.gsub!(/(_#{APPROACHES.join('|_')})$/,'') unless approach.blank?
+          [symbol_or_string.to_s.singularize, approach]
+        end
+      end
+
+      attr_reader :name, :approach, :ids, :source
+
+      delegate :find, :sample, :to => :source
+
+      def initialize *opts
+        node_name, @structure, @options = extract_params_from_attrs *opts
+        @name, @approach = self.class.extract_info(node_name.dup)
+        @ids = []
+        @source = define_source if @structure.is_a?(Hash)
+
+        if @approach.blank?
+          extract_options
+          complicated_approch
+          load_nodes
+        else
+          simple_approach
+        end
+
+        raise InvalideStructureError.new("Approch was not specified") if @approach.blank?
+        raise MissingFixtureError.new("Approch was not specified") if @approach.blank?
+        
+        after_initialize
+      end
+
+      # Just in case Fixturer requires anything to be done after the node initialization
+      def after_initialize
+      end
+
+      # Keeps the number, that represents the amount of the records that will
+      # created for this node.
+      # This will be the final number of the records that are going to be created.
+      # In case there was a ratio specified, that method will randomly get a
+      # number within the provided range and keep it.
+      def amount
+        @amount || get_random_amount
+      end
+
+      # Returns an aliased node name. The one that will be used for keeping it
+      # in sup and sub structures
+      def node_name
+        @alias_as || @name
+      end
+
+      protected
+
+      # There are four possible options here
+      #  - structure
+      #  - node_name, structure
+      #  - structure, options
+      #  - node_name, structure, options
+      def extract_params_from_attrs *attrs
+        structure = if attrs.size == 1 
+          attrs.first
+        elsif attrs.size == 3
+          options = attrs.pop
+          attrs
+        else
+          options = attrs.pop if attrs.first.is_a?(Hash)
+          attrs
+        end
+
+        raise InvalideStructureError.new("Node has faced invalid structure") unless self.class.valid_structure?(structure)
+        structure.flatten << (options || {})
+      end
+
+      # Complicated approach is used, once the amount directives were specified
+      # within node subconfig.
+      def complicated_approch
+        approach = @options.select { |k,v| APPROACHES.include? k }
+        raise InvalideStructureError.new("Amount is not specified or specified multiple times") unless approach.keys.size == 1
+        case (@approach = approach.keys[0])
+        when "amount"
+          @amount = @options[@approach].to_i
+        when "ratio"
+          @options[@approach].is_a?(String) || @options[@approach].kind_of?(Numeric) ?
+            set_simple_limits(@options[@approach].to_i) :
+            extract_limits(@options[@approach])
+        end
+      end
+
+      # Simple approach is used when the amount of the records is specified as the
+      # Yaml node content, and the way this number should be treated as a node
+      # suffix 
+      def simple_approach
+        case @approach
+        when "amount"
+          @amount = @structure.to_i
+        when "ratio"
+          set_simple_limits @structure.to_i
+        end
+      end
+
+      # Clear the node subconfig. Will extract all the options or directives from
+      # provided Hash, and assigne the to the corresponding variables.
+      def extract_options
+        @options.merge! @structure.extract!(*APPROACHES).delete_if {|k,v| v.nil?}
+        @alias_as = @structure.delete("as")
+        @structure.each_pair {| key, value | (@aliases ||= {})[$1] = value if key =~ /^(.*)_as$/ }
+        @structure.delete_if {| key, value | key =~ /_as$/ }
+      end
+
+      # Defines a simple limits for random amount. It is as simple as
+      #   lowest possible value a half of middle_line
+      #   highest value is twice the middle_line
+      def set_simple_limits middle_line
+        @upper_limit, @lower_limit = [middle_line / 2, middle_line * 2]
+      end
+
+      def extract_limits hash
+        @upper_limit, @lower_limit = [hash['lower_limit'].to_i, hash['upper_limit'].to_i]
+      end
+
+      # Returns manimum and minumum options within an array, for the amount of
+      # the records, that will be used to generate the amount of the records
+      # that will created for this node.
+      #
+      # Example:
+      #
+      #   [5, 12]
+      def get_limits
+        [@upper_limit, @lower_limit]
+      end
+
+      # Generates the number, that represents the amount of the records that will
+      # created for this node.
+      def get_random_amount
+        min, max = get_limits
+
+        if max - min > 0
+          min + Random.rand(max - min)
+        else
+          min
+        end
+      end
+
+      # Returns orm class deducted from fixturer
+      def orm_class
+        raise "Implement"
+      end
+
+      def define_source
+        source_refs = @structure.delete('source')
+        return unless source_refs
+        Cockroach::Source.get_source source_refs
+      end
+    end
+  end
+end