taglish 0.1.0

data/lib/taglish/tag_list.rb

@@ -0,0 +1,115 @@
+require 'active_support/core_ext/module/delegation'
+
+##
+# Contains a list of strings.
+# Works like an array.
+class Taglish::TagList < Array
+  attr_accessor :tag_type
+  attr_accessor :taggable
+
+  def initialize(tag_type, *args)
+    self.tag_type = tag_type  or raise "tag_type is required"
+    add(*args)
+  end
+
+  ##
+  # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+  #
+  # Example:
+  #   tag_list.add("Fun", "Happy")
+  #   tag_list.add("Fun, Happy", :parse => true)
+  def add(*names)
+    extract_and_apply_options!(names)
+    concat(names)
+    clean!
+    self
+  end
+
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  #   tag_list = TagList.from("One , Two,  Three")
+  #   tag_list # ["One", "Two", "Three"]
+  def self.from(tag_type, string)
+    string = string.join(tag_type.glue) if string.respond_to?(:join)
+
+    new(tag_type).tap do |tag_list|
+      string = string.to_s.dup
+
+      # Parse the quoted tags
+      d = tag_type.delimiter
+      d = d.join("|") if d.kind_of?(Array) 
+      string.gsub!(/(\A|#{d})\s*"(.*?)"\s*(#{d}\s*|\z)/) { tag_list << $2; $3 }
+      string.gsub!(/(\A|#{d})\s*'(.*?)'\s*(#{d}\s*|\z)/) { tag_list << $2; $3 }
+
+      tag_list.add(string.split(Regexp.new d))
+    end
+  end
+
+  ##
+  # Remove specific tags from the tag_list.
+  # Use the <tt>:parse</tt> option to add an unparsed tag string.
+  #
+  # Example:
+  #   tag_list.remove("Sad", "Lonely")
+  #   tag_list.remove("Sad, Lonely", :parse => true)
+  def remove(*names)
+    extract_and_apply_options!(names)
+    if tag_type.scored
+      delete_if { |name| names.include?(name.sub(Taglish::Taggable::SCORED_TAG_REGEX, '\1')) }
+    else
+      delete_if { |name| names.include?(name) }
+    end
+    self
+  end
+
+  ##
+  # Transform the tag_list into a tag string suitable for edting in a form.
+  # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+  #
+  # Example:
+  #   tag_list = TagList.new("Round", "Square,Cube")
+  #   tag_list.to_s # 'Round, "Square,Cube"'
+  def to_s
+    tags = frozen? ? self.dup : self
+    tags.send(:clean!)
+
+    tags.map do |name|
+      d = tag_type.delimiter
+      d = Regexp.new d.join("|") if d.kind_of? Array
+      name.index(d) ? "\"#{name}\"" : name
+    end.join(tag_type.glue)
+  end
+
+  def to_tagging_array
+    map { |name|
+      ar = tag_type.name_and_score(name)
+      Taglish::Tagging.new(:name => ar[0], :score => ar[1])
+    }
+  end
+
+  private
+
+  # Remove whitespace, duplicates, and blanks.
+  def clean!
+    # Do this in self.from instead, or wherever we parse from strings:
+    reject!(&:blank?)
+    map!(&:strip)
+    map!(&:downcase)     if tag_type.force_lowercase
+    map!(&:parameterize) if tag_type.force_parameterize
+
+    uniq!
+  end
+   
+  def extract_and_apply_options!(args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    options.assert_valid_keys :parse
+
+    if options[:parse]
+      args.map! { |a| self.class.from(a) }
+    end
+
+    args.flatten!
+  end
+end

data/lib/taglish/tag_type.rb

@@ -0,0 +1,65 @@
+class Taglish::TagType
+  attr_accessor :name, :scored, :ordered, :delimiter, :score_delimiter,
+    :force_parameterize, :force_lowercase
+
+  def initialize(name, opts={})
+    opts = {
+      :scored => false,
+      :ordered => false,
+      :delimiter => Taglish::DEFAULT_DELIMITER,
+      :score_delimiter => Taglish::DEFAULT_SCORE_DELIMITER,
+      :force_parameterize => false,
+      :force_lowercase => false
+    }.merge(opts)
+    
+    self.name               = name
+    self.scored             = opts[:scored]
+    self.ordered            = opts[:ordered]
+    self.delimiter          = opts[:delimiter]
+    self.score_delimiter    = opts[:score_delimiter]
+    self.force_parameterize = opts[:force_parameterize]
+    self.force_lowercase    = opts[:force_lowercase]
+  end
+
+  def scored?
+    scored
+  end
+
+  def ordered?
+    ordered
+  end
+
+  def name_and_score(tag_str)
+    if scored
+      tag_str =~ Taglish::Taggable::SCORED_TAG_REGEX or raise "Scored tag has no score: #{tag_str}"
+      [$1, $2.to_i]
+    else
+      [tag_str, nil]
+    end
+  end
+
+  def find_or_create_tags(*tag_list)
+    return [] if tag_list.empty?
+    
+    list = scored ? tag_list.map{|t| name_and_score(t)[0]} : tag_list
+
+    existing_tags = Tag.named_any(list).all
+    new_tag_names = list.reject do |name|
+      name = comparable_name(name)
+      existing_tags.any? {|tag| comparable_name(tag.name) == name}
+    end
+    created_tags = new_tag_names.map {|name| Tag.create(:name => name) }
+
+    existing_tags + created_tags
+  end
+
+  ##
+  # Returns the proper string used to join tags:
+  # basically the first choice of delimiters,
+  # with a space after each delimiter.
+  def glue
+    d = delimiter.kind_of?(Array) ? delimiter[0] : delimiter
+    d.ends_with?(" ") ? d : "#{d} "
+  end
+
+end

data/lib/taglish/taggable.rb

@@ -0,0 +1,144 @@
+module Taglish::Taggable
+
+  SCORED_TAG_REGEX = /^(.+):(-?\d+)$/
+
+  def taggable?
+    false
+  end
+
+  def taglish
+    taglish_on(:tags)
+  end
+
+  def ordered_taglish
+    ordered_taglish_on(:tags)
+  end
+
+  def scored_taglish
+    scored_taglish_on(:tags)
+  end
+
+  ##
+  # Make a model taggable on specified contexts.
+  #
+  # @param [Array] tag_types An array of taggable contexts
+  #
+  # Example:
+  #   class User < ActiveRecord::Base
+  #     scored_taglish_on :languages, :skills
+  #   end
+  def scored_taglish_on(*tag_types)
+    taggable_on(false, true, tag_types)
+  end
+
+  ##
+  # Make a model taggable on specified contexts.
+  #
+  # @param [Array] tag_types An array of taggable contexts
+  #
+  # Example:
+  #   class User < ActiveRecord::Base
+  #     taglish_on :languages, :skills
+  #   end
+  def taglish_on(*tag_types)
+    taggable_on(false, false, tag_types)
+  end
+
+  ##
+  # Make a model taggable on specified contexts.
+  #
+  # @param [Array] tag_types An array of taggable contexts
+  #
+  # Example:
+  #   class User < ActiveRecord::Base
+  #     scored_taglish_on :languages, :skills
+  #   end
+  def ordered_taglish_on(*tag_types)
+    taggable_on(true, false, tag_types)
+  end
+
+  private
+
+  def taggable_on(ordered, scored, *new_tag_types)
+    # Assume new_tag_types has plural forms, like `skills`:
+    new_tag_types = new_tag_types.to_a.flatten.compact.map(&:to_sym)
+    unless taggable?
+      class_eval do
+        class_attribute :tag_types
+        self.tag_types = HashWithIndifferentAccess.new
+
+        has_many :taggings, :as => :taggable, :dependent => :destroy,
+          :include => :tag, :class_name => "Taglish::Tagging"
+        has_many :all_tags, :through => :taggings, :source => :tag,
+          :class_name => "Taglish::Tag"
+
+        def self.taggable?
+          true
+        end
+
+        include Taglish::Util
+        include Taglish::Core
+      end
+    end
+    # THEN: Copy/paste the save method, and think about how to implement
+    # set_tag_list_on.
+    # THEN: Implement tag_list_on.
+    # LATER: Implement TagList (extending Array) to save back tags
+    # if the user removes from/adds to the array.
+    new_tag_types.each do |ptt|   # ptt is the plural form
+      stt = ptt.to_s.singularize
+
+      tag_type = Taglish::TagType.new(ptt, :scored => scored, :ordered => ordered)
+      self.tag_types[ptt] = tag_type
+
+      taggings_scope_name = ptt.to_sym
+      taggings_order = tag_type.ordered ? "#{Taglish::Tagging.table_name}.id" : nil
+
+      class_eval do
+        has_many taggings_scope_name, :as => :taggable,
+                                      :dependent => :destroy,
+                                      :include => :tag,
+                                      :class_name => 'Taglish::Tagging',
+                                      :conditions => ["#{Taglish::Tagging.table_name}.context = ?", ptt],
+                                      :order => taggings_order
+
+        has_many "#{stt}_tags".to_sym, :through => taggings_scope_name,
+                                       :source => :tag,
+                                       :class_name => "Taglish:Tag",
+                                       :order => taggings_order
+
+      end
+
+      class_eval %(
+        def #{stt}_list
+          tag_list_on(tag_types['#{ptt}'])
+        end
+
+        def #{stt}_list=(new_tags)
+          set_tag_list_on(tag_types['#{ptt}'], new_tags)
+        end
+
+        def all_#{ptt}
+          all_tags_list_on('#{ptt}')
+        end
+
+        def add_#{stt}(tag)
+          add_tag_on('#{ptt}', tag)
+        end
+      )
+
+      if scored
+        class_eval %(
+          def score_for_#{stt}(tag)
+            raise "TODO"
+          end
+
+          def set_score_for_#{stt}(tag, score)
+            set_score_for_tag_on('#{ptt}', tag, score)
+          end
+        )
+      end
+    end
+  end
+
+end

data/lib/taglish/tagging.rb

@@ -0,0 +1,50 @@
+class Taglish::Tagging < ActiveRecord::Base
+  include Taglish::Util
+
+  attr_accessible :tag, :tag_id, :context, :taggable, :taggable_type, :taggable_id,
+    :tagger, :tagger_type, :tagger_id, :score, :name
+
+  belongs_to :tag, :class_name => 'Taglish::Tag'
+  belongs_to :taggable, :polymorphic => true
+  belongs_to :tagger, :polymorphic => true
+
+  validates_presence_of :context
+  validates_presence_of :tag_id
+  validates_uniqueness_of :tag_id, :scope => [ :taggable_type, :taggable_id, :context, :tagger_id, :tagger_type ]
+
+  # after_destroy :remove_unused_tags
+
+  def tag_type
+    @tag_type ||= taggable.tag_types[context]
+  end
+
+  def name
+    @name ||= tag.name
+  end
+
+  def name=(v)
+    raise "Can't change the name of a tag/tagging" if @name or (tag and tag.name)
+    @name = v
+  end
+
+  def ==(object)
+    super || (
+      object.is_a?(Tagging) &&
+      context == object.context &&
+      name == object.name &&
+      score == object.score)
+  end
+
+  def to_s
+    score ? "#{name}:#{score}" : name
+  end
+
+  private
+
+  def remove_unused_tags
+    if taggable.remove_unused_tags_for?(context)
+      tag.destroy if tag.taggings.count.zero?
+    end
+  end
+
+end

data/lib/taglish/util.rb

@@ -0,0 +1,4 @@
+module Taglish::Util
+
+
+end

data/lib/taglish/version.rb

@@ -0,0 +1,3 @@
+module Taglish
+  VERSION = '0.1.0'
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'taglish'

data/spec/database.yml.sample

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: acts_as_taggable_on.sqlite3
+
+mysql:
+  adapter: mysql2
+  hostname: localhost
+  username: root
+  password:
+  database: acts_as_taggable_on
+  charset: utf8
+  
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: acts_as_taggable_on
+  encoding: utf8

data/spec/models.rb

@@ -0,0 +1,64 @@
+class TaggableModel < ActiveRecord::Base
+  taglish
+  taglish_on :languages
+  taglish_on :skills
+  taglish_on :needs, :offerings
+  has_many :untaggable_models
+end
+
+class CachedModel < ActiveRecord::Base
+  taglish
+end
+
+class OtherCachedModel < ActiveRecord::Base
+  taglish_on :languages, :statuses, :glasses
+end
+
+class OtherTaggableModel < ActiveRecord::Base
+  taglish_on :tags, :languages
+  taglish_on :needs, :offerings
+end
+
+class InheritingTaggableModel < TaggableModel
+end
+
+class AlteredInheritingTaggableModel < TaggableModel
+  taglish_on :parts
+end
+
+class TaggableUser < ActiveRecord::Base
+  # TODO LATER
+  # acts_as_tagger
+end
+
+class InheritingTaggableUser < TaggableUser
+end
+
+class UntaggableModel < ActiveRecord::Base
+  belongs_to :taggable_model
+end
+
+class NonStandardIdTaggableModel < ActiveRecord::Base
+  primary_key = "an_id"
+  taglish
+  taglish_on :languages
+  taglish_on :skills
+  taglish_on :needs, :offerings
+  has_many :untaggable_models
+end
+
+class OrderedTaggableModel < ActiveRecord::Base
+  ordered_taglish
+  ordered_taglish_on :colors
+end
+
+class MixedTaggableModel < ActiveRecord::Base
+  taglish_on :skills
+  ordered_taglish_on :colors
+  scored_taglish_on :question_counts
+  taglish_on :needs, :offerings
+end
+
+class ScoredTaggableModel < ActiveRecord::Base
+  scored_taglish_on :question_counts
+end