audiothority 0.1.0

data/lib/audiothority/summary.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Audiothority
+  class Summary
+    def initialize(state)
+      @state = state
+    end
+
+    def display(console)
+      if @state.any?
+        @state.each do |path, violations|
+          console.say %(#{path} is inconsistent due to:)
+          violations.each do |violation|
+            checkmark = console.set_color(%(  ✗ ), :red, :bold)
+            console.say(checkmark + violation.message)
+          end
+        end
+      else
+        checkmark = console.set_color(%(  ✓ ), :green, :bold)
+        console.say(checkmark + %(All is good))
+      end
+    end
+  end
+
+  class PathsOnlySummary < Summary
+    def display(console)
+      @state.each do |path, _|
+        console.say(File.expand_path(path))
+      end
+    end
+  end
+end

data/lib/audiothority/tracker.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Audiothority
+  class Tracker
+    def initialize
+      @suspects = {}
+    end
+
+    def suspects
+      @suspects.freeze
+    end
+
+    def mark(path, violations)
+      @suspects[path] = violations
+    end
+  end
+end

data/lib/audiothority/validation.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Audiothority
+  class Validation
+    def initialize(valid=true)
+      @valid = valid
+    end
+
+    def valid?
+      !!@valid
+    end
+
+    def invalid?
+      !valid?
+    end
+  end
+
+  class Violation < Validation
+    attr_reader :field, :reason, :message
+
+    def initialize(field, reason, message, applicable=true)
+      super(false)
+      @field = field
+      @reason = reason
+      @message = message
+      @applicable = applicable
+    end
+
+    def applicable?
+      !!@applicable
+    end
+  end
+end

data/lib/audiothority/validators.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Audiothority
+  module Validators
+    def self.default
+      [Artist, Album, TrackNumber, Year].map(&:new)
+    end
+  end
+end
+
+require 'audiothority/validators/unique'
+require 'audiothority/validators/album'
+require 'audiothority/validators/artist'
+require 'audiothority/validators/track'
+require 'audiothority/validators/year'

data/lib/audiothority/validators/album.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Audiothority
+  module Validators
+    class Album < Unique
+      def initialize
+        super(:album)
+      end
+    end
+  end
+end

data/lib/audiothority/validators/artist.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Audiothority
+  module Validators
+    class Artist < Unique
+      def initialize
+        super(:artist)
+      end
+    end
+  end
+end

data/lib/audiothority/validators/track.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Audiothority
+  module Validators
+    class TrackNumber
+      def validate(tags)
+        missing = tags.map(&:track).select(&:zero?)
+        if missing.empty?
+          Validation.new
+        else
+          Violation.new(:track, :missing, 'track(s) without track numbers', false)
+        end
+      end
+    end
+  end
+end

data/lib/audiothority/validators/unique.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Audiothority
+  module Validators
+    class Unique
+      def initialize(thing)
+        @thing = thing
+      end
+
+      def validate(tags)
+        items = tags.map { |t| t.send(@thing) }.uniq
+        if items.one?
+          Validation.new
+        elsif items.compact.empty?
+          Violation.new(@thing, :missing, %(missing #{@thing} field))
+        elsif items.size > 1
+          Violation.new(@thing, :multiple, %(multiple #{@thing}s: #{items.map(&:inspect).join(', ')}))
+        end
+      end
+    end
+  end
+end

data/lib/audiothority/validators/year.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Audiothority
+  module Validators
+    class Year < Unique
+      def initialize
+        super(:year)
+      end
+    end
+  end
+end

data/lib/audiothority/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Audiothority
+  VERSION = '0.1.0'.freeze
+end

data/spec/audiothority/crawler_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  describe Crawler do
+    let :crawler do
+      described_class.new([dir], blacklist)
+    end
+
+    let :dir do
+      double(:pathname)
+    end
+
+    let :blacklist do
+      []
+    end
+
+    let :child do
+      double(:child)
+    end
+
+    describe '#crawl' do
+      it 'does not yield non-readable paths' do
+        non_readable = double(readable?: false)
+        allow(dir).to receive(:each_child).and_yield(non_readable)
+        expect { |b| crawler.crawl(&b) }.to_not yield_control
+      end
+
+      it 'does not yield empty directories' do
+        empty_path = double(readable?: true, directory?: true, children: [])
+        allow(dir).to receive(:each_child).and_yield(empty_path)
+        expect { |b| crawler.crawl(&b) }.to_not yield_control
+      end
+
+      it 'does not yield single files' do
+        single_file = double(readable?: true, directory?: false)
+        allow(dir).to receive(:each_child).and_yield(single_file)
+        expect { |b| crawler.crawl(&b) }.to_not yield_control
+      end
+
+      it 'yields non-empty directories' do
+        valid_dir = double(readable?: true, directory?: true, children: ['non-empty'])
+        allow(dir).to receive(:each_child).and_yield(valid_dir)
+        expect { |b| crawler.crawl(&b) }.to yield_with_args(valid_dir)
+      end
+
+      context 'with blacklist' do
+        let :blacklist do
+          [/ignore/]
+        end
+
+        it 'does not yield paths that match the blacklist' do
+          blacklisted_dir = double(readable?: true, directory?: true, children: ['non-empty'], basename: 'ignored')
+          allow(dir).to receive(:each_child).and_yield(blacklisted_dir)
+          expect { |b| crawler.crawl(&b) }.to_not yield_control
+        end
+      end
+    end
+  end
+end

data/spec/audiothority/custodian_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  describe Custodian do
+    let :custodian do
+      described_class.new(custody, suspects, fileutils)
+    end
+
+    let :custody do
+      Dir.mktmpdir
+    end
+
+    let :suspects do
+      {
+        Pathname.new('suspect1') => double(:violations),
+        Pathname.new('suspect2') => double(:violations),
+      }
+    end
+
+    let :fileutils do
+      double(:fileutils)
+    end
+
+    before do
+      allow(fileutils).to receive(:copy_entry)
+    end
+
+    after do
+      FileUtils.remove_entry_secure(custody) if File.exists?(custody)
+    end
+
+    describe '#throw_in_custody' do
+      context 'when `custody` exists' do
+        before do
+          custodian.throw_in_custody
+        end
+
+        it 'moves all suspects to custody' do
+          expect(fileutils).to have_received(:copy_entry).with('suspect1', %(#{custody}/suspect1), anything)
+          expect(fileutils).to have_received(:copy_entry).with('suspect2', %(#{custody}/suspect2), anything)
+        end
+
+        it 'peserves attributes' do
+          expect(fileutils).to have_received(:copy_entry).with(anything, anything, true).twice
+        end
+      end
+
+      context 'when `custody does not exist' do
+        let :custody do
+          'i do not exist, mkay?'
+        end
+
+        it 'assumes that the custody has been torched' do
+          expect { custodian.throw_in_custody }.to raise_error(CustodyTorchedError, /seems to have been torched/)
+        end
+      end
+    end
+  end
+end

data/spec/audiothority/extract_spec.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  describe Extract do
+    let :extract do
+      described_class.new(file_ref)
+    end
+
+    let :file_ref do
+      double(:file_ref)
+    end
+
+    before do
+      allow(file_ref).to receive(:new).and_return(*refs)
+    end
+
+    describe '#as_tags' do
+      context 'when given a proper set of audio files' do
+        let :paths do
+          [double(:audio_file)]
+        end
+
+        let :refs do
+          [double(:file_ref, null?: false, tag: tags.first, close: nil)]
+        end
+
+        let :tags do
+          [double(:tag)]
+        end
+
+        it 'yields extracted tags' do
+          expect { |b| extract.as_tags(paths, &b) }.to yield_with_args(tags)
+        end
+
+        it 'closes file refs' do
+          extract.as_tags(paths) { }
+          refs.each do |ref|
+            expect(ref).to have_received(:close)
+          end
+        end
+      end
+
+      context 'when given a set of files that includes non-audio files' do
+        let :paths do
+          [double(:audio_file), double(:non_audio_file)]
+        end
+
+        let :refs do
+          [
+            double(:file_ref, null?: false, tag: tags.first, close: nil),
+            double(:file_ref, null?: true, close: nil),
+          ]
+        end
+
+        let :tags do
+          [double(:tag)]
+        end
+
+        it 'skips `null` tags' do
+          expect { |b| extract.as_tags(paths, &b) }.to yield_with_args(tags)
+        end
+
+        it 'closes `null` refs' do
+          extract.as_tags(paths) { }
+          expect(refs.last).to have_received(:close)
+        end
+
+        it 'closes file refs' do
+          extract.as_tags(paths) { }
+          refs.each do |ref|
+            expect(ref).to have_received(:close)
+          end
+        end
+      end
+
+      context 'when given a set of non-audio files' do
+        let :paths do
+          [double(:non_audio_file), double(:non_audio_file)]
+        end
+
+        let :refs do
+          [
+            double(:file_ref, null?: true, close: nil),
+            double(:file_ref, null?: true, close: nil),
+          ]
+        end
+
+        it 'does not yield anything' do
+          expect { |b| extract.as_tags(paths, &b) }.to_not yield_control
+        end
+
+        it 'closes file refs' do
+          extract.as_tags(paths) { }
+          refs.each do |ref|
+            expect(ref).to have_received(:close)
+          end
+        end
+      end
+
+      context 'when given `:save` => true' do
+        let :paths do
+          [double(:audio_file)]
+        end
+
+        let :refs do
+          [double(:file_ref, null?: false, tag: tags.first, close: nil, save: nil)]
+        end
+
+        let :tags do
+          [double(:tag)]
+        end
+
+        it 'saves file refs before closing them' do
+          extract.as_tags(paths, save: true) { }
+          refs.each do |ref|
+            expect(ref).to have_received(:save).ordered
+            expect(ref).to have_received(:close).ordered
+          end
+        end
+      end
+    end
+  end
+end

data/spec/audiothority/inspector_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Audiothority
+  describe Inspector do
+    let :inspector do
+      described_class.new(crawler, [validator], tracker, extract: extract)
+    end
+
+    let :crawler do
+      double(:crawler)
+    end
+
+    let :validator do
+      double(:validator)
+    end
+
+    let :tracker do
+      double(:tracker, mark: nil)
+    end
+
+    let :extract do
+      double(:extract)
+    end
+
+    let :path do
+      double(:path, children: children)
+    end
+
+    let :children do
+      [Pathname.new('file01')]
+    end
+
+    let :violation do
+      double(:violation, invalid?: true)
+    end
+
+    let :tags do
+      [double(:tag)]
+    end
+
+    before do
+      allow(crawler).to receive(:crawl).and_yield(path)
+      allow(extract).to receive(:as_tags).with(children).and_yield(tags)
+      allow(validator).to receive(:validate).with(tags).and_return(violation)
+    end
+
+    before do
+      inspector.investigate
+    end
+
+    describe '#investigate' do
+      it 'crawls for paths with violations' do
+        expect(crawler).to have_received(:crawl)
+      end
+
+      it 'extracts tags' do
+        expect(extract).to have_received(:as_tags).with(children)
+      end
+
+      it 'validates each tag set' do
+        expect(validator).to have_received(:validate).with(tags)
+      end
+
+      it 'tracks paths with violations' do
+        expect(tracker).to have_received(:mark).with(path, [violation])
+      end
+    end
+  end
+end