rumbly 0.1.0

data/lib/rumbly/diagram/base.rb

@@ -0,0 +1,47 @@
+require 'active_support/core_ext/string/inflections'
+
+module Rumbly
+  module Diagram
+    
+    # This is an abstract class that defines the API for creating UML class diagrams.
+    # Implementations for specific formats (e.g. Yumly, Graphviz, text, etc.) should
+    # subclass this class and implement the following methods: +setup+,
+    # +process_klass+, +middle+, +process_relationship+, and +finish+.
+    class Base
+      
+      class << self
+        
+        # Creates a specific subclass of this base diagram class based on the diagram
+        # type specific in the global options, then calls its +#build+ method to create
+        # and save the UML class diagram.
+        def create (application)
+          diagram_type = Rumbly::options.diagram.type
+          require "rumbly/diagram/#{diagram_type}"
+          Rumbly::Diagram.const_get(diagram_type.to_s.classify).new(application).build
+        end
+        
+      end
+      
+      attr_reader :application
+      
+      def initialize (application)
+        @application = application
+      end
+
+      # Builds a UML class diagram via the callbacks defined for this base class.
+      def build
+        setup
+        @application.klasses.each do |klass|
+          process_klass(klass)
+        end
+        middle
+        @application.relationships.each do |relationship|
+          process_relationship(relationship)
+        end
+        finish
+      end
+    
+    end
+    
+  end
+end

data/lib/rumbly/diagram/debug.rb

@@ -0,0 +1,37 @@
+require 'rumbly/diagram/base'
+
+module Rumbly
+  module Diagram
+    
+    class Debug < Base
+      
+      def setup
+        puts "Application: #{application.name}"
+        puts
+        puts "Classes:"
+        puts
+      end
+      
+      def process_klass (klass)
+        puts "  #{klass.name}"
+        klass.attributes.each { |a| puts "    #{a.label}" }
+        puts
+      end
+      
+      def middle
+        puts "Relationships:"
+        puts
+      end
+      
+      def process_relationship (relationship)
+        puts "    #{relationship.label}"
+      end
+      
+      def finish
+        puts
+      end
+      
+    end
+    
+  end
+end

data/lib/rumbly/diagram/graphviz.rb

@@ -0,0 +1,44 @@
+require 'rumbly/diagram/base'
+require 'active_support/core_ext/module/delegation'
+require 'graphviz'
+
+module Rumbly
+  module Diagram
+    
+    class Graphviz < Base
+
+      attr_reader :graph
+      
+      delegate :add_nodes, :add_edges, :get_node, :output, to: :graph
+      
+      def setup
+        @graph = GraphViz.digraph(@application.name)
+        @graph.node[:shape] = :record
+        @graph.node[:fontsize] = 10
+        @graph.node[:fontname] = 'Arial'
+      end
+      
+      def process_klass (k)
+        add_nodes(k.name)
+      end
+      
+      def middle
+      end
+      
+      def process_relationship (r)
+        add_edges(find(r.source), find(r.target))
+      end
+      
+      def find (klass)
+        get_node(klass.name)
+      end
+      
+      def finish
+        d = Rumbly::options.diagram
+        output(d.format => "#{d.file}.#{d.format}")
+      end
+      
+    end
+    
+  end
+end

data/lib/rumbly/model/abstract.rb

@@ -0,0 +1,24 @@
+module Rumbly
+  module Model
+    
+    # The +Abstract+ module is extended (not included) by abstract subclasses that
+    # declare their public attributes and wish to have stub methods for these attributes
+    # generated automatically. The stub methods raise an exception with the abstract
+    # class name so implementers know that they need to implement the given method(s) in
+    # their concrete subclass(es).
+    module Abstract
+      
+      # Creates stub accesor methods for each of the given +attributes+. Each method
+      # raises a +RuntimeError+, since the extending class is meant to be abstract.
+      def stub_required_methods (cls, attributes)
+        attributes.keys.each do |a|
+          message = "Method '%s' called on abstract '#{cls.name}' class"
+          define_method(a) { raise (message % a) }
+          define_method("#{a}=") { |x| raise (message % "#{a}=") }
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rumbly/model/active_record/application.rb

