mongoid-tags-arent-hard 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongoid_delorean.gemspec
+gemspec
+
+gem "rspec"
+gem 'database_cleaner'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Mark Bates
+
+MIT License
+
+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,91 @@
+# Mongoid::TagsArentHard
+
+A tagging gem for Mongoid 3 that doesn't actually suck.
+
+For some reason all of the tagging gems for Mongoid suck. Not sure why, it's really not that hard a problem to solve. One of the biggest complaints I have is that you can't have a model that has two types of "tags". The other problem I have with the other gems is that I want to be able to set my tags equal to a string and have it become an Array, and vice versa. This gem solves both of those problems.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mongoid-tags-arent-hard'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid-tags-arent-hard
+
+## Usage
+
+To add tags to a model you need to first include the <code>Mongoid::TagsArentHard</code> module and then define what you want the field to be called using the <code>taggable_with</code> method.
+
+<pre><code>
+class Foo
+  include Mongoid::Document
+  include Mongoid::TagsArentHard
+
+  taggable_with :tags
+  taggable_with :colors, separator: ";"
+end
+</code></pre>
+
+Now we have two different types of "tags"; the first being called <code>tags</code> and the second being called <code>colors</code>. We have also told the <code>colors</code> to use <code>";"</code> as its separator.
+
+Now we can do fun things like this:
+
+<pre><code>
+# set with either a string or an array:
+foo = Foo.new(tags: "a,b,c", colors: ["red", "blue"])
+
+# retrieve the list:
+foo.tags #=> ["a", "b", "c"]
+foo.colors #=> ["red", "blue"]
+
+# append with either a string or an array:
+foo.tags << "d"
+foo.tags #=> ["a", "b", "c", "d"]
+foo.colors << ["green", "yellow"]
+foo.colors #=> ["red", "blue", "green", "yellow"]
+
+# set with either a string or an array:
+foo.tags = ["x", "y", "z"]
+foo.tags #=> ["x", "y", "z"]
+foo.colors = "black;brown"
+foo.colors #=> ["black", "brown"]
+</code></pre>
+
+### Searching
+
+There are a few scopes included that make it easy to find objects that have the tags you are looking for. These methods are generated using the name of the field you designed, so in our previous example we would have the following methods available to us:
+
+<pre><code>
+# Find objects with any of the values:
+Foo.with_any_tags("a")
+Foo.with_any_tags(["a", "b"])
+Foo.with_any_tags("a, b")
+Foo.with_any_colors("a")
+Foo.with_any_colors(["a", "b"])
+Foo.with_any_colors("a, b")
+
+# Find objects with all of these values:
+Foo.with_all_tags("a")
+Foo.with_all_tags(["a", "b"])
+Foo.with_all_tags("a, b")
+Foo.with_all_colors("a")
+Foo.with_all_colors(["a", "b"])
+Foo.with_all_colors("a, b")
+</code></pre>
+
+Again, notice that you can use either a string, an array, or a splatted list as values to these scopes.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write your tests
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'  
+Bundler::GemHelper.install_tasks
+
+desc "Run tests"
+task :default => [:ruby]
+
+task :ruby do
+  system "bundle exec rspec"
+end

data/lib/mongoid-tags-arent-hard.rb

@@ -0,0 +1,18 @@
+require 'delegate'
+require 'mongoid'
+require "mongoid/tags_arent_hard/version"
+require "mongoid/tags_arent_hard/configuration"
+require "mongoid/tags_arent_hard/tags_arent_hard"
+require "mongoid/tags_arent_hard/tags"
+
+module Mongoid
+  module TagsArentHard
+
+    def self.config(&block)
+      @config ||= Configuration.new
+      yield @config if block_given?
+      return @config
+    end
+    
+  end
+end

data/lib/mongoid/tags_arent_hard/configuration.rb

@@ -0,0 +1,12 @@
+module Mongoid
+  module TagsArentHard
+    class Configuration
+      attr_accessor :separator
+
+      def initialize
+        self.separator = ","
+      end
+
+    end
+  end
+end

data/lib/mongoid/tags_arent_hard/tags.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module TagsArentHard
+    class Tags
+
+      attr_accessor :tag_list
+      attr_accessor :options
+      delegate :join, :map, :each, :inspect, :==, :===, :eql?, :__bson_dump__, to: :tag_list
+
+      def initialize(*tag_list, options)
+        self.options = {separator: Mongoid::TagsArentHard.config.separator}.merge(options)
+        self.tag_list = []
+        self.<<(*tag_list)
+      end
+
+      def normalize(*tag_list)
+        tag_list.flatten.map {|s| s.split(self.options[:separator]).map {|x| x.strip}}.flatten
+      end
+
+      def <<(*tag_list)
+        self.tag_list << self.normalize(*tag_list)
+        self.tag_list.flatten!
+        self.tag_list.uniq!
+        return self.tag_list
+      end
+
+      def to_s
+        self.join(self.options[:separator])
+      end
+
+      def to_str
+        self.to_s
+      end
+
+    end
+  end
+end

