yard-activerecord 0.0.11 → 0.0.12

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YzQxYzljYjFkODJmOWU1NmQ4YjA0NzFiNGQwMjJlODgyZTg2MjA3NA==
-  data.tar.gz: !binary |-
-    N2I0MjRjZjI1OGMzZWFkMjZiMjExYTBjZWEzZWMwZmM5MDIyMGMwMA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    OWFjZTE3OTVjN2JiODcxMGQ4NmE1NmEzYTY0MWUyNzNkYmFlM2RhNTI0MWI2
-    OWU3YzUzNDFlOWE4MjhiZDZmZmQ5YzNkZWEwYTljNTU1NDcwN2E5MWE0ZGVm
-    NTVlM2U2YzgzNDAzMGYyNzUyYzliNzMzN2Q2Mjc4Mzc3ZWE2OTc=
-  data.tar.gz: !binary |-
-    YTIzNGM4NGJhNmYzZmI2MTY3Yjc4Y2ZiMDQ3ZTRjYWYzODdlMDE4NWQzMjJj
-    MDlkNjU2MGFiN2FlMWRiNDdjMzlkMjc0OWI2MTM4NThmODM0NWQ0NjIxZDE2
-    OWNlNmVjZTU3NmNlN2MyMTcwMTM4NzUwMWRlZjkxZDI4ZTMyMzY=
+SHA1:
+  metadata.gz: 7004249aaeef940d9c42dcd0b0b70d1b79132458
+  data.tar.gz: 74166e2dbe0f6a0e1bac5ebf82ea9b314fc0ce07
+SHA512:
+  metadata.gz: ee09ea1271e6f0739b5ed17928d2079c04da45c65a88cfdb48e20b677dc790d1b0caca1265324afc76a5c89a321d756e7ab4180d760720693b4566a37eb59c76
+  data.tar.gz: 486069183cbb3b5b7d175f6659fa3da539e31847537781f2262c2ed036d9360f0f5c3cdb18b45ae2ac21e26e90f44fa4113af12054a5467f3ae5390c11d7b28a

data/README.md

