casey_jones 0.0.99

data/Gemfile

@@ -0,0 +1,5 @@
+gem 'rails',        '3.0.0.beta4'
+gem 'sqlite3-ruby', :require => 'sqlite3'
+gem 'jeweler'
+gem "da_huangs_ruby_extensions"
+

data/README

@@ -0,0 +1,59 @@
+== HABTM Example
+
+Complex forms on a HABTM association.
+
+Using code borrowed from Pat (http://patshaughnessy.net), whose view_mapper
+finally taught this hobbyist hacker to write forms.
+
+Hopefully this will fit snugly into someone else's gem
+
+== Installation
+
+* Install as a gem:
+    # Add to your Gemfile
+    gem "anaf_habtm"
+* or as a plugin
+    rails plugin install git://github.com/tylergannon/anaf_habtm.git
+
+Run the generator to place the javascript in the right place:
+
+    rails generate anaf_habtm
+        
+Add the following to your layout:
+    <%= javascript_include_tag 'nested_attributes.js' %>
+
+== Usage
+
+Inside your model, call anaf_habtm just as you would call has_and_belongs_to_many,
+except now you need to offer a code block telling rails what to do with each object.
+The plugin will handle deleting stuff.
+
+    # Basically, your code block needs to return an object of the correct
+    # type for your association collection, or else nil if your code
+    # determines that the object should be rejected.
+    class Customer < ActiveRecord::Base
+      anaf_habtm :orders, :autosave => true, :uniq => false do |params, order|
+        order = order ||= Order.new
+        order.attributes = params
+        logger.error params.inspect
+        order
+      end
+    end
+
+    class Order < ActiveRecord::Base
+      has_and_belongs_to_many :customers
+      anaf_habtm :items, :autosave => true, :uniq => false do |params, item|
+        logger.error "ITEM:::  #{params.inspect}"
+        item ||= Item.find_or_create_by_name(params["name"])
+      end
+    end
+
+== Additional info
+
+See the example app at http://github.com/tylergannon/accepts-nested-attributes-habtm-example for more details.
+
+Also check out Pat's view_mapper... it can generate the code you need inside your views.  
+
+http://github.com/patshaughnessy/view_mapper
+
+

data/Rakefile

@@ -0,0 +1,70 @@
+
+PKG_FILES = FileList[
+  'anaf_habtm.gemspec',
+  'Gemfile',
+  'install.rb',
+  'Rakefile', 'README', 'uninstall.rb',
+  'assets/**/*',
+  'lib/**/*',
+  'rails/**/*',
+  'test/**/*'
+]
+
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "casey_jones"
+    s.author = "Tyler Gannon"
+    s.email = "t--g__a--nnon@gmail.com"
+    s.homepage = "http://github.com/tylergannon/anaf_habtm"
+    s.platform = Gem::Platform::RUBY
+    s.description = "some extra stuff for rails apps"
+    s.summary = "My favorite rails goodies all in one"
+    s.files = PKG_FILES.to_a
+    s.require_path = "lib"
+    s.has_rdoc = false
+    s.extra_rdoc_files = ["README"]
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "da_huangs_ruby_extensions #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/acts_as_linkable/acts_as_linkable.rb

@@ -0,0 +1,34 @@
+module ActsAsLinkable
+  module ActiveRecordExtensions
+    def acts_as_linkable(opts={}, &block)
+      class_eval "def link_attr; #{opts.inspect}; end;"
+    end
+  end
+
+  module ActionViewExtensions
+    def link(obj)
+      raise "I can't link to nil." unless obj
+      if (obj.class == Array) || (obj.class == ActiveRecord::Relation)
+        obj.map{|v| link(v)}.to_sentence
+      else
+        p = obj.link_attr
+        p[:partial] = "#{obj.class.name.tableize}/link" if p.empty?
+        unless p[:partial].nil?
+          obj_name = (p[:object_name] ||= obj.class.name.underscore).to_s.to_sym
+          (render :partial => p[:partial], :locals => {obj_name => obj}).strip
+        else
+          opts = {}
+          link_attr = obj.link_attr
+          link_attr.each do |key, val|
+            link_attr[key] = obj.send(val) if val.class == Symbol
+          end
+          opts[:title] = link_attr[:title] if link_attr.has_key?(:title)
+          link_to link_attr[:name], obj, opts
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Base.extend(ActsAsLinkable::ActiveRecordExtensions)
+ActionView::Base.send :include, ActsAsLinkable::ActionViewExtensions
+

data/lib/ajax_loading/ajax_loading.rb

@@ -0,0 +1,2 @@
+require 'ajax_loading/controller_resource'
+

data/lib/ajax_loading/controller_resource.rb

@@ -0,0 +1,37 @@
+module AjaxLoading
+  class ControllerResource < CanCan::ControllerResource
+    def initialize(controller, name, parent = nil, options = {})
+      super(controller, name, parent, options)
+    end
+
+    def load_resource
+      puts "AjaxLoading::load_resource"
+      params = @controller.params
+      if params.has_key?(:associated)
+        ass_params = params[:associated]
+        relation = ass_params["class_name"].constantize.find(ass_params["id"])
+        association = ass_params["association"]
+        instance_variable_set 'container',
+            ass_params["container"] ||= relation.element_id(:show, association)
+
+        self.model_instance = relation.send(association)
+      elsif collection_action?
+        self.model_instance = model_class.where('1=1')
+      else
+        super
+      end
+    end
+
+    private
+
+    def instance_variable_set(name, value)
+      name = '@'+name unless name.include?('@')
+      @controller.instance_variable_set(name, value)
+    end
+    def instance_variable_get(name)
+      name = '@'+name unless name.include?('@')
+      @controller.instance_variable_get(name)
+    end
+  end
+end
+

data/lib/anaf_active_record.rb

@@ -0,0 +1,45 @@
+
+module AnafHabtm
+  module ActiveRecord
+    def anaf_habtm(association, options={}, &block)
+      class_eval do
+        # Define a proc that will look up the (potentially) existing object
+        finder = proc {|id| association.to_s.singularize.camelize.constantize.where(:id=>id).first
+        }
+
+        # Define a proc that will set the association collection
+        set_collection = proc {|me, coll| me.send("#{association.to_s.tableize}=", coll)}
+        has_and_belongs_to_many association.to_sym, options
+        # Define the actual association setter.
+        define_method "#{association.to_s.tableize}_attributes=", lambda{|attributes_for_association|
+          coll = []
+
+          attributes_for_association.each_value do |params|
+            next if params["_destroy"] == "1"
+            obj = finder.call(params["id"]) if params.has_key?("id")
+            params.extend(AnafHabtm::HashExtension)
+            # ActiveRecord::Base.attributes=() doesn't like extra parameters.
+            coll << block.call(params.copy_without_destroy, obj)
+          end
+          set_collection.call(self, coll)
+        }
+      end
+    end
+
+    def named_association(member, attribute, opts={})
+      member = member.to_s
+      klass = opts.has_key?(:class) ? opts[:class_name] : member.to_s.singularize.camelize
+      attribute = attribute.to_s
+      if opts.has_key?(:create)
+        class_eval "def #{member}_#{attribute}=(#{attribute});
+        return if #{attribute}.blank?
+        self.#{member} = #{klass}.find_or_create_by_#{attribute}(#{attribute})
+        end;"
+      else
+        class_eval "def #{member}_#{attribute}=(#{attribute}); self.#{member} = #{klass}.find_by_#{attribute}(#{attribute}) unless #{attribute}.blank?; end;"
+      end
+      class_eval "def #{member}_#{attribute}; #{member}.#{attribute} if #{member}; end;"
+    end
+  end
+end
+

data/lib/casey_jones.rb

@@ -0,0 +1,8 @@
+require 'casey_jones/active_record_extensions'
+require 'casey_jones/application_helper_methods'
+require 'casey_jones/string_reader'
+require 'ajax_loading/ajax_loading'
+require 'acts_as_linkable/acts_as_linkable'
+ActiveRecord::Base.extend(CaseyJones::ActiveRecord)
+ActionView::Base.send :include, CaseyJones::ApplicationHelperMethods
+

data/lib/casey_jones/active_record_extensions.rb

@@ -0,0 +1,160 @@
+
+module CaseyJones
+  module ActiveRecord
+    def autocomplete_format(&block)
+      class_eval do
+        @autocomplete_block = block
+        def self.to_autocomplete(items)
+            items.map{|t| @autocomplete_block.call(t)}.to_json
+        end
+      end
+    end
+
+    #  Needs to call scopes on a class and pass it values that are
+    #   pulled from a hash called obj_attr
+    def make_scope_string(find_opts)
+      _scopes = []
+      find_opts.each{ |scope, attr_name|
+        if attr_name.class == Hash
+          _scopes << "#{scope.to_s}(obj_attr[#{name.first[0].to_s}][#{name.first[1].to_s}])"
+        else
+          _scopes << "#{scope.to_s}(obj_attr[#{name.to_s}])"
+        end
+      }
+      _scopes.join(".")
+    end
+
+    def anaf_habtm(association, options={})
+      ar_opts = options[:ar_options] ||= {}
+      klass = ar_opts[:class_name] ||= association.to_s.singularize.camelize
+      class_eval do
+        has_and_belongs_to_many association.to_sym, ar_opts
+      end
+      find_line = "obj = obj ||= #{klass}.#{make_scope_string(options[:find])}.first" if options.has_key?(:find)
+      association = association.to_s.underscore.tableize
+      scope_string =
+      class_eval <<END
+          def #{association}_attributes=(attr_hash)
+            obj_coll = []
+            attr_hash.each_value do |obj_attr|
+              next if obj_attr["_destroy"] == "1"
+              obj = #{klass}.find(obj_attr["id"]) if obj_attr.has_key?("id")
+              obj_attr = obj_attr.reject_keys ["id", "_destroy"]
+              #{find_line}
+              if obj && obj.update_attributes(obj_attr)
+                obj_coll << obj
+              elsif (obj = #{klass}.new(obj_attributes)) && obj.save
+                obj_coll << obj
+              end
+            end
+            self.#{association} = obj_coll
+          end
+END
+    end
+
+    def association_text(association, opts={})
+      raise "Must give a name for text_association" unless opts.has_key?(:name)
+      class_eval do
+        if opts.has_key?(:class_name)
+          klass = opts[:class_name].constantize
+        else
+          klass = association.to_s.singularize.camelize.constantize
+        end
+        define_method "#{association.to_s}_text=", lambda{ |text|
+          return if text.empty?
+          coll = StringReader.new.read_items(text) do |name, commentary|
+            a = klass.undecorate(name) if klass.methods.include?("undecorate")
+            if opts.has_key?(:scope)
+              obj = self.send(association).scopes[opts[:scope]].call(name).first
+            end
+            params = {opts[:name]=>name}
+            params[opts[:commentary]] = commentary if opts.has_key?(:commentary)
+            obj = obj ||= klass.new
+            obj = klass.find(obj) unless obj.new_record?
+            obj.decoration = a if a
+            obj.attributes = params
+            obj.save
+            obj
+          end
+          self.send("#{association.to_s}=", coll)
+        }
+
+        define_method "#{association.to_s}_text", lambda{
+          StringReader.new.write_items(self.send(association.to_s)) do |item|
+            name = item.send(opts[:name])
+            name = item.decorate(name) if item.methods.include?("decorate")
+            [name, opts.has_key?(:commentary) ? item.send(opts[:commentary]) : ""]
+          end
+        }
+      end
+    end
+
+    def named_association(member, attribute, opts={})
+      member = member.to_s
+      klass = (opts.has_key?(:class_name) ? opts[:class_name] : member.to_s.singularize.camelize).constantize
+      attribute = attribute.to_s
+      if opts.has_key?(:create)
+        class_eval do
+          define_method "#{member}_#{attribute}=", lambda{|value|
+            return if value.blank?
+            obj = klass.named(value)
+            obj = obj ||= klass.create(attribute => value)
+            self.send("#{member}=", obj)
+          }
+        end
+      else
+        class_eval do
+          define_method "#{member}_#{attribute}=", lambda{|value|
+            self.send("#{member}=",klass.named(value)) unless value.blank?
+          }
+        end
+      end
+      class_eval "def #{member}_#{attribute};
+         #{member}.#{attribute} if #{member};
+       end;"
+    end
+
+    def search_on(*cols)
+      class_eval "def self.search_columns; #{cols.map{|t| t.to_s}.to_ary.inspect}; end;"
+      class_eval do
+        scope :search, lambda{|str|
+          items = like_condition(str.downcase)
+          if scopes.has_key?(:search_mod)
+            items = items.search_mod
+          end
+          items
+        }
+        scope :with_name, lambda{|str|
+          equals_condition(str.downcase).limit(1)
+        }
+      end
+    end
+
+    def lookup(params)
+      str = params[:id]
+      if str.match(/\D/)
+        named(str)
+      else
+        find(str)
+      end
+    end
+
+    def like_condition(str)
+      where(condition("ilike '%#{str}%'"))
+    end
+
+    def equals_condition(str)
+      where(condition("= '#{str.downcase}'"))
+    end
+
+
+    def named(str)
+      with_name(str).first
+    end
+
+    def condition(cond)
+       search_columns.map{|c| "trim(lower(#{c})) #{cond}"}.join(" or ")
+    end
+  end
+end
+

data/lib/casey_jones/application_helper_methods.rb

@@ -0,0 +1,39 @@
+module CaseyJones
+  module ApplicationHelperMethods
+    def remove_child_link(name, form_builder)
+      value = form_builder.object.new_record? ? "1" : "false"
+      klass = form_builder.object.class.name.underscore
+      form_builder.hidden_field(:_destroy,  {:value=>value, "data-remove"=>klass}) +
+      link_to(name, options={}, html_options={"href"=>"#", "class"=>"remove-child-link", :tabindex=> "0"})
+    end
+
+    def add_child_link(name, child, form_builder, options={})
+      # puts "||#{form_builder}||"
+      new_form = new_child_fields(child, form_builder, options)
+      raw(content_tag(:div, new_form, {:id=>"#{child}_template", :class=>"form-template"}, escape=false))+
+      link_to(name, options={}, html_options={"href"=>"#", "class"=>"add-child-link", "data-class-name"=>child})
+    end
+
+    def new_child_fields(child, form_builder, options={})
+      partial = options[:partial] ||= child.underscore
+      output = ""
+      form_builder.fields_for(child.pluralize.to_sym, child.camelize.constantize.new, :child_index => "__#{child}_id__") do |f|
+        output += render(:partial => partial, :locals => { :f => f })
+      end
+      output
+    end
+
+    def tfwac(f, field, controller, opts={})
+      opts["data-auto-complete"]='tf'
+      opts["data-auto-complete-url"]=eval("#{controller.to_s.underscore.tableize}_path(:format=>:json)")
+      f.text_field field, opts
+    end
+
+    def text_area_with_auto_complete(f, field, controller, opts={})
+      opts["data-auto-complete"]='ta'
+      opts["data-auto-complete-url"]=eval("#{controller.to_s.underscore.tableize}_path(:format=>:json)")
+      f.text_area field, opts
+    end
+  end
+end
+

data/lib/casey_jones/string_reader.rb

@@ -0,0 +1,113 @@
+module AnafHabtm
+  class StringReader
+    KEY_SYMPTOM = "*"
+    POSS_SYMPTOM = "-"
+    START_COMMENT = "{"
+    ONE_LINE_COMMENT = "/"
+    END_COMMENT = "}"
+    NEWLINE = "\n"
+    
+    DELIM = [START_COMMENT, NEWLINE, ONE_LINE_COMMENT, END_COMMENT]
+    
+    MULTI_LINE = :multi_line
+    ONE_LINE = :one_line
+    NAME = :name
+    COMMENT = [MULTI_LINE, ONE_LINE]
+    
+    @item = ""
+    @comment = nil
+    @items = []
+    
+    def save(block)
+      unless @item.strip.empty?
+        @items << block.call(@item.strip, @comment.nil? ? nil : @comment.strip)
+      end
+      @item = ""
+      @comment = nil
+    end
+    
+    def write_items(coll, &block)
+      lines = []
+      coll.each do |obj|
+        item, comment = block.call(obj)
+        if comment.nil? || comment.empty?
+          lines << item
+        elsif comment.index("/") || comment.index("\n")
+          lines << "#{item} {#{comment}}"
+        else
+          lines << "#{item} / #{comment}"
+        end
+      end
+      lines.join("\n")
+    end
+    
+    def read_items(str, &block)    
+      @items = []
+      buffer = ""
+      @item = ""
+      @comment = nil
+      state = NAME
+
+      str.chars.each do |char|
+        if (char == "/") && (state != MULTI_LINE)
+          @item = buffer.strip
+          buffer = ""
+          state = ONE_LINE
+        elsif char == "{"
+          @item = buffer.strip
+          buffer = ""
+          state = MULTI_LINE
+        elsif char == "}"
+          @comment = buffer.strip unless buffer.strip.empty?
+          buffer = ""
+          save(block)
+          state = NAME
+        elsif char == "\n"
+          if state == NAME
+            @item = buffer.strip
+            buffer = ""
+            save(block)
+          elsif state == ONE_LINE
+            @comment = buffer.strip
+            state = NAME
+            buffer = ""
+            save(block)
+          else
+            buffer << char
+          end
+        else
+          buffer << char
+        end
+      end
+      
+      if state == ONE_LINE
+        @comment = buffer
+      elsif state == MULTI_LINE
+        @comment = buffer
+      else
+        @item = buffer
+      end
+      save(block)
+      @items
+    end
+    
+    def self.parse_symptom(obj, symptom)
+      if symptom.index(KEY_SYMPTOM) == 0
+        obj.key_symptom = true
+        obj.symptom_name = symptom[KEY_SYMPTOM.length..symptom.length]
+      elsif symptom.index(POSS_SYMPTOM) == 0
+        obj.maybe = true
+        obj.symptom_name = symptom[POSS_SYMPTOM.length..symptom.length]
+      else
+        obj.symptom_name = symptom
+      end
+    end
+    
+    def self.decorate_symptom(obj)
+      decorator = ""
+      decorator = KEY_SYMPTOM if obj.key_symptom
+      decorator = POSS_SYMPTOM if obj.maybe
+      "#{decorator}#{obj.symptom_name}"
+    end
+  end
+end

data/lib/generators/anaf_habtm/anaf_habtm_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators'
+
+class AnafHabtmGenerator < Rails::Generators::Base
+  self.source_root File.expand_path("assets", File.dirname(__FILE__))
+
+  def copy_initializer_file
+    copy_file "nested_attributes.js", "public/javascripts/nested_attributes.js"
+    copy_file "nested_attributes.css", "public/stylesheets/nested_attributes.css"
+  end
+end
+

data/lib/generators/anaf_habtm/assets/nested_attributes.css

@@ -0,0 +1,3 @@
+
+.form-template {
+  display: none; }

data/lib/generators/anaf_habtm/assets/nested_attributes.js

@@ -0,0 +1,73 @@
+
+function setUpDocument($jq) {
+  $jq.find("input[data-auto-complete|=tf]").each( function(idx, el){
+    $(el).autocomplete({
+      source: $(el).attr('data-auto-complete-url'),
+      minLength: 2
+    });
+  });
+
+  $jq.find("textarea[data-auto-complete|=ta]").each( function(idx, el){
+    setTextAreaAutoComplete($(el));
+  });
+
+  $jq.find("a.add-child-link").click( function() {
+    klass = $(this).attr('data-class-name');
+    $el = $(this).prev().children().first().clone();
+    new_id=new Date().getTime()
+    $el.html($el.html().replace(new RegExp('__'+klass+'_id__', 'g'), new_id));
+    $el.find('input[data-remove|='+klass+']').attr('value', 'false');
+    $(this).closest('.child').find('.'+klass+'_children').first()
+        .append($el).show();
+    setUpDocument($el);
+    return false;
+  });
+
+  $jq.find('a.remove-child-link').click( function() {
+    $(this).prev('input[type|=hidden]').val('1');
+    $(this).closest('.child').hide();
+    return false;
+  });
+}
+
+$(function () {
+  setUpDocument($("body"));
+
+});
+  var text_area_delimiter = '\n';
+    function split(val) {
+        return val.split(new RegExp(text_area_delimiter+'\s*'));
+    }
+    function extractLast(term) {
+        return split(term).pop();
+    }
+function setTextAreaAutoComplete($el) {
+    $el.autocomplete({
+		source: function(request, response) {
+			$.getJSON($el.attr('data-auto-complete-url'), {
+				term: extractLast(request.term)
+			}, response);
+		},
+		search: function() {
+			// custom minLength
+			var term = extractLast(this.value);
+			if (term.length < 2) {
+				return false;
+			}
+		},
+		focus: function() {
+			// prevent value inserted on focus
+			return false;
+		},
+		select: function(event, ui) {
+			var terms = split( this.value );
+			terms.pop();  // remove the current input
+			terms.push( ui.item.value );	// add the selected item
+			// add placeholder to get the comma-and-space at the end
+			// terms.push("");
+			this.value = terms.join(text_area_delimiter);
+			return false;
+		}
+	});
+}
+

data/test/anaf_habtm_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class AnafHabtmTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: casey_jones
+version: !ruby/object:Gem::Version 
+  hash: 217
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 99
+  version: 0.0.99
+platform: ruby
+authors: 
+- Tyler Gannon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-21 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: some extra stuff for rails apps
+email: t--g__a--nnon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Gemfile
+- README
+- Rakefile
+- install.rb
+- lib/acts_as_linkable/acts_as_linkable.rb
+- lib/ajax_loading/ajax_loading.rb
+- lib/ajax_loading/controller_resource.rb
+- lib/anaf_active_record.rb
+- lib/casey_jones.rb
+- lib/casey_jones/active_record_extensions.rb
+- lib/casey_jones/application_helper_methods.rb
+- lib/casey_jones/string_reader.rb
+- lib/generators/anaf_habtm/anaf_habtm_generator.rb
+- lib/generators/anaf_habtm/assets/nested_attributes.css
+- lib/generators/anaf_habtm/assets/nested_attributes.js
+- test/anaf_habtm_test.rb
+- test/test_helper.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/tylergannon/anaf_habtm
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: My favorite rails goodies all in one
+test_files: 
+- test/anaf_habtm_test.rb
+- test/test_helper.rb