data_works 0.1.1

data/lib/data_works/version.rb

@@ -0,0 +1,4 @@
+module DataWorks
+  VERSION = "0.1.1"
+end
+

data/lib/data_works/visualization.rb

@@ -0,0 +1,127 @@
+require 'graphviz'
+require 'launchy'
+
+module DataWorks
+  module Visualization
+
+    def visualize
+      @g = Graphviz::Graph.new
+      build_nodes
+      connect_nodes
+      filename = "factoried-data-diagram-#{Time.new.strftime("%Y%m%d%H%M%S")}#{rand(1000)}.png"
+      path = begin
+               File.join(Rails.root, "tmp", filename)
+             rescue NameError => error # if not in Rails environment i.e. dev testing
+               root = File.expand_path('../..', File.dirname(__FILE__))
+               File.join root, 'tmp', filename
+             end
+      Graphviz::output(@g, path: path)
+      Launchy.open(path)
+    end
+
+    private
+
+    def get_node_shape(model)
+      model.is_a?(ActiveRecord::Base) ? 'oval' :'diamond'
+    end
+
+    def build_nodes
+      @nodes = {}
+      @data.keys.each do |model_name|
+        @nodes[model_name] = @data[model_name].each_with_index.map do |model, i|
+          @g.add_node("#{model_name}#{i+1}", shape: get_node_shape(model))
+        end
+      end
+    end
+
+    def connect_nodes
+      model_names = @data.keys
+      for model_name1 in model_names
+        for model_name2 in model_names
+          connect_model_kinds(model_name1, model_name2)
+        end
+      end
+      connect_non_active_record_nodes
+    end
+
+    def connect_non_active_record_nodes
+      model_names = @data.keys.select do |k|
+        k.to_s.classify.constantize.new.is_a?(ActiveHash::Base)
+      end
+
+      model_names.each do |m|
+        children = @data.values.
+                     flatten.
+                     reject{|e| e.is_a?(m.to_s.classify.constantize)}.
+                     select { |e| !!e.class.reflect_on_association(m) }
+
+        parents = @data[m]
+
+        children.each do |child|
+          parent = parents.detect { |p| p.id == child.send("#{m}_id") }
+          connect(parent, child)
+        end
+      end
+    end
+
+    # accepts symbols like :district, :district_schedule_context
+    def connect_model_kinds(model_type1, model_type2)
+      return if model_type1 == model_type2
+      models = @data[model_type1]
+      models.each do |parent|
+        find_and_connect_children_to_parent(parent, model_type2)
+      end
+    end
+
+    def find_and_connect_children_to_parent(parent, child_type)
+      assoc = child_association(parent, child_type)
+      return if assoc.nil?
+      parent.reload
+      children = [parent.send(assoc)].flatten
+      for child in children
+        connect(parent, child)
+      end
+    end
+
+    def child_association(parent, child_type)
+      assoc = child_associations_for(parent).detect do |name, obj|
+        name.to_s.singularize.to_sym == child_type.to_s.singularize.to_sym
+      end
+      assoc.try(:first)
+    end
+
+    def child_associations_for(parent)
+      return [] unless parent.class.respond_to?(:reflections)
+      parent.class.reflections.to_a.select do |name, obj|
+        (obj.macro == :has_many || obj.macro == :has_one) && !obj.options[:through]
+      end
+    end
+
+    def connect(parent, child)
+      child_model_name = model_name_of(child)
+      parent_model_name = model_name_of(parent)
+      if @data[parent_model_name]
+        i = @data[parent_model_name].find_index { |model| model.id == parent.id }
+        parent_node = @nodes[parent_model_name][i]
+        if parent_node
+          if @data[child_model_name]
+            i = @data[child_model_name].find_index { |model| model.id == child.id }
+            if i.nil? # this factory was not created via the DataWorks
+              child_node = @g.add_node("#{child_model_name} (unmanaged)", shape: get_node_shape(child))
+            else
+              child_node = @nodes[child_model_name][i]
+            end
+            if child_node
+              parent_node.connect(child_node)
+            end
+          end
+        end
+      end
+    end
+
+    def model_name_of(model)
+      model.class.name.underscore.to_sym
+    end
+
+  end
+end

data/lib/data_works/works.rb