@@ -0,0 +1,42 @@
+require 'rumbly/model/application'
+require 'rumbly/model/active_record/klass'
+require 'rumbly/model/active_record/relationship'
+
+module Rumbly
+  module Model
+    module ActiveRecord
+      
+      # This class is an +ActiveRecord+-specific implementation of the abstract
+      # +Rumbly::Model::Application+ class for representing model classes and
+      # relationships within the currently loaded environment.
+      class Application < Rumbly::Model::Application
+        
+        attr_reader :name, :klasses, :relationships
+        
+        # Returns the name of the current +ActiveRecord+ application.
+        def name
+          @name ||= Rails.application.class.parent.name
+        end
+        
+        # Returns an array of all +Rumbly::Model::ActiveRecord::Klass+ objects for the
+        # current loaded +ActiveRecord+ environment.
+        def klasses
+          if @klasses.nil?
+            # build the klass list in two steps to avoid infinite loop in second call
+            @klasses  = Klass.all_from_base_descendents(self)
+            @klasses += Klass.all_from_polymorphic_associations(self)
+          end
+          @klasses
+        end
+
+        # Returns an array of +Rumbly::Model::ActiveRecord::Relationship+ objects for
+        # the currently loaded +ActiveRecord+ environment.
+        def relationships
+          @relationships ||= Relationship.all_from_active_record(self)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rumbly/model/active_record/attribute.rb

@@ -0,0 +1,157 @@
+require 'rumbly/model/attribute'
+
+module Rumbly
+  module Model
+    module ActiveRecord
+      
+      # This class is an +ActiveRecord+-specific implementation of the abstract
+      # +Rumbly::Model::Attribute+ class use dto represent declared attributes (columns)
+      # on model classes in the currently loaded environment.
+      class Attribute < Rumbly::Model::Attribute
+
+        # Returns an array of +Rumbly::Model::ActiveRecord::Attribute+ objects, each
+        # of which wraps a field (column) from the given +ActiveRecord+ model class.
+        def self.all_from_klass (klass)
+          klass.cls.columns.map do |column|
+            new(klass, column)
+          end
+        end
+
+        def initialize (klass, column)
+          @klass = klass
+          @cls = klass.cls
+          @column = column
+        end
+        
+        # Returns the name of this +ActiveRecord+ attribute based on the column
+        # definition.
+        def name
+          @name ||= @column.name
+        end
+
+        # Returns the type of this +ActiveRecord+ attribute based on the column
+        # definition.
+        def type
+          @type ||= begin
+            type = @column.type.to_s
+            unless @column.limit.nil?
+              type += "(#{@column.limit})"
+            end
+            unless @column.precision.nil? || @column.scale.nil?
+              type += "(#{@column.precision},#{@column.scale})"
+            end
+            type
+          end
+        end
+
+        # Returns +nil+ since +ActiveRecord+ doesn't declare attribute visibility.
+        def visibility
+          nil
+        end
+        
+        # Returns +nil+ since +ActiveRecord+ doesn't allow for non-intrinsic attributes.
+        def multiplicity
+          nil
+        end
+        
+        # Returns this attribute's default value based on +ActiveRecord+ column definition.
+        def default
+          @default ||= @column.default
+        end
+        
+        # Returns +nil+ since +ActiveRecord+ doesn't support any of the standard UML
+        # attribute properties (e.g. read-only, union, composite, etc.).
+        def properties
+          []
+        end
+
+        # Returns an +Array+ of +String+ values representing constraints placed on this
+        # attribute via +ActiveModel+ validations. Only simple, declarative validations
+        # will be reflected as constraints (i.e. not conditional or custom
+        # validations). Also, some parameters or conditions on simple validations will
+        # not be shown, e.g. scope or case-sensitivity on a uniqueness validation.
+        # Currently, the following +ActiveModel+ validations are ignored: +inclusion+,
+        # +exclusion+, +format+, and any conditional validations.
+        def constraints
+          @constraints ||= begin
+            constraints = []
+            constraints << 'required' if required?
+            constraints << 'unique' if unique?
+            append_numeric_constraints(constraints)
+            append_length_constraints(constraints)
+            constraints
+          end
+        end
+
+        # Returns +nil+ since +ActiveRecord+ doesn't declare derived attributes.
+        def derived
+          nil
+        end
+
+        # Returns +nil+ since +ActiveRecord+ doesn't declare static (class) attributes.
+        def static
+          nil
+        end
+        
+        private
+        
+        def required?
+          @cls.validators_on(name).map(&:kind).include?(:presence)
+        end
+        
+        def unique?
+          @cls.validators_on(name).map(&:kind).include?(:uniqueness)
+        end
+        
+        NUMERIC_VALIDATORS = [
+          [ :integer_only,             'integer' ],
+          [ :odd,                      'odd'     ],
+          [ :even,                     'even'    ],
+          [ :greater_than,             '> %{x}'  ],
+          [ :greater_than_or_equal_to, '>= %{x}' ],
+          [ :equal_to,                 '= %{x}'  ],
+          [ :less_than,                '< %{x}'  ],
+          [ :less_than_or_equal_to,    '<= %{x}' ],
+        ]
+        
+        # Appends any numeric constraints on this +ActiveRecord+ attribute via one or
+        # more +numericality+ validations.
+        def append_numeric_constraints (constraints)
+          validators = @cls.validators_on(name).select { |v| v.kind == :numericality }
+          unless validators.nil? || validators.empty?
+            options = validators.map { |v| v.options }.inject { |all,v| all.merge(v) }
+            NUMERIC_VALIDATORS.each do |validator|
+              key, str = validator
+              if options.has_key?(key)
+                constraints << str.gsub(/x/,key.to_s) % options
+              end
+            end
+          end
+        end
+
+        # Appends any length constraints put on this +ActiveRecord+ attribute via one
+        # or more +length+ validations.
+        def append_length_constraints (constraints)
+          validators = @cls.validators_on(name).select { |v| v.kind == :length }
+          unless validators.nil? || validators.empty?
+            options = validators.map { |v| v.options }.inject { |all,v| all.merge(v) }
+            constraints << case
+            when options.has_key?(:is)
+              "length = #{options[:is]}"
+            when options.has_key?(:in)
+              "length in (#{options[:in]})"
+            when options.has_key?(:minimum) && options.has_key?(:maximum)
+              "#{options[:minimum]} <= length <= #{options[:maximum]}"
+            when options.has_key?(:minimum)
+              "length >= #{options[:minimum]}"
+            when options.has_key?(:maximum)
+              "length <= #{options[:maximum]}"
+            end
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rumbly/model/active_record/klass.rb

