active_schema 0.1.0

data/lib/active_schema/associations/generator.rb

@@ -0,0 +1,25 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+module ActiveSchema
+  module Associations
+    class Generator
+      def initialize(from_table, to_table, column_name)
+        @from_table   = from_table
+        @to_table     = to_table
+        @column_name  = column_name
+      end
+
+      def generate
+        [ByForwardForeignKey, ByReverseForeignKey].each do |generators|
+          generators.new(@from_table.model,
+            @to_table.model,
+            @column_name,
+            @from_table.unique_index_on?(@column_name)).generate
+          
+        end
+      end
+
+    end
+  end
+end

data/lib/active_schema/configuration.rb

@@ -0,0 +1,20 @@
+module ActiveSchema
+  class Configuration
+    attr_accessor :feeder,
+      :skip_validation_for_column,
+      :skip_model
+
+    def initialize
+      self.feeder = OnTheFlyFeeder.new(self)
+      self.skip_validation_for_column = proc {|column|
+        column.name =~ /^(((created|updated)_(at|on))|position)$/
+      }
+      self.skip_model = proc {|model|
+        model == ::ActiveRecord::Base ||
+          (model.respond_to?(:abstract_class?) && model.abstract_class?)
+      }
+    end
+
+  end
+end
+

data/lib/active_schema/feeder.rb

@@ -0,0 +1,45 @@
+module ActiveSchema
+  class Feeder
+    attr_reader :associations_generator, :validations_generator, :table_hub
+    def initialize(configuration = ActiveSchema.configuration)
+      @table_hub = TableHub.new
+      @associations_generator = Associations::Generator
+      @validations_generator  = Validations::Generator
+      @configuration = configuration
+    end
+
+    def add_model(model)
+      table_hub.add_model(model)
+    end
+
+    def dispatch_attachments(model)
+      table = table_hub.tables[model.table_name]
+      generate_validations(table)
+      generate_assocations(table)
+    end
+
+    def generate_assocations(table)
+      table_hub.relations[table.model.table_name].select(&:model).each do |linked_table|
+        generate_associations_between(table, linked_table)
+      end
+    end
+
+    def generate_associations_between(table1, table2)
+      generate_directed_associations_between(table1, table2)
+      generate_directed_associations_between(table2, table1)
+    end
+
+    def generate_validations(table)
+      validations_generator.new(table, @configuration.skip_validation_for_column).generate
+    end
+
+    def generate_directed_associations_between(table1, table2)
+      table1.foreign_keys.each do |column, ref_table|
+        if ref_table == table2
+          associations_generator.new(table1, ref_table, column).generate
+        end
+      end
+    end
+
+  end
+end

data/lib/active_schema/in_advance_feeder.rb

@@ -0,0 +1,10 @@
+require 'active_schema/feeder'
+
+module ActiveSchema
+  class InAdvanceFeeder < Feeder
+    def model_loaded(model)
+      add_model(model)
+      dispatch_attachments(model)
+    end
+  end
+end

data/lib/active_schema/on_the_fly_feeder.rb

@@ -0,0 +1,26 @@
+require 'active_schema/feeder'
+
+module ActiveSchema
+  class OnTheFlyFeeder < Feeder
+    def model_loaded(model)
+      add_model(model)
+      add_indexes(model)
+      add_foreign_keys(model)
+      dispatch_attachments(model)
+    end
+
+    private
+    def add_indexes(model)
+      model.connection.indexes(model.table_name).each do |index|
+        table_hub.add_index(model.table_name, index)
+      end
+    end
+
+    def add_foreign_keys(model)
+      model.connection.foreign_keys(model.table_name).each do |fk|
+        table_hub.add_foreign_key(fk.from_table, fk.to_table, fk.options[:column])
+      end
+
+    end
+  end
+end

data/lib/active_schema/schema_feeder.rb

@@ -0,0 +1,41 @@
+require 'active_schema/in_advance_feeder'
+
+module ActiveSchema
+  class FilteredSchemaReader
+    def initialize(schema_feeder, schema)
+      @schema_feeder = schema_feeder
+      @schema = schema
+    end
+
+    def filtered_lines
+      @schema.split.grep /^\s*(add_index|add_foreign_key)/
+    end
+
+    def evaluate
+      @schema_feeder.instance_eval(filtered_lines*"\n")
+    end
+
+  end
+
+  class SchemaFeeder < InAdvanceFeeder
+    def add_index(table_name, column_name, options = {})
+      index = ::ActiveRecord::ConnectionAdapters::IndexDefinition\
+        .new(table_name, options[:name], options[:unique], Array(column_name), options[:lengths])
+      table_hub.add_index(table_name, index)
+    end
+
+    def add_foreign_key(from_table, to_table, options = {})
+      column = options[:column] ? options[:column] : "#{to_table.singularize}_id"
+      table_hub.add_foreign_key(from_table, to_table, column)
+    end
+
+    def read(schema)
+      FilteredSchemaReader.new(self, schema).evaluate
+    end
+
+    def feed
+      yield self
+    end
+
+  end
+end