@@ -1,4 +1,8 @@
-# YARD ActiveRecord Plugin #
+# YARD ActiveRecord Plugin
+
+[![Version](http://img.shields.io/gem/v/yard-activerecord.svg?style=flat-square)](https://rubygems.org/gems/yard-activerecord)
+[![Downloads](http://img.shields.io/gem/dt/yard-activerecord.svg?style=flat-square)](https://rubygems.org/gems/yard-activerecord)
+[![Open Github issues](http://img.shields.io/github/issues/theodorton/yard-activerecord.svg?style=flat-square)](https://github.com/theodorton/yard-activerecord/issues)
 
 A YARD extension that handles and interprets methods used when developing
 applications with ActiveRecord. The extension handles attributes,
@@ -6,7 +10,7 @@ associations, delegates and scopes. A must for any Rails app using YARD as
 documentation plugin.
 
 
-## Installation ##
+## Installation
 
 Run the following command in order to load YARD plugins:
 
@@ -14,7 +18,7 @@ Run the following command in order to load YARD plugins:
 $ yard config load_plugins true
 ```
 
-## Attributes ##
+## Attributes
 
 In order for this plugin to document any database attributes you need to add
 `schema.rb` to your list of files. This is preferably done with in `.yardopts`
@@ -56,27 +60,39 @@ Example:
 
 The documentation will then be skipped for this table/class.
 
-## Associations ##
+## Associations
 
 The plugin handles `has_one`, `belongs_to`, `has_many` and
 `has_and_belongs_to_many` associations. The annotation for each association
 includes a link to the referred model. For associations with a list of objects
 the documentation will simply be marked as `Array<ModelName>`.
 
-## Delegates ##
+## Delegates
 
 The plugin handles `delegate`-methods and marks these delegated instance
 methods simply as aliases for the associated object.
 
-## Scopes ##
+## Scopes
 
 The plugin will add class methods for any scopes you have defined in your
 models.
 
+## Validations ##
+
+The plugin will add information about validations onto each field.  It only handles
+the new style validations in the form of:
+
+    validates :foo, :presence=>true, :length=>{ is: 6 }
+
+Validations in the older form of:
 
-## Other useful plugins ##
+    validates_presence_of :foo
+
+are not supported.
+
+## Other useful plugins
 
 Check out:
- 
+
   * [https://github.com/ogeidix/yard-rails-plugin](https://github.com/ogeidix/yard-rails-plugin)
 

data/lib/yard-activerecord.rb

@@ -3,6 +3,8 @@ require 'yard'
 module YARD::Handlers::Ruby::ActiveRecord
 end
 
+YARD::Templates::Engine.register_template_path File.dirname(__FILE__) + '/../templates'
+
 root = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH << root unless $LOAD_PATH.include? root
 
@@ -18,3 +20,4 @@ require 'yard-activerecord/associations/has_and_belongs_to_many_handler'
 require 'yard-activerecord/delegations/delegate_handler'
 
 require 'yard-activerecord/scopes/scope_handler'
+require 'yard-activerecord/validations/validates_handler'

data/lib/yard-activerecord/associations/base.rb

@@ -8,13 +8,13 @@ module YARD::Handlers::Ruby::ActiveRecord::Associations
     def process
       namespace.groups << group_name unless namespace.groups.include? group_name
 
-      object           = YARD::CodeObjects::MethodObject.new(namespace, method_name)
+      object           = register YARD::CodeObjects::MethodObject.new(namespace, method_name)
       object.group     = group_name
-      object.docstring = return_description
+      object.docstring = return_description if object.docstring.empty?
       object.docstring.add_tag get_tag(:return, '', class_name)
-      object.docstring.add_tag get_tag(:see, 'http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html')
+      object.docstring.add_tag get_tag(:see, "ActiveRecord::Associations", nil,
+        'http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html' )
       object.dynamic = true
-      register object
     end
 
     def group_name
@@ -49,8 +49,8 @@ module YARD::Handlers::Ruby::ActiveRecord::Associations
       "An array of associated #{method_name}."
     end
 
-    def get_tag(tag, text, return_classes = [])
-      YARD::Tags::Tag.new(tag, text, [return_classes].flatten)
+    def get_tag(tag, text, return_classes = [], name=nil)
+      YARD::Tags::Tag.new(tag, text, [return_classes].flatten, name)
     end
   end
 end

data/lib/yard-activerecord/delegations/delegate_handler.rb

@@ -14,14 +14,13 @@ module YARD::Handlers::Ruby::ActiveRecord::Delegations
       class_name = class_name.to_s.gsub(/\A.*\:/,'').capitalize
       params.each do |method_name|
         method_name.gsub!(/[\:\'\"]/,'')
-        object = YARD::CodeObjects::MethodObject.new(namespace, method_name)
+        object = register YARD::CodeObjects::MethodObject.new(namespace, method_name)
         object.group = "Delegated Instance Attributes"
         object.docstring = "Alias for {#{class_name}##{method_name}}"
         object.docstring.add_tag get_tag(:return,
             "{#{class_name}##{method_name}}", 'Object')
-        object.docstring.add_tag get_tag(:see,
+        object.docstring.add_tag get_tag(:see,"Module#delegate",nil,
             "http://api.rubyonrails.org/classes/Module.html#method-i-delegate")
-        register object
       end
       group_name = "Delegated Instance Attributes"
       namespace.groups << group_name unless namespace.groups.include? group_name
@@ -29,8 +28,8 @@ module YARD::Handlers::Ruby::ActiveRecord::Delegations
 
     private
 
-    def get_tag(tag, text, return_classes = [])
-      YARD::Tags::Tag.new(tag, text, [return_classes].flatten)
+    def get_tag(tag, text, return_classes = [], name=nil)
+      YARD::Tags::Tag.new(tag, text, [return_classes].flatten,name)
     end
   end
 end

data/lib/yard-activerecord/fields/field_handler.rb

@@ -5,39 +5,43 @@ module YARD::Handlers::Ruby::ActiveRecord::Fields
     handles method_call(:integer)
     handles method_call(:float)
     handles method_call(:boolean)
+    handles method_call(:decimal)
     handles method_call(:timestamp)
     handles method_call(:datetime)
     handles method_call(:date)
-  
+
     def process
       return unless statement.namespace.jump(:ident).source == 't'
       method_name = call_params.first
-      
+
       return if method_name['_id'] # Skip all id fields, associations will handle that
-      
+
       ensure_loaded! P(globals.klass)
       namespace = P(globals.klass)
       return if namespace.nil?
 
       method_definition = namespace.instance_attributes[method_name.to_sym] || {}
-      
+
       { read: method_name, write: "#{method_name}=" }.each do |(rw, name)|
-        next if method_definition[rw]
-        rw_object = YARD::CodeObjects::MethodObject.new(namespace, name)
+        method = method_definition[rw]
+        if method
+          method.docstring.add_tag( get_tag(:return, '', class_name) ) unless method.has_tag?( :return )
+          next
+        end
+        rw_object = register YARD::CodeObjects::MethodObject.new(namespace, name)
         rw_object.docstring = description(name)
         rw_object.docstring.add_tag get_tag(:return, '', class_name)
         rw_object.dynamic = true
-        register rw_object
         method_definition[rw] = rw_object
       end
 
       namespace.instance_attributes[method_name.to_sym] = method_definition
     end
-  
+
     def description(method_name)
       '' # "Database field value of #{method_name}. Defined in {file:db/schema.rb}"
     end
-  
+
     def get_tag(tag, text, return_classes)
       YARD::Tags::Tag.new(:return, text, [return_classes].flatten)
     end

data/lib/yard-activerecord/scopes/scope_handler.rb

@@ -6,12 +6,11 @@ module YARD::Handlers::Ruby::ActiveRecord::Scopes
     namespace_only
     
     def process
-      object = YARD::CodeObjects::MethodObject.new(namespace, method_name, :class)
+      object = register YARD::CodeObjects::MethodObject.new(namespace, method_name, :class)
       object.docstring = return_description
       object.docstring.add_tag get_tag(:return, '', class_name)
-      object.docstring.add_tag get_tag(:see,
-'http://api.rubyonrails.org/classes/ActiveRecord/NamedScope/ClassMethods.html')
-      register object
+      object.docstring.add_tag get_tag(:see,"ActiveRecord::Scoping", nil,
+        'http://api.rubyonrails.org/classes/ActiveRecord/Scoping/Named/ClassMethods.html')
     end
     
     private
@@ -29,8 +28,8 @@ module YARD::Handlers::Ruby::ActiveRecord::Scopes
       "Array<#{namespace}>"
     end
 
-    def get_tag(tag, text, return_classes = [])
-      YARD::Tags::Tag.new(tag, text, [return_classes].flatten)
+    def get_tag(tag, text, return_classes = [],name=nil)
+      YARD::Tags::Tag.new(tag, text, [return_classes].flatten,name)
     end
   end
-end
+end

data/lib/yard-activerecord/validations/validates_handler.rb

@@ -0,0 +1,110 @@
+require 'active_support/inflector'
+require 'active_support/core_ext/array'
+
+module YARD::Handlers::Ruby::ActiveRecord::Validate
+
+  # Links with a value of nil will be link to
+  # the Rails Validations guide.
+  # Other projects can add to the
+  STANDARD_LINKS = [
+    :acceptance,
+    :validates_associated,
+    :confirmation,
+    :exclusion,
+    :format,
+    :inclusion,
+    :length,
+    :numericality,
+    :presence,
+    :absence,
+    :uniqueness,
+    :validates_with,
+    :validates_each
+  ]
+
+  def self.add_validation_type( type, link )
+    @custom_types ||= {}
+    @custom_types[type.to_sym] = link
+  end
+
+  def self.link_for_validation( type )
+    type = type.downcase.to_sym
+    if STANDARD_LINKS.include?( type )
+      "http://edgeguides.rubyonrails.org/active_record_validations.html##{type}"
+    elsif @custom_types && link = @custom_types[ type ]
+      link
+    else
+      nil
+    end
+  end
+
+  # Define validations tag for later use
+  YARD::Tags::Library.define_tag("Validations", :validates )
+
+  # Document ActiveRecord validations.
+  # This handler handles the validates statement.
+  # It will parse the list of fields, the validation types and their options,
+  # and the optional :if/:unless clause.
+  # It only handles the newer Rails ":validates" syntax and does not
+  # recognize the older "validates_presence_of" type methods.
+  class ValidatesHandler < YARD::Handlers::Ruby::MethodHandler
+    namespace_only
+    handles method_call(:validates)
+    def process
+
+      validations = {}
+      attributes  = []
+      conditions  = {}
+
+      # Read each parameter to the statement and parse out
+      # it's type and intent
+      statement.parameters(false).compact.map do |param|
+        # list types are options
+        if param.type == :list
+          param.each do | n |
+            kw = n.jump(:label, :symbol_literal ).source.gsub(/:/,'')
+            # if/unless are conditions that apply to all the validations
+            if ['if','unless','on'].include?(kw)
+              conditions[ kw ] = n.children.last.source
+            else # otherwise it's type specific
+              opts = n.jump(:hash)
+              value = ( opts != n ) ? opts.source : nil
+              validations[ kw ] = value
+            end
+          end
+        elsif param.type == :symbol_literal
+          attributes << param.jump(:ident, :kw, :tstring_content).source
+        end
+      end
+
+      # abort in case we didn't parse anything
+      return if validations.empty?
+
+      # Loop through each attribute and set a tag on each
+      attributes.each do | attribute |
+        method_definition = namespace.instance_attributes[attribute.to_sym] || {}
+        method = method_definition[:read]
+        if ! method
+          meths = namespace.meths(:all => true)
+          method = meths.find {|m| m.name == attribute.to_sym }
+        end
+        # If the method isn't defined yet, go ahead and create one
+        if ! method
+          method = register YARD::CodeObjects::MethodObject.new(namespace, attribute )
+          method.scope = :instance
+          method.explicit = false
+          method_definition[:read] = method
+          namespace.instance_attributes[attribute.to_sym] = method_definition
+        end
+        tag = YARD::Tags::OptionTag.new(:validates, '', conditions ) #, [] )
+        tag.types = {} #[]
+        validations.each{ |arg,options|
+          tag.types[ arg ] = options
+        }
+        method.docstring.add_tag tag
+      end
+
+    end
+  end
+
+end

data/lib/yard-activerecord/version.rb

@@ -1,5 +1,5 @@
 module YARD
   module ActiveRecord
-    VERSION = "0.0.11"
+    VERSION = "0.0.12"
   end
 end

data/templates/default/tags/html/validations.erb

@@ -0,0 +1,15 @@
+<p class="tag_title">Validations<% if @condition %> (<i><%= @condition %></i> )<% end %>:</p>
+<ul class="validations">
+  <% for tag in @tags %>
+    <% tag.types.each do | type, options | %>
+      <li>
+        <% if link = YARD::Handlers::Ruby::ActiveRecord::Validate.link_for_validation( type ) %>
+            <%= linkify(link, type.capitalize ) %>
+        <% else %>
+            <%= type.capitalize %>
+        <% end %>
+        <% if options %> (<%= options %>) <% end %>
+      </li>
+    <% end %>
+  <% end %>
+</ul>

data/templates/default/tags/setup.rb

@@ -0,0 +1,23 @@
+def init
+  super
+  if object.has_tag?(:validates)
+    create_tag_methods([:validates])
+    sections << Section.new(:validates)
+  end
+end
+
+def validates
+  all_tags = object.tags(:validates)
+  out = ''
+  conditions = all_tags.map{| tag | tag.pair.to_s }.uniq.compact
+  conditions.each do | condition |
+    @tags = all_tags.select{|tag| tag.pair.to_s == condition }
+    condition = @tags.first.pair.map do | type, check |
+      check = linkify( check.gsub(/^:/,'#') ) if check =~/^:/ # it's a symbol, convert to link
+      "#{type} => #{check}"
+    end
+    @condition = condition.empty? ? nil : condition.join(',')
+    out << erb( :validations )
+  end
+  out
+end

data/templates/default/tags/text/validations.erb

@@ -0,0 +1,7 @@
+Validations<% if @condition %> (<%= @condition %> )<% end %>:
+---------
+<% for tag in @tags %>
+  <% for type in tag.types %>
+    <%= type %>
+  <% end %>
+<% end %>

metadata

@@ -1,44 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: yard-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Theodor Tonum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-28 00:00:00.000000000 Z
+date: 2014-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "\n    YARD-Activerecord is a YARD extension that handles and interprets
+description: "\n    YARD-Activerecord is a YARD extension that handles and interprets
   methods\n    used when developing applications with ActiveRecord. The extension
   handles\n    attributes, associations, delegates and scopes. A must for any Rails
   app\n    using YARD as documentation plugin. "
@@ -48,7 +48,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
@@ -66,7 +66,11 @@ files:
 - lib/yard-activerecord/fields/define_handler.rb
 - lib/yard-activerecord/fields/field_handler.rb
 - lib/yard-activerecord/scopes/scope_handler.rb
+- lib/yard-activerecord/validations/validates_handler.rb
 - lib/yard-activerecord/version.rb
+- templates/default/tags/html/validations.erb
+- templates/default/tags/setup.rb
+- templates/default/tags/text/validations.erb
 - test.rb
 - yard-activerecord.gemspec
 homepage: https://github.com/theodorton/yard-activerecord
@@ -79,19 +83,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: ActiveRecord Handlers for YARD
 test_files: []
-has_rdoc: