schemaker 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

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

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# gem "activerecord", ">= 3.0.1"
+
+group :development do
+  gem "activerecord", ">= 3.0.1"
+  gem "rspec",        ">= 2.6.0"
+  gem "bundler",      "~> 1.0.6"
+  gem "jeweler",      "~> 1.6.2"
+  gem "rcov",         ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Kristian Mandrup
+
+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.textile

@@ -0,0 +1,49 @@
+h1. Schemaker
+
+This is the *Schema Maker* also known as the *schemaker*. This gem can help configure your model relationships for 3 models, the subject, the join and the object model.
+Typically when you add some behavior field to a subject (fx a UserAccount model class), this may require a 1-M or M-M relationship to the object of that relationship.
+With _ActiveRecord_ this can require a join model or just a symmetrical _:has_and_belongs_to_many_. If you apply Schemaker, it will handle all this magic for you!
+
+Schemaker is intended for use when creating gems that require somewhat complex model relationships for adding behavior. It does the "heavy lifting" on this part of the work.
+There will likely be adapters for other data stores too, to simplify ensuring that your gem can support and store the relationships correctly for these data stores.
+
+h2. Install
+
+Gemfile:
+
+@gem 'schemaker@
+
+@$ bundle@
+
+h2. Usage
+
+Create a complex Many-to-Many join through the join model
+
+<pre>require 'schemaker'  
+  
+models = Schemaker::Models.new UserAccount, Role, UsersRoles, :subject_key => :troles
+models.configure</pre>
+
+Create a "quick join" (a symmetrical :has_and_belongs_to_many for the subject and object model)
+
+@models.subject_model.quick_join@
+
+Create a :has_one to relationship from the subject to the object
+
+@models.subject_model.create_has_one :object@
+
+h2. Contributing to schemaker
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+h2. Copyright
+
+Copyright (c) 2011 Kristian Mandrup. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+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 = "schemaker"
+  gem.homepage = "http://github.com/kristianmandrup/schemaker"
+  gem.license = "MIT"
+  gem.summary = %Q{Schema maker takes care of configuring your model schemas to map behavior}
+  gem.description = %Q{Configures relationships between subject, join and object model for a given behavior}
+  gem.email = "kmandrup@gmail.com"
+  gem.authors = ["Kristian Mandrup"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "schemaker #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/schemaker/models/base_model.rb

@@ -0,0 +1,204 @@
+# 
+# @author Kristian Mandrup
+#
+# Basic Model configuration functionality
+# 
+# Each type of model to be configured shares some common functionality and state, that is encapsulated here for reuse
+#
+module Schemaker
+  class BaseModel
+    attr_accessor :models, :my_class
+    attr_reader :logs # can be used to later check which relationships were set up        
+
+    # @param [Schema::Models] each model needs to have access to the collection of models it may need to create relations with
+    # @param [Class] each model must have a reference to the Class it aims to configure!
+    def initialize models, my_class
+      raise ArgumentError, "The first argument must be a Schema::Models instance" if !models.is_a?(Schemaker::Models)
+      raise ArgumentError, "The second argument must be the Class that is to be configured" if !my_class.is_a?(Class)
+
+      @models   = models     
+      @my_class = my_class 
+      @logs = []         
+    end
+
+    # The models :subject and :object must both be configured 
+    # with a has_many relationship to the join model which the has_many :through references
+    def configure
+      create_has_many :join, class_name_option(join_class)
+    end
+
+    # The class name of the Class to be configured
+    # @return [String] class name
+    def clazz_name
+      my_class.to_s
+    end
+    alias_method :my_class_name, :clazz_name
+
+    def self.model_types
+      [:object, :subject, :join]
+    end
+
+    # Generate convenience methods for: :object, :subject, :join
+    # - object_model
+    # - object_class
+    # - object_class_name
+
+    model_types.each do |model_type|
+      class_eval %{
+        def #{model_type}_model
+          models.#{model_type}_model
+        end
+
+        def #{model_type}_class
+          models.#{model_type}_class
+        end
+
+        def #{model_type}_class_name
+          #{model_type}_class.clazz_name
+        end            
+      }
+    end
+    
+    protected
+
+    # Is global logging turned on 
+    def log_on?
+      Schemaker.log_on?
+    end
+
+    # Create a 'belongs_to' relationship on the model (Class)
+    # Example:
+    #   Role.belongs_to :user, :class_name => 'User'
+    def create_belongs_to clazz, options = {}
+      make_relationship :belongs_to, clazz, options.merge(:key => singular_key(clazz))
+    end
+
+    # Create a 'has_many' relationship on the model (Class)
+    # Example:
+    #   User.has_many :roles, :class_name => 'Role'
+    def create_has_many clazz, options = {} 
+      make_relationship :has_many, clazz, options
+    end        
+
+    # Create a 'has_many' relationship on the model (Class)
+    # Example:
+    #   User.has_one :roles, :class_name => 'Role'
+    def create_has_one clazz, options = {} 
+      make_relationship :has_one, clazz, options.merge(:key => singular_key(clazz))
+    end        
+
+    # Create a 'has_many :through' relationship on the model (Class)
+    # Example:
+    #   User.has_many :roles, :class_name => 'Role', :through => 'UsersRoles'
+    def create_has_many_through clazz, options = {}
+      create_has_many clazz, through_options(options)
+    end
+
+    # To setup symmetrical has_and_belongs_to_many relationship:
+    #
+    # Example:
+    #
+    #   class UserAccount < ActiveRecord::Base    
+    #     has_and_belongs_to_many :troles, :class_name => 'Role'
+    #   end
+    #   
+    #   class Role < ActiveRecord::Base    
+    #     has_and_belongs_to_many :user_accounts, :class_name => 'User'
+    #   end
+    #
+    def has_and_belongs_many to_clazz, options = {}
+      make_relationship :has_and_belongs_to_many, to_clazz, options[:from]
+      to_clazz.make_relationship :has_and_belongs_to_many, my_class, options[:to]
+    end
+
+    # Creates a given type of relationship
+    # @param [Symbol] the type of relationship, fx :has_many
+    # @param [Class, Symbol] the Class that is the object of the relationship, fx Role for a User.has_many relationship
+    # @param [Hash] any extra relationship options, fx for a :through relationship, or to indicate :class_name etc.        
+    def make_relationship relationship_name, clazz, options = {} 
+      key_name = options.delete(:key) || key(clazz)          
+
+      opts_str = options.empty? ? '' : options.inspect.insert(0, ', ').gsub(/[{}]/ , '')
+      log "#{my_class_name}.#{relationship_name} :#{key_name}#{opts_str}" if log_on?          
+
+      return my_class.send(relationship_name, key_name) if options.empty?
+
+      my_class.send(relationship_name, key_name, options)
+    end              
+
+    # creates a key for a given type
+    # @param type [Symbol] - either :object, :subject or :join
+    def key type
+      models.key type
+    end                
+
+    def get_class type
+      models.get_class type          
+    end
+
+    def singular_key cls_name
+      model = get_class(cls_name)
+      model.to_s.singularize.underscore
+    end
+
+    def make_key cls_name
+      models.make_key cls_name
+    end
+
+    # log the relationship being added
+    # - to STDOUT via puts
+    # - to a logs list
+    def log msg
+      puts msg
+      logs << msg          
+    end        
+
+    # sets up the :source relationship option, typically for a has_many through relationship
+    def source_option cls_name
+      model = get_class(cls_name)
+      {:source => source(model) }
+    end
+
+    # sets up the :class_name relationship option for a given class (model
+    # @param [Class, String] the class to point to
+    def class_name_option cls_name
+      model = get_class(cls_name)
+      {:class_name => model.to_s }
+    end
+
+    # sets up the :through relationship option, always points to the join model 
+    def through_option 
+      {:through => join_model.through_key }
+    end
+
+    # sets up the :foreign_key relationship option
+    # the foreign key name should always correspond to 'my own' class name
+    def foreign_key_option cls_name
+      model = get_class(cls_name)
+      {:foreign_key => foreign_key(model) }
+    end
+
+    # sets up the full :through relationship options
+    # Example:
+    #   :class_name => 'Role', :through => 'UsersRoles', :source => :role, :foreign_key => :user_id)
+    def through_options cls_name
+      model = get_class(cls_name)
+      through_option.merge(source_option model).merge(class_name_option model)
+    end
+
+    # creates the source
+    # Role becomes :role
+    def source cls_name
+      model = get_class(cls_name)
+      model.to_s.underscore.singularize.to_sym
+    end                        
+
+    # creates the foreign key
+    # RefManyAccount becomes :account_id
+    def foreign_key cls_name
+      model = get_class(cls_name)
+      name = model.to_s.underscore.split('_').last.singularize
+      :"#{name}_id"
+    end                           
+  end
+end

data/lib/schemaker/models/join_model.rb

@@ -0,0 +1,40 @@
+# 
+# @author Kristian Mandrup
+#
+# Model configuration of the Join model (fx UsersRoles)
+# 
+# Knows how to configure the Join model between a subject model (the main target of the behavior fx UserAccount) and the object model (the behavior to be added, fx Role) 
+#
+module Schemaker
+  class JoinModel < BaseModel
+
+    # @param [Schema::Models] each model needs to have access to the collection of models it may need to create relations with
+    # @param [Class] reference to the Class it aims to configure!
+    def initialize models, clazz
+      super
+    end
+
+    def simple_key
+      clazz_name.to_s.underscore
+    end
+
+    def through_key
+      make_key clazz_name
+    end
+
+    # The join model always belongs to both the object and subject model
+    # the subject and object model can then each have a has_many relationship to the join model
+    # thus creating a Many-to-Many relationship via the join model
+    
+    # Example:
+    #   UsersRoles
+    #     belongs_to :user, :class_name => 'UserAccount' (subject)             
+    #     belongs_to :role, :class_name => 'Role' (object)
+    #
+    # @note Do not call super here! 
+    def configure          
+      create_belongs_to :subject, class_name_option(:subject)
+      create_belongs_to :object, class_name_option(:object)
+    end                
+  end
+end

data/lib/schemaker/models/object_model.rb

@@ -0,0 +1,33 @@
+# 
+# @author Kristian Mandrup
+#
+# Model configuration of the Object model (fx Role)
+# 
+# Knows how to configure the relationship fro the Object model to the subject model via the Join model
+#
+module Schemaker
+  class ObjectModel < BaseModel
+
+    # @param [Schema::Models] each model needs to have access to the collection of models it may need to create relations with
+    # @param [Class] reference to the Class it aims to configure!
+    def initialize models, clazz
+      super          
+    end
+
+    # Configures has_many through relationship via Join model for the object model (fx Role)
+    #
+    # Example:
+    #   Role (object)
+    #     has_many :accounts,   :class_name => 'RefManyAccount', :through => :accounts_roles (subject)
+    #     has_many :user_roles, :class_name => 'UserRole' (join)
+    def configure         
+      super
+      create_has_many_through :subject
+    end
+
+    # @note important to use super to avoid recursive stack overflow!
+    def through_options options = {}
+      options.merge super(:subject)
+    end           
+  end
+end

data/lib/schemaker/models/subject_model.rb

@@ -0,0 +1,41 @@
+# 
+# @author Kristian Mandrup
+#
+# Model configuration of the Subject model (fx Role)
+# 
+# Knows how to configure the relationship fro the Object model to the subject model via the Join model
+#
+module Schemaker
+  class SubjectModel < BaseModel
+
+    # the main field for the behavior to add, fx :troles for adding roles behavior
+    attr_accessor :main_field
+
+    # @param [Schema::Models] each model needs to have access to the collection of models it may need to create relations with
+    # @param [Class] reference to the Class it aims to configure!
+    # @param [Symbol] the name of the main field for the behavior to add, fx :troles for adding roles behavior
+    def initialize models, clazz, main_field
+      super models, clazz
+      @main_field = main_field
+    end
+
+    # Used to set up a 'quick join' using Rails conventions and 'has_and_belongs_to_many' on the subject and object 
+    def quick_join options = {}
+      create_has_and_belongs_to_many :object
+    end
+
+    # Example:
+    #   UserAccount (subject)        
+    #     has_many :user_roles, :class_name => 'UserRole' (join)
+    #     has_many :roles,      :class_name => 'Role', :through => :users_roles (subject)        
+    def configure 
+      super
+      create_has_many_through :object, :key => main_field          
+    end  
+
+    # @note important to use super to avoid recursive stack overflow!                
+    def through_options options = {}
+      options.merge super(:object).merge(foreign_key_option :subject)
+    end                       
+  end
+end

data/lib/schemaker/models.rb

@@ -0,0 +1,109 @@
+# 
+# @author Kristian Mandrup
+#
+# Model configuration
+# Has responsibiloity to configure relationships between all models
+# A single behavior decoration can have up to three acting models in a joined relationship
+
+# The subject model: 
+# - is the model which is the subject of the behavior added.
+# - it has the main field, which CAN be a relationship to the object model, either directly or via a join model (fx in Relational DBs)
+# 
+# The object model: 
+# - is the object of interest to the subject, fx a Role model is the object of interest for a UserAccount (subject)
+# - the object can be referenced directly, via a join model or embedded under the subject
+#
+# The join model: 
+# - is used to bind object to subject in a Many-to-Many relationship, typically for Relational DBs
+# - it must have a foreign key for both object and subject model, and most often no primary key of its own
+
+module Schemaker  
+  class Models
+    attr_accessor :subject_model, :object_model, :join_model
+
+    # Sets up the models that take part in the model relationship to be configured
+    # @param subject_class [Class]
+    # @param object_class [Class]
+    # @param join_class [Class]        
+    # @param options [Hash] - contains the key to be used for the main field (subject key) and possibly other options to configure the models more precisely as needed 
+    def initialize subject_class, object_class, join_class, options = {}
+      @subject_model  = SubjectModel.new self, subject_class, options[:subject_key]
+      @object_model   = ObjectModel.new self, object_class
+      @join_model     = JoinModel.new self, join_class
+    end
+
+    # creates a key for a given type
+    # @param type [Symbol] - either :object, :subject or :join
+    def key type
+      make_key get_class(type)
+    end                
+
+    # configure each model in turn
+    def configure
+      [subject_model, object_model, join_model].each do
+        |model| model.configure
+      end  
+    end
+
+    def logs
+      @logs ||= [subject_model, object_model, join_model].inject([]) do |res, model|
+        res << model.logs
+        res
+      end.flatten
+    end
+
+    def self.model_types
+      [:object, :subject, :join]
+    end
+
+    # generate methods:
+    # - object_class
+    # - subject_class
+    # - join_class
+    model_types.each do |model_type|
+      class_eval %{
+        def #{model_type}_class
+          #{model_type}_model.clazz_name              
+        end
+      }
+    end
+                               
+    # retrieves a given Class ie. a type of model
+    # @param [Class, String, Symbol, BaseModel] which class to get
+    # @return [Class] the Class (model) of interest
+    def get_class type
+      case type
+      when Class
+        type
+      when BaseModel
+        type.my_class
+      when String, Symbol
+        return get_class send("#{type}_model") if [:subject, :object, :join].include?(type.to_sym)
+        type.to_s.constantize
+      else
+        raise "Can't determine a class from: #{type}"
+      end          
+    end
+
+    # creates a key from a class name
+    # fx UsersRoles becomes :user_roles, where only the last part is pluralised! 
+    # @param [String] the class name
+    def make_key class_name
+      name = class_name.to_s.pluralize.gsub(/::/, '__').underscore
+      only_last_part_plural(name).to_sym
+    end                               
+
+    protected
+
+    # Takes a composite name and makes a nice sounding key that follows the Rails conventions
+    # fx UsersRoles becomes :user_roles, where only the last part is pluralised!
+    # @param [String] the class name, fx UsersRoles
+    def only_last_part_plural cls_name 
+      parts = cls_name.split('_')
+      name = parts.inject([]) do |res, part|
+        res << (part != parts.last ? part.singularize : part)
+        res
+      end.join('_')          
+    end                
+  end
+end

data/lib/schemaker.rb

@@ -0,0 +1,14 @@
+module Schemaker
+  class << self
+    attr_accessor :log_on
+    
+    alias_method :log_on?, :log_on
+  end
+    
+  autoload :Models, 'schemaker/models'
+  
+  autoload :BaseModel,    'schemaker/models/base_model'
+  autoload :JoinModel,    'schemaker/models/join_model'
+  autoload :ObjectModel,  'schemaker/models/object_model'
+  autoload :SubjectModel, 'schemaker/models/subject_model'  
+end

data/schemaker.gemspec

@@ -0,0 +1,71 @@
+# 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 = %q{schemaker}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Kristian Mandrup}]
+  s.date = %q{2011-06-12}
+  s.description = %q{Configures relationships between subject, join and object model for a given behavior}
+  s.email = %q{kmandrup@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.textile"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.textile",
+    "Rakefile",
+    "VERSION",
+    "lib/schemaker.rb",
+    "lib/schemaker/models.rb",
+    "lib/schemaker/models/base_model.rb",
+    "lib/schemaker/models/join_model.rb",
+    "lib/schemaker/models/object_model.rb",
+    "lib/schemaker/models/subject_model.rb",
+    "schemaker.gemspec",
+    "spec/models_helper.rb",
+    "spec/schemaker/model/join_spec.rb",
+    "spec/schemaker/model/object_spec.rb",
+    "spec/schemaker/model/subject_spec.rb",
+    "spec/schemaker/models_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kristianmandrup/schemaker}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{Schema maker takes care of configuring your model schemas to map behavior}
+
+  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_development_dependency(%q<activerecord>, [">= 3.0.1"])
+      s.add_development_dependency(%q<rspec>, [">= 2.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.6"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 3.0.1"])
+      s.add_dependency(%q<rspec>, [">= 2.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.6"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 3.0.1"])
+    s.add_dependency(%q<rspec>, [">= 2.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.6"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/models_helper.rb

@@ -0,0 +1,53 @@
+require 'rspec'
+require 'active_record'
+require 'schemaker'
+
+Schemaker.log_on = true
+
+class UserAccount < ActiveRecord::Base  
+end
+
+class Role < ActiveRecord::Base  
+end
+
+class UsersRoles < ActiveRecord::Base  
+end
+
+def join_class
+  UsersRoles
+end
+
+def object_class
+  Role
+end
+
+def subject_class
+  UserAccount
+end
+
+def logs_matches logs, str
+  logs.any? {|log| match? log, str }
+end
+
+def matches log, str
+  log.should match(str) # /#{Regexp.escape(str)}/
+end
+
+def match? log, str
+  log =~ /#{Regexp.escape(str)}/
+end
+
+
+def matches_all log, *strings
+  strings.each {|str| match? log, str}
+end
+
+
+def models_class
+  Schemaker::Models
+end
+
+
+def models
+  @models ||= models_class.new subject_class, object_class, join_class, :subject_key => :troles
+end

data/spec/schemaker/model/join_spec.rb

@@ -0,0 +1,27 @@
+require 'models_helper'
+
+class UsersRoles < ActiveRecord::Base  
+end
+
+def join_model_class
+  Schemaker::JoinModel
+end
+
+describe join_model_class do
+  let(:join_model) do
+    join_model_class.new models, UsersRoles
+  end
+  
+  describe '#configure' do
+    it 'should configure join model' do
+      join_model.configure
+
+      # check the logs!
+      last_log  = join_model.logs.last 
+      first_log = join_model.logs.first 
+
+      matches_all first_log, 'belongs_to :user_account', ':class_name=>"UserAccount"'
+      matches_all last_log, 'belongs_to :role', ':class_name=>"Role"'
+    end
+  end
+end

data/spec/schemaker/model/object_spec.rb

@@ -0,0 +1,24 @@
+require 'models_helper'
+
+def object_model_class
+  Schemaker::ObjectModel
+end
+
+describe object_model_class do
+  let(:object_model) do
+    object_model_class.new models, Role
+  end
+  
+  describe '#configure' do
+    it 'should configure object model' do
+      object_model.configure
+
+      # check the logs!
+      last_log  = object_model.logs.last 
+      first_log = object_model.logs.first 
+
+      matches_all first_log, 'has_many :user_roles', ':class_name=>"UsersRoles"'
+      matches_all last_log, 'Role.has_many :user_accounts', ':through=>:user_roles', ':source=>:user_account', ':class_name=>"UserAccount"'
+    end        
+  end
+end

data/spec/schemaker/model/subject_spec.rb

@@ -0,0 +1,25 @@
+require 'troles/common/config/schema/models_helper'
+
+def subject_model_class
+  Schemaker::SubjectModel
+end
+
+describe subject_model_class do
+  let(:subject_model) do
+    subject_model_class.new models, UserAccount, :troles
+  end
+  
+  describe '#configure' do
+    it 'should configure subject model' do
+      subject_model.configure
+
+      # check the logs!
+      last_log  = subject_model.logs.last 
+      first_log = subject_model.logs.first 
+
+      matches_all first_log, 'has_many :user_roles', ':class_name=>"UsersRoles"'
+      # has_many :roles, {:through=>:user_roles, :source=>:role, :class_name=>"Role", :foreign_key=>:account_id}
+      matches_all last_log, 'UserAccount.has_many :troles', ':through=>:user_roles', ':source=>:role', ':class_name=>"Role"', ':foreign_key=>:account_id'
+    end        
+  end
+end

data/spec/schemaker/models_spec.rb

@@ -0,0 +1,16 @@
+require 'models_helper'
+
+describe models_class do
+  let(:models) do
+    # subject, object, join
+    models_class.new UserAccount, Role, UsersRoles, :subject_key => :troles
+  end
+
+  describe '#configure' do
+    it 'should configure all models' do
+      models.configure      
+      
+      logs_matches(models.logs, 'UserAccount.has_many :troles').should
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'schemaker'
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: schemaker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Kristian Mandrup
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-06-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2156091260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :development
+  prerelease: false
+  version_requirements: *2156091260
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156086680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156086680
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2156085240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :development
+  prerelease: false
+  version_requirements: *2156085240
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2156084180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: *2156084180
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &2156081880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156081880
+description: Configures relationships between subject, join and object model for a
+  given behavior
+email: kmandrup@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.textile
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.textile
+- Rakefile
+- VERSION
+- lib/schemaker.rb
+- lib/schemaker/models.rb
+- lib/schemaker/models/base_model.rb
+- lib/schemaker/models/join_model.rb
+- lib/schemaker/models/object_model.rb
+- lib/schemaker/models/subject_model.rb
+- schemaker.gemspec
+- spec/models_helper.rb
+- spec/schemaker/model/join_spec.rb
+- spec/schemaker/model/object_spec.rb
+- spec/schemaker/model/subject_spec.rb
+- spec/schemaker/models_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/kristianmandrup/schemaker
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -374026981416273501
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Schema maker takes care of configuring your model schemas to map behavior
+test_files: []