data_works 0.1.1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-minimal

data/bin/_guard-core

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application '_guard-core' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("guard", "_guard-core")

data/bin/guard

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'guard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("guard", "guard")

data/bin/rake

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/data_works.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "data_works/version"
+
+Gem::Specification.new do |s|
+  s.name          = "data_works"
+  s.version       = DataWorks::VERSION
+  s.authors       = ["Wyatt Greene", "Anne Geiersbach", "Dennis Chan", "Luke Inglis"]
+  s.email         = ["ld.inglis@gmail.com"]
+  s.summary       = %q{Reducing the complexity of testing complex data models }
+  s.description   = %q{DataWorks makes it easier to work with FactoryBot in the context of a complex data model.}
+  s.homepage      = 'https://github.com/ludamillion/data_works'
+  s.licenses      = ["MIT", "Copyright (c) 2018 District Management Group"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activerecord", "~> 4.1"
+  s.add_dependency "activesupport", "~> 4.1"
+  s.add_dependency 'factory_girl', '>= 3.0'
+  s.add_dependency 'graphviz', '~> 0.1.0'
+  s.add_dependency 'launchy', '~> 2.4'
+
+  s.add_development_dependency "bundler", "~> 1.9"
+  s.add_development_dependency "rake", "~> 10.4"
+  s.add_development_dependency "database_cleaner", "~> 1.4.0"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "active_hash", "~> 1.5.0"
+end

data/lib/data_works.rb

@@ -0,0 +1,15 @@
+require 'data_works/version'
+require 'active_record'
+require 'active_support/core_ext/string/inflections'
+
+require 'data_works/exceptions'
+require 'data_works/stale_relationship_checker'
+require 'data_works/relationships'
+require 'data_works/visualization'
+require 'data_works/necessary_parent'
+require 'data_works/parent_creator'
+require 'data_works/grafter'
+require 'data_works/works'
+require 'data_works/base'
+require 'data_works/config'
+require "data_works/railtie" if defined?(Rails)

data/lib/data_works/base.rb

@@ -0,0 +1,26 @@
+# This class wraps DataWorks::Works and only exposes methods that are
+# meant to be public.  The sole purpose of this class is information
+# hiding.
+module DataWorks
+  class Base
+
+    def initialize
+      @works = DataWorks::Works.new
+    end
+
+    # we expose the public interface here
+    def method_missing(method_name, *args, &block)
+      method_name = method_name.to_s
+      if method_name =~ /\A(add_|the_)(\w+)\Z/ ||
+         method_name =~ /\A(\w+)(\d+)\Z/ ||
+         method_name =~ /\Aset_(current_default|restriction)\Z/ ||
+         method_name =~ /\Aclear_(current_default|restriction)_for\Z/ ||
+         method_name == 'visualize'
+        @works.send(method_name, *args, &block)
+      else
+        raise NoMethodError.new("#{method_name} method not found in data works")
+      end
+    end
+
+  end
+end

data/lib/data_works/config.rb

@@ -0,0 +1,19 @@
+module DataWorks
+
+  def self.configure
+    yield(Config)
+  end
+
+  class Config
+
+    def self.necessary_parents=(hash)
+      Relationships.necessary_parents = hash
+    end
+
+    def self.autocreated_children=(hash)
+      Relationships.autocreated_children = hash
+    end
+
+  end
+
+end

data/lib/data_works/exceptions.rb

@@ -0,0 +1,6 @@
+module DataWorks
+
+  class DataWorksError < StandardError; end
+  class ModelRelationshipsOutOfDateError < DataWorksError; end
+
+end

data/lib/data_works/grafter.rb

@@ -0,0 +1,51 @@
+module DataWorks
+  class Grafter
+
+    class ModelCreator
+      def initialize(works, model_name, model_attrs)
+        @works = works
+        @model_name = model_name.to_sym
+        @model_attrs = model_attrs
+        @parent_creator = ParentCreator.new(@works, @model_name, @model_attrs)
+      end
+
+      def create_model_and_its_necessary_parents
+        created_parents = @parent_creator.create_necessary_parents(parents_we_already_have)
+        FactoryGirl.create(@model_name, @model_attrs.merge(created_parents))
+      end
+
+      private
+
+      # If we use DataWorks like this:
+      #     data.add_student(:school => some_school)
+      # then we are passing in a necessary parent model (the school), so
+      # DataWorks does not have to autogenerate it, since we already have it.
+      def parents_we_already_have
+        provided_attribute_names = @model_attrs.keys
+        necessary_parent_names = Relationships.necessary_parents_for(@model_name).map(&:association_name)
+        provided_attribute_names & necessary_parent_names
+      end
+    end
+
+    def initialize(works, model_name)
+      @works = works
+      @model_name = model_name.to_sym
+    end
+
+    def add_many(number, model_attrs={})
+      new_models = []
+      number.times do
+        new_models << add_one(model_attrs)
+      end
+      new_models
+    end
+
+    def add_one(model_attrs={})
+      model_creator = ModelCreator.new(@works, @model_name, model_attrs)
+      new_model = model_creator.create_model_and_its_necessary_parents
+      @works.was_added(@model_name, new_model)
+      new_model
+    end
+
+  end
+end

data/lib/data_works/necessary_parent.rb

@@ -0,0 +1,27 @@
+# The purpose of this class is to encapsulate the idea that when configuring
+# DataWorks, necessary_parents can include symbols or hashes, like so:
+#
+#   config.necessary_parents = {
+#     district:                      [ ],
+#     event:                         [:schedule, :school],
+#     scheduled_service:             [{:schedulable => :event}, :student],
+#     school:                        [:district]
+#     student:                       [:school]
+#   }
+#
+module DataWorks
+  class NecessaryParent
+
+    attr_reader :association_name, :model_name
+
+    def initialize(entry)
+      if entry.is_a? Hash
+        @association_name = entry.keys.first
+        @model_name  = entry.values.first
+      else
+        @association_name = @model_name = entry
+      end
+    end
+
+  end
+end

data/lib/data_works/parent_creator.rb

@@ -0,0 +1,67 @@
+module DataWorks
+  class ParentCreator
+
+    def initialize(works, model_name, model_attrs)
+      @works = works
+      @model_name = model_name.to_sym
+      @parents = {}
+    end
+
+    # This returns a hash of the parent models created, so that they can be
+    # easily merged into a model attribute hash.  For example, if a school
+    # parent model was created for a student model, then it would be returned
+    # like so:
+    #    { :school => the_school_model }
+    def create_necessary_parents(parents_we_already_have)
+      for missing_necessary_parent in missing_necessary_parents(parents_we_already_have)
+        find_or_add(missing_necessary_parent)
+      end
+      @parents
+    end
+
+    private
+
+    def missing_necessary_parents(parents_we_already_have)
+      Relationships.necessary_parents_for(@model_name).reject do |necessary_parent|
+        parents_we_already_have.include?(necessary_parent.association_name)
+      end
+    end
+
+    def find_or_add(necessary_parent)
+      parent_model = @works.find_or_add(necessary_parent.model_name)
+      destroy_zombies(parent_model, necessary_parent.association_name)
+      @parents[necessary_parent.association_name] = parent_model
+    end
+
+    # Consider the case where a model has a has_one relationship with its
+    # child.  The model autocreates the child model using a callback like
+    # before_validation or after_initialize.
+    #
+    # This can confuse DataWorks because DataWorks creates models by starting
+    # at the child and creating all of the necessary ancestors.  It's a
+    # "child creates parent" strategy.  When a model class autocreates a
+    # child, it happens outside of DataWorks so DataWorks does not know about
+    # it and it goes against the flow since it has a "parent creates child"
+    # strategy.
+    #
+    # The upshot is that a bunch of unmanaged zombie objects will be lying
+    # around that could disrupt tests.  So we specifically have to delete
+    # any model objects that a parent may have created outside of DataWorks
+    # before they cause trouble.
+    def destroy_zombies(parent_model, parent_association_name)
+      if zombies_possible?(parent_association_name)
+        destroy_zombie_child_of(parent_model)
+      end
+    end
+
+    def zombies_possible?(parent_association_name)
+      Relationships.autocreated_children_of(parent_association_name).include?(@model_name)
+    end
+
+    def destroy_zombie_child_of(parent_model)
+      child = parent_model.send(@model_name)
+      child.destroy if child.persisted? && !child.destroyed?
+    end
+
+  end
+end

data/lib/data_works/railtie.rb

@@ -0,0 +1,17 @@
+require 'data_works'
+require 'rails'
+
+module DataWorks
+  class Railtie < Rails::Railtie
+    railtie_name :data_works
+
+    rake_tasks do
+      namespace :data_works do
+        desc "tell data_works that the model relationships are accurate"
+        task :bless => :environment do
+          DataWorks::StaleRelationshipChecker.create_snapshot!
+        end
+      end
+    end
+  end
+end

data/lib/data_works/relationships.rb

@@ -0,0 +1,29 @@
+module DataWorks
+  class Relationships
+
+    def self.autocreated_children=(hash)
+      @autocreated_children = hash
+    end
+
+    def self.autocreated_children_of(model_name)
+      @autocreated_children[model_name] || []
+    end
+
+    def self.necessary_parents=(hash)
+      @necessary_parents = hash
+      StaleRelationshipChecker.check!
+    end
+
+    def self.necessary_parents_for(model_name)
+      result = @necessary_parents[model_name]
+      if result.nil?
+        message = "The model '#{model_name}' is not registered. "
+        message << "It should be registered in the DataWorks.configure section "
+        message << "of your spec_helper.rb file."
+        raise DataWorksError.new(message)
+      end
+      result.map{|x| NecessaryParent.new(x)}
+    end
+
+  end
+end

data/lib/data_works/stale_relationship_checker.rb

@@ -0,0 +1,87 @@
+module DataWorks
+  class StaleRelationshipChecker
+    class << self
+
+      def check!
+        if snapshot_exists?
+          check_for_staleness!
+        else
+          create_snapshot!
+        end
+      end
+
+      def create_snapshot!
+        File.open(filepath, 'w') do |f|
+          f.puts explanatory_comments
+          f.puts "DataWorks::MOST_RECENT_SNAPSHOT = ["
+          current_snapshot.each do |class_name, belongs_to_name|
+            f.puts "  ['#{class_name}', #{belongs_to_name}],"
+          end
+          f.puts "]"
+        end
+      end
+
+    private
+
+      def check_for_staleness!
+        load_snapshot
+        saved = DataWorks::MOST_RECENT_SNAPSHOT
+        current = current_snapshot
+        if saved != current
+          differences = (saved - current) + (current - saved)
+          message = "DataWorks has detected changes to your data model. "
+          message << "DataWorks requires that the config.necessary_parents "
+          message << "in your spec_helper.rb file be an accurate description "
+          message << "of what parent objects need to be automatically "
+          message << "factoried. Please update this configuration to be "
+          message << "accurate, if necessary.  Then run rake data_works:bless "
+          message << "to tell DataWorks that the configuration is now "
+          message << "up-to-date."
+          message << "\nHere's a hint as to where the data model changes "
+          message << "are #{differences.inspect}."
+          raise ModelRelationshipsOutOfDateError.new(message)
+        end
+      end
+
+      def snapshot_exists?
+        File.exists?(filepath)
+      end
+
+      def explanatory_comments
+        <<-COMMENTS.strip_heredoc
+          # THIS IS A GENERATED FILE.  DO NOT EDIT.
+          #
+          # Generated on #{Time.now.inspect}.
+          #
+          # This file is used by DataWorks to check whether data model
+          # changes have occurred.  When you change the data model, you
+          # need to update DataWorks' configuration.  See the DataWorks
+          # README for details.
+          #
+        COMMENTS
+      end
+
+      def current_snapshot
+        all_active_record_classes.map do |ar_class|
+          [ar_class.name, ar_class.reflect_on_all_associations(:belongs_to).map(&:name)]
+        end.sort_by(&:first)
+      end
+
+      def load_snapshot
+        load filepath
+      end
+
+      def filepath
+        File.join(Rails.root, 'db', 'data_works_relationship_snapshot.rb')
+      end
+
+      def all_active_record_classes
+        @all_classes ||= begin
+          Rails.application.eager_load!
+          ActiveRecord::Base.send(:descendants)
+        end
+      end
+
+    end
+  end
+end