has_machine_tags 0.1.6 → 0.1.7

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+== 0.1.7
+* Converted tests to bacon
+* Added proper versioning
+* Got rid of jeweler and $: hacks
+
 == 0.1.6
 * Release to rubyforge
 * Allow default_predicates to be a proc

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT LICENSE
 
-Copyright (c) 2009 Gabriel Horner
+Copyright (c) 2010 Gabriel Horner
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -13,6 +13,7 @@ machine tags ripe for modeling relationships between objects. Read the HasMachin
 documentation for a more thorough explanation.
 
 A demo app using this plugin is {here}[http://github.com/cldwalker/tag-tree].
+This gem should run on all major Ruby versions and work with Rails 2.3.x and up.
 
 == Install
 

data/Rakefile

@@ -1,50 +1,35 @@
 require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-begin
-  require 'rcov/rcovtask'
+require 'fileutils'
 
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/**/*_test.rb']
-    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
-    t.verbose = true
-  end
-rescue LoadError
-  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+def gemspec
+  @gemspec ||= eval(File.read('gemspec'), binding, 'gemspec')
 end
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "has_machine_tags"
-    s.summary = "A rails tagging plugin implementing flickr's machine tags + maybe more (semantic tags)."
-    s.description = "This plugin implements Flickr's machine tags while still maintaining standard tagging behavior. This allows for more precise tagging as tags can have unlimited contexts provided by combinations of namespaces and predicates. These unlimited contexts also make machine tags ripe for modeling relationships between objects."
-    s.email = "gabriel.horner@gmail.com"
-    s.homepage = "http://tagaholic.me/has_machine_tags/"
-    s.authors = ["Gabriel Horner"]
-    s.rubyforge_project = ['tagaholic']
-    s.has_rdoc = true
-    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
-    s.files = FileList["CHANGELOG.rdoc", "README.rdoc", "LICENSE.txt", "init.rb", "Rakefile", "VERSION.yml", "{rails,generators,bin,lib,test}/**/*"]
-  end
+desc "Build the gem"
+task :gem=>:gemspec do
+  sh "gem build gemspec"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+end
+
+desc "Install the gem locally"
+task :install => :gem do
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version}}
+end
 
-rescue LoadError
-  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
 end
 
-Rake::TestTask.new do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
 end
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'test'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+desc 'Run tests'
+task :test do |t|
+  sh 'bacon -q -Ilib -I. test/*_test.rb'
 end
 
-task :default => :test
+task :default => :test

data/gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless Object.const_defined?(:Gem)
+require File.dirname(__FILE__) + "/lib/has_machine_tags/version"
+
+Gem::Specification.new do |s|
+  s.name        = "has_machine_tags"
+  s.version     = HasMachineTags::VERSION
+  s.authors     = ["Gabriel Horner"]
+  s.email       = "gabriel.horner@gmail.com"
+  s.homepage    = "http://tagaholic.me/has_machine_tags/"
+  s.summary = "A rails tagging gem which implements flickr's machine tags and maybe more (semantic tags)."
+  s.description = "This gem implements Flickr's machine tags while still maintaining standard tagging behavior. This allows for more precise tagging as tags can have unlimited contexts provided by combinations of namespaces and predicates. These unlimited contexts also make machine tags ripe for modeling relationships between objects."
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project = 'tagaholic'
+  s.add_development_dependency 'bacon'
+  s.files = Dir.glob(%w[{lib,test,generators}/**/*.rb bin/* [A-Z]*.{txt,rdoc} ext/**/*.{rb,c}]) + %w{Rakefile gemspec init.rb}
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+end

data/init.rb

@@ -1 +1,13 @@
-require File.join(File.dirname(__FILE__), 'rails', 'init.rb')
+require 'has_machine_tags'
+require 'has_machine_tags/tag_methods'
+
+#attempt to load constant
+::Tag rescue nil
+if Object.const_defined? :Tag
+  ::Tag.class_eval %[include HasMachineTags::TagMethods]
+else
+  require 'has_machine_tags/tag'
+end
+
+require 'has_machine_tags/tagging'
+ActiveRecord::Base.send :include, HasMachineTags

data/lib/has_machine_tags/console.rb

