govuk_content_models 14.1.1 → 15.0.0

data/app/models/artefact.rb

@@ -212,7 +212,8 @@ class Artefact
   def as_json(options={})
     super.tap { |hash|
       if hash["tag_ids"]
-        hash["tags"] = Tag.by_tag_ids!(hash["tag_ids"]).map(&:as_json)
+        Tag.validate_tag_ids(hash["tag_ids"])
+        hash["tags"] = Tag.by_tag_ids(hash["tag_ids"]).map(&:as_json)
       else
         hash["tag_ids"] = []
         hash["tags"] = []
@@ -354,7 +355,6 @@ class Artefact
   end
 
   def snapshot
-    reconcile_tag_ids
     attributes.except "_id", "created_at", "updated_at", "actions"
   end
 

data/app/models/tag.rb

@@ -3,7 +3,7 @@ require 'tag_id_validator'
 
 class Tag
   include Mongoid::Document
-  
+
   field :tag_id,            type: String
   field :title,             type: String
   field :tag_type,          type: String #TODO: list of accepted types?
@@ -66,17 +66,18 @@ class Tag
   end
 
   def self.by_tag_id(tag_id, tag_type = nil)
-    scope = tag_type ? Tag.where(tag_type: tag_type) : Tag
-    scope.where(tag_id: tag_id).first
+    by_tag_ids([tag_id], tag_type).first
   end
 
-  # Retrieve a list of tags by tag ID. Any missing tags become `nil`.
   def self.by_tag_ids(tag_id_list, tag_type = nil)
-    scope = tag_type ? Tag.where(tag_type: tag_type) : Tag
+    tag_scope = tag_type ? Tag.where(tag_type: tag_type) : Tag
+    tag_scope = tag_scope.any_in(tag_id: tag_id_list)
 
-    # Load up all the tags in a single query
-    tags = scope.any_in(tag_id: tag_id_list).to_a
-    tag_id_list.map { |tag_id| tags.find { |t| t.tag_id == tag_id } }
+    # Sort by id list because MongoID 2.x doesn't preserve order
+    tags_by_id = tag_scope.each_with_object({}) do |tag, hash|
+      hash[tag.tag_id] = tag
+    end
+    tag_id_list.map { |tag_id| tags_by_id[tag_id] }.compact
   end
 
   def self.by_tag_types_and_ids(tag_types_and_ids)
@@ -85,16 +86,9 @@ class Tag
   end
 
   # Retrieve a list of tags by tag ID. Any missing tags raise an exception.
-  def self.by_tag_ids!(tag_id_list, tag_type = nil)
-    tags = by_tag_ids(tag_id_list, tag_type)
-    if tags.any?(&:nil?)
-      # Find the tag IDs for which the resulting tag is nil
-      missing_ids = tag_id_list.zip(tags).select { |tag_id, tag|
-        tag.nil?
-      }.map(&:first)
-      raise MissingTags, missing_ids
-    else
-      tags
-    end
+  def self.validate_tag_ids(tag_id_list, tag_type = nil)
+    found_tags = by_tag_ids(tag_id_list, tag_type)
+    missing_tag_ids = tag_id_list - found_tags.map(&:tag_id)
+    raise MissingTags.new(missing_tag_ids) if missing_tag_ids.any?
   end
 end

data/app/traits/taggable.rb

@@ -1,39 +1,47 @@
 module Taggable
   module ClassMethods
-    def stores_tags_for(*keys)
-      tag_types = keys.to_a.flatten.compact.map(&:to_s)
+    def stores_tags_for(*tag_types)
+      tag_types = tag_types.map {|tag_type|
+        raise ArgumentError.new("Please provide tag types as symbols") unless tag_type.is_a?(Symbol)
+        tag_type.to_s
+      }
+
       class_attribute :tag_types
       self.tag_types = tag_types
 
-      tag_types.each do |k|
-        define_method "#{k}=" do |values|
-          set_tags_of_type(k, values)
+      tag_types.each do |tag_type|
+        define_method("#{tag_type}=") do |tag_ids|
+          set_tags_of_type(tag_type, tag_ids)
         end
-        alias_method :"#{k.singularize}_ids=", :"#{k}="
+        alias_method :"#{tag_type.singularize}_ids=", :"#{tag_type}="
 
-        define_method k do
-          tags_of_type(k.singularize)
+        define_method(tag_type) do |*args|
+          include_draft = args.first
+          tags_of_type(tag_type.singularize, include_draft)
         end
-        define_method "#{k.singularize}_ids" do
-          tags_of_type(k.singularize).collect(&:tag_id)
+
+        define_method("#{tag_type.singularize}_ids") do |*args|
+          send(tag_type, *args).map(&:tag_id)
         end
       end
     end
 
-    def has_primary_tag_for(*keys)
-      tag_types = keys.to_a.flatten.compact.map(&:to_s)
+    def has_primary_tag_for(*tag_types)
+      tag_types = tag_types.map {|tag_type|
+        raise ArgumentError.new("Please provide tag types as symbols") unless tag_type.is_a?(Symbol)
+        tag_type.to_s
+      }
+
       class_attribute :primary_tag_types
       self.primary_tag_types = tag_types
 
-      tag_types.each do |key|
-        method_name = "primary_#{key}"
-
-        define_method "#{method_name}=" do |value|
-          set_primary_tag_of_type(key.to_s, value)
+      tag_types.each do |tag_type|
+        define_method("primary_#{tag_type}=") do |tag_id|
+          set_primary_tag_of_type(tag_type, tag_id)
         end
 
-        define_method method_name do
-          tags_of_type(key.to_s).first
+        define_method("primary_#{tag_type}") do
+          tags_of_type(tag_type).first
         end
       end
     end
@@ -49,74 +57,50 @@ module Taggable
     klass.__send__       :private, :tag_ids=
   end
 
-  def set_tags_of_type(collection_name, values)
+  def set_tags_of_type(collection_name, tag_ids)
     tag_type = collection_name.singularize
+    tag_ids = Array(tag_ids)
 
-    # Ensure all tags loaded from database. This feels inelegant
-    # but ensures integrity. It could go away if we moved to a more
-    # consistent repository approach to retrieving and constructing
-    # objects, or if we used a custom serialization type for tags
-    # as documented on http://mongoid.org/en/mongoid/docs/documents.html
-    tags
+    Tag.validate_tag_ids(tag_ids, tag_type)
 
-    # Make sure that 'values' is an array. This stops the method blowing up
-    # if nil is provided.
-    values_as_array = Array(values)
+    current_tags = attributes['tags'].reject {|t| t[:tag_type] == tag_type }
 
-    # This will raise a Tag::MissingTags exception unless all the tags exist
-    new_tags = Tag.by_tag_ids!(values_as_array, tag_type)
-
-    @tags.reject! { |t| t.tag_type == tag_type }
-    @tags += new_tags
+    self.tags = current_tags + tag_ids.map {|tag_id|
+      {tag_id: tag_id, tag_type: tag_type}
+    }
   end
 
   # The primary tag is simply the first one of its
   # type. If that tag is already applied this method
   # moves it to the start of the list. If it's not then
   # we add it at the start of the list.
-  def set_primary_tag_of_type(tag_type, value)
-    tags
+  def set_primary_tag_of_type(tag_type, tag_id)
+    Tag.validate_tag_ids([tag_id], tag_type)
 
-    tag = Tag.by_tag_id(value, tag_type)
-    raise "Missing tag" unless tag
-    raise "Wrong tag type" unless tag.tag_type == tag_type
+    tag_tuple = {tag_id: tag_id, tag_type: tag_type}
 
-    @tags -= [tag]
-    @tags.unshift(tag)
-  end
+    current_tags = attributes['tags'].dup
+    current_tags.delete(tag_tuple)
 
-  def tags_of_type(tag_type)
-    tags.select { |t| t.tag_type == tag_type }
+    self.tags = current_tags.unshift(tag_tuple)
   end
 
-  def reconcile_tag_ids
-    # Ensure tags are loaded so we don't accidentally
-    # remove all tagging in situations where tags haven't
-    # been accessed during the lifetime of the object
-    tags
-
-    self.tag_ids = @tags.collect(&:tag_id)
-    self.tags = @tags.map {|tag|
-      { tag_id: tag.tag_id, tag_type: tag.tag_type }
-    }
-  end
-
-  def tags
-    @tags ||= Tag.by_tag_ids(tag_ids).compact.to_a
+  def tags_of_type(tag_type, include_draft = false)
+    tags(include_draft).select { |t| t.tag_type == tag_type }
   end
 
-  def reload
-    @tags = nil
-    super
+  def tags=(new_tag_tuples)
+    self.tag_ids = new_tag_tuples.map {|tuple| tuple[:tag_id] }
+    super(new_tag_tuples)
   end
 
-  def save(options={})
-    reconcile_tag_ids
-    super(options)
-  end
+  def tags(include_draft = false)
+    all_tags = Tag.by_tag_ids(tag_ids)
 
-  def save!(options={})
-    reconcile_tag_ids
-    super(options)
+    if include_draft
+      all_tags
+    else
+      all_tags.reject {|tag| tag.state == 'draft' }
+    end
   end
 end

data/lib/govuk_content_models/version.rb

@@ -1,4 +1,4 @@
 module GovukContentModels
   # Changing this causes Jenkins to tag and release the gem into the wild
-  VERSION = "14.1.1"
+  VERSION = "15.0.0"
 end

data/test/models/artefact_tag_test.rb

@@ -24,7 +24,6 @@ class ArtefactTagTest < ActiveSupport::TestCase
     a = FactoryGirl.create(:artefact)
     a.sections = ['crime', 'crime/the-police']
     a.primary_section = 'crime'
-    a.reconcile_tag_ids
 
     assert_equal 'Crime', a.section
   end
@@ -36,7 +35,6 @@ class ArtefactTagTest < ActiveSupport::TestCase
 
     a = FactoryGirl.create(:artefact)
     a.primary_section = child.tag_id
-    a.reconcile_tag_ids
 
     assert_equal "#{parent.title}:#{child.title}", a.section
   end
@@ -47,7 +45,6 @@ class ArtefactTagTest < ActiveSupport::TestCase
     a.sections = ['crime', 'crime/the-police']
     a.legacy_sources = ['businesslink']
     a.keywords = ['bacon']
-    a.reconcile_tag_ids
 
     expected_tags = [
       { tag_id: "crime", tag_type: "section" },

data/test/models/tag_test.rb

@@ -55,13 +55,11 @@ class TagTest < ActiveSupport::TestCase
     )
   end
 
-  test "should return nil for missing tags" do
-    tag_ids = %w(crime business batman housing)
+  test "should not return missing tags" do
+    tag_ids = %w(crime business not_a_real_tag housing)
     tags = Tag.by_tag_ids(tag_ids)
-    assert_nil tags[2]
-    [0, 1, 3].each do |i|
-      assert_equal tag_ids[i], tags[i].tag_id
-    end
+
+    assert_equal %w(crime business housing), tags.map(&:tag_id)
   end
 
   test "should return nil for tags of the wrong type" do
@@ -71,22 +69,15 @@ class TagTest < ActiveSupport::TestCase
     [0, 1].each do |i| assert_equal tag_ids[i], tags[i].tag_id end
   end
 
-  test "should return multiple tags from the bang method" do
-    assert_equal(
-      %w(Crime Business),
-      Tag.by_tag_ids!(%w(crime business)).map(&:title)
-    )
-  end
-
   test "should raise an exception if any tags are missing" do
     assert_raises Tag::MissingTags do
-      Tag.by_tag_ids!(%w(crime business batman))
+      Tag.validate_tag_ids(%w(crime business batman))
     end
   end
 
   test "should raise an exception with the wrong tag type" do
     assert_raises Tag::MissingTags do
-      Tag.by_tag_ids!(%w(crime business pie chips), "section")
+      Tag.validate_tag_ids(%w(crime business pie chips), "section")
     end
   end
 

data/test/traits/taggable_test.rb

@@ -6,9 +6,10 @@ class TaggableTest < ActiveSupport::TestCase
   TEST_KEYWORDS = [['cheese', 'Cheese'], ['bacon', 'Bacon']]
 
   setup do
-    parent_section = FactoryGirl.create(:tag, :tag_id => 'crime', :tag_type => 'section', :title => 'Crime')
-    FactoryGirl.create(:tag, :tag_id => 'crime/the-police', :tag_type => 'section', :title => 'The Police', :parent_id => parent_section.id)
-    FactoryGirl.create(:tag, :tag_id => 'crime/batman', :tag_type => 'section', :title => 'Batman', :parent_id => parent_section.id)
+    @parent_section = FactoryGirl.create(:tag, :tag_id => 'crime', :tag_type => 'section', :title => 'Crime')
+    FactoryGirl.create(:tag, :tag_id => 'crime/the-police', :tag_type => 'section', :title => 'The Police', :parent_id => @parent_section.id)
+    FactoryGirl.create(:tag, :tag_id => 'crime/batman', :tag_type => 'section', :title => 'Batman', :parent_id => @parent_section.id)
+    @draft_section = FactoryGirl.create(:tag, parent_id: @parent_section.id, state: 'draft')
 
     TEST_KEYWORDS.each do |tag_id, title|
       FactoryGirl.create(:tag, :tag_id => tag_id, :tag_type => 'keyword', :title => title)
@@ -19,7 +20,6 @@ class TaggableTest < ActiveSupport::TestCase
 
   test "can set sections" do
     @item.sections = ['crime', 'crime/the-police']
-    @item.reconcile_tag_ids
 
     assert_equal ['crime', 'crime/the-police'], @item.tag_ids, 'Mismatched tags'
     assert_equal ['crime', 'crime/the-police'], @item.sections.collect(&:tag_id), 'Mismatched sections'
@@ -30,7 +30,6 @@ class TaggableTest < ActiveSupport::TestCase
   test "can set sections and primary section separately" do
     @item.sections = ['crime', 'crime/the-police']
     @item.primary_section = 'crime'
-    @item.reconcile_tag_ids
 
     assert_equal ['crime', 'crime/the-police'], @item.tag_ids, 'Mismatched tags'
     assert_equal ['crime', 'crime/the-police'], @item.sections.collect(&:tag_id), 'Mismatched sections'
@@ -41,7 +40,6 @@ class TaggableTest < ActiveSupport::TestCase
   test "can set subsection as primary section" do
     @item.sections = ['crime/the-police', 'crime']
     @item.primary_section = 'crime/the-police'
-    @item.reconcile_tag_ids
     assert_equal 'The Police', @item.primary_section.title
   end
 
@@ -69,7 +67,6 @@ class TaggableTest < ActiveSupport::TestCase
     @item.keywords = ['cheese', 'bacon']
     @item.sections = ['crime']
     @item.primary_section = 'crime'
-    @item.reconcile_tag_ids
 
     assert_equal ['bacon', 'cheese', 'crime'], @item.tag_ids.sort
     assert_equal 'Crime', @item.primary_section.title
@@ -78,14 +75,13 @@ class TaggableTest < ActiveSupport::TestCase
   test "setting primary section adds section to tags" do
     @item.sections = ['crime', 'crime/the-police']
     @item.primary_section = 'crime/batman'
-    @item.reconcile_tag_ids
+
     assert_includes @item.sections.collect(&:tag_id), 'crime/batman'
   end
 
   test "setting primary section to existing section works" do
     @item.sections = ['crime', 'crime/the-police']
     @item.primary_section = 'crime/the-police'
-    @item.reconcile_tag_ids
     # Note: not testing the order of the sections in this test, just testing
     # that the section is still present and not duplicated
     assert_equal ['crime', 'crime/the-police'], @item.sections.collect(&:tag_id).sort
@@ -122,4 +118,15 @@ class TaggableTest < ActiveSupport::TestCase
 
     assert_equal [], @item.section_ids
   end
+
+  test "returns draft tags only if requested" do
+    @item.section_ids = [@parent_section.tag_id, @draft_section.tag_id]
+    @item.save!
+
+    assert_equal [@parent_section.tag_id], @item.section_ids
+    assert_equal [@parent_section.tag_id, @draft_section.tag_id], @item.section_ids(draft: true)
+
+    assert_equal [@parent_section], @item.sections
+    assert_equal [@parent_section, @draft_section], @item.sections(draft: true)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: govuk_content_models
 version: !ruby/object:Gem::Version
-  version: 14.1.1
+  version: 15.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bson_ext
@@ -466,7 +466,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2394194236032864468
+      hash: -116450993641469610
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -475,7 +475,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2394194236032864468
+      hash: -116450993641469610
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23