nanoc 4.0.0b3 → 4.0.0b4

data/lib/nanoc/base/source_data/layout.rb

@@ -1,111 +0,0 @@
-module Nanoc::Int
-  # Represents a layout in a nanoc site. It has content, attributes, an
-  # identifier and a modification time (to speed up compilation).
-  #
-  # @api private
-  class Layout
-    extend Nanoc::Int::Memoization
-
-    # @return [String] The raw content of this layout
-    attr_reader :raw_content
-
-    # @return [Hash] This layout's attributes
-    attr_reader :attributes
-
-    # @return [Nanoc::Identifier] This layout's identifier
-    attr_accessor :identifier
-
-    # Creates a new layout.
-    #
-    # @param [String] raw_content The raw content of this layout.
-    #
-    # @param [Hash] attributes A hash containing this layout's attributes.
-    #
-    # @param [String] identifier This layout's identifier.
-    #
-    # @param [Hash] params Extra parameters. Unused.
-    def initialize(raw_content, attributes, identifier, params = {})
-      @raw_content  = raw_content
-      @attributes   = attributes.__nanoc_symbolize_keys_recursively
-      @identifier   = Nanoc::Identifier.from(identifier)
-    end
-
-    # Requests the attribute with the given key.
-    #
-    # @param [Symbol] key The name of the attribute to fetch.
-    #
-    # @return [Object] The value of the requested attribute.
-    def [](key)
-      @attributes[key]
-    end
-
-    def []=(key, value)
-      @attributes[key] = value
-    end
-
-    # Returns the type of this object. Will always return `:layout`, because
-    # this is a layout. For items, this method returns `:item`.
-    #
-    # @api private
-    #
-    # @return [Symbol] :layout
-    def type
-      :layout
-    end
-
-    # Prevents all further modifications to the layout.
-    #
-    # @return [void]
-    def freeze
-      attributes.__nanoc_freeze_recursively
-      identifier.freeze
-      raw_content.freeze
-    end
-
-    # Returns an object that can be used for uniquely identifying objects.
-    #
-    # @api private
-    #
-    # @return [Object] An unique reference to this object
-    def reference
-      [type, identifier]
-    end
-
-    def inspect
-      "<#{self.class} identifier=\"#{identifier}\">"
-    end
-
-    # @return [String] The checksum for this object. If its contents change,
-    #   the checksum will change as well.
-    def __nanoc_checksum
-      Nanoc::Int::Checksummer.calc(self)
-    end
-    memoize :__nanoc_checksum
-
-    def hash
-      self.class.hash ^ identifier.hash
-    end
-
-    def eql?(other)
-      self.class == other.class && identifier == other.identifier
-    end
-
-    def ==(other)
-      self.eql?(other)
-    end
-
-    def marshal_dump
-      [
-        @raw_content,
-        @attributes,
-        @identifier
-      ]
-    end
-
-    def marshal_load(source)
-      @raw_content,
-      @attributes,
-      @identifier = *source
-    end
-  end
-end

data/test/base/checksummer_spec.rb

@@ -1,256 +0,0 @@
-require 'tempfile'
-
-describe Nanoc::Int::Checksummer do
-  subject { Nanoc::Int::Checksummer }
-
-  CHECKSUM_REGEX = /\A[0-9a-zA-Z\/+]+=*\Z/
-
-  describe 'for String' do
-    it 'should checksum strings' do
-      subject.calc('foo').must_equal('+5k/BWvkYc6T1qhGaSyf3861CyE=')
-    end
-  end
-
-  describe 'for Array' do
-    it 'should checksum arrays' do
-      subject.calc([1, 'a', :a]).must_equal 'YtWOEFUAMQritkY38KXHFZM/n2E='
-    end
-
-    it 'should take order into account when checksumming arrays' do
-      subject.calc([:a, 'a', 1]).wont_equal(subject.calc([1, 'a', :a]))
-    end
-
-    it 'should checksum non-serializable arrays' do
-      subject.calc([-> {}]).must_match(CHECKSUM_REGEX)
-    end
-
-    it 'should checksum recursive arrays' do
-      array = [:a]
-      array << array
-      subject.calc(array).must_equal('mR3c98xA5ecazxx+M3h0Ss4/J20=')
-    end
-  end
-
-  describe 'for Hash' do
-    it 'should checksum hashes' do
-      subject.calc({ a: 1, b: 2 }).must_equal 'qY8fW6gWK7F1XQ9MLrx3Gru/RTY='
-    end
-
-    it 'should take order into account when checksumming hashes' do
-      subject.calc({ a: 1, b: 2 }).wont_equal(subject.calc({ b: 2, a: 1 }))
-    end
-
-    it 'should checksum non-serializable hashes' do
-      subject.calc({ a: -> {} }).must_match(CHECKSUM_REGEX)
-    end
-
-    it 'should checksum recursive hash keys' do
-      hash = {}
-      hash[hash] = 123
-      subject.calc(hash).must_equal('mKucWMhRtR/FHWNqR/EErF4qgTk=')
-    end
-
-    it 'should checksum recursive hash values' do
-      hash = {}
-      hash[123] = hash
-      subject.calc(hash).must_equal('PBiDX0nWnV+DAYB+w+xM0Kf21ZM=')
-    end
-  end
-
-  describe 'for Pathname' do
-    let(:file)            { Tempfile.new('foo') }
-    let(:filename)        { file.path }
-    let(:pathname)        { Pathname.new(filename) }
-    let(:atime)           { 1_234_567_890 }
-    let(:mtime)           { 1_234_567_890 }
-    let(:data)            { 'stuffs' }
-    let(:normal_checksum) { 'THy7Y28oroov/KvPxT6wcMnXr/s=' }
-
-    before do
-      file.write(data)
-      file.close
-      File.utime(atime, mtime, filename)
-    end
-
-    after do
-      file.unlink
-    end
-
-    describe 'does not exist' do
-      let(:non_existing_filename) { 'askldjfklaslasdfkjsajdf' }
-      let(:pathname)              { Pathname.new(filename) }
-
-      it 'should still checksum' do
-        subject.calc(pathname).must_equal(normal_checksum)
-      end
-    end
-
-    it 'should get the mtime right' do
-      stat = File.stat(filename)
-      stat.mtime.to_i.must_equal(mtime)
-    end
-
-    it 'should get the file size right' do
-      stat = File.stat(filename)
-      stat.size.must_equal(6)
-    end
-
-    it 'should checksum binary content' do
-      subject.calc(pathname).must_equal(normal_checksum)
-    end
-
-    describe 'if the mtime changes' do
-      let(:mtime) { 1_333_333_333 }
-
-      it 'should have a different checksum' do
-        subject.calc(pathname).must_match(CHECKSUM_REGEX)
-        subject.calc(pathname).wont_equal(normal_checksum)
-      end
-    end
-
-    describe 'if the content changes, but not the file size' do
-      let(:data) { 'STUFF!' }
-
-      it 'should have the same checksum' do
-        subject.calc(pathname).must_equal(normal_checksum)
-      end
-    end
-
-    describe 'if the file size changes' do
-      let(:data) { 'stuff and stuff and stuff!!!' }
-
-      it 'should have a different checksum' do
-        subject.calc(pathname).must_match(CHECKSUM_REGEX)
-        subject.calc(pathname).wont_equal(normal_checksum)
-      end
-    end
-  end
-
-  it 'should not have the same checksum for same content but different class'
-
-  describe 'for Nanoc::Int::RulesCollection' do
-    let(:data)            { 'STUFF!' }
-    let(:normal_checksum) { 'Y6mX13i8ZEd4a11xRPc2yNQSRDs=' }
-
-    let(:rules_collection) do
-      coll = Nanoc::Int::RulesCollection.new(nil)
-      coll.data = data
-      coll
-    end
-
-    it 'should calculate' do
-      subject.calc(rules_collection).must_equal(normal_checksum)
-    end
-
-    describe 'if the content changes' do
-      let(:data) { 'Other stuff!' }
-
-      it 'should have a different checksum' do
-        subject.calc(rules_collection).must_match(CHECKSUM_REGEX)
-        subject.calc(rules_collection).wont_equal(normal_checksum)
-      end
-    end
-  end
-
-  describe 'for Nanoc::Int::CodeSnippet' do
-    let(:data)            { 'asdf' }
-    let(:filename)        { File.expand_path('bob.txt') }
-    let(:code_snippet)    { Nanoc::Int::CodeSnippet.new(data, filename) }
-    let(:normal_checksum) { 's6oZ1xLVekKDVhYrXsJuHChFjek=' }
-
-    it 'should checksum the data' do
-      subject.calc(code_snippet).must_equal(normal_checksum)
-    end
-
-    describe 'if the filename changes' do
-      let(:filename) { File.expand_path('george.txt') }
-
-      it 'should have the same checksum' do
-        subject.calc(code_snippet).must_equal(normal_checksum)
-      end
-    end
-
-    describe 'if the content changes' do
-      let(:data) { 'Other stuff!' }
-
-      it 'should have a different checksum' do
-        subject.calc(code_snippet).must_match(CHECKSUM_REGEX)
-        subject.calc(code_snippet).wont_equal(normal_checksum)
-      end
-    end
-  end
-
-  describe 'for Nanoc::Int::Configuration' do
-    let(:wrapped)         { { a: 1, b: 2 } }
-    let(:configuration)   { Nanoc::Int::Configuration.new(wrapped) }
-    let(:normal_checksum) { 'xwbPeftLbSXYx0OJbKCqrPHctPU=' }
-
-    it 'should checksum the hash' do
-      subject.calc(configuration).must_equal(normal_checksum)
-    end
-
-    describe 'if the content changes' do
-      let(:wrapped) { { a: 666, b: 2 } }
-
-      it 'should have a different checksum' do
-        subject.calc(configuration).must_match(CHECKSUM_REGEX)
-        subject.calc(configuration).wont_equal(normal_checksum)
-      end
-    end
-  end
-
-  describe 'for Nanoc::Int::Item' do
-    let(:content)         { 'asdf' }
-    let(:filename)        { File.expand_path('bob.txt') }
-    let(:attributes)      { { a: 1, b: 2 } }
-    let(:identifier)      { '/foo/' }
-    let(:item)            { Nanoc::Int::Item.new(content, attributes, identifier) }
-    let(:normal_checksum) { '6VtlVLx1JE69erzfDczZW7HSWeY=' }
-
-    it 'should checksum item' do
-      subject.calc(item).must_equal(normal_checksum)
-    end
-
-    describe 'with recursive attributes' do
-      it 'should checksum' do
-        item.attributes[:a] = item
-        subject.calc(item).must_match(CHECKSUM_REGEX)
-        subject.calc(item).wont_equal(normal_checksum)
-      end
-    end
-
-    describe 'with changed attributes' do
-      let(:attributes) { { x: 4, y: 5 } }
-
-      it 'should have a different checksum' do
-        subject.calc(item).must_match(CHECKSUM_REGEX)
-        subject.calc(item).wont_equal(normal_checksum)
-      end
-    end
-
-    describe 'with changed content' do
-      let(:content) { 'something drastically different' }
-
-      it 'should have a different checksum' do
-        subject.calc(item).must_match(CHECKSUM_REGEX)
-        subject.calc(item).wont_equal(normal_checksum)
-      end
-    end
-  end
-
-  describe 'for other marshal-able classes' do
-    let(:obj) { :foobar }
-
-    it 'should checksum' do
-      subject.calc(obj).must_match(CHECKSUM_REGEX)
-    end
-  end
-
-  describe 'for other non-marshal-able classes' do
-    let(:obj) { proc {} }
-
-    it 'should checksum' do
-      subject.calc(obj).must_match(CHECKSUM_REGEX)
-    end
-  end
-end

data/test/base/test_item_rep_recorder_proxy.rb

@@ -1,17 +0,0 @@
-class Nanoc::Int::ItemRepRecorderProxyTest < Nanoc::TestCase
-  def test_double_names
-    proxy = Nanoc::Int::ItemRepRecorderProxy.new(mock)
-
-    proxy.snapshot(:foo, stuff: :giraffe)
-    assert_raises(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName) do
-      proxy.snapshot(:foo, stuff: :donkey)
-    end
-  end
-
-  def test_double_params
-    proxy = Nanoc::Int::ItemRepRecorderProxy.new(mock)
-
-    proxy.snapshot(:foo)
-    proxy.snapshot(:bar)
-  end
-end