@@ -0,0 +1,99 @@
+require 'active_record'
+require 'rumbly/model/klass'
+require 'rumbly/model/active_record/attribute'
+
+module Rumbly
+  module Model
+    module ActiveRecord
+
+      # This class is an +ActiveRecord+-specific implementation of the abstract
+      # +Rumbly::Model::Klass+ class used to represent model classes within the currently
+      # loaded environment. All model class, both persistent and abstract, are modeled
+      # as +Klass+ objects. Also, "virtual" classes (more like interfaces) that are named
+      # as part of any polymorphic associations are also modeled as +Klass+es. These
+      # objects have a name but no underlying +ActiveRecord+ model class.
+      class Klass < Rumbly::Model::Klass
+        
+        class << self
+
+          # Returns an array of +Klass+ objects representing +ActiveRecord+ model classes
+          # (be they persistent or abstract) in the currently loaded environment.
+          def all_from_base_descendents (app)
+            ::ActiveRecord::Base.descendants.select do
+              |cls| class_valid?(cls) 
+            end.map { |cls| new(app, cls) }
+          end
+        
+          # Returns an array of +Klass+ objects representing "virtual" classes that are
+          # named as part of any polymorphic associations. These virtual classes are more
+          # like interfaces, but we model them as +Klasses+ for the purposes of showing
+          # them in a UML class diagram.
+          def all_from_polymorphic_associations (app)
+            Relationship.associations_matching(app, :belongs_to, :polymorphic).map do |a|
+              new(app, nil, a.name)
+            end
+          end
+
+          private
+
+          # A class is valid if it is abstract or concrete with a corresponding table.
+          def class_valid? (cls)
+            cls.abstract_class? || cls.table_exists?
+          end
+        
+        end
+        
+        # Initializes a new +Klass+ from the given +ActiveModel+ model class. Keeps
+        # a back pointer to the top-level +Application+ object. For "virtual" classes
+        # (see above), the +cls+ will be nil and the +name+ will be explicitly given.
+        def initialize (app, cls, name=nil)
+          @app = app
+          @cls = cls
+          @name = name
+        end
+        
+        # Returns the +ActiveRecord+ model class associated with this +Klass+. Should
+        # only be used by other +Rumbly::Model::ActiveRecord+ classes (but no way in
+        # Ruby to enforce that). May be nil if this is a "virtual" class (see above).
+        def cls
+          @cls
+        end
+        
+        # Returns the name of this +Rumbly::Model::ActiveRecord::Klass+.
+        def name
+          @name ||= @cls.name
+        end
+        
+        # Returns an array of +Rumbly::Model::ActiveRecord::Attributes+, each of which
+        # describes an attribute of the +ActiveRecord+ class for this +Klass+. Don't
+        # bother to lookup attributes if this +Klass+ represents an abstract model class
+        # or is a "virtual" class (interface) stemming from a polymorphic association.
+        def attributes
+          @attributes ||= if @cls.nil? or self.abstract?
+            []
+          else
+            Attribute.all_from_klass(self)
+          end
+        end
+        
+        # Returns nil, since +ActiveRecord+ models don't declare their operations.
+        def operations
+          nil
+        end
+        
+        # Returns +true+ if this +Rumbly::Model::ActiveRecord::Klass+ is abstract.
+        def abstract
+          @abstract ||= (@cls.nil? ? false : @cls.abstract_class?)
+        end
+        
+        # Returns +true+ if this +Rumbly::Model::ActiveRecord::Klass+ is a "virtual"
+        # class, i.e. one stemming from a polymorphic association (more like an interface).
+        def virtual
+          @virtual ||= @cls.nil?
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rumbly/model/active_record/relationship.rb

@@ -0,0 +1,166 @@
+require 'rumbly/model/relationship'
+
+module Rumbly
+  module Model
+    module ActiveRecord
+
+      # This class is an +ActiveRecord+-specific implementation of the abstract
+      # +Rumbly::Model::Relationship+ class used to represent declared relationships
+      # (associations) between model classes in the currently loaded environment.
+      class Relationship < Rumbly::Model::Relationship
+        
+        # Returns an array of +Rumbly::Model::ActiveRecord::Relationship+ objects that
+        # represent both associations and generalizations (i.e. subclasses) in the
+        # currently loaded +ActiveRecord+ environment.
+        def self.all_from_active_record (app)
+          all_from_assocations(app) + all_from_generalizations(app)
+        end
+
+        # Returns an array of +Rumbly::Model::ActiveRecord::Relationship+ objects that
+        # represent declared associations between model classes.
+        def self.all_from_assocations (app)
+          all_associations(app).map { |a| new(app, a) }
+        end
+
+        # Returns an array of +Rumbly::Model::ActiveRecord::Relationship+ objects that
+        # represent all subclass relationships between model classes.
+        def self.all_from_generalizations (app)
+          app.klasses.map(&:cls).compact.reject(&:descends_from_active_record?).map do |c|
+            source = c.superclass.name
+            target = c.name
+            new(app, nil, :generalization, source, target)
+          end
+        end
+
+        # Returns an +Array+ of +ActiveRecord+ associations which match the given +type+
+        # and have the given +option+, e.g. +:belongs_to+ and +:polymorphic+.
+        def self.associations_matching (app, type, option)
+          all_associations(app).select { |a| a.macro == type }.select do |a|
+            a.options.keys.include?(option)
+          end
+        end
+        
+        # Returns all +ActiveRecord+ associations for all model classes in the currently
+        # loaded environment.
+        def self.all_associations (app)
+          app.klasses.map(&:cls).compact.map(&:reflect_on_all_associations).flatten
+        end
+
+        # Initializes a new +Relationship+ using the given +ActiveModel+ +association+
+        # (in the case of non-generalizations), or the given +type+, +source+, and
+        # +target+ in the case of generalizations.
+        def initialize (app, association, type=nil, source=nil, target=nil)
+          @app = app
+          @association = association
+          @type = type
+          @source = source
+          @target = target
+        end
+
+        # Returns the UML relationship type for this +Relationship+. For a relationships
+        # that's a generalization (subclass), the +type+ is set upon initialization.
+        # Otherwise, this method examines the +ActiveRecord+ association for clues that
+        # point to the relationship being a simple +association+, an +aggregation+, or
+        # the even stronger +composition+.
+        def type
+          if @type.nil?
+            # relationships are simple associations by default
+            @type = :association
+            if [:has_one, :has_many].include?(@association.macro)
+              autosaves = @association.options[:autosave]
+              dependent = @association.options[:dependent]
+              # if this association auto-saves or nullifies, assume aggregation
+              if autosaves || dependent == :nullify
+                @type = :aggregation
+              end
+              # if this association destroys dependents, assume composition
+              if dependent == :destroy || dependent == :delete
+                @type = :composition
+              end
+            end
+          end
+          return @type
+        end
+
+        # Returns the source +Klass+ for this +Relationship+. Gets the +ActiveRecord+
+        # model class that's the source of the underlying association and looks up
+        # the corresponding +Klass+ object in our cache.
+        def source
+          @source ||= @app.klass_by_name(@association.active_record.name)
+        end
+        
+        # Returns the target +Klass+ for this +Relationship+. Gets the +ActiveRecord+
+        # model class that's the target of the underlying association and looks up
+        # the corresponding +Klass+ object in our cache.
+        def target
+          @target ||= @app.klass_by_name(@association.klass.name)
+        end
+
+        # Returns the name of this +Relationship+, which is just the +name+ from the
+        # +ActiveRecord+ association (or nil if this +Relationship+ doesn't have an
+        # association, i.e. it's a generalization).
+        def name
+          (type == :generalization) ? nil : (@name ||= @association.name)
+        end
+        
+        # Returns the multiplicity of this +Relationship+ based on the type of the
+        # +ActiveRecord+ association, e.g. +:has_one+, +:has_many+, +:belongs_to+, etc.
+        def multiplicity
+          (type == :generalization) ? nil : (@multiplicity ||= derive_multiplicity)
+        end
+        
+        # Returns the "through" class declared 
+        def through
+          (type == :generalization) ? nil : (@through ||= find_through_klass)
+        end
+
+        # Returns true, since +ActiveRecord+ doesn't have the concept of non-navigable
+        # assocations.
+        def navigable
+          true
+        end
+        
+        private
+
+        # Returns an array of two numbers that represents the multiplicity of this
+        # +Relationship+ based on the type of +ActiveRecord+ association it is.
+        def derive_multiplicity
+          case @association.macro
+          when :has_one
+            # has_one associations can have zero or one associated object
+            [0,1]
+          when :has_many, :has_and_belongs_to_many
+            # has_many and habtm associations can have zero or more associated objects
+            [0,::Rumbly::Model::N]
+          when :belongs_to
+            # belongs_to associations normally have zero or one related object, but
+            # we check for a presence validator to see if the link is required
+            validators = source.cls.validators_on(@association.foreign_key.to_sym)
+            if validators.select { |v| v.kind == :presence }.any?
+              [1,1]
+            else
+              [0,1]
+            end
+          end
+        end
+
+        # Finds the +Klass+ object corresponding to the "through" class on the has_one
+        # or has_many association for this +Relationship+.
+        def find_through_klass
+          unless @through_checked
+            @through_checked = true
+            if [:has_one, :has_many].include?(@association.macro)
+              through = @association.options[:through]
+              unless through.nil?
+                return @app.klass_by_name(through)
+              end
+            end
+          end
+          return nil
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rumbly/model/application.rb

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/string/inflections'
+require 'rumbly/model/abstract'
+
+module Rumbly
+  module Model
+    
+    N = Infinity = 1.0/0
+
+    # This is an abstract class that represents the full model of a MVC application,
+    # including all classes and relationships. Object mapper-specific implementations
+    # should subclass this class and implement the following methods: +name+,
+    # +klasses+, and +relationships+.
+    class Application
+      
+      # Attributes and default values of an Application
+      ATTRIBUTES = { name: '', klasses: [], relationships: [] }
+
+      # For each attribute, create stub accessor methods that raise an exception
+      extend Abstract
+      stub_required_methods(Application, ATTRIBUTES)
+      
+      class << self
+        
+        # Creates a new subclass of +Rumbly::Model::Application+ based on the options
+        # set in the main +Rumbly+ module (via rake, command line, etc.). If the
+        # model_type+ option is set to +auto+, the current object mapper library is
+        # auto-detected.
+        def create
+          model_type = auto_detect_model_type
+          require "rumbly/model/#{model_type}/application"
+          Rumbly::Model.const_get(model_type.to_s.classify)::Application.new
+        end
+        
+        private
+        
+        OBJECT_MAPPERS = [ :active_record, :data_mapper, :mongoid, :mongo_mapper ]
+        
+        # Auto-detects the current object mapper gem/library if one isn't specified in
+        # the global +Rumbly::options+ hash.
+        def auto_detect_model_type
+          model_type = Rumbly::options.model.type
+          if model_type == :auto
+            model_type = OBJECT_MAPPERS.detect do |mapper|
+              Class.const_defined?(mapper.to_s.classify)
+            end
+            raise "Couldn't auto-detect object mapper gem/library" if model_type.nil?
+          end
+          model_type.to_s
+        end
+        
+      end
+      
+      # Returns a +Klass+ object from our cache indexed by +name+.
+      def klass_by_name (name)
+        klass_cache[name]
+      end
+      
+      private
+      
+      def klass_cache
+        @klass_cache ||= {}.tap do |cache|
+          klasses.each do |klass|
+            cache[klass.name] = klass
+          end
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/rumbly/model/attribute.rb

@@ -0,0 +1,63 @@
+require 'rumbly/model/abstract'
+
+module Rumbly
+  module Model
+
+    # This is an abstract class that represents a single attribute of one class within
+    # an MVC application. Object mapper-specific implementations should subclass this
+    # class and implement the following methods: +name+, +type+, +visibility+,
+    # +multiplicity+, +default+, +properties+, +constraints+, +derived+, and +static+.
+    class Attribute
+
+      # Attributes and default values of an Attribute
+      ATTRIBUTES = {
+        name: '', type: '', visibility: '', multiplicity: '', default: '',
+        properties: [], constraints: [], derived: false, static: false
+      }
+
+      # For each attribute, create stub accessor methods that raise an exception
+      extend Abstract
+      stub_required_methods(Attribute, ATTRIBUTES)
+      
+      # Simple question mark-style wrapper for the +Attribute#derived+ attribute.
+      def derived?
+        derived
+      end
+
+      # Simple question mark-style wrapper for the +Attribute#static+ attribute.
+      def static?
+        static
+      end
+
+      # Compares +Attribute+ objects using the +name+ attribute.
+      def <=> (other)
+        name <=> other.name
+      end
+
+      # Returns a string that fully describes this +Attribute+, including its visibility,
+      # name, type, multiplicity, default value, and any properties and/or constraints.
+      def label
+        label  = "#{symbol_for_visibility} "
+        label += "/" if derived?
+        label += "#{name}"
+        label += " : #{type}" unless type.nil?
+        label += "[#{multiplicity}]" unless multiplicity.nil?
+        label += " = #{default}" unless default.nil?
+        label += " {#{props_and_constraints}}" unless props_and_constraints.empty?
+        label
+      end
+
+      private
+      
+      VISIBILITY_SYMBOLS = { public: '+', private: '-', protected: '#', package: '~' }
+      def symbol_for_visibility
+        VISIBILITY_SYMBOLS[visibility] || '-'
+      end
+      
+      def props_and_constraints
+        (properties + constraints).join(', ')
+      end
+      
+    end
+  end
+end