@@ -0,0 +1,111 @@
+module DataWorks
+  class Works
+
+    include Visualization
+
+    def initialize
+      # we keep a registry of all models that we create
+      @data = {}
+      # keep a registry of the 'current default' model of a given type
+      @current_default = {}
+      # keep a registry of the 'limiting scope' for parentage
+      @bounding_models = {}
+    end
+
+    def method_missing(method_name, *args, &block)
+      method_name = method_name.to_s
+      if method_name.starts_with? 'add_'
+        add_model(method_name, *args)
+      else
+        get_model(method_name, *args)
+      end
+    end
+
+    def find_or_add(model_name)
+      record = find(model_name, 1)
+      record ? record : send("add_#{model_name}")
+    end
+
+    def was_added(model_name, model)
+      model_name = model_name.to_sym
+      @data[model_name] ||= []
+      @data[model_name] << model
+    end
+
+    def set_current_default(for_model:, to:)
+      @current_default[for_model] = to
+    end
+
+    def clear_current_default_for(model)
+      @current_default.delete(model)
+    end
+
+    def set_restriction(for_model:, to:, &block)
+      if block_given?
+        @bounding_models[for_model] = to
+        block_return = block.call
+        clear_restriction_for(for_model)
+        block_return
+      elsif
+        @bounding_models[for_model] = to
+        to
+      end
+    end
+
+    def clear_restriction_for(model)
+      @bounding_models.delete(model)
+    end
+
+  private
+
+    def add_model(method_name, *args)
+      if method_name =~ /\Aadd_(\w+)\Z/
+        model_name = $1
+        many = args[0].kind_of? Integer
+      end
+      if model_name
+        grafter = Grafter.new(self, (many ? model_name.singularize : model_name))
+        if many
+          grafter.add_many(*args)
+        else
+          grafter.add_one(*args)
+        end
+      end
+    end
+
+    def get_model(method_name, *args)
+      if method_name =~ /\A(\w+?)(\d+)\Z/
+        model_name = $1
+        index = $2
+      elsif method_name =~ /\Athe_(\w+)\Z/
+        model_name = $1
+        index = 1
+      end
+      find(model_name, index)
+    end
+
+    def find(model_name, index)
+      model_name = model_name.to_sym
+      if index == 1 && get_default_for(model_name)
+        get_default_for(model_name)
+      elsif index == 1
+        @data[model_name] ||= []
+        @data[model_name].reject{|e| has_invalid_parent?(e)}.first
+      else
+        @data[model_name] ||= []
+        @data[model_name][index.to_i-1]
+      end
+    end
+
+    def get_default_for(model)
+      @bounding_models[model] || @current_default[model] || nil
+    end
+
+    def has_invalid_parent?(model)
+      @bounding_models.each do |k,v|
+        return true if (model.respond_to?(k) && model.send(k) != v)
+      end
+      false
+    end
+  end
+end

data/lib/tasks/bless.rake

@@ -0,0 +1,6 @@
+namespace :data_works do
+  desc "tell data_works that the model relationships are accurate"
+  task :bless => :environment do
+    DataWorks::StaleRelationshipChecker.create_snapshot!
+  end
+end

data/spec/adding_records_spec.rb