data/lib/active_schema/table.rb

@@ -0,0 +1,30 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+module ActiveSchema
+  class Table
+    attr_accessor :name, :model, :foreign_keys, :indexes
+    def initialize(name, model = nil)
+      @name  = name
+      @model = model
+      @foreign_keys = {}
+      @indexes = []
+    end
+    
+    def add_foreign_key(column, dst_table)
+      @foreign_keys[column] = dst_table
+    end
+    
+    def add_index(index)
+      @indexes << index
+    end
+
+    def unique_index_on?(column)
+      @indexes.any? do |idx|
+        idx.columns.size == 1 &&
+          idx.columns.first == column &&
+          idx.unique
+      end
+    end
+
+  end
+end

data/lib/active_schema/table_hub.rb

@@ -0,0 +1,42 @@
+require 'set'
+
+module ActiveSchema
+  class TableHub
+    attr_accessor :tables, :relations
+    def initialize
+      @tables = {}
+      @relations = Hash.new {|h,k| h[k] = Set.new }
+    end
+
+    def add_foreign_key(from_table_name, to_table_name, column_name)
+      from_table = find_or_create_table(from_table_name)
+      to_table   = find_or_create_table(to_table_name)
+
+      add_relation(from_table, to_table)
+      from_table.add_foreign_key(column_name, to_table)
+    end
+
+    def add_index(table_name, index_def)
+      find_or_create_table(table_name).add_index(index_def)
+    end
+
+    def add_model(model)
+      find_or_create_table(model.table_name).model = model
+    end
+
+    private
+    def add_relation(from_table, to_table)
+      @relations[from_table.name] << to_table
+      @relations[to_table.name]   << from_table
+    end
+
+    def find_or_create_table(table_name)
+      if @tables.has_key?(table_name)
+        @tables[table_name]
+      else
+        @tables[table_name] = Table.new(table_name)
+      end
+    end
+
+  end
+end

data/lib/active_schema/validations/by_column.rb

@@ -0,0 +1,41 @@
+module ActiveSchema::Validations
+  class ByColumn < ValueGenerator
+    def initialize(model, column)
+      super(model)
+      @column = column
+    end
+
+    def validation(name, opts = {})
+      super(name, @column.name.to_sym, opts)
+    end
+
+  end
+
+  class ByDataType < ByColumn
+    def generate
+      if @column.type == :integer
+        validation :validates_numericality_of, {:allow_nil => true, :only_integer => true}
+      elsif @column.number?
+        validation :validates_numericality_of, {:allow_nil => true}
+      elsif @column.text? && @column.limit
+        validation :validates_length_of, {:allow_nil => true, :maximum => @column.limit}
+      elsif @column.type == :enum
+        # Support MySQL ENUM type as provided by the enum_column plugin
+        validation :validates_inclusion_of, :in => @column.limit
+      end
+    end
+  end
+
+  class ByNullability < ByColumn
+    def generate
+      if not @column.null
+        if @column.type == :boolean
+          validation :validates_inclusion_of, :in => [true, false]
+        else
+          validation :validates_presence_of
+        end
+      end
+    end
+  end
+
+end

data/lib/active_schema/validations/by_index.rb

@@ -0,0 +1,5 @@
+module ActiveSchema::Validations
+  class ByIndex < ValueGenerator
+
+  end
+end

data/lib/active_schema/validations/generator.rb

@@ -0,0 +1,45 @@
+module ActiveSchema::Validations
+  class ValueGenerator
+    def initialize(model)
+      @model = model
+    end
+
+    def validation(name, column, opts = {})
+      @model.send(name, column, opts)
+    end
+
+  end
+end
+
+require 'active_schema/validations/by_column'
+require 'active_schema/validations/by_index'
+
+module ActiveSchema::Validations
+  class Generator
+    def initialize(table, skip_validation_for_column)
+      @table = table
+      @model = table.model
+      @skip_validation_for_column = skip_validation_for_column
+    end
+
+    def generate
+      generate_for_columns
+      generate_for_indexes
+    end
+
+    def generate_for_columns
+      @model.columns.each do |column|
+        next if @skip_validation_for_column.call(column)
+        ByDataType.new(@model, column).generate
+        ByNullability.new(@model, column).generate
+      end
+    end
+
+    def generate_for_indexes
+      
+    end
+
+  end
+
+end
+

