sorted_seeder 0.0.10

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjkxYWFhMjE3MTQ5MzZiZmQwYjdiYmE1ZjcyOTk0YjNjYTE1OTYxZQ==
+  data.tar.gz: !binary |-
+    NTA2ODBiNmQyMjEzYzc2MDYxZmVhNzMzMDg2NGQ3MWRkOTFkZTc1Mw==
+SHA512:
+  metadata.gz: !binary |-
+    YWJhZWQ1NTdiYTdkNzZiZGU1MDI4M2E1OTE4OGQ0ZTYxOWUwYjcwZjMzOTlm
+    YzU0MDI5ZDlmNDMyMWNlMGQ4NWU4NjJkOTUwZDJmOTNjYTMyMzQ5MzE4Zjkx
+    ZjhhN2I2NGRjYzcxMGIwYjE2NjVkYTI2NzRmM2E0OTFiOTYwMzE=
+  data.tar.gz: !binary |-
+    ZjQ5NzQ4Yzg3OTM5OTM4MmUxMTNlZDUxMDEwNDYzNmY0NDgwMWQ5YjU2NDQ3
+    ODI3YmU3ZGE3YTJjMjU0OTI5OWZhOTczMjRkMWMxYmU4NzY0OTlkYzA3NmYw
+    MTMwMGExMjM1M2U1ZTExMDk1NmQwMTI1ODZkZDlkZTEwYTZjMzQ=

data/.gitignore