data/lib/rumbly/model/klass.rb

@@ -0,0 +1,38 @@
+require 'rumbly/model/abstract'
+
+module Rumbly
+  module Model
+
+    # This is an abstract class that represents a single model class within an MVC
+    # application. Object mapper-specific implementations should subclass this class and
+    # implement the following methods: +name+, +attributes+, +operations+, +abstract+,
+    # and +virtual+.
+    class Klass
+
+      # Attributes and default values of a Klass
+      ATTRIBUTES = {
+        name: '', attributes: [], operations: [], abstract: false, virtual: false
+      }
+      
+      # For each attribute, create stub accessor methods that raise an exception
+      extend Abstract
+      stub_required_methods(Klass, ATTRIBUTES)
+      
+      # Simple question mark-style wrapper for the +Klass#abstract+ attribute.
+      def abstract?
+        abstract
+      end
+      
+      # Simple question mark-style wrapper for the +Klass#virtual+ attribute.
+      def virtual?
+        virtual
+      end
+
+      # Compares +Klass+ objects using the +name+ attribute.
+      def <=> (other)
+        name <=> other.name
+      end
+      
+    end    
+  end
+end

data/lib/rumbly/model/operation.rb

@@ -0,0 +1,25 @@
+require 'rumbly/model/abstract'
+
+module Rumbly
+  module Model
+
+    # This is an abstract class that represents a single operation from one class within
+    # an MVC application. Object mapper-specific implementations should subclass this
+    # class and implement the following methods: +name+, +parameters+, and +type+.
+    class Operation
+
+      # Attributes and default values of a Operation
+      ATTRIBUTES = { name: '', parameters: [], type: 'void' }
+      
+      # For each attribute, create stub accessor methods that raise an exception
+      extend Abstract
+      stub_required_methods(Operation, ATTRIBUTES)
+
+      # Compares +Operation+ objects using the +name+ attribute.
+      def <=> (other)
+        name <=> other.name
+      end
+
+    end
+  end
+end

data/lib/rumbly/model/parameter.rb

@@ -0,0 +1,25 @@
+require 'rumbly/model/abstract'
+
+module Rumbly
+  module Model
+
+    # This is an abstract class that represents one parameter of an operation from a
+    # class within an MVC application. Object mapper-specific implementations should
+    # subclass this class and implement the following methods: +name+ and +type+.
+    class Parameter
+
+      # Attributes and default values of a Parameter
+      ATTRIBUTES = { name: '', type: '' }
+
+      # For each attribute, create stub accessor methods that raise an exception
+      extend Abstract
+      stub_required_methods(Parameter, ATTRIBUTES)
+
+      # Compares +Parameter+ objects using the +name+ attribute.
+      def <=> (other)
+        name <=> other.name
+      end
+
+    end
+  end
+end

data/lib/rumbly/model/relationship.rb

@@ -0,0 +1,58 @@
+require 'rumbly/model/abstract'
+
+module Rumbly
+  module Model
+
+    # This is an abstract class that represents a (one-way) relationship between two
+    # classes within an MVC application. Object mapper-specific implementations should
+    # subclass this class and implement the following methods: +type+, +source+,
+    # +target+, +name+, +multiplicity+, +through+, and +navigable+.
+    #
+    # According to the UML spec, generalizations don't really have a +name+ or a
+    # +multiplicity+, so these attributes should should be +nil+ for this +Relationship+
+    # type; +navigable+ should always return true for generalizations, and the subclass
+    # should be the +source+, whereas the superclass should be the +target+.
+    class Relationship
+
+      # Attributes and default values of a Relationship
+      ATTRIBUTES = {
+        type: :association, source: nil, target: nil, name: '',
+        multiplicity: nil, through: nil, navigable: false
+      }
+
+      # For each attribute, create stub accessor methods that raise an exception
+      extend Abstract
+      stub_required_methods(Relationship, ATTRIBUTES)
+
+      # Valid Relationship types
+      RELATIONSHIP_TYPES = [
+        :dependency, :association, :aggregation, :composition, :generalization
+      ]
+
+      # Simple question mark-style wrapper for the +Relationship#navigable+ attribute.
+      def navigable?
+        navigable
+      end
+      
+      # Compares two +Relationship+ objects by first seeing if their sources or targets
+      # differ. If those are the same, then use the name, then type, then through.
+      def <=> (other)
+        (source <=> other.source).nonzero? || (target <=> other.target).nonzero? ||
+        (name <=> other.name).nonzero? || (type <=> other.type).nonzero? ||
+        (through <=> other.through)
+      end
+      
+      # Returns a string that fully describes this +Relationship+, including its type,
+      # name, source, target, through class, and multiplicity.
+      def label
+        label  = "#{type.to_s}"
+        label += " '#{name}'"
+        label += " from #{source.name}"
+        label += " to #{target.name}"
+        label += " through #{through.name}" unless through.nil?
+        label += " #{multiplicity.inspect}"
+      end
+      
+    end
+  end
+end

data/lib/rumbly/model/simple.rb

@@ -0,0 +1,25 @@
+module Rumbly
+  module Model
+    module Simple
+    
+      classes = %w{ application klass attribute operation parameter relationship }
+      classes.each { |c| require "rumbly/model/#{c}" }
+
+      def self.define_class(classname)
+        parent = Rumbly::Model.const_get(classname)
+        cls = Class.new(parent) do
+          parent::ATTRIBUTES.keys.each { |a| attr_accessor a }
+          def initialize (attrs={})
+            (self.class.superclass)::ATTRIBUTES.each_pair do |a,v|
+              instance_variable_set("@#{a}", attrs[a] || v)
+            end
+          end
+        end
+        const_set(classname, cls)
+      end
+      
+      classes.each { |c| define_class(c.capitalize) }
+      
+    end
+  end
+end

data/lib/rumbly/options_hash.rb

@@ -0,0 +1,101 @@
+module Rumbly
+
+  # An +OptionsHash+ is a subclass of +Hash+ class that adds the following functionality:
+  # - all keys are converted to symbols when storing or retrieving
+  # - values can be accessed using methods named after keys (ala Structs)
+  # - nested values can be accessed using chained method calls or dotted key values
+  # - keys are implicitly created if an unknown method is called
+  # - the +has_key?+ method is enhanced to test for nested key paths
+  class OptionsHash < ::Hash
+    
+    # Converts +key+ to a +Symbol+ before calling the normal +Hash#[]+ method. If the
+    # key is a dotted list of keys, digs down into any nested hashes to find the value.
+    # Returns +nil+ if any of the sub-hashes are not present.
+    def [] (key)
+      unless key =~ /\./
+        super(key.to_sym)
+      else
+        k, *r = *split_key(key)
+        if (sub = self[k]).nil?
+          nil
+        else
+          self[k][join_keys(r)]
+        end
+      end
+    end
+      
+    # Converts +key+ to a +Symbol+ before calling the normal +Hash#[]=+ method. If the
+    # key is a dotted list of keys, digs down into any nested hashes (creating them if
+    # necessary) to store the value.
+    def []= (key, value)
+      unless key =~ /\./
+        super(key.to_sym, value)
+      else
+        k, *r = *split_key(key)
+        sub = get_or_create_value(k)
+        sub[join_keys(r)] = value
+      end
+    end
+    
+    # Returns +true+ if this +OptionsHash+ has a value stored under the given +key+.
+    # In the case of a compound key (multiple keys separated by dots), digs down into
+    # any nested hashes to find a value. Returns +false+ if any of the sub-hashes or
+    # values are nil.
+    def has_key? (key)
+      unless key =~ /\./
+        super(key.to_sym)
+      else
+        k, *r = *split_key(key)
+        return false if (sub = self[k]).nil?
+        return sub.has_key?(join_keys(r))
+      end
+    end
+    
+    # Allows values to be stored and retrieved using methods named for the keys. If
+    # an attempt is made to access a key that doesn't exist, a nested +OptionsHash+
+    # will be created as the value stored for the given key. This allows for setting
+    # a nested option without having to explicitly create each nested hash.
+    def method_missing (name, *args, &blk)
+      unless respond_to?(name)
+        if reader?(name, args, blk)
+          get_or_create_value(name)
+        elsif writer?(name, args, blk)
+          store_value(chop_sym(name), args[0])
+        end
+      end
+    end
+    
+    private
+    
+    def split_key (path)
+      path.to_s.split('.').map(&:to_sym)
+    end
+    
+    def join_keys (a)
+      a.join('.')
+    end
+
+    def reader? (name, args, blk)
+      blk.nil? && args.empty?
+    end
+  
+    def writer? (name, args, blk)
+      blk.nil? && args.size == 1 && name =~ /=$/
+    end
+    
+    def chop_sym (sym)
+      sym.to_s.chop.to_sym
+    end
+    
+    def get_or_create_value (key)
+      self[key] ||= OptionsHash.new
+    end
+
+    def store_value (key, value)
+      get_or_create_value(key)
+      store(key, value)
+    end      
+  
+  end
+
+end