@@ -0,0 +1,118 @@
+require_relative "helper/data_works_spec_helper"
+
+describe TheDataWorks do
+  let!(:data) { TheDataWorks.new }
+
+  describe 'adding a record with no necessary parents' do
+    describe "add_pet" do
+      it 'creates a Pet record' do
+        expect { data.add_pet }.to change(Pet, :count).by(1)
+      end
+    end
+
+    describe 'with factory traits' do
+      let(:put_a_bird_on_it) { data.add_pet_bird }
+
+      describe "add_pet_bird" do
+        it 'creates a Pet record' do
+          expect { put_a_bird_on_it }.to change(Pet, :count).by(1)
+        end
+        it 'creates a record with the required trait' do
+          the_bird = put_a_bird_on_it
+          expect( the_bird.kind ).to eq 'Bird'
+        end
+      end
+    end
+  end
+
+  describe 'adding a record with one necessary parent' do
+    describe 'add_pet_sitter' do
+      it 'creates a PetSitter record' do
+        expect { data.add_pet_sitter }.to change(PetSitter, :count).by(1)
+      end
+      it 'creates an Agency record' do
+        expect { data.add_pet_sitter }.to change(Agency, :count).by(1)
+      end
+    end
+
+    describe 'with factory traits' do
+      describe 'on the child model' do
+        let(:da_hoomans_toy) { data.add_hooman_toy }
+
+        describe "add_hooman_toy" do
+            it 'creates a Pet record' do # As it still should
+            expect { da_hoomans_toy }.to change(Pet, :count).by(1)
+            end
+            it 'creates a record with the required trait' do
+            robo_vac = da_hoomans_toy
+            expect( robo_vac.kind ).to eq 'Robot Vacuum' # add the correct trait
+            end
+        end
+      end
+
+      describe 'on the child and parent models' do
+        let(:a_tiny_bell) { data.add_bell_toy }
+
+        describe "add_bell_toy" do
+            it 'creates a Pet record' do # As it still should
+            expect { a_tiny_bell }.to change(Pet, :count).by(1)
+            end
+            it 'creates a record with the required trait on both models' do
+            the_bell = a_tiny_bell
+            the_bird = data.the_pet_bird
+            expect( the_bell.kind ).to eq 'Bell' # add the correct trait
+            expect( the_bird.kind ).to eq 'Bird' # add the correct trait
+            end
+        end
+      end
+    end
+  end
+
+  describe 'adding a record with multiple necessary parents' do
+    describe 'add_pet_sitting_patronage' do
+      it 'creates a PetSittingPatronage record' do
+        expect { data.add_pet_sitting_patronage }.to change(PetSittingPatronage, :count).by(1)
+      end
+      it 'creates a Pet record' do
+        expect { data.add_pet_sitting_patronage }.to change(Pet, :count).by(1)
+      end
+      it 'creates a PetSitter record' do
+        expect { data.add_pet_sitting_patronage }.to change(PetSitter, :count).by(1)
+      end
+      it 'creates an Agency record' do # necessary for PetSitter
+        expect { data.add_pet_sitting_patronage }.to change(Agency, :count).by(1)
+      end
+    end
+  end
+
+  describe 'adding multiple records at once' do
+    describe 'add_pets(2)' do
+      it 'creates two Pet records' do
+        expect { data.add_pets(2) }.to change(Pet, :count).by(2)
+      end
+    end
+    describe 'add_pet_sitter(s)' do
+      it 'creates a PetSitter record' do
+        expect { data.add_pet_sitters(2) }.to change(PetSitter, :count).by(2)
+      end
+      it 'creates an Agency record' do
+        expect { data.add_pet_sitters(2) }.to change(Agency, :count).by(1)
+      end
+    end
+  end
+
+  describe 'adding a record with custom associations' do
+    describe 'add_picture' do
+      it 'creates a Picture record' do
+        expect { data.add_picture }.to change(Picture, :count).by(1)
+      end
+      it 'creates a Product record (polymorhpic)' do
+        expect { data.add_picture }.to change(Product, :count).by(1)
+      end
+      it 'creates an Album record (custom foreign key)' do
+        expect { data.add_picture }.to change(Album, :count).by(1)
+      end
+    end
+  end
+
+end

data/spec/factories/factories.rb

@@ -0,0 +1,78 @@
+require_relative '../lib/data_faker'
+
+FactoryGirl.define do
+  factory :pet do
+    name { fake_string }
+    kind { animal_types.sample }
+    birth_year { (1914..2014).to_a.sample }
+
+    trait :bird do
+      kind 'Bird'
+    end
+
+    factory :pet_bird, traits: [:bird]
+  end
+
+  factory :agency do
+    name { fake_string }
+  end
+
+  factory :address do
+    street { fake_string + %w(Street Avenue Lane Road).sample }
+    city   { fake_word.capitalize }
+    state  { fake_word.capitalize }
+  end
+
+  factory :pet_food do
+    name { "#{animal_types.sample} #{%w(Kibble Chow Food Munchies).sample}" }
+  end
+
+  factory :pet_profile do
+    description { "#{fake_string} #{fake_string} #{fake_string}" }
+  end
+
+  factory :pet_sitter do
+    name { fake_string }
+    kind { Kind.all.sample }
+  end
+
+  factory :pet_sitting_patronage do
+  end
+
+  factory :tag do
+    registered_name { fake_string }
+  end
+
+  factory :toy do
+    name { "#{%w(Fluffy Rubber Squeeky).sample} #{%w(Ball Stick Shoe Book).sample}" }
+
+    trait :hooman do
+      kind 'Robot Vacuum' # you know the one
+    end
+
+    trait :bell do
+      kind 'Bell'
+    end
+
+    factory :hooman_toy, traits: [:hooman]
+    factory :bell_toy, traits: [:bell]
+  end
+
+  factory :kind do
+    name { fake_word }
+  end
+
+  factory :picture do
+  end
+
+  factory :album do
+    name { fake_word }
+  end
+
+  factory :product do
+  end
+end
+
+def animal_types
+  %w(Cat Dog Ferret Moose Octopus)
+end