@@ -0,0 +1,18 @@
+.idea/
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sorted_seeder.gemspec
+gemspec
+
+gem "gem-release"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 RealNobody
+
+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,111 @@
+# SortedSeeder
+
+SortedSeeder is a small utility for organizing how your system is seeded.
+
+**When using this system, all seeding actions are expected to be idempotent.**  That is,
+the seed system assumes that the seed function can safely be called multiple times without causing any problems with
+the data.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sorted_seeder'
+
+OR
+
+    gem 'sorted_seeder', :git => "git@github.com:RealNobody/sorted_seeder.git"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sorted_seeder
+
+## Usage
+
+### Seeding
+
+To seed the database, simply call:
+
+`SortedSeeder::Seeder.seed_all`
+
+This is the master function which will perform all seeding tasks.  Seeding tasks are split into two types of seeding
+tasks which are generally performed in this order:
+
+1. Database seeding
+2. Generic seeding
+
+I recommend putting this call into your `/db/seeds.rb` and make that file simply:
+
+    require "sorted_seeder"
+
+    SortedSeeder::Seeder.seed_all
+
+
+#### Database Seeding
+
+There are 2 different ways to seed a database table, which are tried in this order:
+
+1. A special seeding class will be looked for that matches the name of the database table class with "Seeder"
+appended.  (i.e. if the database class is `MyTable`, then the seeder class that will be looked for is `MyTableSeeder`.
+A class function named `seed` will be called on this class to seed the table.  If the class cannot be found, the
+system will look for the appropriately underscore named file in `<Rails.root>/db/seeders/`.  (i.e.
+`<Rails.root>/db/seeders/my_table_seeder.rb`
+2. A class function named `seed` will be called on the class for the database table.
+
+I don't recommend the second option, but I support it because this was the initial implementation I made.
+
+#### Generic Seeding
+
+All *.rb files under the `<Rails.root>/db/seeders/` folder will be loaded.  The full path under the seeder folder
+will be classified to create a class name for the expected class within the file.  That class will be constantized
+and if the class exists and has a `seed` class function, that function will be called.
+
+Example custom seed file for a database table named `users`:  `/db/seeders/user_seeder.rb`
+
+    class UserSeeder
+      class << self
+        def seed
+          User.find_or_initialize_by(email: "my@email.com").tap do |user|
+            user.name = "Seeded User"
+            user.save!()
+          end
+        end
+      end
+    end
+
+Example seeder for a non SQL database resource like Redis:  `/db/seeders/zip_seeder.rb`
+
+    class ZipSeeder
+      class << self
+        def seed
+          # Load information into Redis
+        end
+      end
+    end
+
+#### Seeding order
+
+Database tables are by default sorted based on the relationships defined in the table classes such that tables which
+depend on other tables are seeded after the tables that they depend on.
+
+If there is a cyclic dependency, there is no guarantee in which order the tables will be seeded.
+
+Custom seed classes can define when they are called by overriding the `<=>(right_operator)` method which is called
+when sorting the seeding classes.  The right operator will either be another custom sorter class or an instance of
+the SortedSeeder::Seeder class which represents the seeder for a table.  This class exposes the `table` that it will seed.
+
+NOTE:  A SortedSeeder:Seeder is created for every table so that you can insert a custom seeder before or after any table
+you may need to.
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/sorted_seeder/seeder.rb

@@ -0,0 +1,447 @@
+module SortedSeeder
+  class Seeder
+    attr_reader :table
+    attr_reader :seeder_class
+
+    @@create_order        = nil
+    @@seeder_classes      = nil
+    @@database_connection = nil
+
+    class SeederSorter
+      attr_accessor :seed_base_object
+
+      def initialize(seed_base_object)
+        @seed_base_object = seed_base_object
+      end
+
+      def <=>(other_object)
+        compare_value = nil
+        compare_value = (@seed_base_object <=> other_object.seed_base_object) if @seed_base_object.respond_to?(:<=>)
+
+        unless compare_value
+          compare_value = (other_object.seed_base_object <=> @seed_base_object) if other_object.seed_base_object.respond_to?(:<=>)
+
+          if compare_value
+            compare_value = -1 * compare_value
+          else
+            if other_object.seed_base_object.is_a?(Class)
+              if seed_base_object.is_a?(Class)
+                compare_value = (seed_base_object.name <=> other_object.seed_base_object.name)
+              else
+                compare_value = -1
+              end
+            else
+              if seed_base_object.is_a?(Class)
+                compare_value = 1
+              else
+                compare_value = 0
+              end
+            end
+          end
+        end
+
+        compare_value
+      end
+    end
+
+    class << self
+      def seed_all(db_connection = nil)
+        seeder_classes(db_connection).each do |seed_class|
+          seed_class.seed
+        end
+      end
+
+      def seeder_classes(db_connection = nil)
+        unless @@seeder_classes
+          @@seeder_classes = []
+
+          # table object seeders
+          SortedSeeder::Seeder.create_order(db_connection).each do |table|
+            table_seed_class = SortedSeeder::Seeder.seed_class(table.name)
+
+            if !table_seed_class && table.respond_to?(:seed)
+              table_seed_class = table
+            end
+
+            @@seeder_classes << SortedSeeder::Seeder.new(table, table_seed_class)
+          end
+
+          # table object seeders
+          SortedSeeder::Seeder.unclassed_tables(db_connection).each do |table|
+            table_seed_class = SortedSeeder::Seeder.seed_class(table)
+
+            @@seeder_classes << SortedSeeder::Seeder.new(table, table_seed_class)
+          end
+
+          if Object.const_defined?("Rails", false)
+            seeder_root  = Rails.root.join("db/seeders/").to_s
+            seeder_files = Dir[Rails.root.join("db/seeders/**/*.rb")]
+
+            seeder_files.each do |seeder_file|
+              class_name = File.basename(seeder_file, ".rb").classify
+
+              check_class, full_module_name = find_file_class(seeder_file, seeder_root)
+              unless check_class && check_class.const_defined?(class_name, false)
+                require seeder_file
+                check_class, full_module_name = find_file_class(seeder_file, seeder_root)
+              end
+
+              if check_class
+                full_module_name << class_name
+                if check_class.const_defined?(class_name, false)
+                  check_class = full_module_name.join("::").constantize
+                else
+                  check_class = nil
+                end
+              end
+
+              if check_class && check_class.respond_to?(:seed)
+                unless @@seeder_classes.include?(check_class) ||
+                    @@seeder_classes.any? { |seeder| seeder.is_a?(SortedSeeder::Seeder) && seeder.seeder_class == check_class }
+                  @@seeder_classes << check_class
+                end
+              end
+            end
+          end
+
+          seed_sorts = @@seeder_classes.map { |seed_class| SeederSorter.new(seed_class) }
+          seed_sorts.sort!
+
+          @@seeder_classes = seed_sorts.map(&:seed_base_object)
+        end
+
+        @@seeder_classes
+      end
+
+      def find_file_class(seeder_file, seeder_root)
+        check_class      = Object
+        full_module_name = []
+
+        File.dirname(seeder_file.to_s[seeder_root.length..-1]).split("/").map do |module_element|
+          if (module_element != ".")
+            full_module_name << module_element.classify
+            if check_class.const_defined?(full_module_name[-1], false)
+              check_class = full_module_name.join("::").constantize
+            else
+              check_class = nil
+              break
+            end
+          end
+        end
+
+        return check_class, full_module_name
+      end
+
+      def unclassed_tables(db_connection = nil)
+        create_order(db_connection)
+
+        @@other_tables
+      end
+
+      def create_order(db_connection = nil)
+        unless @@create_order
+          @@database_connection = db_connection
+
+          if Object.const_defined?("ActiveRecord", false) && ActiveRecord.const_defined?("Base", false)
+            @@database_connection ||= ActiveRecord::Base
+          end
+
+          if Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+            @@database_connection ||= Sequel::DATABASES[0]
+          end
+
+          @@create_order = []
+          @@other_tables = []
+
+          if Object.const_defined?("ActiveRecord", false) && ActiveRecord.const_defined?("Base", false)
+            active_record_create_order
+          end
+
+          if Object.const_defined?("Sequel", false) && Sequel.const_defined?("Model", false)
+            sequel_record_create_order
+          end
+        end
+
+        @@create_order
+      end
+
+      def active_record_create_order
+        table_objects      = []
+        polymorphic_tables = {}
+
+        @@database_connection.connection rescue nil
+        if @@database_connection.respond_to?(:connected?) && @@database_connection.connected?
+          @@database_connection.connection.tables.each do |table_name|
+            table = nil
+
+            seeder = SortedSeeder::Seeder.seed_class(table_name, true)
+            if seeder && seeder.respond_to?(:table)
+              table = seeder.table
+            end
+            if !table && Object.const_defined?(table_name.to_s.classify)
+              table = table_name.to_s.classify.constantize
+            end
+
+            # is_a?(ActiveRecord::Base) doesn't work, so I am doing it this way...
+            table_is_active_record = false
+            table_super_class      = table.superclass if table
+            while !table_is_active_record && table_super_class
+              table_is_active_record = (table_super_class == ActiveRecord::Base)
+              table_super_class      = table_super_class.superclass
+            end
+
+            if table && table_is_active_record
+              table_objects << table
+            else
+              SortedSeeder::Seeder.unclassed_tables << table_name
+            end
+          end
+
+          table_objects.each do |table|
+            [:has_one, :has_many].each do |relationship|
+              table.reflect_on_all_associations(relationship).each do |association|
+                if association.options[:as]
+                  polymorphic_tables[association.class_name] ||= []
+
+                  unless polymorphic_tables[association.class_name].include?(table)
+                    polymorphic_tables[association.class_name] << table
+                  end
+                end
+              end
+            end
+          end
+
+          table_objects.each do |table|
+            unless SortedSeeder::Seeder.create_order.include?(table)
+              prev_table = active_record_pre_table(table, polymorphic_tables, [])
+
+              while (prev_table)
+                SortedSeeder::Seeder.create_order << prev_table
+                prev_table = active_record_pre_table(table, polymorphic_tables, [])
+              end
+
+              SortedSeeder::Seeder.create_order << table
+            end
+          end
+        end
+      end
+
+      def sequel_record_create_order
+        if Sequel::DATABASES.length > 0
+          table_objects      = []
+          polymorphic_tables = {}
+
+          raise("Unsure what database to use.") if Sequel::DATABASES.length > 1
+          @@database_connection.tables.each do |table_name|
+            table = nil
+
+            seeder = SortedSeeder::Seeder.seed_class(table_name, true)
+            if seeder && seeder.respond_to?(:table)
+              table = seeder.table
+            end
+            if !table && Object.const_defined?(table_name.to_s.classify)
+              table = table_name.to_s.classify.constantize
+            end
+
+            # is_a?(Sequel::Model) doesn't work, so I am doing it this way...
+            table_is_sequel_model = false
+            table_super_class     = table.superclass if table
+            while !table_is_sequel_model && table_super_class
+              table_is_sequel_model = (table_super_class == Sequel::Model)
+              table_super_class     = table_super_class.superclass
+            end
+
+            if table && table_is_sequel_model
+              table_objects << table
+            else
+              SortedSeeder::Seeder.unclassed_tables << table_name
+            end
+          end
+
+          # Sequel doesn't natively support polymorphic tables, so we don't support them here.
+          table_objects.each do |table|
+            unless SortedSeeder::Seeder.create_order.include?(table)
+              prev_table = sequel_pre_table(table, polymorphic_tables, [])
+
+              while (prev_table)
+                SortedSeeder::Seeder.create_order << prev_table
+                prev_table = sequel_pre_table(table, polymorphic_tables, [])
+              end
+
+              SortedSeeder::Seeder.create_order << table
+            end
+          end
+        end
+      end
+
+      def active_record_pre_table(table, polymorphic_tables, processing_tables)
+        processing_tables << table
+        prev_table = nil
+
+        relations = table.reflect_on_all_associations(:belongs_to)
+        relations.each do |belongs_to|
+          if belongs_to.options && belongs_to.options[:polymorphic]
+            if polymorphic_tables[table.name]
+              polymorphic_tables[table.name].each do |polymorphic_prev_table|
+                prev_table = polymorphic_prev_table unless SortedSeeder::Seeder.create_order.include?(polymorphic_prev_table)
+                break if prev_table
+              end
+            end
+          else
+            belongs_to_table_name = (belongs_to.options[:class_name] || belongs_to.name.to_s.classify).to_s
+            prev_table            = belongs_to_table_name.constantize
+
+            if prev_table &&
+                (SortedSeeder::Seeder.create_order.include?(prev_table) ||
+                    table == prev_table ||
+                    processing_tables.include?(prev_table))
+              prev_table = nil
+            end
+          end
+
+          prev_prev_table = nil
+          prev_prev_table = active_record_pre_table(prev_table, polymorphic_tables, processing_tables) if prev_table
+          prev_table      = prev_prev_table || prev_table
+
+          break if prev_table
+        end
+
+        prev_table
+      end
+
+      # associated_class is late-bound, and Sequel doesn't validate it until it is called.
+      # This causes it to be able to fail unexpectedly, This is just a little safer...
+      def sequel_associated_class(relation)
+        begin
+          relation.associated_class
+        rescue NameError => error
+          if Object.const_defined?(relation[:class_name].to_s.classify)
+            relation[:class_name].to_s.classify.constantize
+          else
+            nil
+          end
+        end
+      end
+
+      def sequel_pre_table(table, polymorphic_tables, processing_tables)
+        processing_tables << table
+        prev_table = nil
+
+        relations = table.all_association_reflections
+        relations.each do |belongs_to|
+          next unless [:one_through_one, :one_to_one, :many_to_one].include?(belongs_to[:type])
+
+          if [:one_through_one, :one_to_one].include?(belongs_to[:type])
+            related_table = sequel_associated_class(belongs_to)
+            if related_table
+              related_table.all_association_reflections.each do |reverse_reflection|
+                if sequel_associated_class(reverse_reflection) == table
+                  if [:one_to_many].include? reverse_reflection[:type]
+                    prev_table = related_table
+                    break
+                  end
+                end
+              end
+            end
+          else
+            prev_table = sequel_associated_class(belongs_to)
+          end
+
+          if prev_table &&
+              (SortedSeeder::Seeder.create_order.include?(prev_table) ||
+                  table == prev_table ||
+                  processing_tables.include?(prev_table))
+            prev_table = nil
+          end
+
+          prev_prev_table = nil
+          prev_prev_table = sequel_pre_table(prev_table, polymorphic_tables, processing_tables) if prev_table
+          prev_table      = prev_prev_table || prev_table
+
+          break if prev_table
+        end
+
+        prev_table
+      end
+
+      def seed_class(table_name, seek_table_name = false)
+        seed_class_name      = "#{table_name.to_s.classify}Seeder"
+        seed_class_base_name = seed_class_name.demodulize
+        base_module          = seed_class_name.split("::")[0..-2].join("::")
+        base_module_classes  = [Object]
+
+        unless base_module.blank?
+          base_module_classes = base_module_classes.unshift base_module.constantize
+        end
+
+        return_class = nil
+        2.times do
+          base_module_classes.each do |base_class|
+            if (base_class.const_defined?(seed_class_base_name, false))
+              if base_class == Object
+                return_class = seed_class_base_name.constantize
+              else
+                return_class = "#{base_class.name}::#{seed_class_base_name}".constantize
+              end
+
+              break
+            end
+          end
+
+          break if return_class
+
+          seeder_file = "db/seeders/"
+          seeder_file += base_module.split("::").map { |module_name| module_name.underscore }.join("/")
+          seeder_file += "/" unless seeder_file[-1] == "/"
+          seeder_file += seed_class_base_name.underscore
+          seeder_file += ".rb"
+          seeder_file = File.join(Rails.root, seeder_file)
+
+          break unless File.exists?(seeder_file)
+
+          require seeder_file
+        end
+
+        unless return_class.respond_to?(:seed)
+          unless seek_table_name && return_class.respond_to?(:table)
+            return_class = nil
+          end
+        end
+
+        return_class
+      end
+    end
+
+    def initialize(table, seeder_class)
+      @table        = table
+      @seeder_class = seeder_class
+    end
+
+    def seed
+      seeder_class.seed if seeder_class
+    end
+
+    def <=>(other_object)
+      if (other_object.is_a?(SortedSeeder::Seeder))
+        return 0 if other_object.table == self.table
+
+        SortedSeeder::Seeder.create_order.each do |create_table|
+          if create_table == self.table
+            return -1
+          elsif create_table == other_object.table
+            return 1
+          end
+        end
+      else
+        if other_object.respond_to?(:<=>)
+          comparison = (other_object <=> self)
+          if comparison
+            return -1 * comparison
+          end
+        end
+      end
+
+      return -1
+    end
+  end
+end

data/lib/sorted_seeder/version.rb

@@ -0,0 +1,3 @@
+module SortedSeeder
+  VERSION = "0.0.10"
+end

data/lib/sorted_seeder.rb

@@ -0,0 +1,6 @@
+require "sorted_seeder/version"
+require "sorted_seeder/seeder"
+
+module SortedSeeder
+  # Your code goes here...
+end

data/sorted_seeder.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sorted_seeder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sorted_seeder"
+  spec.version       = SortedSeeder::VERSION
+  spec.authors       = ["RealNobody"]
+  spec.email         = ["Erik.Littell@Deem.com"]
+  spec.description   = %q{A system for organizing and simplifying seeding your environment.}
+  spec.summary       = %q{A system for organizing and simplifying seeding your environment.}
+  spec.homepage      = "https://github.com/RealNobody/sorted_seeder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: sorted_seeder
+version: !ruby/object:Gem::Version
+  version: 0.0.10
+platform: ruby
+authors:
+- RealNobody
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A system for organizing and simplifying seeding your environment.
+email:
+- Erik.Littell@Deem.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sorted_seeder.rb
+- lib/sorted_seeder/seeder.rb
+- lib/sorted_seeder/version.rb
+- sorted_seeder.gemspec
+homepage: https://github.com/RealNobody/sorted_seeder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A system for organizing and simplifying seeding your environment.
+test_files: []
+has_rdoc: