taglish 0.1.0

data/.gitignore

@@ -0,0 +1,10 @@
+.bundle
+*.sqlite3
+tmp/*
+tmp/**/*
+.*.swp
+.*.swo
+spec/database.yml
+spec/debug.log
+README.html
+pkg

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,107 @@
+PATH
+  remote: .
+  specs:
+    taglish (0.1.0)
+      rails (~> 3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.8)
+      actionpack (= 3.2.8)
+      mail (~> 2.4.4)
+    actionpack (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.3)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.1)
+    journey (1.0.4)
+    json (1.7.5)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.3.6)
+    mysql2 (0.3.11)
+    pg (0.14.1)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.8)
+      actionmailer (= 3.2.8)
+      actionpack (= 3.2.8)
+      activerecord (= 3.2.8)
+      activeresource (= 3.2.8)
+      activesupport (= 3.2.8)
+      bundler (~> 1.0)
+      railties (= 3.2.8)
+    railties (3.2.8)
+      actionpack (= 3.2.8)
+      activesupport (= 3.2.8)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.6)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mysql2 (~> 0.3.7)
+  pg
+  rspec (~> 2.6)
+  sqlite3
+  taglish!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Paul A. Jungwirth and Illuminated Computing Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,11 @@
+Taglish
+=======
+
+Taglish is yet another tagging library for Rails.
+It borrows heavily from [acts-as-taggable-on](https://github.com/mbleigh/acts-as-taggable-on), but it has a different feature set, the reflection stuff is refactored for greater comprehension, and it aims to remove [acts-as-taggable-on's memory leaks](https://github.com/mbleigh/acts-as-taggable-on/issues/94).
+It is also faster for large tag sets.
+Its major new feature is support for "scored" tags, so a model can have tags like `ruby:9, sql:5, js:4`.
+
+It is still in heavy development, so lots of things are changing and I don't make any promises.
+
+

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development
+
+desc 'Default: run specs'
+task :default => :spec  
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+Bundler::GemHelper.install_tasks
+
+task :readme => [] do |task|
+  `markdown README.md >README.html`
+end

data/lib/generators/taglish/migration/migration_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Taglish
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for Tag and Tagging models"
+
+    def self.orm
+      Rails::Generators.options[:rails][:orm]
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+    end
+
+    def self.orm_has_migration?
+      [:active_record].include? orm
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        migration_number += 1
+        migration_number.to_s
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      if self.class.orm_has_migration?
+        migration_template 'migration.rb', 'db/migrate/taglish_migration''
+      end
+    end
+  end
+end
+

data/lib/generators/taglish/migration/templates/active_record/migration.rb

@@ -0,0 +1,31 @@
+class TaglishMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :name
+    end
+
+    create_table :taggings do |t|
+      t.references :tag
+
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.references :taggable, :polymorphic => true
+      t.references :tagger, :polymorphic => true
+
+      # Limit is created to prevent MySQL error on index
+      # length for MyISAM table type: http://bit.ly/vgW2Ql
+      t.string :context, :limit => 128
+      t.integer :score
+
+      t.datetime :created_at
+    end
+
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type, :context, :tag_id]
+  end
+
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

data/lib/taglish.rb

@@ -0,0 +1,33 @@
+require "active_record"
+require "active_record/version"
+require "action_view"
+
+require "digest/sha1"
+
+module Taglish
+  DEFAULT_DELIMITER = ','
+  DEFAULT_SCORE_DELIMITER = ':'
+
+end
+
+
+require 'taglish/util'
+require 'taglish/tag_type'
+require 'taglish/tag'
+require 'taglish/taggable'
+require 'taglish/tagging'
+require 'taglish/tag_list'
+require 'taglish/core'
+
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend Taglish::Taggable
+  # TODO LATER:
+  # ActiveRecord::Base.send :include, Taglish::Tagger
+end
+
+if defined?(ActionView::Base)
+  # TODO:
+  # ActionView::Base.send :include, Taglish::TagsHelper
+end
+

data/lib/taglish/core.rb

@@ -0,0 +1,157 @@
+module Taglish::Core
+
+  def self.included(base)
+    base.class_eval do
+      after_save :save_tags
+    end
+  end
+
+  # Returns an array of Tags
+  # context should be plural
+  def tags_on(context)
+    taggings.on(context).map{|tg| tg.tag}
+  end
+
+  # Returns an array of Taggings
+  # context should be plural
+  def taggings_on(context)
+    q = taggings.includes(:tag).where(%Q{
+                 #{Taglish::Tagging.table_name}.context = ?
+             AND #{Taglish::Tagging.table_name}.tagger_id IS NULL}, context.to_s)
+    q = q.order("#{Taglish::Tagging.table_name}.id") if tags_have_order?(context)
+    q
+  end
+
+  # Returns an array of strings
+  def tag_list_on(tag_type)
+    n = tag_list_variable_name_for(tag_type)
+    instance_variable_get(n) ||
+      instance_variable_set(n,
+        Taglish::TagList.new(tag_type, *taggings_on(tag_type.name).map(&:to_s)))
+  end
+
+  def set_tag_list_on(tag_type, new_list)
+    n = tag_list_variable_name_for(tag_type)
+    mark_tag_list_as_changed(tag_type, new_list)
+    instance_variable_set(n, Taglish::TagList.from(tag_type, new_list))
+  end
+
+  def taggings_by_name(context)
+    Hash[taggings_on(context).map{|tg| [tg.name, tg]}]
+  end
+
+  def mark_tag_list_as_changed(tag_type, new_list)
+    value = new_list.is_a?(Array) ? new_list.join(', ') : new_list
+    attrib = tag_list_attribute_name_for(tag_type)
+
+    old = changed_attributes[attrib]
+    if old.nil?
+      old = tag_list_on(tag_type).to_s
+      if old.to_s != value.to_s
+        changed_attributes[attrib] = old
+        tag_list_changed!(tag_type)
+      end
+    else
+      if old.to_s == value.to_s
+        changed_attributes.delete(attrib)
+        tag_list_changed!(tag_type, false)
+      end
+    end
+  end
+
+  def all_tags_list_on(context)
+    raise "TODO LATER"
+  end
+
+  def add_tag_on(context, tag)
+  end
+
+  # context is plural
+  def tags_have_score?(context)
+    tag_types[context].scored?
+  end
+
+  # context is plural
+  def tags_have_order?(context)
+    tag_types[context].ordered?
+  end
+
+  def taggable?
+    self.class.taggable?
+  end
+
+  def tag_list_changed?(tag_type)
+    instance_variable_get(dirty_tag_list_variable_name_for(tag_type))
+  end
+
+  def tag_list_changed!(tag_type, changed=true)
+    instance_variable_set(dirty_tag_list_variable_name_for(tag_type), changed)
+  end
+
+  def reload(*args)
+    self.class.tag_types.each do |tt_name, tt|
+      instance_variable_set(tag_list_variable_name_for(tt), nil)
+      tag_list_changed!(tt, false)
+    end
+   
+    super(*args)
+  end
+
+  def save_tags
+    self.class.tag_types.each do |tag_type_name, tag_type|
+      # next unless changed_attributes[tag_list_attribute_name_for(tag_type)]
+      next unless tag_list_changed?(tag_type)
+
+      new_tag_list = instance_variable_get(tag_list_variable_name_for(tag_type))
+
+      # Tag objects for the new set of taggings:
+      # tags = tag_type.find_or_create_tags(*new_tags)
+
+      # Tagging objects for the new set of taggings (not persisted):
+      # new_taggings = Hash[new_tag_list.to_tagging_array.map{|tg| [tg.name, tg]}]
+      new_taggings = new_tag_list.to_tagging_array
+
+      # Tagging objects for the previous set of taggings:
+      current_taggings = taggings_by_name(tag_type_name)
+
+      if tag_type.ordered?
+        raise "TODO: Ordering not supported yet"
+      else
+        new_taggings.each do |tg|
+          old_tg = current_taggings[tg.name]
+          if old_tg
+            if old_tg.score != tg.score
+              old_tg.update_attribute(:score, tg.score)
+            end
+            current_taggings.delete tg.name
+          else
+            tg.taggable = self
+            tg.tag = Taglish::Tag.find_or_create_by_name(tg.name)
+            tg.context = tag_type_name
+            tg.save!
+          end
+        end
+      end
+
+      # Remove unused taggings:
+      Taglish::Tagging.destroy_all :id => current_taggings.values.map(&:id)
+    end
+
+    true
+  end
+
+  private
+
+  def tag_list_variable_name_for(tag_type)
+    "@#{tag_type.name}_list"
+  end
+
+  def tag_list_attribute_name_for(tag_type)
+    "#{tag_type.name.to_s.singularize}_list"
+  end
+
+  def dirty_tag_list_variable_name_for(tag_type)
+    "#{tag_list_variable_name_for(tag_type)}_changed"
+  end
+
+end

data/lib/taglish/tag.rb

@@ -0,0 +1,31 @@
+class Taglish::Tag < ActiveRecord::Base
+  include Taglish::Util
+
+  attr_accessible :name
+
+  has_many :taggings, :dependent => :destroy, :class_name => 'Taglish::Tagging'
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  validates_length_of :name, :maximum => 255
+
+  def ==(object)
+    super || (object.is_a?(Tag) && name == object.name)
+  end
+
+  def to_s
+    name
+  end
+
+  def count
+    read_attribute(:count).to_i
+  end
+
+  class << self
+    private
+    def comparable_name(str)
+      str.mb_chars.downcase.to_s
+    end
+  end
+
+end