classy-inheritance 0.6.2 → 0.6.4

data/.gitignore

@@ -0,0 +1,7 @@
+*.DS_Store
+*.swp
+nbproject/**
+pkg/**
+doc/**
+email.txt
+test/database.sqlite3

data/Manifest.txt

@@ -1,26 +1,12 @@
 History.txt
 License.txt
 Manifest.txt
-PostInstall.txt
-README
 README.txt
 Rakefile
-config/hoe.rb
-config/requirements.rb
 lib/classy-inheritance.rb
-lib/classy-inheritance/version.rb
-script/console
-script/destroy
-script/generate
-script/txt2html
-setup.rb
-tasks/deployment.rake
-tasks/environment.rake
-tasks/website.rake
 test/test_classy-inheritance.rb
 test/test_helper.rb
-website/index.html
-website/index.txt
-website/javascripts/rounded_corners_lite.inc.js
-website/stylesheets/screen.css
-website/template.html.erb
+test/test_polymorphic_associations.rb
+test/test_with_optional_dependency.rb
+test/test_with_prefix_postfix.rb
+test/test_with_standard_attributes.rb

data/README.txt

@@ -1,32 +1,37 @@
-= classy-inheritance
-
-* FIX (url)
+classy-inheritance
+    by Andrew Stone
+    http://stonean.com
 
 == DESCRIPTION:
 
-FIX (describe your package)
-
-== FEATURES/PROBLEMS:
+Classy Inheritance adds a depends_on class method to your ActiveRecord model so that you can define requisite objects.
 
-* FIX (list of features or problems)
+This functionality is provided using the existing ActiveRecord methods without monkey patching any core code. Essentially, it provides an easy interface to generate code that anyone could add to their model to receive the same result. Depending on the parameters to your depends_on call, it may add some of the following methods: validates_presence_of, validates_associated, has_one or belongs_to.
 
 == SYNOPSIS:
 
-  FIX (code sample of usage)
+class User < ActiveRecord::Base
+  depends_on :profile, :attrs => [:first_name, :last_name, :email]
+end
 
-== REQUIREMENTS:
+# Pass-through methods to profile attributes.  Now you don't have to manage
+# two different objects.
+@user.first_name = 'Andrew'
+@user.last_name = 'Stone'
+@user.email = 'andy@stonean.com'
 
-* FIX (list of requirements)
+# Manages profile relationship for you
+@user.save
 
 == INSTALL:
 
-* FIX (sudo gem install, anything else)
+sudo gem install classy-inheritance
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2008 FIX
+Copyright (c) 2009 Andrew Stone
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -45,4 +50,4 @@ 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.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,4 +1,30 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
-
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require 'classy-inheritance'
+
+task :default => 'spec:run'
+
+PROJ.name = 'classy-inheritance'
+PROJ.authors = 'Andrew Stone'
+PROJ.email = 'andy@stonean.com'
+PROJ.url = 'http://stonean.com/wiki/classy-inheritance'
+PROJ.version = Stonean::ClassyInheritance::VERSION
+PROJ.rubyforge.name = 'classyinherit'
+
+PROJ.spec.opts << '--color'
+
+# EOF

data/lib/classy-inheritance.rb

@@ -1,28 +1,10 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-
-module ActiveRecord::Validations::ClassMethods
-  def validates_associated(*attr_names)
-    configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save }
-    configuration.update(attr_names.extract_options!)
-
-    validates_each(attr_names, configuration) do |record, attr_name, value|
-      associate = record.send(attr_name)
-      if associate && !associate.valid?
-        associate.errors.each do |key, value|
-          record.errors.add(key, value)
-        end
-      end
-    end
-  end
-end
-                                  
 
 module Stonean
   module ClassyInheritance
-    def self.included(base)
-      base.extend Stonean::ClassyInheritance::ClassMethods
+    VERSION = '0.6.4'
+
+    def self.version
+      VERSION
     end
 
     module ClassMethods
@@ -40,10 +22,10 @@ module Stonean
 
         if options.has_key?(:validates_associated_if) && options[:validates_associated_if] != true
           if [Symbol, String, Proc].include?(options[:validates_associated_if].class)
-            validates_associated model_sym, :if => options[:validates_associated_if]
+            validates_associated_dependent model_sym, options, :if => options[:validates_associated_if]
           end
         else
-          validates_associated model_sym
+          validates_associated_dependent model_sym, options 
         end
 
         # Before save functionality to create/update the requisite object
@@ -53,7 +35,7 @@ module Stonean
         define_find_with_method(model_sym)
 
         if options[:as]
-          define_can_be_method_on_requisite_class(options[:class_name] || model_sym, options[:as])
+          define_can_be_method_on_requisite_class(options[:class_name] || model_sym.to_s.classify, options[:as])
         end
 
         options[:attrs].each{|attr| define_accessors(model_sym, attr, options)}
@@ -175,11 +157,11 @@ module Stonean
       end
 
       def define_can_be_method_on_requisite_class(model_sym, polymorphic_name)
-        klass = model_sym.to_s.classify
+        klass = model_sym.to_s
         requisite_klass = eval(klass)
         unless requisite_klass.respond_to?(self.name.underscore.to_sym)
           requisite_klass.send :can_be, self.name.underscore, 
-                                      :as => polymorphic_name 
+            :as => polymorphic_name 
         end
       end
 
@@ -190,4 +172,32 @@ module Stonean
     end # ClassMethods
   end # ClassyInheritance module
 end # Stonean module
-ActiveRecord::Base.send :include, Stonean::ClassyInheritance
+
+if Object.const_defined?("ActiveRecord") && ActiveRecord.const_defined?("Base")
+  module ActiveRecord::Validations::ClassMethods
+
+    def validates_associated_dependent(model_sym, options, configuration = {})
+      configuration = { :message => I18n.translate('activerecord.errors.messages.invalid'), :on => :save }.update(configuration)
+
+      validates_each(model_sym, configuration) do |record, attr_name, value|
+        associate = record.send(attr_name)
+        if associate && !associate.valid?
+          associate.errors.each do |key, value|
+            if options[:prefix]
+              key = (options[:prefix] == true) ? "#{model_sym}_#{key}" : "#{options[:prefix]}_#{key}"
+            end
+            if options[:postfix]
+              key = (options[:postfix] == true) ? "#{key}_#{model_sym}" : "#{key}_#{options[:postfix]}"
+            end
+            record.errors.add(key, value) unless record.errors[key]
+          end
+        end
+      end
+    end
+  end
+                                    
+
+  ActiveRecord::Base.class_eval do
+    extend Stonean::ClassyInheritance::ClassMethods
+  end
+end

data/tasks/ann.rake

@@ -0,0 +1,80 @@
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF

data/tasks/gem.rake

@@ -0,0 +1,201 @@
+
+require 'find'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+module Bones
+class GemPackageTask < Rake::PackageTask
+  # Ruby GEM spec containing the metadata for this package.  The
+  # name, version and package_files are automatically determined
+  # from the GEM spec and don't need to be explicitly provided.
+  #
+  attr_accessor :gem_spec
+
+  # Tasks from the Bones gem directory
+  attr_reader :bones_files
+
+  # Create a GEM Package task library.  Automatically define the gem
+  # if a block is given.  If no block is supplied, then +define+
+  # needs to be called to define the task.
+  #
+  def initialize(gem_spec)
+    init(gem_spec)
+    yield self if block_given?
+    define if block_given?
+  end
+
+  # Initialization tasks without the "yield self" or define
+  # operations.
+  #
+  def init(gem)
+    super(gem.name, gem.version)
+    @gem_spec = gem
+    @package_files += gem_spec.files if gem_spec.files
+    @bones_files = []
+
+    local_setup = File.join(Dir.pwd, %w[tasks setup.rb])
+    if !test(?e, local_setup)
+      Dir.glob(::Bones.path(%w[lib bones tasks *])).each {|fn| bones_files << fn}
+    end
+  end
+
+  # Create the Rake tasks and actions specified by this
+  # GemPackageTask.  (+define+ is automatically called if a block is
+  # given to +new+).
+  #
+  def define
+    super
+    task :prereqs
+    task :package => ['gem:prereqs', "#{package_dir_path}/#{gem_file}"]
+    file "#{package_dir_path}/#{gem_file}" => [package_dir_path] + package_files + bones_files do
+      when_writing("Creating GEM") {
+        chdir(package_dir_path) do
+          Gem::Builder.new(gem_spec).build
+          verbose(true) {
+            mv gem_file, "../#{gem_file}"
+          }
+        end
+      }
+    end
+
+    file package_dir_path => bones_files do
+      mkdir_p package_dir rescue nil
+
+      gem_spec.files = (gem_spec.files +
+          bones_files.map {|fn| File.join('tasks', File.basename(fn))}).sort
+
+      bones_files.each do |fn|
+        base_fn = File.join('tasks', File.basename(fn))
+        f = File.join(package_dir_path, base_fn)
+        fdir = File.dirname(f)
+        mkdir_p(fdir) if !File.exist?(fdir)
+        if File.directory?(fn)
+          mkdir_p(f)
+        else
+          raise "file name conflict for '#{base_fn}' (conflicts with '#{fn}')" if test(?e, f)
+          safe_ln(fn, f)
+        end
+      end
+    end
+  end
+  
+  def gem_file
+    if @gem_spec.platform == Gem::Platform::RUBY
+      "#{package_name}.gem"
+    else
+      "#{package_name}-#{@gem_spec.platform}.gem"
+    end
+  end
+end  # class GemPackageTask
+end  # module Bones
+
+namespace :gem do
+
+  PROJ.gem._spec = Gem::Specification.new do |s|
+    s.name = PROJ.name
+    s.version = PROJ.version
+    s.summary = PROJ.summary
+    s.authors = Array(PROJ.authors)
+    s.email = PROJ.email
+    s.homepage = Array(PROJ.url).first
+    s.rubyforge_project = PROJ.rubyforge.name
+
+    s.description = PROJ.description
+
+    PROJ.gem.dependencies.each do |dep|
+      s.add_dependency(*dep)
+    end
+
+    PROJ.gem.development_dependencies.each do |dep|
+      s.add_development_dependency(*dep)
+    end
+
+    s.files = PROJ.gem.files
+    s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+    s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
+
+    s.bindir = 'bin'
+    dirs = Dir["{#{PROJ.libs.join(',')}}"]
+    s.require_paths = dirs unless dirs.empty?
+
+    incl = Regexp.new(PROJ.rdoc.include.join('|'))
+    excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+    excl = Regexp.new(excl.join('|'))
+    rdoc_files = PROJ.gem.files.find_all do |fn|
+                   case fn
+                   when excl; false
+                   when incl; true
+                   else false end
+                 end
+    s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
+    s.extra_rdoc_files = rdoc_files
+    s.has_rdoc = true
+
+    if test ?f, PROJ.test.file
+      s.test_file = PROJ.test.file
+    else
+      s.test_files = PROJ.test.files.to_a
+    end
+
+    # Do any extra stuff the user wants
+    PROJ.gem.extras.each do |msg, val|
+      case val
+      when Proc
+        val.call(s.send(msg))
+      else
+        s.send "#{msg}=", val
+      end
+    end
+  end  # Gem::Specification.new
+
+  Bones::GemPackageTask.new(PROJ.gem._spec) do |pkg|
+    pkg.need_tar = PROJ.gem.need_tar
+    pkg.need_zip = PROJ.gem.need_zip
+  end
+
+  desc 'Show information about the gem'
+  task :debug => 'gem:prereqs' do
+    puts PROJ.gem._spec.to_ruby
+  end
+
+  desc 'Write the gemspec '
+  task :spec => 'gem:prereqs' do
+    File.open("#{PROJ.name}.gemspec", 'w') do |f|
+      f.write PROJ.gem._spec.to_ruby
+    end
+  end
+
+  desc 'Install the gem'
+  task :install => [:clobber, 'gem:package'] do
+    sh "#{SUDO} #{GEM} install --local pkg/#{PROJ.gem._spec.full_name}"
+
+    # use this version of the command for rubygems > 1.0.0
+    #sh "#{SUDO} #{GEM} install --no-update-sources pkg/#{PROJ.gem._spec.full_name}"
+  end
+
+  desc 'Uninstall the gem'
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PROJ.name)
+    if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+      sh "#{SUDO} #{GEM} uninstall --version '#{PROJ.version}' --ignore-dependencies --executables #{PROJ.name}"
+    end
+  end
+
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
+  desc 'Cleanup the gem'
+  task :cleanup do
+    sh "#{SUDO} #{GEM} cleanup #{PROJ.gem._spec.name}"
+  end
+end  # namespace :gem
+
+
+desc 'Alias to gem:package'
+task :gem => 'gem:package'
+
+task :clobber => 'gem:clobber_package'
+remove_desc_for_task 'gem:clobber_package'
+
+# EOF