data/lib/rumbly/railtie.rb

@@ -0,0 +1,9 @@
+module Rumbly
+  # If Ruby on Rails is running, adds a set of rake tasks to make it easy to generate UML
+  # class diagrams for whatever object mapper you're using in your Rails application.
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'rumbly/tasks.rake'
+    end
+  end
+end

data/lib/rumbly/tasks.rake

@@ -0,0 +1,50 @@
+require 'rumbly'
+require 'rumbly/model/application'
+require 'rumbly/diagram/base'
+
+def say(message)
+  print message unless Rake.application.options.quiet
+end
+
+namespace :rumbly do
+  
+  # Allows options given via Rake environment to override default options. Nested
+  # options are accessed using dot notation, e.g. "diagram.type = graphviz".
+  task :options do
+    ENV.each do |key, value|
+      # if option exists in defaults, do some basic conversions and override
+      key.downcase.gsub(/_/,'.')
+      if Rumbly::options.has_key?(key)
+        value = case value
+        when "true", "yes" then true
+        when "false", "no" then false
+        when /,/ then value.split(/\s*,\s*/).map(&:to_sym)
+        else value
+        end
+        Rumbly::options[key] = value
+      end
+    end
+  end
+
+  # Loads the Ruby on Rails environment and model classes.
+  task :load_model do
+    say "Loading Rails application environment..."
+    Rake::Task[:environment].invoke
+    say "done.\n"
+    say "Loading Rails application classes..."
+    Rails.application.eager_load!
+    say "done.\n"
+  end
+
+  # Generates a UML diagram based on the given options and the loaded Rails model.
+  task generate: [:options, :load_model] do
+    say "Generating UML diagram for Rails model..."
+    app = Rumbly::Model::Application.create
+    Rumbly::Diagram::Base.create(app)
+    say "done.\n"
+  end
+  
+end
+
+desc "Generate a UML diagram based on your Rails model classes"
+task rumbly: 'rumbly:generate'

data/lib/rumbly.rb

@@ -0,0 +1,24 @@
+require 'rumbly/options_hash'
+require 'rumbly/railtie' if defined?(Rails)
+
+module Rumbly
+
+  class << self
+    attr_accessor :options
+  end
+
+  # setup default options
+  self.options = OptionsHash.new
+  
+  # general options
+  self.options.messages = :verbose
+  
+  # model options
+  self.options.model.type = :auto
+  
+  # diagram options
+  self.options.diagram.type   = :graphviz
+  self.options.diagram.file   = 'classes'
+  self.options.diagram.format = :pdf
+
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: rumbly
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dustin Frazier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2010-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70245880702880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245880702880
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: &70245880731300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245880731300
+description: More detailed description coming soon...
+email: ruby@frayzhe.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rumbly/diagram/base.rb
+- lib/rumbly/diagram/debug.rb
+- lib/rumbly/diagram/graphviz.rb
+- lib/rumbly/model/abstract.rb
+- lib/rumbly/model/active_record/application.rb
+- lib/rumbly/model/active_record/attribute.rb
+- lib/rumbly/model/active_record/klass.rb
+- lib/rumbly/model/active_record/relationship.rb
+- lib/rumbly/model/application.rb
+- lib/rumbly/model/attribute.rb
+- lib/rumbly/model/klass.rb
+- lib/rumbly/model/operation.rb
+- lib/rumbly/model/parameter.rb
+- lib/rumbly/model/relationship.rb
+- lib/rumbly/model/simple.rb
+- lib/rumbly/options_hash.rb
+- lib/rumbly/railtie.rb
+- lib/rumbly.rb
+- lib/rumbly/tasks.rake
+homepage: http://github.com/frayzhe/rumbly
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Let's get ready to rumble
+test_files: []