data/nbproject/project.properties

@@ -0,0 +1,7 @@
+file.reference.active_schema-lib=lib
+file.reference.active_schema-spec=spec
+main.file=
+platform.active=Ruby_0
+source.encoding=UTF-8
+src.dir=${file.reference.active_schema-lib}
+test.src.dir=${file.reference.active_schema-spec}

data/nbproject/project.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>active_schema</name>
+            <source-roots>
+                <root id="src.dir"/>
+            </source-roots>
+            <test-roots>
+                <root id="test.src.dir"/>
+            </test-roots>
+        </data>
+    </configuration>
+</project>

data/spec/.rspec

@@ -0,0 +1 @@
+--color

data/spec/active_schema/active_record/base_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'active_model/observing'
+
+describe "Integration" do
+  before do
+    @base_class = Class.new()
+    @base_class.send(:include, ActiveModel::Observing)
+    @base_class.extend(ActiveSchema::ActiveRecord::ClassMethods)
+    @base_class.send(:include, ActiveSchema::ActiveRecord::InstanceMethods)
+    @feeder = mock("Feeder").as_null_object
+    @base_class.active_schema_configuration.stub!(:feeder).and_return(@feeder)
+  end
+
+  it "responds to the active_schema method" do
+    @base_class.should respond_to(:active_schema)
+  end
+
+  context "activation" do
+    it "has a nil-valued class attribute active_schema_activated" do
+      @base_class.should respond_to(:active_schema_activated)
+      @base_class.active_schema_activated.should be_nil
+    end
+
+    it "should not bubble up the activation" do
+      sub_class = Class.new(@base_class)
+      sub_class.active_schema
+      @base_class.active_schema_activated.should be_nil
+    end
+
+    it "inherits activation in subclasses" do
+      sub_class = Class.new(@base_class)
+      sub_class.active_schema
+      below_sub_class = Class.new(sub_class)
+      below_sub_class.active_schema_activated.should be_true
+    end
+
+    it "does not overwrite activation or deactivation in subclasses" do
+      sub_class = Class.new(@base_class)
+      below_sub_class = Class.new(sub_class)
+      below_sub_class.active_schema_activated = false
+      sub_class.active_schema
+      below_sub_class.active_schema_activated.should be_false
+    end
+
+    it "allows independent subclass forks" do
+      sub_class1 = Class.new(@base_class)
+      sub_class2 = Class.new(@base_class)
+      sub_class1.active_schema
+      sub_class1.active_schema_activated.should be_true
+      sub_class2.active_schema_activated.should be_false
+    end
+  end
+
+  context "model loading" do
+    before do
+      @base_class.add_observer(ActiveRecord::ModelLoadedObserver.new)
+    end
+
+    it "loads model in directly activated class" do
+      @feeder.should_receive(:model_loaded).with(instance_of(Class))
+      sub_class = Class.new(@base_class)
+      sub_class.active_schema
+    end
+
+    it "loads model in superclass activated class" do
+      @feeder.should_receive(:model_loaded).with(instance_of(Class)).twice
+      @base_class.active_schema
+      sub_class = Class.new(@base_class)
+    end
+  end
+
+  context "observers" do
+    it "allows observers to be added" do
+      @base_class.should respond_to(:add_observer)
+    end
+
+    it "should call observers when subclassed" do
+      observer = mock("Observer")
+      observer.should_receive(:update).with(:observed_class_inherited, instance_of(Class))
+      @base_class.add_observer(observer)
+      Class.new(@base_class)
+    end
+  end
+end
+
+
+describe ActiveRecord::Base do
+  before do
+    @prisoner_model = prisoner_model
+    @facility_model = facility_model
+  end
+
+  it "should have the active_schema method" do
+    described_class.should respond_to(:active_schema)
+  end
+
+  it "should have a correct Configuration object attached" do
+    @prisoner_model.active_schema_configuration.should be_instance_of(ActiveSchema::Configuration)
+    @prisoner_model.active_schema_configuration.feeder.should be_instance_of(ActiveSchema::OnTheFlyFeeder)
+  end
+
+  it "should activate model" do
+    @prisoner_model.active_schema
+    @prisoner_model.active_schema_activated.should be_true
+  end
+
+  it "adds (some) validations" do
+    @prisoner_model.active_schema
+    @prisoner_model.validators_on(:name).should_not be_empty
+  end
+
+  it "adds (some) assocations" do
+    @prisoner_model.active_schema
+    @facility_model.active_schema
+    @prisoner_model.new.should respond_to(:facility)
+  end
+end