annotate models with associations

dseverin () — Sat, 03 May 2008 11:05:17 GMT

slightly modified http://repo.pragprog.com/svn/Public/plugins/annotate_models/lib/annotate_models.rb to include short declarations for model associations.



require "config/environment"



MODEL_DIR   = File.join(RAILS_ROOT, "app/models")

FIXTURE_DIR = File.join(RAILS_ROOT, "test/fixtures")



module AnnotateModels



  PREFIX = "== Schema Information"

  

  # Simple quoting for the default column value

  def self.quote(value)

    case value

      when NilClass                 then "NULL"

      when TrueClass                then "TRUE"

      when FalseClass               then "FALSE"

      when Float, Fixnum, Bignum    then value.to_s

      # BigDecimals need to be output in a non-normalized form and quoted.

      when BigDecimal               then value.to_s('F')

      else

        value.inspect

    end

  end



  # Use the column information in an ActiveRecord class

  # to create a comment block containing a line for

  # each column. The line contains the column name,

  # the type (and length), and any optional attributes

  def self.get_schema_info(klass, header)

    info = "# == Model #{klass}\n# #{header}\n#\n"

    info << "# Table name: #{klass.table_name}\n#\n"

    

    max_size = klass.column_names.collect{|name| name.size}.max + 1

    klass.columns.each do |col|

      attrs = []

      attrs << "default(#{quote(col.default)})" if col.default

      attrs << "not null" unless col.null

      attrs << "primary key" if col.name == klass.primary_key



      col_type = col.type.to_s

      if col_type == "decimal"

        col_type << "(#{col.precision}, #{col.scale})"

      else

        col_type << "(#{col.limit})" if col.limit

      end 

      info << sprintf("#  %-#{max_size}.#{max_size}s:%-15.15s %s\n", col.name, col_type, attrs.join(", "))

    end

    assoc_list = klass.reflect_on_all_associations.sort {|x,y| d = x.class_name.to_s <=> y.class_name.to_s; c = d == 0 ? x.macro.to_s <=> y.macro.to_s : d; c == 0 ? x.name.to_s <=> y.name.to_s : c }

    unless assoc_list.empty?

      info << "#\n# == Associations\n" 

      assoc_list.each do |assoc|

        ao = assoc.options.dup

        ao.delete(:class_name)

        line = "# * " +sprintf("%-25s :%-25s (%s) %s", assoc.macro, assoc.name, assoc.class_name, ao.empty? ? '' : ao.inspect)

        info << line << "\n"

      end 

    end

    info << "#\n\n"

  end



  # Add a schema block to a file. If the file already contains

  # a schema info block (a comment starting

  # with "Schema as of ..."), remove it first.



  def self.annotate_one_file(file_name, info_block)

    if File.exist?(file_name)

      content = File.read(file_name)



      # Remove old schema info

      content.sub!(/^# #{PREFIX}.*?\n(#.*\n)*\n/, '')



      # Write it back

      File.open(file_name, "w") { |f| f.puts info_block + content }

    end

  end

  

  # Given the name of an ActiveRecord class, create a schema

  # info block (basically a comment containing information

  # on the columns and their types) and put it at the front

  # of the model and fixture source files.



  def self.annotate(klass, header)

    info = get_schema_info(klass, header)

    

    model_file_name = File.join(MODEL_DIR, klass.name.underscore + ".rb")

    annotate_one_file(model_file_name, info)



    fixture_file_name = File.join(FIXTURE_DIR, klass.table_name + ".yml")

    annotate_one_file(fixture_file_name, info)

  end



  # Return a list of the model files to annotate. If we have 

  # command line arguments, they're assumed to be either

  # the underscore or CamelCase versions of model names.

  # Otherwise we take all the model files in the 

  # app/models directory.

  def self.get_model_names

    models = ARGV.dup

    models.shift

    

    if models.empty?

      Dir.chdir(MODEL_DIR) do 

        models = Dir["**/*.rb"]

      end

    end

    models

  end



  # We're passed a name of things that might be 

  # ActiveRecord models. If we can find the class, and

  # if its a subclass of ActiveRecord::Base,

  # then pas it to the associated block



  def self.do_annotations

    header = PREFIX.dup

    version = ActiveRecord::Migrator.current_version rescue 0

    if version > 0

      header << "\n# Schema version: #{version}"

    end

    

    self.get_model_names.each do |m|

      class_name = m.sub(/\.rb$/,'').camelize

      begin

        klass = class_name.split('::').inject(Object){ |klass,part| klass.const_get(part) }

        if klass < ActiveRecord::Base && !klass.abstract_class?

          puts "Annotating #{class_name}"

          self.annotate(klass, header)

        else

          puts "Skipping #{class_name}"

        end

      rescue Exception => e

        puts "Unable to annotate #{class_name}: #{e.message}"

      end

      

    end

  end

end

PgProc - call PostgreSQL functions from Rails app

dseverin () — Thu, 22 Dec 2005 18:52:12 GMT



# Just for fun and horror: make database functions a part of your Rails model! :)

#

# Class to access to PostgreSQL functions. Returned value depends on params and query result, see below.

#

# Currently supported options are:

#     :order => '1 desc' # to add order clause

#     :use_from => true  # to add "* from" for non-model function queries, which return records

#     :all => true       # to return not first but all found models

#     :cast => string    # to cast result (useful for functions, returning +setof record+)

#

# Call-patterns:

#

# A) Model loading from functions that return setof system known rowtype

#     PgProc.function(ModelClass[, options])

#         PgProc.get_descendants(ContentNode, 123)

#

#     PgProc.function(ModelClass, value[, options ])

#         PgProc.get_children(ContentNode, 123, :order => 'position', :all => true)

#

# returns either:

# * empty array if nothing found

# * first found model object, if found only one and +:all+ option is not set

# * array of model objects

#

# B) Values from functions

#

# PgProc.function(:type_symbol, value, [type_symbol2, value2, ...[, options]]) - for explicit parameter typecast

#     PgProc.array_append(:"int[]", '{1,2,3,4}', :int, 5) # => {1,2,3,4,5}

#

# PgProc.function(*args [, options])

#     PgProc.generate_series(1,10,2, :order => '1 desc') # => [9,5,7,3,2,1]

#

# PgProc.function() - for functions w/o params

#     PgProc.now()

#

# returns either:

# * empty string for +void+ functions

# * single value, if resultset has 1x1 dimension

# * array of values if resultset has Nx1 dimension (N>1)

# * array of rows otherwise

#

# Throws PGError, if function doesn't exist or wrong params supplied



class PgProc < ActiveRecord::Base

    set_table_name 'pg_catalog.pg_proc'

    set_primary_key 'oid'

    def readonly?

      true

    end



private

    def self.method_missing(meth_sym, *args)

      func_name = meth_sym.id2name

      super unless find(:first, :conditions => ['proname = ?', func_name])

      if ! args.empty? && args.last.is_a?(Hash)

        options = args.pop

        order_str = " ORDER BY #{options[:order]}" if options[:order]

      else

        options = {}

        order_str = nil

      end

      from_str = " * FROM " if options[:use_from]

      if args.empty?

        temp = connection.query("select #{from_str} #{func_name}() #{options[:cast]} #{order_str}")

      elsif args.first.is_a?(Class)

        model_klass = args.shift

        if args.length == 0

          temp = model_klass.find_by_sql("select * from  #{func_name}()  #{options[:cast]} #{order_str}")

        else

          temp = model_klass.find_by_sql("select * from  #{func_name}(#{quote_bound_value(args)})  #{options[:cast]} #{order_str}")

        end

        return temp if options[:all]

        return temp.length == 1 ? temp.first : temp

      else

          if args.length % 2 == 0 && args.first.is_a?(Symbol)

            temp = connection.query("select #{from_str} #{func_name}(#{quote_bound_value_types(args)}) #{options[:cast]} #{order_str}")

          else

            temp = connection.query("select #{from_str} #{func_name}(#{quote_bound_value(args)})  #{options[:cast]} #{order_str}")

          end

      end

      return temp.first.first if temp.length == 1 && temp.first.length == 1

      return temp.flatten if temp.length > 1 && temp.first.length == 1

      return temp

    end

    def self.quote_bound_value_types(value)

      i = true

      value.partition {|v| i = !i }.transpose.map{|v| "#{connection.quote(v[0])}::#{v[1]}"}.join(',')

    end

end

DZone Snippets: rails code

annotate models with associations

PgProc - call PostgreSQL functions from Rails app