@@ -31,14 +31,5 @@ module HasMachineTags
         self.tag_list
       end
     end
-    
-    module ClassMethods
-      # Updates items tagged with an old tag to use the given new tag in place of the old tag.
-      def find_and_change_tag(old_tag, new_tag)
-        results = tagged_with(old_tag)
-        results.each {|e| e.tag_add_and_remove(old_tag, new_tag)}
-        puts "Changed tag for #{results.length} records"
-      end
-    end
   end
 end

data/lib/has_machine_tags/tag_console.rb

@@ -1,6 +1,11 @@
 module HasMachineTags
-  module TagConsole #:nodoc:
-    def self.included(base)
+  # Provides named_scopes and class methods to the Tag model, useful in machine tag analysis from the console.
+  # To use:
+  #   class Tag
+  #     include HasMachineTags::TagConsole
+  #   end
+  module TagConsole
+    def self.included(base) #:nodoc:
       base.class_eval %[
         named_scope :namespace_counts, :select=>'*, namespace as counter, count(namespace) as count', :group=>"namespace HAVING count(namespace)>=1"
         named_scope :predicate_counts, :select=>'*, predicate as counter, count(predicate) as count', :group=>"predicate HAVING count(predicate)>=1"
@@ -13,20 +18,12 @@ module HasMachineTags
     end
     
     module ClassMethods
-      #:stopdoc:
+      # Array of words in namespace field
       def namespaces; distinct_namespaces.map(&:namespace).compact; end
+      # Array of words in predicate field
       def predicates; distinct_predicates.map(&:predicate).compact; end
+      # Array of words in value field
       def values; distinct_values.map(&:value).compact; end
-      #:startdoc:
-  
-      # To be used with the *counts methods.
-      # For example:
-      #   stat(:namespace_counts) 
-      # This prints out pairs of a namespaces and their counts in the tags table.
-      def stat(type)
-        shortcuts = {:n=>:namespace_counts, :p=>:predicate_counts, :v=>:value_counts }
-        send(shortcuts[type] || type).map {|e| [e.counter, e.count] }
-      end
     end
   end
 end

data/lib/has_machine_tags/tag_list.rb

@@ -40,6 +40,10 @@ module HasMachineTags
       }.flatten
     end
 
+    def primary_namespace #:nodoc:
+      namespace_hashes.sort {|x,y| y[1].size <=> x[1].size }[0][0]
+    end
+
     def namespace_hashes #:nodoc:
       self.inject({}) {|h, e|
         namespace, *predicate_value = Tag.split_machine_tag(e)

data/lib/has_machine_tags/version.rb

@@ -0,0 +1,3 @@
+module HasMachineTags
+  VERSION = '0.1.7'
+end

data/lib/has_machine_tags.rb

@@ -1,8 +1,7 @@
-current_dir = File.dirname(__FILE__)
-$:.unshift(current_dir) unless $:.include?(current_dir) || $:.include?(File.expand_path(current_dir))
 require 'has_machine_tags/finder'
 require 'has_machine_tags/tag_list'
 require 'has_machine_tags/console'
+require 'has_machine_tags/version'
 
 module HasMachineTags
   def self.included(base) #:nodoc:
@@ -11,7 +10,7 @@ module HasMachineTags
   
   module ClassMethods
     # ==== Options:
-    # [:console] When true, adds additional helper methods from HasMachineTags::Console to use mainly in irb.
+    # [:console] When true, adds additional instance methods to use mainly in irb.
     # [:reverse_has_many] Defines a has_many :through from tags to the model using the plural of the model name.
     # [:quick_mode] When true, enables a quick mode to input machine tags with HasMachineTags::InstanceMethods.tag_list=(). See examples at HasMachineTags::TagList.new().
     def has_machine_tags(options={})
@@ -24,10 +23,8 @@ module HasMachineTags
         
         include HasMachineTags::InstanceMethods
         extend HasMachineTags::Finder
-        if options[:console]
-          include HasMachineTags::Console::InstanceMethods
-          extend HasMachineTags::Console::ClassMethods
-        end
+        include HasMachineTags::Console::InstanceMethods if options[:console]
+
         if respond_to?(:named_scope)
           named_scope :tagged_with, lambda{ |*args|
             find_options_for_tagged_with(*args)

data/test/finder_test.rb

@@ -1,80 +1,78 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class HasMachineTags::FinderTest < Test::Unit::TestCase
-  before(:each) { 
-    [Tag, Tagging, TaggableModel].each {|e| e.delete_all}
-  }
+describe "Finder" do
+  before { [Tag, Tagging, TaggableModel].each {|e| e.delete_all} }
   
   def create_extra_taggable
     TaggableModel.create(:tag_list=>"blah:blih=bluh")
   end
   
-  context "TaggableModel" do
-    context "finds by" do
-      before(:each) { 
+  describe "TaggableModel" do
+    describe "finds by" do
+      before {
         @taggable = TaggableModel.create(:tag_list=>"url:lang=ruby")
         create_extra_taggable
       }
     
-      test "namespace wildcard machine tag" do
+      it "namespace wildcard machine tag" do
         TaggableModel.tagged_with("url:").should == [@taggable]
       end
     
-      test "predicate wildcard machine tag" do
+      it "predicate wildcard machine tag" do
         TaggableModel.tagged_with("lang=").should == [@taggable]
       end
     
-      test "value wildcard machine tag" do
+      it "value wildcard machine tag" do
         TaggableModel.tagged_with("=ruby").should == [@taggable]
       end
     
-      test "namespace-value wildcard machine tag" do
+      it "namespace-value wildcard machine tag" do
         TaggableModel.tagged_with("url.ruby").should == [@taggable]
       end
       
-      test "predicate-value wildcard machine tag" do
+      it "predicate-value wildcard machine tag" do
         TaggableModel.tagged_with("lang=ruby").should == [@taggable]
       end
     end
     
-    context "finds with" do
-      test "multiple machine tags as an array" do
+    describe "finds with" do
+      it "multiple machine tags as an array" do
         @taggable = TaggableModel.create(:tag_list=>"article:todo=later")
         @taggable2 = TaggableModel.create(:tag_list=>"article:tags=funny")
         create_extra_taggable
         results = TaggableModel.tagged_with(["article:todo=later", "article:tags=funny"])
         results.size.should == 2
-        results.include?(@taggable).should be(true)
-        results.include?(@taggable2).should be(true)
+        results.include?(@taggable).should == true
+        results.include?(@taggable2).should == true
       end
       
-      test "multiple machine tags as a delimited string" do
+      it "multiple machine tags as a delimited string" do
         @taggable = TaggableModel.create(:tag_list=>"article:todo=later")
         @taggable2 = TaggableModel.create(:tag_list=>"article:tags=funny")
         create_extra_taggable
         results = TaggableModel.tagged_with("article:todo=later, article:tags=funny")
         results.size.should == 2
-        results.include?(@taggable).should be(true)
-        results.include?(@taggable2).should be(true)
+        results.include?(@taggable).should == true
+        results.include?(@taggable2).should == true
       end
       
-      test "condition option" do
+      it "condition option" do
         @taggable = TaggableModel.create(:title=>"so limiting", :tag_list=>"url:tags=funny" )
         create_extra_taggable
         TaggableModel.tagged_with("url:tags=funny", :conditions=>"title = 'so limiting'").should == [@taggable]
       end
     end
 
-    context "when queried with normal tag" do
-      before(:each) { @taggable = TaggableModel.new }
-      test "doesn't find if machine tagged" do
+    describe "when queried with normal tag" do
+      before { @taggable = TaggableModel.new }
+      it "doesn't find if machine tagged" do
         @taggable.tag_list = 'url:tags=square'
         @taggable.save
         Tag.count.should == 1
         TaggableModel.tagged_with("square").should == []
       end
     
-      test "finds if tagged normally" do
+      it "finds if tagged normally" do
         @taggable.tag_list = 'square, some:machine=tag'
         @taggable.save
         TaggableModel.tagged_with("square").should == [@taggable]

data/test/has_machine_tags_test.rb

@@ -1,56 +1,56 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class HasMachineTagsTest < Test::Unit::TestCase
-  context "TagList" do
-    before(:each) { @taggable = TaggableModel.new }
+describe "HasMachineTags" do
+  describe "TagList" do
+    before { @taggable = TaggableModel.new }
     
-    test "sets tag list with array" do
+    it "sets tag list with array" do
       arr = ['some', 'tag:name=blah']
       @taggable.tag_list = arr
       @taggable.tag_list.should == arr
     end
     
-    test "sets tag list with delimited string" do
+    it "sets tag list with delimited string" do
       arr = ['more', 'tag:type=clever']
       @taggable.tag_list = arr.join(", ")
       @taggable.tag_list.should == arr
     end
     
-    test "sets tag list with messy delimited string" do
+    it "sets tag list with messy delimited string" do
       arr = ['more', 'tag:type=dumb', 'really']
       @taggable.tag_list = "more,tag:type=dumb,   really"
       @taggable.tag_list.should == arr
       @taggable.tag_list.to_s.should == arr.join(", ")
     end
     
-    context "with quick_mode" do
-      before(:all) { TaggableModel.quick_mode = true }
-      after(:all) { TaggableModel.quick_mode = false }
+    describe "with quick_mode" do
+      before_all { TaggableModel.quick_mode = true }
       
-      test "sets tag list normally with non quick_mode characters" do
+      it "sets tag list normally with non quick_mode characters" do
         arr = ['more', 'tag:type=dumb', 'really']
         @taggable.tag_list = "more,tag:type=dumb,   really"
         @taggable.tag_list.should == arr
       end
       
-      test "sets default predicate and infers namespace" do
+      it "sets default predicate and infers namespace" do
         @taggable.tag_list = "gem:irb;name=utility_belt, article"
         @taggable.tag_list.should == ["gem:tags=irb", "gem:name=utility_belt", "article"]
       end
+      after_all { TaggableModel.quick_mode = false }
     end
   end
   
-  context "InstanceMethods" do
-    before(:each) { @taggable = TaggableModel.new }
+  describe "InstanceMethods" do
+    before { @taggable = TaggableModel.new }
   
-    test "creates all tags" do
+    it "creates all tags" do
       tags = ['some', 'tag:name=blah']
       @taggable.tag_list = tags
       @taggable.save!
       @taggable.tags.map(&:name).should == tags
     end
     
-    test "only creates new tags" do
+    it "only creates new tags" do
       @taggable.tag_list = "bling"
       @taggable.save!
       tag_count = Tag.count
@@ -60,7 +60,7 @@ class HasMachineTagsTest < Test::Unit::TestCase
       Tag.count.should == tag_count + 1
     end
     
-    test "deletes unused tags" do
+    it "deletes unused tags" do
       @taggable.tag_list == 'bling, bling3'
       @taggable.save!
       @taggable.tag_list = "bling4"
@@ -69,4 +69,4 @@ class HasMachineTagsTest < Test::Unit::TestCase
       @taggable.tags.map(&:name).should == ['bling4']
     end
   end
-end
+end

data/test/tag_methods_test.rb

@@ -1,109 +1,109 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class HasMachineTags::TagMethodsTest < Test::Unit::TestCase
-  test "create with normal tag name only touches name" do
+describe "TagMethods" do
+  it "create with normal tag name only touches name" do
     obj = Tag.create(:name=>'blah1')
     [:name, :namespace, :predicate, :value].map {|e| obj.send(e)}.should == ['blah1', nil, nil, nil]
   end
   
-  test "create with machine tag name sets all name fields" do
+  it "create with machine tag name sets all name fields" do
     obj = Tag.create(:name=>'gem:name=machine')
     [:name, :namespace, :predicate, :value].map {|e| obj.send(e)}.should == ['gem:name=machine', 'gem', 'name', 'machine']
   end
   
-  context "update" do
-    before(:each) { @obj = Tag.new }
+  describe "update" do
+    before { @obj = Tag.new }
     
-    test "with normal tag name only touches name" do
+    it "with normal tag name only touches name" do
       @obj.update_attributes :name=> 'bling'
       [:name, :namespace, :predicate, :value].map {|e| @obj.send(e)}.should == ['bling', nil, nil, nil]
     end
 
-    test "with machine tag name sets all name fields" do
+    it "with machine tag name sets all name fields" do
       @obj.update_attributes :name=>'gem:prop=value'
       [:name, :namespace, :predicate, :value].map {|e| @obj.send(e)}.should == ['gem:prop=value', 'gem', 'prop', 'value']
     end
 
-    test "with no name sets no name fields" do
+    it "with no name sets no name fields" do
       @obj.update_attributes :name=>'blah2'
       @obj.update_attributes :predicate=>'changed'
       @obj.name.should == 'blah2'
     end
   end
   
-  context "match_wildcard_machine_tag" do
-    test "matches namespace with asterisk" do
+  describe "match_wildcard_machine_tag" do
+    it "matches namespace with asterisk" do
       Tag.match_wildcard_machine_tag('name:*=').should == [[:namespace,'name']]
     end
     
-    test "matches namespace without asterisk" do
+    it "matches namespace without asterisk" do
       Tag.match_wildcard_machine_tag('name:').should == [[:namespace,'name']]
     end
     
-    test "matches predicate with asterisk" do
+    it "matches predicate with asterisk" do
       Tag.match_wildcard_machine_tag('*:pred=').should == [[:predicate,'pred']]
     end
     
-    test "matches predicate without asterisk" do
+    it "matches predicate without asterisk" do
       Tag.match_wildcard_machine_tag('pred=').should == [[:predicate,'pred']]
     end
     
-    test "matches value with asterisk" do
+    it "matches value with asterisk" do
       Tag.match_wildcard_machine_tag('*:*=val').should == [[:value, 'val']]
     end
     
-    test "matches value without asterisk" do
+    it "matches value without asterisk" do
       Tag.match_wildcard_machine_tag('=val').should == [[:value, 'val']]
     end
     
-    test "matches namespace and predicate without asterisk" do
+    it "matches namespace and predicate without asterisk" do
       Tag.match_wildcard_machine_tag('name:pred').should == [[:namespace, 'name'], [:predicate, 'pred']]
     end
 
-    test "matches namespace and predicate with asterisk" do
+    it "matches namespace and predicate with asterisk" do
       Tag.match_wildcard_machine_tag('name:pred=').should == [[:namespace, 'name'], [:predicate, 'pred']]
     end
     
-    test "matches predicate and value without asterisk" do
+    it "matches predicate and value without asterisk" do
       Tag.match_wildcard_machine_tag('pred=val').should == [[:predicate, 'pred'], [:value, 'val']]
     end
 
-    test "matches predicate and value with asterisk" do
+    it "matches predicate and value with asterisk" do
       Tag.match_wildcard_machine_tag('*:pred=val').should == [[:predicate, 'pred'], [:value, 'val']]
     end
     
-    test "matches namespace and value without asterisk" do
+    it "matches namespace and value without asterisk" do
       Tag.match_wildcard_machine_tag('name.val').should == [[:namespace, 'name'], [:value, 'val']]
     end
 
-    test "matches namespace and value with asterisk" do
+    it "matches namespace and value with asterisk" do
       Tag.match_wildcard_machine_tag('name:*=val').should == [[:namespace, 'name'], [:value, 'val']]
     end
     
-    test "doesn't match total wildcard" do
+    it "doesn't match total wildcard" do
       Tag.match_wildcard_machine_tag('*:*=').should == []
     end
 
-    test "doesn't match machine tag" do
+    it "doesn't match machine tag" do
       Tag.match_wildcard_machine_tag('name:pred=val').should == nil
     end
     
-    test "doesn't match normal tag" do
+    it "doesn't match normal tag" do
       Tag.match_wildcard_machine_tag('name').should == nil
     end
   end
   
-  test "validates name when no invalid characters" do
-    Tag.new(:name=>'valid!name_really?').valid?.should be(true)
+  it "validates name when no invalid characters" do
+    Tag.new(:name=>'valid!name_really?').valid?.should == true
   end
 
-  test "validates name when machine tag format" do
-    Tag.new(:name=>'name:pred=value').valid?.should be(true)
+  it "validates name when machine tag format" do
+    Tag.new(:name=>'name:pred=value').valid?.should == true
   end
 
-  test "invalidates name when invalid characters present" do
+  it "invalidates name when invalid characters present" do
     %w{some.tag another:tag so=invalid yet,another whoop*}.each do |e|
-      Tag.new(:name=>e).valid?.should be(false)
+      Tag.new(:name=>e).valid?.should == false
     end
   end
 end

data/test/test_helper.rb

@@ -1,9 +1,7 @@
 require 'rubygems'
 require 'activerecord'
-require 'test/unit'
-require 'context' #gem install jeremymcanally-context -s http://gems.github.com
-require 'matchy' #gem install jeremymcanally-matchy -s http://gems.github.com
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bacon'
+require 'has_machine_tags'
 require File.join(File.dirname(__FILE__), '..', 'init')
 
 #Setup logger
@@ -22,5 +20,7 @@ class TaggableModel < ActiveRecord::Base
   has_machine_tags
 end
 
-class Test::Unit::TestCase
-end
+class Bacon::Context
+  def after_all; yield; end
+  def before_all; yield; end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: has_machine_tags
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,29 +14,32 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-22 00:00:00 -04:00
+date: 2010-06-10 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
-description: This plugin implements Flickr's machine tags while still maintaining standard tagging behavior. This allows for more precise tagging as tags can have unlimited contexts provided by combinations of namespaces and predicates. These unlimited contexts also make machine tags ripe for modeling relationships between objects.
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: This gem implements Flickr's machine tags while still maintaining standard tagging behavior. This allows for more precise tagging as tags can have unlimited contexts provided by combinations of namespaces and predicates. These unlimited contexts also make machine tags ripe for modeling relationships between objects.
 email: gabriel.horner@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE.txt
 - README.rdoc
-files: 
-- CHANGELOG.rdoc
 - LICENSE.txt
-- README.rdoc
-- Rakefile
-- VERSION.yml
-- generators/has_machine_tags_migration/has_machine_tags_migration_generator.rb
-- generators/has_machine_tags_migration/templates/migration.rb
-- init.rb
-- lib/has_machine_tags.rb
+files: 
 - lib/has_machine_tags/console.rb
 - lib/has_machine_tags/finder.rb
 - lib/has_machine_tags/tag.rb
@@ -39,44 +47,54 @@ files:
 - lib/has_machine_tags/tag_list.rb
 - lib/has_machine_tags/tag_methods.rb
 - lib/has_machine_tags/tagging.rb
-- rails/init.rb
+- lib/has_machine_tags/version.rb
+- lib/has_machine_tags.rb
 - test/finder_test.rb
 - test/has_machine_tags_test.rb
 - test/schema.rb
 - test/tag_methods_test.rb
 - test/test_helper.rb
+- generators/has_machine_tags_migration/has_machine_tags_migration_generator.rb
+- generators/has_machine_tags_migration/templates/migration.rb
+- LICENSE.txt
+- CHANGELOG.rdoc
+- README.rdoc
+- Rakefile
+- gemspec
+- init.rb
 has_rdoc: true
 homepage: http://tagaholic.me/has_machine_tags/
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
-rubyforge_project: 
-- tagaholic
-rubygems_version: 1.3.5
+rubyforge_project: tagaholic
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: A rails tagging plugin implementing flickr's machine tags + maybe more (semantic tags).
-test_files: 
-- test/finder_test.rb
-- test/has_machine_tags_test.rb
-- test/schema.rb
-- test/tag_methods_test.rb
-- test/test_helper.rb
+summary: A rails tagging gem which implements flickr's machine tags and maybe more (semantic tags).
+test_files: []
+

data/VERSION.yml

@@ -1,4 +0,0 @@
---- 
-:major: 0
-:minor: 1
-:patch: 6

data/rails/init.rb

@@ -1,13 +0,0 @@
-require 'has_machine_tags'
-require 'has_machine_tags/tag_methods'
-
-#attempt to load constant
-::Tag rescue nil
-if Object.const_defined? :Tag
-  ::Tag.class_eval %[include HasMachineTags::TagMethods]
-else
-  require 'has_machine_tags/tag'
-end
-
-require 'has_machine_tags/tagging'
-ActiveRecord::Base.send :include, HasMachineTags