polytag 0.0.4 → 0.1.0

data/.pryrc

@@ -0,0 +1,27 @@
+begin
+  require 'awesome_print'
+  Pry.config.print = proc { |output, value| output.puts value.ai }
+rescue LoadError => err
+  puts "no awesome_print :("
+end
+
+GEM_DIR  = File.dirname(__FILE__)
+SPEC_DIR = File.join(GEM_DIR, 'spec')
+
+# Load dependencies
+require 'rspec/rails/extensions/active_record/base'
+require 'active_support'
+require 'active_record'
+
+# Load in the support for AR
+require "#{SPEC_DIR}/support/active_record"
+
+# Load in the gem we are testing
+require 'polytag'
+
+# The test models
+require "#{SPEC_DIR}/support/owner"
+require "#{SPEC_DIR}/support/test_taggable_one"
+require "#{SPEC_DIR}/support/test_taggable_two"
+require "#{SPEC_DIR}/support/test_taggable_three"
+require "#{SPEC_DIR}/support/test_taggable_four"

data/.rspec

@@ -1,4 +1,6 @@
 --color
---format documentation
+--format Fuubar
 --backtrace
 --profile
+--order default
+--fail-fast

data/README.md

@@ -1,8 +1,6 @@
 # Polytag
 
-![CircleCI Build Status](https://circleci.com/gh/JIFFinc/polytag.png)
-
-Adds the ability to easily add tags with optional tag groups to models.
+TODO: Write a gem description
 
 ## Installation
 
@@ -20,7 +18,31 @@ Or install it yourself as:
 
 ## Usage
 
-Please see specs in the meantime.
+Basic usage with a model
+
+```ruby
+class User < ActiveRecord::Base
+  include Polytag::Concerns::Taggable
+end
+
+user = User.new
+
+# Add a tag
+user.tag.new('apple')
+=> #<Polytag::Tag>
+
+# Remove a tag
+user.tag.del('apple')
+=> true/false
+
+# Check for tag
+user.tag.has_tag?('apple')
+=> true/false
+
+# Get all tags
+user.tags
+=> #<ActiveRecord::Relation>
+```
 
 ## Contributing
 

data/lib/generators/polytag/install/templates/create_polytag_tables.rb

@@ -2,32 +2,46 @@ class CreatePolytagTables < ActiveRecord::Migration
   def self.up
     # Create the tags table
     create_table :polytag_tags do |t|
-      t.belongs_to :polytag_tag_group, index:true, null: true, default: nil
       t.string :name, index: true
+      t.belongs_to :polytag_tag_group, index: true
       t.timestamps
     end
 
-    # Create the relations table
-    create_table :polytag_tag_relations do |t|
-      t.belongs_to :tagged, polymorphic: true, index: true
-      t.belongs_to :polytag_tag, index: true
+     # Create the tag groups table
+    create_table :polytag_tag_groups do |t|
+      t.string :name, index: true
+      t.belongs_to :owner, polymorphic: true, index: true
       t.timestamps
     end
 
-     # Create the tag groups table
-    create_table :polytag_tag_groups do |t|
+    # Create the tag group relations table
+    create_table :polytag_connections do |t|
+      t.belongs_to :polytag_tag, index: true
+      t.belongs_to :polytag_tag_group, index: true
       t.belongs_to :owner, polymorphic: true, index: true
-      t.string :name, index: true, null: true, default: nil
+      t.belongs_to :tagged, polymorphic: true, index: true
       t.timestamps
     end
 
     # Index for the category and name
-    add_index :polytag_tags, [:polytag_tag_group_id, :name], unique: true
-    add_index :polytag_tag_groups, [:owner_type, :owner_id, :name], unique: true
+    add_index :polytag_tags, [:polytag_tag_group_id, :name],
+      name: :polytag_tags_unique,
+      unique: true
+
+    add_index :polytag_tag_groups,
+      [:owner_type, :owner_id, :name],
+      name: :polytag_tag_groups_unique,
+      unique: true
+
+    add_index :polytag_connections,
+      [:polytag_tag_id, :polytag_tag_group_id, :owner_type, :owner_id, :tagged_type, :tagged_id],
+      name: :polytag_connections_unique,
+      unique: true
   end
 
   def self.down
     drop_table :polytag_tags
-    drop_table :polytag_tag_relations
+    drop_table :polytag_tag_groups
+    drop_table :polytag_tag_connections
   end
 end

data/lib/polytag.rb

@@ -1,87 +1,250 @@
 require "polytag/version"
+require "polytag/exceptions"
+
+# Real work
+require "polytag/connection"
 require "polytag/tag"
 require "polytag/tag_group"
-require "polytag/tag_group/owner"
-require "polytag/tag_relation"
 
+# Taggable Concerns
+require "polytag/concerns/taggable/association_extensions"
+require "polytag/concerns/taggable/class_helpers"
+require "polytag/concerns/taggable/model_helpers"
+require "polytag/concerns/taggable"
+
+# Tag Owner Concerns
+require "polytag/concerns/tag_owner/association_extensions/owned_tags"
+require "polytag/concerns/tag_owner/association_extensions"
+require "polytag/concerns/tag_owner/class_helpers"
+require "polytag/concerns/tag_owner/model_helpers"
+require "polytag/concerns/tag_owner"
+
+# Polytag Module
 module Polytag
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.has_many :polytag_tag_relations, class_name: '::Polytag::TagRelation',
-                                          as: :tagged
+  class << self
+    def get(type = :tag, foc = nil, data = {})
+      force_name_search = false
+      retried = false
+
+      # Allow hashes to be passed
+      if type.is_a?(Hash) || type.is_a?(ActiveRecord::Base)
+        data = type
+        type = nil
+        foc  = nil
+      elsif foc.is_a?(Hash) || foc.is_a?(ActiveRecord::Base)
+        data = foc
+        foc  = nil
+      end
 
-    base.has_many :tag_relations, class_name: '::Polytag::TagRelation',
-                                  as: :tagged
+      # Reject nil or false data keys
+      # also grab the foc value
+      if data.is_a?(Hash)
+        data = data.delete_if { |k, v| v.nil? || v == false }
+        foc  = data.delete(:foc) if data.has_key?(:foc)
+        data[:tag_group] = :default if data[:owner] && ! data[:tag_group]
+      end
 
-    base.has_many :polytag_tags, class_name: '::Polytag::Tag',
-                                 through: :polytag_tag_relations
+      # Ensure that we are processing the right data if the data comes in in a unexpected way
+      if data.is_a?(Hash) && data.keys.size == 1 && [:tag, :tag_group].include?(data.keys.first)
+        type = data.keys.first
+        data = data[data.keys.first]
+      end
 
-    base.has_many :tags, class_name: '::Polytag::Tag',
-                         through: :polytag_tag_relations,
-                         source: :polytag_tag
-  end
+      # Return the model if the model passed matches
+      if data.is_a?(ActiveRecord::Base)
+        return data if data.instance_of?(Tag) && (type ? type == :tag : true)
+        return data if data.instance_of?(TagGroup) && (type ? type == :tag_group : true)
+        return data if data.instance_of?(Connection) && (type ? type == :connection : true)
+        raise NotAPolytagModel, "#{data.inspect} is not a Polytag model in the requested form."
+      elsif data.is_a?(String) || data.is_a?(Symbol)
+        data = "#{data}".strip
+      end
 
-  def tag_group(_tag_group = nil)
-    @__polytag_tag_group_hash__ ||= {}
+      # Handle how the results are returned
+      if data.is_a?(Hash) && data.keys.sort == [:owner, :tag, :tag_group, :tagged]
+
+        # Get the tag owner
+        tag_owner = get_tag_owner_or_taggable(:hash, data[:owner])
+
+        # Get the tag group
+        querydata = {owner: tag_owner, tag_group: data[:tag_group], foc: foc}
+        tag_group = get(:tag_group, foc, querydata)
+
+        # Get the tag
+        querydata = {tag: data[:tag], tag_group: tag_group, foc: foc}
+        tag       = get(:tag, foc, querydata)
+
+        # Create the data we are using to create the connection
+        querydata = tag_owner.merge foc: foc,
+          polytag_tag_id: tag.id,
+          polytag_tag_group_id: tag_group.id,
+          tagged: data[:tagged]
+
+        __connection_processor(querydata)
+      elsif data.is_a?(Hash) && data.keys.sort == [:tag, :tag_group, :tagged]
+
+        # Get the tag group
+        querydata = {tag_group: data[:tag_group], foc: foc}
+        tag_group = get(:tag_group, foc, querydata)
+
+        # Get the tag
+        querydata = {tag: data[:tag], tag_group: tag_group, foc: foc}
+        tag       = get(:tag, foc, querydata)
+
+        # Create the data we are using to create the connection
+        querydata = {}.merge foc: foc,
+          polytag_tag_group_id: tag_group.id,
+          polytag_tag_id: tag.id,
+          tagged: data[:tagged]
+
+        __connection_processor(querydata)
+      elsif data.is_a?(Hash) && data.keys.sort == [:tag, :tagged]
+
+        # Get the tag
+        querydata = {tag: data[:tag], foc: foc}
+        tag = get(:tag, foc, querydata) do |ar|
+          ar.where(polytag_tag_group_id: nil)
+        end
+
+        # If we expected a result and we don't have one raise
+        raise CantFindPolytagModel if foc && ! tag
+
+        # Create the data we are using to create the connection
+        querydata = {}.merge foc: foc,
+          polytag_tag_group_id: nil,
+          polytag_tag_id: tag.id,
+          tagged: data[:tagged]
+
+        __connection_processor(querydata)
+      elsif data.is_a?(Hash) && data.keys.sort == [:owner, :tag, :tag_group]
+
+        # Get the tag owner
+        tag_owner = get_tag_owner_or_taggable(data[:owner])
+
+        # Get the tag group
+        querydata = {owner: tag_owner, tag_group: data[:tag_group], foc: foc}
+        tag_group = get(:tag_group, foc || :first, querydata)
+
+        # Get the tag
+        querydata = {tag: data[:tag], tag_group: tag_group, foc: foc}
+        tag       = get(:tag, foc, querydata)
+
+        return tag
+      elsif data.is_a?(Hash) && data.keys.sort == [:owner, :tag_group]
+        # Get the tag group with owner
+        tag_owner = get_tag_owner_or_taggable(:hash, data[:owner])
+
+        get(:tag_group, foc, data[:tag_group]) do |ar|
+          ar.where(tag_owner)
+        end
+      elsif data.is_a?(Hash) && data.keys.sort == [:tag, :tag_group]
+        # Get the tag with tag group
+        tag_group = get(:tag_group, foc || :first, data[:tag_group])
+
+        get(:tag, foc, data[:tag]) do |ar|
+          ar.where(polytag_tag_group_id: tag_group.id)
+        end
+      elsif type && ! force_name_search && __numerical_string_id?(data)
+
+        # Force foc to be a first if the option is requested
+        foc = :first if foc
+
+        result = const_get("#{type}".camelize).where(id: data.to_i)
+        result = yield(result) if block_given?
+        result = result.__send__(foc) if foc
+        return result
+      elsif type && (force_name_search || data.is_a?(String))
+
+        result = const_get("#{type}".camelize).where(name: data)
+        result = yield(result) if block_given?
+        result = result.__send__(foc) if foc
+        return result
+      else
+        raise CantFindPolytagModel, "Can't find a polytag model with #{data.inspect}."
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      raise e if e.instance_of?(CantFindPolytagModel) || retried
+      force_name_search = true
+      retried = true
+      foc = :first
+      retry
+    end
 
-    if _tag_group
-      @__polytag_tag_group_hash__.merge!(_tag_group)
-      @__polytag_tag_group__ = Polytag::TagGroup.search_by_hash(@__polytag_tag_group_hash__).first_or_create
-    else
-      @__polytag_tag_group_hash__ = {} if _tag_group.is_a?(Hash) && _tag_group.empty?
-      @__polytag_tag_group__
+    def tag_group_owner?(owner = {}, raise_on_error = false)
+      owner = get_polymorphic(owner)
+      return true if __inherits(data.class, ActiveRecord::Base, Concerns::TagOwner)
+      raise NotTagOwner, "This model #{owner.inspect} is not a polytag tag owner."
+    rescue NotTagOwner, NotTagOwnerOrTaggable => e
+      raise e unless raise_on_error
+      false
     end
-  end
 
-  def add_tag(tag, _tag_group = {})
-    polytag_tags << polytag_tags.where(name: tag, polytag_tag_group_id: tag_group(_tag_group).try(&:id)).first_or_initialize
-  end
+    def get_tag_owner_or_taggable(result = :object, data = {})
 
-  def add_tag!(tag, _tag_group = {})
-    polytag_tags << polytag_tags.where(name: tag, polytag_tag_group_id: tag_group(_tag_group).try(&:id)).first_or_create
-  end
+      # Ensure result is is always set
+      if result.is_a?(Hash) || result.is_a?(ActiveRecord::Base)
+        data   = result
+        result = :object
+      end
 
-  def add_tags(*_tags)
-    _tag_group = _tags.pop if _tags.last.is_a?(Hash)
-    _tags.map { |x| add_tag(x, _tag_group || {}) }
-  end
+      if data.is_a?(Hash)
+        data = if data.keys.sort == [:id, :type]
+          data[:type].camelize.constantize.find(data[:id])
+        elsif data.keys.sort == [:owner_id, :owner_type]
+          data[:owner_type].camelize.constantize.find(data[:owner_id])
+        elsif data.keys.sort == [:tagged_id, :tagged_type]
+          data[:tagged_type].camelize.constantize.find(data[:tagged_id])
+        end
+      end
 
-  def add_tags!(*_tags)
-    _tag_group = _tags.pop if _tags.last.is_a?(Hash)
-    _tags.map { |x| add_tag!(x, _tag_group || {}) }
-  end
+      # The class we need to test
+      dclass = data.class
 
-  def remove_tag!(tag, _tag_group = {})
-    tag_id = polytag_tags.where(name: tag, polytag_tag_group_id: tag_group(_tag_group).try(&:id)).first.try(:id)
-    tag_relations.where("polytag_tag_relations.polytag_tag_id = ?", tag_id).delete_all
-  end
+      # Ensure that the model we return is a taggable or tag owner
+      if __inherits(dclass, ActiveRecord::Base, Concerns::TagOwner) || __inherits(dclass, ActiveRecord::Base, Concerns::Taggable)
 
-  module ClassMethods
+        # Return hash options for the type
+        if result == :hash
+          if __inherits(dclass, ActiveRecord::Base, Concerns::TagOwner)
+            return {owner_type: "#{dclass}", owner_id: data.id}
+          elsif __inherits(dclass, ActiveRecord::Base, Concerns::Taggable)
+            return {tagged_type: "#{dclass}", tagged_id: data.id}
+          end
+        end
 
-    # Get records with tags
-    def has_tags(*tags)
-      includes(polytag_tag_relations: :polytag_tag).references(:polytag_tags).where("polytag_tags.name IN (?)", tags).group("#{table_name}.id")
+        # Return the raw object
+        return data if result == :object
+      end
+
+      # Raise if not a taggable or tag owner object
+      raise NotTagOwnerOrTaggable, "The model #{data.inspect} is not a polytag tag owner or taggable model."
     end
 
-    alias_method :has_tag, :has_tags
+    private
 
-    def in_tag_group(_tag_group = {})
-      if _tag_group[:group_ids]
-        tag_groups = _tag_group[:group_ids]
-      else
-        tag_groups = Polytag::TagGroup.select('polytag_tag_groups.id').search_by_hash(_tag_group).map{ |tg| tg.try(:id) }.flatten
+    def __inherits(klass, *ancestors)
+      ancestors.inject(true) do |result, ancestor|
+        result && klass.ancestors.include?(ancestor)
       end
+    end
 
-      return tag_groups if _tag_group[:multi]
+    def __connection_processor(data)
+      foc = data.delete(:foc)
 
-      includes(polytag_tag_relations: :polytag_tag).references(:polytag_tags).where('polytag_tags.polytag_tag_group_id IN (?)', tag_groups)
-    end
+      # Get the item we are trying to tag
+      taggable  = get_tag_owner_or_taggable(:hash, data.delete(:tagged))
+
+      # Get the connection where statement
+      connection_hash = data.merge(taggable)
 
-    def in_tag_groups(*tag_groups)
-      tag_groups = tag_groups.map{ |tg| in_tag_group(tg.merge(multi: true)) }.flatten.compact
-      in_tag_group(group_ids: tag_groups)
+      # Find the object and create it if applicable
+      result = Connection.where(connection_hash)
+      result = result.__send__(foc) if foc
+      result
     end
 
-    # @TODO: Implement results must be connected to all tags
+    def __numerical_string_id?(data)
+      (data.is_a?(String) && data.match(/^\d+$/)) || data.is_a?(Fixnum)
+    end
   end
 end