tags 1.0.1 → 1.1.0

data/lib/tags.rb

@@ -1,48 +1,35 @@
-require 'set'
-require 'active_support'
+require 'forwardable'
 
 class Tags
+  extend Forwardable
+  include Enumerable
 
-  include Comparable
+  def_delegators :tags, :empty?, :to_ary, :to_a, :each, :size
 
-  ##################################################
-
-  def initialize(str_or_ary = nil)
-    ary = str_or_ary.is_a?(Array) ? str_or_ary : str_or_ary.to_s.split(' ')
-    @tags_set = Set.new(ary)
+  def initialize(tags)
+    @tags = tags.is_a?(Array) ? tags : tags.to_s.split(/\W+/)
+    @tags.each &:downcase!
+    @tags.uniq!
   end
 
   def to_s
-    to_a.join(' ')
-  end
-
-  def to_a
-    tags_set.to_a
+    tags.join ', '
   end
 
-  def to_set
-    tags_set.dup
+  def +(other)
+    self.class.new(to_a + other.to_a)
   end
 
   def -(other)
-    raise ArgumentError, "must be a #{self.class} object" unless other.is_a?(self.class)
-    ary_diff = (tags_set - other.to_set).to_a
-    self.class.new(ary_diff)
-  end
-
-  def +(other)
-    raise ArgumentError, "must be a #{self.class} object" unless other.is_a?(self.class)
-    ary_add = (tags_set + other.to_set).to_a
-    self.class.new(ary_add)
+    self.class.new(to_a - other.to_a)
   end
 
-  def <=>(other)
-    tags_set <=> other.to_set
+  def ==(other)
+    to_a == Array(other)
   end
 
-  ##################################################
-  private
+private
 
-  attr_reader :tags_set
+  attr_reader :tags
 
 end

data/lib/tags/version.rb

@@ -1,3 +1,3 @@
 class Tags
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/tags_spec.rb

@@ -2,68 +2,86 @@ require 'spec_helper'
 
 describe Tags do
 
-  describe "#to_s" do
-    it { Tags.new("one two").to_s.should eq("one two") }
-    it { Tags.new.to_s.should eq("") }
-  end
+  describe "instance methods" do
+    subject { described_class.new @arg }
 
-  describe "#to_a" do
-    it { Tags.new("one two").to_a.should eq(["one", "two"]) }
-    it { Tags.new.to_a.should eq([]) }
-  end
+    describe "#to_s" do
+      context "with a blank string" do
+        before { @arg = "" }
+        its(:to_s) { should eq("") }
+      end
 
-  describe "#to_set" do
-    it { Tags.new("one two").to_set.should eq(Set.new(["one", "two"])) }
-    it { Tags.new.to_set.should eq(Set.new) }
-  end
+      context "with tags separated by commas or whitespace" do
+        before { @arg = "barley, hops water, yeast" }
+        its(:to_s) { should eq("barley, hops, water, yeast") }
+      end
 
-  describe "#-" do
-    context "with a Tags" do
-      it { (Tags.new - Tags.new("one")).should eq(Tags.new) }
-      it { (Tags.new("one") - Tags.new("one")).should eq(Tags.new) }
-      it { (Tags.new("one two") - Tags.new("one")).should eq(Tags.new("two")) }
-      it { (Tags.new("one two") - Tags.new("three")).should eq(Tags.new("one two")) }
-      it { (Tags.new("one two three") - Tags.new("one three")).should eq(Tags.new("two")) }
+      context "given nil" do
+        before { @arg = nil }
+        its(:to_s) { should eq("") }
+      end
     end
 
-    it "argument must be of the Tags type" do
-      lambda do
-        Tags.new("one") - ["one"]
-      end.should raise_error(ArgumentError, "must be a Tags object")
-    end
-  end
+    describe "#to_a" do
+      context "with a blank string" do
+        before { @arg = "" }
+        its(:to_a) { should eq([]) }
+      end
 
-  describe "#+" do
-    context "with a Tags" do
-      it { (Tags.new + Tags.new("one")).should eq(Tags.new("one")) }
-      it { (Tags.new("one") + Tags.new("one")).should eq(Tags.new("one")) }
-      it { (Tags.new("one two") + Tags.new).should eq(Tags.new("one two")) }
-      it { (Tags.new("one two") + Tags.new("three")).should eq(Tags.new("one two three")) }
-    end
+      context "with tags separated by commas or whitespace" do
+        before { @arg = "barley, hops water, yeast" }
+        its(:to_a) { should eq(%w[barley hops water yeast]) }
+      end
+
+      context "with duplicate tags" do
+        before { @arg = "barley, hops, barley" }
+        it "eliminates duplicates" do
+          subject.to_a.should eq(%w[barley hops])
+        end
+      end
+
+      context "with mixed-case tags" do
+        before { @arg = "Barley, hOps, YEAST" }
+        it "lowercases the tags" do
+          subject.to_a.should eq(%w[barley hops yeast])
+        end
+      end
 
-    it "argument must be of the Tags type" do
-      lambda do
-        Tags.new("one") + ["one"]
-      end.should raise_error(ArgumentError, "must be a Tags object")
+      context "with duplicate mixed case tags" do
+        before { @arg = "barley, hops, BarlEy" }
+        it "eliminates duplicates ignoring case" do
+          subject.to_a.should eq(%w[barley hops])
+        end
+      end
     end
-  end
 
-  describe "#==" do
-    context "with a Tags containing the same items" do
-      it { Tags.new("one two").should eq(Tags.new("one two")) }
-      it { Tags.new("one two three").should eq(Tags.new("one two three")) }
-      it { Tags.new("one two").should eq(Tags.new("one two")) }
-      it { Tags.new.should eq(Tags.new) }
+    describe "#+" do
+      it "combines tags into one" do
+        @arg = "foo, bar"
+        result = subject + described_class.new("baz, buz")
+        result.should eq(described_class.new("foo, bar, baz, buz"))
+      end
 
-      it { Tags.new("one two").should_not eq(Tags.new("one two three")) }
-      it { Tags.new.should_not eq(Tags.new("one two three")) }
+      # more examples
+      it { (Tags.new(nil) + Tags.new("one")).should eq(Tags.new("one")) }
+      it { (Tags.new("one") + Tags.new("one")).should eq(Tags.new("one")) }
+      it { (Tags.new("one two") + Tags.new(nil)).should eq(Tags.new("one two")) }
+      it { (Tags.new("one two") + Tags.new("three")).should eq(Tags.new("one two three")) }
     end
 
-    context "with a non-Tags" do
-      it { Tags.new("one").should_not eq("str") }
-      it { Tags.new("one").should_not eq(["str"]) }
-      it { Tags.new("one").should_not eq(Set.new(["str"])) }
-      it { Tags.new.should_not eq(nil) }
+    describe "#-" do
+      it "returns the difference of the tags" do
+        @arg = "foo, buz"
+        result = subject - described_class.new("baz, buz")
+        result.should eq(described_class.new("foo"))
+      end
+
+      # more examples
+      it { (Tags.new(nil) - Tags.new("one")).should eq(Tags.new(nil)) }
+      it { (Tags.new("one") - Tags.new("one")).should eq(Tags.new(nil)) }
+      it { (Tags.new("one two") - Tags.new("one")).should eq(Tags.new("two")) }
+      it { (Tags.new("one two") - Tags.new("three")).should eq(Tags.new("one two")) }
+      it { (Tags.new("one two three") - Tags.new("one three")).should eq(Tags.new("two")) }
     end
   end
 

data/tags.gemspec

@@ -16,6 +16,4 @@ Gem::Specification.new do |spec|
   spec.version       = Tags::VERSION
 
   spec.add_development_dependency "rspec", ">= 2.8"
-
-  spec.add_dependency "activesupport", ">= 3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tags
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70244872203780 !ruby/object:Gem::Requirement
+  requirement: &70238186485360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,18 +21,7 @@ dependencies:
         version: '2.8'
   type: :development
   prerelease: false
-  version_requirements: *70244872203780
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: &70244872202800 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70244872202800
+  version_requirements: *70238186485360
 description: A Ruby object with the behavior of a list of tags.
 email:
 - austinthecoder@gmail.com