data/lib/mongoid/tags_arent_hard/tags_arent_hard.rb

@@ -0,0 +1,46 @@
+module Mongoid
+  module TagsArentHard
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      
+      def taggable_with(name, options = {})
+        options = {separator: Mongoid::TagsArentHard.config.separator}.merge(options)
+        self.field(name, type: Array, default: [])
+        self.class_eval do
+          define_method(name) do
+            val = super()
+            unless val.is_a?(Mongoid::TagsArentHard::Tags)
+              val = Mongoid::TagsArentHard::Tags.new(val, options)
+              self.send("#{name}=", val)
+            end
+            return val
+          end
+          define_method("#{name}=") do |val|
+            unless val.is_a?(Mongoid::TagsArentHard::Tags)
+              val = Mongoid::TagsArentHard::Tags.new(val, options)
+            end
+            super(val)
+          end
+
+        end
+        self.class.send(:define_method, "with_#{name}") do |*val|
+          self.send("with_any_#{name}", *val)
+        end
+
+        self.class.send(:define_method, "with_any_#{name}") do |*val|
+          any_in(name => Mongoid::TagsArentHard::Tags.new(*val, {}).tag_list)
+        end
+
+        self.class.send(:define_method, "with_all_#{name}") do |*val|
+          all_in(name => Mongoid::TagsArentHard::Tags.new(*val, {}).tag_list)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mongoid/tags_arent_hard/version.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  module Tags
+    module Arent
+      module Hard
+        VERSION = "1.0.0"
+      end
+    end
+  end
+end

data/mongoid-tags-arent-hard.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid/tags_arent_hard/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mongoid-tags-arent-hard"
+  gem.version       = Mongoid::Tags::Arent::Hard::VERSION
+  gem.authors       = ["Mark Bates"]
+  gem.email         = ["mark@markbates.com"]
+  gem.description   = %q{A tagging gem for Mongoid 3 that doesn't actually suck.}
+  gem.summary       = %q{A tagging gem for Mongoid 3 that doesn't actually suck.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency("mongoid", ">=3.0.0")
+end

data/spec/config.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: mongoid_tags_arent_hard_test
+      hosts:
+        - localhost:27017

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'bundler/setup'
+
+require 'mongoid-tags-arent-hard' # and any other gems you need
+
+require 'database_cleaner'
+
+Mongoid.load!(File.join(File.dirname(__FILE__), "config.yml"), :test)
+# require File.join(File.dirname(__FILE__), "support", "models")
+
+DatabaseCleaner[:mongoid].strategy = :truncation
+
+RSpec.configure do |config|
+
+  config.before(:each) do
+    DatabaseCleaner.clean
+    Mongoid::TagsArentHard.config.separator = ","
+  end
+
+  config.after(:each) do
+    Mongoid::TagsArentHard.config.separator = ","
+  end
+
+end

data/spec/tags_arent_hard/tags_arent_hard_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+class Foo
+  include Mongoid::Document
+  include Mongoid::TagsArentHard
+
+  taggable_with :tags
+  taggable_with :colors, separator: ";"
+end
+
+describe Mongoid::TagsArentHard do
+  
+  let(:foo) { Foo.new }
+
+  {tags: ",", colors: ";"}.each do |_name, _separator|
+
+    describe ".taggable_with" do
+
+      it "defines a getter for '#{_name}'" do
+        foo.send(_name).should be_kind_of(Mongoid::TagsArentHard::Tags)
+        foo.send(_name).should eql([])
+      end
+
+      it "defines a setter for '#{_name}' (string)" do
+        foo.send("#{_name}=", "foo #{_separator} bar")
+        foo.send(_name).should eql(["foo","bar"])
+      end
+
+      it "defines a setter for '#{_name}' (array)" do
+        foo.send("#{_name}=", ["foo", "bar"])
+        foo.send(_name).should eql(["foo","bar"])
+      end
+      
+    end
+
+    describe '#save' do
+      
+      it "saves the #{_name} correctly" do
+        foo.send("#{_name}=", "foo#{_separator}bar")
+        foo.save!
+        foo.reload
+        foo.send(_name).should eql(["foo","bar"])
+      end
+
+    end
+
+    context 'class scopes' do
+
+      before(:each) do
+        @foo1 = Foo.create!(_name => "a#{_separator}b#{_separator}c")
+        @foo2 = Foo.create!(_name => "b#{_separator}c#{_separator}f")
+        @foo3 = Foo.create!(_name => "d#{_separator}e#{_separator}f")
+      end
+      
+      describe "with_#{_name}" do
+        
+        it "returns all models with a specific #{_name} (splatted)" do
+          results = Foo.send("with_#{_name}", "a")
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_#{_name}", "b")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+        end
+
+        it "returns all models with a specific #{_name} (arrayed)" do
+          results = Foo.send("with_#{_name}", ["a"])
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_#{_name}", ["b"])
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+        end
+
+      end
+
+      describe "with_any_#{_name}" do
+        
+        it "returns all models with any #{_name} (splatted)" do
+          results = Foo.send("with_any_#{_name}", "a")
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_any_#{_name}", "b")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+
+          results = Foo.send("with_any_#{_name}", "a", "e")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo3)
+        end
+
+        it "returns all models with any #{_name} (arrayed)" do
+          results = Foo.send("with_any_#{_name}", ["a"])
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_any_#{_name}", ["b"])
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+
+          results = Foo.send("with_any_#{_name}", ["a", "e"])
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo3)
+        end
+
+        it "returns all models with any #{_name} (string)" do
+          results = Foo.send("with_any_#{_name}", "a")
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_any_#{_name}", "b")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+
+          results = Foo.send("with_any_#{_name}", "a,e")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo3)
+        end
+
+      end
+
+      describe "with_all_#{_name}" do
+        
+        it "returns all models with all #{_name} (splatted)" do
+          results = Foo.send("with_all_#{_name}", "a")
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_all_#{_name}", "b")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+
+          results = Foo.send("with_all_#{_name}", "a", "e")
+          results.should have(0).foos
+
+          results = Foo.send("with_all_#{_name}", "b", "f")
+          results.should have(1).foo
+          results.should include(@foo2)
+        end
+
+        it "returns all models with all #{_name} (arrayed)" do
+          results = Foo.send("with_all_#{_name}", ["a"])
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_all_#{_name}", ["b"])
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+
+          results = Foo.send("with_all_#{_name}", ["a", "e"])
+          results.should have(0).foos
+
+          results = Foo.send("with_all_#{_name}", ["b", "f"])
+          results.should have(1).foo
+          results.should include(@foo2)
+        end
+
+        it "returns all models with all #{_name} (string)" do
+          results = Foo.send("with_all_#{_name}", "a")
+          results.should have(1).foo
+          results.should include(@foo1)
+
+          results = Foo.send("with_all_#{_name}", "b")
+          results.should have(2).foos
+          results.should include(@foo1)
+          results.should include(@foo2)
+
+          results = Foo.send("with_all_#{_name}", "a,e")
+          results.should have(0).foos
+
+          results = Foo.send("with_all_#{_name}", "b,f")
+          results.should have(1).foo
+          results.should include(@foo2)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/tags_arent_hard/tags_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe Mongoid::TagsArentHard::Tags do
+  
+  let(:tags) { Mongoid::TagsArentHard::Tags.new(%w{foo bar baz}, {}) }
+
+  after(:each) do
+    Mongoid::TagsArentHard.config.separator = ","
+  end
+
+  describe 'initialize' do
+    
+    it "takes an array of tags" do
+      tags = Mongoid::TagsArentHard::Tags.new(["foo", "bar"], {})
+      tags.should eql(["foo", "bar"])
+    end
+
+    it "takes a splatted list" do
+      tags = Mongoid::TagsArentHard::Tags.new("foo", "bar", {})
+      tags.should eql(["foo", "bar"])
+    end
+
+    it "takes a string" do
+      tags = Mongoid::TagsArentHard::Tags.new("foo,bar", {})
+      tags.should eql(["foo", "bar"])
+    end
+
+    it "takes a string with a different separator" do
+      tags = Mongoid::TagsArentHard::Tags.new("foo bar", separator: " ")
+      tags.should eql(["foo", "bar"])
+    end
+
+  end
+
+  describe '<<' do
+    
+    it "takes a string" do
+      tags << "fubar"
+      tags.should eql(["foo", "bar", "baz", "fubar"])
+
+      tags << "a,b"
+      tags.should eql(["foo", "bar", "baz", "fubar", "a", "b"])
+    end
+
+    it "takes an array" do
+      tags << ["a", "b"]
+      tags.should eql(["foo", "bar", "baz", "a", "b"])
+    end
+
+    it "should not allow duplicates" do
+      tags << "foo"
+      tags.should eql(["foo", "bar", "baz"])
+    end
+
+  end
+
+  describe 'to_s, to_str' do
+    
+    it "returns a comma separated list of tags" do
+      tags.to_s.should eql("foo,bar,baz")
+      tags.to_str.should eql("foo,bar,baz")
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-tags-arent-hard
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mark Bates
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: A tagging gem for Mongoid 3 that doesn't actually suck.
+email:
+- mark@markbates.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mongoid-tags-arent-hard.rb
+- lib/mongoid/tags_arent_hard/configuration.rb
+- lib/mongoid/tags_arent_hard/tags.rb
+- lib/mongoid/tags_arent_hard/tags_arent_hard.rb
+- lib/mongoid/tags_arent_hard/version.rb
+- mongoid-tags-arent-hard.gemspec
+- spec/config.yml
+- spec/spec_helper.rb
+- spec/tags_arent_hard/tags_arent_hard_spec.rb
+- spec/tags_arent_hard/tags_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A tagging gem for Mongoid 3 that doesn't actually suck.
+test_files:
+- spec/config.yml
+- spec/spec_helper.rb
+- spec/tags_arent_hard/tags_arent_hard_spec.rb
+- spec/tags_arent_hard/tags_spec.rb