document_mapper 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9ab11d53186b4024ab9e6d6dccbe9b87e79ac6bcc5eaca018ad6ac5aba88b06
-  data.tar.gz: c0431bd44df0df6e1d98f559155a457cde183332c7dd931ad49d071aa0479611
+  metadata.gz: 686cfa311491dffd0850086273e27f69df1db880f6d2628c20ae22d6e05051f3
+  data.tar.gz: cca3a95f9b6b940e0217e4bb6fae4a67cb65a004aa71b498cdf728bc982c00ec
 SHA512:
-  metadata.gz: 6f0d93678a4030ed955b38d7b529821a5c04dc7e13cb4d9f0b948387f01be750e744a9521e5710e326cff5fa7a6a7c23f7bd680fe4ca4e76e5318f8193d0af91
-  data.tar.gz: a2801844b698e9510e4734eef79df903e23dcd6449d34477bef0ba4bbd0d0eda22fe88d4952f07d7c4182642f807cf9462929d35e4174587678313580b0c57d5
+  metadata.gz: b4dbfa2ab84854f3b8d3e365fcf61bf75f573a7f1f4ab426cda3bf5592d5223531f40ce91bff1a7fb0601e00ae1fa6aea02118710c121563d1013d40af28941d
+  data.tar.gz: f549a89c9744e30b38dd621b63d09df35f163f5401798d201cd012f14fdf2ff7ab6ad96f8af11ceb548ef3ede288d6b5fc1a0e1a911e7b4c17d9a090b859ab00

data/lib/document_mapper/attribute_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DocumentMapper
   module AttributeMethods
     module Read
@@ -10,8 +12,9 @@ module DocumentMapper
 
       module ClassMethods
         def define_read_method(attr_name)
-          access_code = "attributes[:#{attr_name}]"
-          generated_attribute_methods.module_eval("def #{attr_name}; #{access_code}; end", __FILE__, __LINE__)
+          generated_attribute_methods.redefine_method(attr_name) do
+            attributes[attr_name]
+          end
         end
       end
     end

data/lib/document_mapper/constants.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module DocumentMapper
   OPERATOR_MAPPING = {
-    'equal'   => :==,
-    'gt'      => :>,
-    'gte'     => :>=,
-    'in'      => :in?,
+    'equal' => :==,
+    'gt' => :>,
+    'gte' => :>=,
+    'in' => :in?,
     'include' => :include?,
-    'lt'      => :<,
-    'lte'     => :<=
-  }
+    'lt' => :<,
+    'lte' => :<=
+  }.freeze
 
   VALID_OPERATORS = OPERATOR_MAPPING.keys
 end

data/lib/document_mapper/core_ext/object.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Backported from ActiveSupport 3.1. Should be removed once the 3.1
 # version is out.
 
@@ -13,6 +15,6 @@ class Object
   def in?(another_object)
     another_object.include?(self)
   rescue NoMethodError
-    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+    raise ArgumentError, 'The parameter passed to #in? must respond to #include?'
   end
 end

data/lib/document_mapper/core_ext/symbol.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 class Symbol
   DocumentMapper::VALID_OPERATORS.each do |operator|
-    class_eval <<-OPERATORS
+    class_eval <<-OPERATORS, __FILE__, __LINE__ + 1
       def #{operator}
         DocumentMapper::Selector.new(:attribute => self, :operator => '#{operator}')
       end
     OPERATORS
   end
-  
-  unless method_defined?(:"<=>")
+
+  unless method_defined?(:<=>)
     def <=>(other)
-      self.to_s <=> other.to_s
+      to_s <=> other.to_s
     end
   end
 end

data/lib/document_mapper/document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 
 module DocumentMapper
@@ -14,9 +16,10 @@ module DocumentMapper
       @documents = []
     end
 
-    def ==(other_document)
-      return false unless other_document.is_a? Document
-      self.file_path == other_document.file_path
+    def ==(other)
+      return false unless other.is_a? Document
+
+      file_path == other.file_path
     end
 
     module ClassMethods
@@ -25,17 +28,16 @@ module DocumentMapper
       end
 
       def reload
-        self.reset
+        reset
         self.directory = @directory.path
       end
 
       def from_file(file_path)
-        if !File.exist? file_path
-          raise FileNotFoundError
-        end
-        self.new.tap do |document|
+        raise FileNotFoundError unless File.exist? file_path
+
+        new.tap do |document|
           document.attributes = {
-            :file_path => File.expand_path(file_path)
+            file_path: File.expand_path(file_path)
           }
           document.read_yaml
           @documents << document
@@ -44,11 +46,13 @@ module DocumentMapper
 
       def directory=(new_directory)
         raise FileNotFoundError unless File.directory?(new_directory)
-        self.reset
+
+        reset
         @directory = Dir.new File.expand_path(new_directory)
         @directory.each do |file|
-          next if file[0,1] == '.'
-          self.from_file [@directory.path, file].join('/')
+          next if file[0, 1] == '.'
+
+          from_file [@directory.path, file].join('/')
         end
       end
 
@@ -56,7 +60,8 @@ module DocumentMapper
         documents = @documents.dup
         options[:where].each do |selector, selector_value|
           documents = documents.select do |document|
-            next unless document.attributes.has_key? selector.attribute
+            next unless document.attributes.key? selector.attribute
+
             document_value = document.send(selector.attribute)
             operator = OPERATOR_MAPPING[selector.operator]
             document_value.send operator, selector_value

data/lib/document_mapper/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DocumentMapper
   FileNotFoundError = Class.new StandardError
   OperatorNotSupportedError = Class.new StandardError

data/lib/document_mapper/query.rb

@@ -1,15 +1,20 @@
+# frozen_string_literal: true
+
 module DocumentMapper
   class Query
     def initialize(model)
       @model = model
       @where = {}
+      @limit = nil
+      @offset = nil
+      @order_by = nil
     end
 
     def where(constraints_hash)
-      selector_hash = constraints_hash.reject { |key, value| !key.is_a? Selector }
-      symbol_hash = constraints_hash.reject { |key, value| key.is_a? Selector }
+      selector_hash = constraints_hash.select { |key, _value| key.is_a? Selector }
+      symbol_hash = constraints_hash.reject { |key, _value| key.is_a? Selector }
       symbol_hash.each do |attribute, value|
-        selector = Selector.new(:attribute => attribute, :operator => 'equal')
+        selector = Selector.new(attribute: attribute, operator: 'equal')
         selector_hash.update({ selector => value })
       end
       @where.merge! selector_hash
@@ -17,7 +22,7 @@ module DocumentMapper
     end
 
     def order_by(field)
-      @order_by = field.is_a?(Symbol) ? {field => :asc} : field
+      @order_by = field.is_a?(Symbol) ? { field => :asc } : field
       self
     end
 
@@ -32,21 +37,17 @@ module DocumentMapper
     end
 
     def first
-      self.all.first
+      all.first
     end
 
     def last
-      self.all.last
+      all.last
     end
 
     def all
-      result = @model.select(:where => @where, :order_by => @order_by)
-      if @offset.present?
-        result = result.last([result.size - @offset, 0].max)
-      end
-      if @limit.present?
-        result = result.first(@limit)
-      end
+      result = @model.select(where: @where, order_by: @order_by)
+      result = result.last([result.size - @offset, 0].max) if @offset.present?
+      result = result.first(@limit) if @limit.present?
       result
     end
   end

data/lib/document_mapper/selector.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module DocumentMapper
   class Selector
     attr_reader :attribute, :operator
 
     def initialize(opts = {})
-      unless VALID_OPERATORS.include? opts[:operator]
-        raise OperatorNotSupportedError
-      end
-      @attribute, @operator = opts[:attribute], opts[:operator]
+      raise OperatorNotSupportedError unless VALID_OPERATORS.include? opts[:operator]
+
+      @attribute = opts[:attribute]
+      @operator = opts[:operator]
     end
   end
 end

data/lib/document_mapper/to_html.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tilt'
 
 module DocumentMapper
@@ -7,4 +9,3 @@ module DocumentMapper
     end
   end
 end
-

data/lib/document_mapper/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DocumentMapper
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/lib/document_mapper/yaml_parsing.rb

@@ -1,45 +1,56 @@
+# frozen_string_literal: true
+
+require 'date'
+
 module DocumentMapper
   class YamlParsingError < StandardError; end
 
+  PERMITTED_CLASSES = [
+    Date,
+    Symbol
+  ].freeze
+
   module YamlParsing
     def read_yaml
-      file_path = self.attributes[:file_path]
-      @content = File.read(file_path)
+      file_path = attributes[:file_path]
+      file_content = File.read(file_path)
 
-      if @content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
-        @content = @content[($1.size + $2.size)..-1]
-        self.attributes.update(yaml_load($1, file_path).transform_keys(&:to_sym))
+      if file_content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        @content = file_content[(Regexp.last_match(1).size + Regexp.last_match(2).size)..]
+        attributes.update(yaml_load(Regexp.last_match(1), file_path).transform_keys(&:to_sym))
       end
 
       file_name = File.basename(file_path)
       extension = File.extname(file_path)
-      self.attributes.update({
-        :file_name => file_name,
-        :extension => extension.sub(/^\./, ''),
-        :file_name_without_extension => File.basename(file_path, extension)
-      })
+      attributes.update({
+                          file_name: file_name,
+                          extension: extension.sub(/^\./, ''),
+                          file_name_without_extension: File.basename(file_path, extension)
+                        })
 
-      if !self.attributes.has_key? :date
+      unless attributes.key? :date
         begin
           match = attributes[:file_name].match(/(\d{4})-(\d{1,2})-(\d{1,2}).*/)
-          year, month, day = match[1].to_i, match[2].to_i, match[3].to_i
-          self.attributes[:date] = Date.new(year, month, day)
-        rescue NoMethodError => err
+          year = match[1].to_i
+          month = match[2].to_i
+          day = match[3].to_i
+          attributes[:date] = ::Date.new(year, month, day)
+        rescue NoMethodError
         end
       end
 
-      if self.attributes.has_key? :date
-        self.attributes[:year] = self.attributes[:date].year
-        self.attributes[:month] = self.attributes[:date].month
-        self.attributes[:day] = self.attributes[:date].day
+      if attributes.key? :date
+        attributes[:year] = attributes[:date].year
+        attributes[:month] = attributes[:date].month
+        attributes[:day] = attributes[:date].day
       end
 
-      self.class.define_attribute_methods self.attributes.keys
-      self.attributes.keys.each { |attr| self.class.define_read_method attr }
+      self.class.define_attribute_methods attributes.keys
+      attributes.each_key { |attr| self.class.define_read_method attr }
     end
 
     def yaml_load(yaml, file)
-      YAML.load(yaml)
+      YAML.safe_load(yaml, permitted_classes: PERMITTED_CLASSES)
     rescue ArgumentError, Psych::SyntaxError
       raise YamlParsingError, "Unable to parse YAML of #{file}"
     end

data/lib/document_mapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/class'
 require 'active_support/concern'
 require 'yaml'

data/test/document_mapper/core_ext/symbol_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_base'
 include DocumentMapper
 
@@ -9,16 +11,14 @@ describe Symbol do
   end
 
   it 'should not raise an error on valid operators' do
-    begin
-      :my_attribute.equal
-      :my_attribute.gt
-      :my_attribute.gte
-      :my_attribute.in
-      :my_attribute.lt
-      :my_attribute.lte
-    rescue StandardError => e
-      assert false, 'Calling operator on symbol raised error'
-    end
+    :my_attribute.equal
+    :my_attribute.gt
+    :my_attribute.gte
+    :my_attribute.in
+    :my_attribute.lt
+    :my_attribute.lte
+  rescue StandardError
+    assert false, 'Calling operator on symbol raised error'
   end
 
   it 'should raise an error on invalid operators' do

data/test/document_mapper/document_mapper_test.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'test_base'
 include DocumentMapper
 
 describe MyDocument do
   before do
+    MyDocument.directory = 'test/documents'
     MyDocument.reset
   end
 
@@ -67,17 +70,17 @@ describe MyDocument do
 
       it 'should not freak out if there is no date' do
         @document = sample_document_without_date
-        assert_equal nil, @document.date
-        assert_equal nil, @document.year
-        assert_equal nil, @document.month
-        assert_equal nil, @document.day
+        assert_nil @document.date
+        assert_nil @document.year
+        assert_nil @document.month
+        assert_nil @document.day
       end
     end
 
     describe 'loading a documents directory' do
       it 'should load all the documents in that directory' do
         MyDocument.directory = 'test/documents'
-        assert_equal_set [1,2,3,4], MyDocument.all.map(&:id)
+        assert_equal_set [1, 2, 3, 4], MyDocument.all.map(&:id)
       end
 
       it 'should ignore all dotfile' do
@@ -111,15 +114,15 @@ describe MyDocument do
     end
 
     it 'should limit the documents to the number specified' do
-      assert_equal_set [1,2], MyDocument.order_by(:id).limit(2).all.map(&:id)
+      assert_equal_set [1, 2], MyDocument.order_by(:id).limit(2).all.map(&:id)
     end
 
     it 'should offset the documents by the number specified' do
-      assert_equal_set [3,4], MyDocument.order_by(:id).offset(2).all.map(&:id)
+      assert_equal_set [3, 4], MyDocument.order_by(:id).offset(2).all.map(&:id)
     end
 
     it 'should support offset and limit at the same time' do
-      assert_equal_set [2,3], MyDocument.order_by(:id).offset(1).limit(2).all.map(&:id)
+      assert_equal_set [2, 3], MyDocument.order_by(:id).offset(1).limit(2).all.map(&:id)
     end
 
     it 'should not freak out about an offset higher than the document count' do
@@ -145,71 +148,71 @@ describe MyDocument do
 
     describe 'with an equal operator' do
       it 'should return the right documents' do
-        found_document = MyDocument.where(:title => @document_1.title).first
+        found_document = MyDocument.where(title: @document_1.title).first
         assert_equal @document_1, found_document
-        found_document = MyDocument.where(:title => @document_2.title).first
+        found_document = MyDocument.where(title: @document_2.title).first
         assert_equal @document_2, found_document
       end
 
       it 'should be chainable' do
-        document_proxy = MyDocument.where(:title => @document_1.title)
-        document_proxy.where(:id => @document_1.id)
+        document_proxy = MyDocument.where(title: @document_1.title)
+        document_proxy.where(id: @document_1.id)
         assert_equal @document_1, document_proxy.first
       end
 
       it 'should work with file names without extensions' do
         file_name = '2010-08-08-test-document-file'
-        selector_hash = { :file_name_without_extension => file_name }
+        selector_hash = { file_name_without_extension: file_name }
         found_document = MyDocument.where(selector_hash).first
         assert_equal sample_document_1, found_document
       end
 
       it 'should work with file names' do
         file_name = '2010-08-08-test-document-file.textile'
-        found_document = MyDocument.where(:file_name => file_name).first
+        found_document = MyDocument.where(file_name: file_name).first
         assert_equal sample_document_1, found_document
       end
 
       it 'should work with dates' do
-        found_documents = MyDocument.where(:year => 2010).all
+        found_documents = MyDocument.where(year: 2010).all
         expected_documents = [sample_document_1, sample_document_2]
         assert_equal_set expected_documents.map(&:id), found_documents.map(&:id)
       end
 
       it 'should not be confused by attributes not present in all documents' do
         MyDocument.directory = 'test/documents'
-        result = MyDocument.where(:seldom_attribute => 'is seldom').all
+        result = MyDocument.where(seldom_attribute: 'is seldom').all
         assert_equal_set [4], result.map(&:id)
       end
     end
 
     describe 'with a gt operator' do
       it 'should return the right documents' do
-        selector = Selector.new :attribute => :id, :operator => 'gt'
+        selector = Selector.new attribute: :id, operator: 'gt'
         found_documents = MyDocument.where(selector => 2).all
-        assert_equal_set [3,4], found_documents.map(&:id)
+        assert_equal_set [3, 4], found_documents.map(&:id)
       end
     end
 
     describe 'with a gte operator' do
       it 'should return the right documents' do
-        selector = Selector.new :attribute => :id, :operator => 'gte'
+        selector = Selector.new attribute: :id, operator: 'gte'
         found_documents = MyDocument.where(selector => 2).all
-        assert_equal_set [2,3,4], found_documents.map(&:id)
+        assert_equal_set [2, 3, 4], found_documents.map(&:id)
       end
     end
 
     describe 'with an in operator' do
       it 'should return the right documents' do
-        selector = Selector.new :attribute => :id, :operator => 'in'
-        found_documents = MyDocument.where(selector => [2,3]).all
-        assert_equal_set [2,3], found_documents.map(&:id)
+        selector = Selector.new attribute: :id, operator: 'in'
+        found_documents = MyDocument.where(selector => [2, 3]).all
+        assert_equal_set [2, 3], found_documents.map(&:id)
       end
     end
 
     describe 'with an lt operator' do
       it 'should return the right documents' do
-        selector = Selector.new :attribute => :id, :operator => 'lt'
+        selector = Selector.new attribute: :id, operator: 'lt'
         found_documents = MyDocument.where(selector => 2).all
         assert_equal_set [1], found_documents.map(&:id)
       end
@@ -217,25 +220,25 @@ describe MyDocument do
 
     describe 'with an lte operator' do
       it 'should return the right documents' do
-        selector = Selector.new :attribute => :id, :operator => 'lte'
+        selector = Selector.new attribute: :id, operator: 'lte'
         found_documents = MyDocument.where(selector => 2).all
-        assert_equal_set [1,2], found_documents.map(&:id)
+        assert_equal_set [1, 2], found_documents.map(&:id)
       end
     end
 
     describe 'with an include operator' do
       it 'include should return the right documents' do
-        selector = Selector.new :attribute => :tags, :operator => 'include'
+        selector = Selector.new attribute: :tags, operator: 'include'
         found_documents = MyDocument.where(selector => 'ruby').all
-        assert_equal_set [1,2], found_documents.map(&:id)
+        assert_equal_set [1, 2], found_documents.map(&:id)
       end
     end
 
     describe 'with mixed operators' do
       it 'should return the right documents' do
-        in_selector = Selector.new :attribute => :id, :operator => 'in'
-        gt_selector = Selector.new :attribute => :id, :operator => 'gt'
-        documents_proxy = MyDocument.where(in_selector => [2,3])
+        in_selector = Selector.new attribute: :id, operator: 'in'
+        gt_selector = Selector.new attribute: :id, operator: 'gt'
+        documents_proxy = MyDocument.where(in_selector => [2, 3])
         found_documents = documents_proxy.where(gt_selector => 2).all
         assert_equal_set [3], found_documents.map(&:id)
       end
@@ -243,9 +246,9 @@ describe MyDocument do
 
     describe 'using multiple constrains in one where' do
       it 'should return the right documents' do
-        selector = Selector.new :attribute => :id, :operator => 'lte'
+        selector = Selector.new attribute: :id, operator: 'lte'
         found_documents = MyDocument.where(selector => 2, :status => :published).all
-        assert_equal_set [1,2], found_documents.map(&:id)
+        assert_equal_set [1, 2], found_documents.map(&:id)
       end
     end
   end
@@ -256,41 +259,39 @@ describe MyDocument do
     end
 
     it 'should support ordering by attribute ascending' do
-      found_documents = MyDocument.order_by(:title => :asc).all
-      assert_equal [2,3,1,4], found_documents.map(&:id)
+      found_documents = MyDocument.order_by(title: :asc).all
+      assert_equal [2, 3, 1, 4], found_documents.map(&:id)
     end
 
     it 'should support ordering by attribute descending' do
-      found_documents = MyDocument.order_by(:title => :desc).all
-      assert_equal [4,1,3,2], found_documents.map(&:id)
+      found_documents = MyDocument.order_by(title: :desc).all
+      assert_equal [4, 1, 3, 2], found_documents.map(&:id)
     end
 
     it 'should order by attribute ascending by default' do
       found_documents = MyDocument.order_by(:title).all
-      assert_equal [2,3,1,4], found_documents.map(&:id)
+      assert_equal [2, 3, 1, 4], found_documents.map(&:id)
     end
 
     it 'should exclude documents that do not own the attribute' do
       found_documents = MyDocument.order_by(:status).all
-      assert_equal [1,2].to_set, found_documents.map(&:id).to_set
+      assert_equal [1, 2].to_set, found_documents.map(&:id).to_set
     end
   end
 
   describe 'reloading the Document class' do
     it 'should discover new documents' do
       @file_path = 'test/documents/2011-04-26-new-stuff.textile'
-      File.open(@file_path, 'w') do |f|
-        f.write <<-EOS
----
-id: 5
-title: Some brand new document
----
-
-Very new stuff.
-EOS
-      end
+      File.write(@file_path, <<~DOCUMENT)
+        ---
+        id: 5
+        title: Some brand new document
+        ---
+
+        Very new stuff.
+      DOCUMENT
       MyDocument.reload
-      assert_equal [1,2,3,4,5].sort, MyDocument.all.map(&:id).sort
+      assert_equal [1, 2, 3, 4, 5].sort, MyDocument.all.map(&:id).sort
     end
 
     def teardown
@@ -304,7 +305,7 @@ EOS
     end
 
     it 'should return an ordered list of all the attributes' do
-      expected_attributes = %w(
+      expected_attributes = %w[
         date
         day
         extension
@@ -320,7 +321,7 @@ EOS
         tags
         title
         year
-      ).map(&:to_sym)
+      ].map(&:to_sym)
       assert_equal expected_attributes, MyDocument.attributes
     end
   end
@@ -338,21 +339,9 @@ EOS
 
   describe 'loading a document with invalid yaml' do
     it 'should raise with a decent error message' do
-      @file_path = File.expand_path('test/documents/invalid_yaml.textile')
-      File.open(@file_path, 'w') do |f|
-        f.write <<-EOS
----
-title: Look: Invalid YAML!
----
-
-This is definitely gonna blow up.
-EOS
-      end
-      proc { MyDocument.reload }.must_raise(DocumentMapper::YamlParsingError, "Unable to parse YAML of #{@file_path}")
-    end
-
-    def teardown
-      File.delete @file_path
+      _ do
+        MyDocument.directory = 'test/documents_with_invalid_yaml'
+      end.must_raise(DocumentMapper::YamlParsingError, "Unable to parse YAML of #{@file_path}")
     end
   end
 

data/test/document_mapper/selector_test.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 require 'test_base'
 include DocumentMapper
 
 describe Selector do
   it 'should initialize with an attribute and an operator' do
-    selector = Selector.new :attribute => :author, :operator => 'equal'
+    selector = Selector.new attribute: :author, operator: 'equal'
     assert_equal :author, selector.attribute
     assert_equal 'equal', selector.operator
   end
 
   it 'should raise an exception if the operator is not supported' do
     assert_raises OperatorNotSupportedError do
-      selector = Selector.new :attribute => :author, :operator => 'zomg'
+      Selector.new attribute: :author, operator: 'zomg'
     end
   end
 end

data/test/documents_with_invalid_yaml/2010-08-08-test-document-file.textile

@@ -0,0 +1,8 @@
+---
+id: 1
+title: Some fancy title
+tags: [ruby]
+status: :published
+---
+
+I like being the demo text.

data/test/documents_with_invalid_yaml/invalid_yaml.textile

@@ -0,0 +1,5 @@
+---
+title: Look: Invalid YAML!
+---
+
+This is definitely gonna blow up.

data/test/test_base.rb

@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler/setup'
 require 'set'
-require 'minitest/spec'
-MiniTest::Unit.autorun
+require 'minitest/autorun'
+MiniTest.autorun
 
 lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
 $LOAD_PATH.unshift lib_dir unless $LOAD_PATH.include?(lib_dir)
 require 'document_mapper'
 
+# Prevent verbose warnings
+# $VERBOSE = nil
+
 class MyDocument
   include DocumentMapper::Document
 end
@@ -16,9 +21,11 @@ class MyOtherDocument
   include DocumentMapper::Document
 end
 
-module MiniTest::Assertions
-  def assert_equal_set exp, act, msg = nil
-    msg = message(msg) { "Expected #{mu_pp(exp)}, not #{mu_pp(act)}" }
-    assert(exp.to_set == act.to_set, msg)
+module MiniTest
+  module Assertions
+    def assert_equal_set(exp, act, msg = nil)
+      msg = message(msg) { "Expected #{mu_pp(exp)}, not #{mu_pp(act)}" }
+      assert(exp.to_set == act.to_set, msg)
+    end
   end
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: document_mapper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ralph von der Heyden
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-27 00:00:00.000000000 Z
+date: 2022-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activemodel
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: RedCloth
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: RedCloth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "  DocumentMapper is an object mapper for plain text documents. The documents
   look like the ones used in jekyll (http://github.com/mojombo/jekyll). They consist
   of a preambel written in YAML (also called YAML front matter), and some content
@@ -125,12 +153,15 @@ files:
 - test/documents/2010-08-09-another-test-document.textile
 - test/documents/document_with_date_in_yaml.textile
 - test/documents/document_without_date.textile
+- test/documents_with_invalid_yaml/2010-08-08-test-document-file.textile
+- test/documents_with_invalid_yaml/invalid_yaml.textile
 - test/other_documents/2011-12-26-some-test-document.textile
 - test/test_base.rb
 homepage: http://github.com/ralph/document_mapper
 licenses: []
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -138,15 +169,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
-specification_version: 3
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
 summary: DocumentMapper is an object mapper for plain text documents.
 test_files: []