audio-feed-manager 0.0.1

data/lib/audio_feed_manager/tags.rb

@@ -0,0 +1,9 @@
+module AudioFeedManager
+  class Tags < Struct.new(:title, :artist)
+    include HashConstructor
+
+    def self.blank
+      new
+    end
+  end
+end

data/lib/audio_feed_manager/unique_id_generator.rb

@@ -0,0 +1,19 @@
+module AudioFeedManager
+  class UniqueIdGenerator
+    takes :directory_lister
+
+    def generate(name, directory)
+      existing_ids = directory_lister.list(directory)
+      base_id = name.downcase.gsub(/[\s\.,']/, '-').gsub(/[^a-z0-9\-]/, '')
+
+      proposed_id = base_id
+      idx = 1
+      while existing_ids.include?(proposed_id)
+        proposed_id = "#{base_id}-#{idx}"
+        idx += 1
+      end
+
+      proposed_id
+    end
+  end
+end

data/lib/audio_feed_manager/url_maker.rb

@@ -0,0 +1,13 @@
+module AudioFeedManager
+  class UrlMaker
+    takes :rss_files_prefix, :data_files_prefix, :s3_gateway
+
+    def feed_url(feed)
+      s3_gateway.url("#{rss_files_prefix}/#{feed.secret_token}.xml")
+    end
+
+    def audio_file_url(audio_file)
+      s3_gateway.url("#{data_files_prefix}/#{audio_file.secret_token}#{audio_file.extension}")
+    end
+  end
+end

data/lib/audio_feed_manager/version.rb

@@ -0,0 +1,3 @@
+module AudioFeedManager
+  VERSION = "0.0.1"
+end

data/lib/audio_feed_manager.rb

@@ -0,0 +1,57 @@
+require "dependor"
+require "dependor/shorty"
+
+require_relative "audio_feed_manager/support/getter_setter_method"
+require_relative "audio_feed_manager/support/hash_constructor"
+
+require_relative "audio_feed_manager/error"
+require_relative "audio_feed_manager/cli/command"
+
+require_relative "audio_feed_manager/application"
+require_relative "audio_feed_manager/audio_file"
+require_relative "audio_feed_manager/audio_file_adder"
+require_relative "audio_feed_manager/audio_file_repository"
+require_relative "audio_feed_manager/config"
+require_relative "audio_feed_manager/config_repository"
+require_relative "audio_feed_manager/cli"
+require_relative "audio_feed_manager/cli/arguments"
+require_relative "audio_feed_manager/cli/arguments_parser"
+require_relative "audio_feed_manager/cli/arguments_specification"
+require_relative "audio_feed_manager/console"
+require_relative "audio_feed_manager/directory_lister"
+require_relative "audio_feed_manager/feed"
+require_relative "audio_feed_manager/feed_items_repository"
+require_relative "audio_feed_manager/feed_repository"
+require_relative "audio_feed_manager/feed_syncer"
+require_relative "audio_feed_manager/file_storage"
+require_relative "audio_feed_manager/id3_tags"
+require_relative "audio_feed_manager/new_model_creator"
+require_relative "audio_feed_manager/rss_generator"
+require_relative "audio_feed_manager/rss_repository"
+require_relative "audio_feed_manager/s3_gateway"
+require_relative "audio_feed_manager/secret_token_generator"
+require_relative "audio_feed_manager/stop_application"
+require_relative "audio_feed_manager/tags"
+require_relative "audio_feed_manager/unique_id_generator"
+require_relative "audio_feed_manager/url_maker"
+require_relative "audio_feed_manager/version"
+
+require_relative "audio_feed_manager/cli/add_audio_file"
+require_relative "audio_feed_manager/cli/add_feed"
+require_relative "audio_feed_manager/cli/initialize_project"
+require_relative "audio_feed_manager/cli/list_feeds"
+require_relative "audio_feed_manager/cli/show_feed"
+require_relative "audio_feed_manager/cli/get_feed_url"
+require_relative "audio_feed_manager/cli/update_feed_rss"
+require_relative "audio_feed_manager/cli/publish"
+
+require_relative "audio_feed_manager/cli/commands_list"
+
+module AudioFeedManager
+  def self.run(pwd: Dir.pwd, argv: ARGV, stdin: $stdin, stdout: $stdout, stderr: $stderr, exit: ->(code) { exit code })
+    app = Application.new(directory: pwd, stdin: stdin, stdout: stdout, stderr: stderr)
+    app.cli.run(argv)
+  rescue StopApplication
+    exit.call(1)
+  end
+end

data/spec/audio_feed_manager/audio_file_adder_spec.rb

@@ -0,0 +1,49 @@
+require 'ostruct'
+
+module AudioFeedManager
+  describe AudioFileAdder do
+    let(:feed) { build_feed }
+    let(:saved_audio_file) { AudioFile.new(id: 'audio_files/saved') }
+
+    fake(:id3_tags)
+    fake(:feed_items_repository)
+    let(:audio_file_repository) { fake(:audio_file_repository, add: saved_audio_file) }
+
+    let(:audio_file_adder) { isolate(AudioFileAdder) }
+
+    it "adds the file based on ID3 tags to the specified feed" do
+      stub(id3_tags).read("/some/file") { Tags.new(title: "Some Audio File", artist: "Some Author") }
+      audio_file = AudioFile.new(title: "Some Audio File", author: "Some Author")
+
+      audio_file_adder.call(feed, "/some/file")
+
+      expect(audio_file_repository).to have_received.add(audio_file, "/some/file")
+    end
+
+    it "adds the audio file to the specified feed" do
+      stub(id3_tags).read("/some/file") { Tags.new(title: "Some Audio File", artist: "Some Author") }
+
+      audio_file_adder.call(feed, "/some/file")
+
+      expect(feed_items_repository).to have_received.add(feed, saved_audio_file)
+    end
+
+    it "fetches title from the lambda if no title discovered" do
+      stub(id3_tags).read("/some/file") { Tags.new(artist: "Some Author") }
+      audio_file = AudioFile.new(title: "some title", author: "Some Author")
+
+      audio_file_adder.call(feed, "/some/file", title: ->() { "some title" })
+
+      expect(audio_file_repository).to have_received.add(audio_file, "/some/file")
+    end
+
+    it "fetches author from the lambda if no author discovered" do
+      stub(id3_tags).read("/some/file") { Tags.new(title: "Some Audio File") }
+      audio_file = AudioFile.new(title: "Some Audio File", author: "some author")
+
+      audio_file_adder.call(feed, "/some/file", author: ->() { "some author" })
+
+      expect(audio_file_repository).to have_received.add(audio_file, "/some/file")
+    end
+  end
+end

data/spec/audio_feed_manager/audio_file_repository_spec.rb

@@ -0,0 +1,58 @@
+module AudioFeedManager
+  describe AudioFileRepository do
+    let(:audio_file) { AudioFile.new(title: "hello", author: "test") }
+    let(:saved_audio_file) { AudioFile.new(id: "audio_files/foo", secret_token: "abcd", extension: ".mp3") }
+
+    let(:audio_files_prefix) { "audio_files" }
+    let(:audio_files_directory) { "/tmp/foo/audio_files" }
+    let(:data_files_directory) { Pathname.new("/tmp/foo/data") }
+    let(:new_model_creator) { fake(:new_model_creator, create: saved_audio_file) }
+    fake(:storage)
+
+    let(:audio_file_repository) { isolate(AudioFileRepository) }
+
+    before do
+      FileUtils.rm_rf("/tmp/foo/data")
+      FileUtils.mkdir_p("/tmp/foo/data")
+    end
+
+    it "saves the metadata while generating a secret token and ID" do
+      audio_file_repository.add(audio_file, fixture_file("test.mp3"))
+
+      expect(new_model_creator).to have_received.create(audio_file, prefix: "audio_files", directory: "/tmp/foo/audio_files")
+    end
+
+    it "saves the file extension" do
+      modified_audio_file = AudioFile.new(title: audio_file.title,
+                                          author: audio_file.author,
+                                          extension: ".mp3",
+                                          size: 11305,
+                                          content_type: "audio/mpeg")
+      audio_file_repository.add(audio_file, fixture_file("test.mp3"))
+
+      expect(new_model_creator).to have_received.create(modified_audio_file, prefix: "audio_files", directory: "/tmp/foo/audio_files")
+    end
+
+    it "copies the given file to a location based on the secret token" do
+      audio_file_repository.add(audio_file, fixture_file("test.mp3"))
+
+      expect(File.exist?("/tmp/foo/data/abcd.mp3")).to be(true)
+    end
+
+    it "fetches the audio files" do
+      stub(storage).read("audio_files/foo") { {id: "audio_files/foo", title: "Foo"} }
+
+      audio_file = audio_file_repository.fetch("audio_files/foo")
+
+      expect(audio_file).to eq(AudioFile.new(id: "audio_files/foo", title: "Foo"))
+    end
+
+    it "raises an error if audio file was not found" do
+      stub(storage).read("audio_files/foo") { raise FileNotFound }
+
+      expect{
+        audio_file_repository.fetch("audio_files/foo")
+      }.to raise_error(AudioFileNotFound)
+    end
+  end
+end

data/spec/audio_feed_manager/cli/add_audio_file_spec.rb

@@ -0,0 +1,44 @@
+module AudioFeedManager
+  describe AddAudioFile do
+    let(:feed) { build_feed }
+    let(:directory) { Pathname.new('/tmp/foo') }
+    fake(:feed_repository)
+    fake(:audio_file_adder)
+    fake(:console)
+    fake(:rss_generator)
+
+    let(:add_audio_file) { isolate(AddAudioFile) }
+
+    it "adds the audio file to the feed" do
+      stub(feed_repository).fetch("feeds/some-id") { feed }
+
+      add_audio_file.run(feed: "feeds/some-id", files: ["file"])
+
+      expect(audio_file_adder).to have_received.call(feed, Pathname.new("/tmp/foo/file"), title: any(Proc), author: any(Proc))
+    end
+
+    it "prints an error message when the feed was not found" do
+      stub(feed_repository).fetch("feeds/some-id") { raise FeedNotFound }
+
+      add_audio_file.run(feed: "feeds/some-id", files: ["/some/file"])
+
+      expect(console).to have_received.die(any_args)
+    end
+
+    it "prints an error message when the file was not found" do
+      stub(feed_repository).fetch("feeds/some-id") { raise Errno::ENOENT }
+
+      add_audio_file.run(feed: "feeds/some-id", files: ["/some/file"])
+
+      expect(console).to have_received.die(any_args)
+    end
+
+    it "generates rss after adding the file" do
+      stub(feed_repository).fetch("feeds/some-id") { feed }
+
+      add_audio_file.run(feed: "feeds/some-id", files: ["file"])
+
+      expect(rss_generator).to have_received.generate(feed)
+    end
+  end
+end

data/spec/audio_feed_manager/cli/add_feed_spec.rb

@@ -0,0 +1,27 @@
+module AudioFeedManager
+  describe AddFeed do
+    fake(:console)
+    fake(:feed_repository)
+    fake(:rss_generator)
+
+    let(:add_feed) { isolate(AddFeed) }
+    let(:feed) { Feed.new(id: "feeds/hello-world")  }
+
+    before do
+      stub(console).ask("Description", default: "Hello World!") { "some description" }
+      stub(feed_repository).add(any_args) { feed }
+    end
+
+    it "adds the feed with the given title" do
+      add_feed.run(title: "Hello World!")
+
+      expect(feed_repository).to have_received.add(Feed.new(title: "Hello World!", description: "some description"))
+    end
+
+    it "generates an RSS file for the created feed" do
+      add_feed.run(title: "Hello World!")
+
+      expect(rss_generator).to have_received.generate(feed)
+    end
+  end
+end

data/spec/audio_feed_manager/cli/arguments_parser_spec.rb

@@ -0,0 +1,85 @@
+module AudioFeedManager
+  describe ArgumentsParser do
+    let(:parser) { isolate(ArgumentsParser) }
+
+    context "with a simple one-argument specification" do
+      let(:specification) {
+        ArgumentsSpecification.specify do |s|
+          s.argument :project_name, required: true, description: "Name of the directory to create the project in"
+        end
+      }
+
+      it "parses a single-argument list into arguments" do
+        arguments = parser.parse(specification, ["foo-bar"])
+
+        expect(arguments.to_hash).to eq({project_name: "foo-bar"})
+      end
+
+      it "fails when there are no arguments" do
+        expect {
+          parser.parse(specification, [])
+        }.to raise_error(InvalidArguments)
+      end
+
+      it "fails when there are two or more arguments" do
+        expect {
+          parser.parse(specification, ["foo", "bar"])
+        }.to raise_error(InvalidArguments)
+      end
+    end
+
+    context "with varargs" do
+      let(:specification) {
+        ArgumentsSpecification.specify do |s|
+          s.varargs :files, minimum: 1, description: "Files to add."
+        end
+      }
+
+      it "parses a single-argument list into arguments" do
+        arguments = parser.parse(specification, ["foo-bar"])
+
+        expect(arguments.to_hash).to eq({files: ["foo-bar"]})
+      end
+
+      it "parses a multi-argument list into arguments" do
+        arguments = parser.parse(specification, ["foo", "bar", "baz"])
+
+        expect(arguments.to_hash).to eq({files: ["foo", "bar", "baz"]})
+      end
+
+      it "fails when there are no arguments" do
+        expect {
+          parser.parse(specification, [])
+        }.to raise_error(InvalidArguments)
+      end
+    end
+
+    context "with optional arguments" do
+      let(:specification) {
+        ArgumentsSpecification.specify do |s|
+          s.argument :author_name, required: false, default: "Anonymous", description: "Author name"
+          s.argument :project_name, required: true, description: "Name of the directory to create the project in"
+        end
+      }
+
+      it "parses a single-argument list into required arguments" do
+        arguments = parser.parse(specification, ["foo-bar"])
+
+        expect(arguments.to_hash[:project_name]).to eq("foo-bar")
+      end
+
+      it "parses a two-argument list into required and optional arguments" do
+        arguments = parser.parse(specification, ["foo", "bar"])
+
+        expect(arguments.to_hash[:project_name]).to eq("foo")
+        expect(arguments.to_hash[:author_name]).to eq("bar")
+      end
+
+      it "raises an error when given more arguments than supported" do
+        expect {
+          parser.parse(specification, ["foo", "bar", "baz"])
+        }.to raise_error(InvalidArguments)
+      end
+    end
+  end
+end

data/spec/audio_feed_manager/cli/arguments_specification_spec.rb

@@ -0,0 +1,51 @@
+module AudioFeedManager
+  describe ArgumentsSpecification do
+    describe "#usage_line" do
+      it "returns the command name" do
+        specification = ArgumentsSpecification.specify do |s|
+          s.name "foo"
+        end
+
+        expect(specification.usage_line).to eq("foo")
+      end
+
+      it "returns the command name and required arguments" do
+        specification = ArgumentsSpecification.specify do |s|
+          s.name "foo"
+          s.argument :some_arg, required: true
+        end
+
+        expect(specification.usage_line).to eq("foo <SOME_ARG>")
+      end
+
+      it "returns the command name and optional arguments" do
+        specification = ArgumentsSpecification.specify do |s|
+          s.name "foo"
+          s.argument :some_arg, required: false
+        end
+
+        expect(specification.usage_line).to eq("foo [SOME_ARG]")
+      end
+
+      it "returns the command name and varargs" do
+        specification = ArgumentsSpecification.specify do |s|
+          s.name "foo"
+          s.varargs :songs
+        end
+
+        expect(specification.usage_line).to eq("foo [SONGS...]")
+      end
+
+      it "returns the command name and a combination of optional, required arguments and varargs" do
+        specification = ArgumentsSpecification.specify do |s|
+          s.name "foo"
+          s.argument :first_arg, required: true
+          s.argument :second_arg, required: false
+          s.varargs :rest
+        end
+
+        expect(specification.usage_line).to eq("foo <FIRST_ARG> [SECOND_ARG] [REST...]")
+      end
+    end
+  end
+end

data/spec/audio_feed_manager/cli/commands_list_spec.rb

@@ -0,0 +1,91 @@
+module AudioFeedManager
+  describe CommandsList do
+    fake(:initialize_project)
+    fake(:add_feed)
+    fake(:list_feeds)
+    fake(:add_audio_file)
+    fake(:show_feed)
+    fake(:get_feed_url)
+    fake(:update_feed_rss)
+    fake(:publish)
+    fake(:console)
+
+    let(:commands_list) { isolate(CommandsList) }
+
+    it "returns the initialize_project command for 'init'" do
+      command, opts = commands_list.get(["init", "foo"])
+
+      expect(command).to be(initialize_project)
+      expect(opts).to eq(["foo"])
+    end
+
+    it "returns help when called with no arguments" do
+      command, opts = commands_list.get([])
+
+      expect(command).to be(commands_list)
+      expect(opts).to eq([])
+    end
+
+    it "returns help when called with 'help'" do
+      command, opts = commands_list.get(["help"])
+
+      expect(command).to be(commands_list)
+      expect(opts).to eq([])
+    end
+
+    it "returns add_feed command for 'feeds add'" do
+      command, opts = commands_list.get(["feeds", "add", "foo"])
+
+      expect(command).to be(add_feed)
+      expect(opts).to eq(["foo"])
+    end
+
+    it "returns show_feed for 'feeds show'" do
+      command, opts = commands_list.get(["feeds", "show", "feeds/hello"])
+
+      expect(command).to be(show_feed)
+      expect(opts).to eq(["feeds/hello"])
+    end
+
+    it "returns get_feed_url for 'feeds get-url'" do
+      command, opts = commands_list.get(["feeds", "get-url", "feeds/hello"])
+
+      expect(command).to be(get_feed_url)
+      expect(opts).to eq(["feeds/hello"])
+    end
+
+    it "returns update_feed_rss for 'feeds update-rss'" do
+      command, opts = commands_list.get(["feeds", "update-rss", "feeds/hello"])
+
+      expect(command).to be(update_feed_rss)
+      expect(opts).to eq(["feeds/hello"])
+    end
+
+    it "returns add_audio_file for 'audio add'" do
+      command, opts = commands_list.get(["audio", "add", "feeds/hello", "/some/file.mp3"])
+
+      expect(command).to be(add_audio_file)
+      expect(opts).to eq(["feeds/hello", "/some/file.mp3"])
+    end
+
+    it "returns list_feeds command for 'feeds list'" do
+      command, opts = commands_list.get(["feeds", "list"])
+
+      expect(command).to be(list_feeds)
+      expect(opts).to eq([])
+    end
+
+    it "returns publish command for 'publish'" do
+      command, opts = commands_list.get(["publish"])
+
+      expect(command).to be(publish)
+      expect(opts).to eq([])
+    end
+
+    it "raises an UnknownCommand error for other commands" do
+      expect {
+        commands_list.get("asdf")
+      }.to raise_error(UnknownCommand)
+    end
+  end
+end

data/spec/audio_feed_manager/cli/get_feed_url_spec.rb

@@ -0,0 +1,26 @@
+module AudioFeedManager
+  describe GetFeedUrl do
+    fake(:feed_repository)
+    let(:console) { FakeConsole.new }
+    fake(:url_maker, feed_url: "http://example.com/feed")
+
+    let(:get_feed_url) { isolate(GetFeedUrl) }
+
+    it "prints the feed url" do
+      feed = build_feed
+      stub(feed_repository).fetch("feeds/foo") { feed }
+
+      get_feed_url.run(feed: "feeds/foo")
+
+      expect(console.out).to eq("http://example.com/feed\n")
+    end
+
+    it "returns a friendly message when feed not found" do
+      stub(feed_repository).fetch("feeds/foo") { raise FeedNotFound.for_id("feeds/foo") }
+
+      get_feed_url.run(feed: "feeds/foo")
+
+      expect(console.out).to include("not found")
+    end
+  end
+end

data/spec/audio_feed_manager/cli/initialize_project_spec.rb

@@ -0,0 +1,47 @@
+module AudioFeedManager
+  describe InitializeProject do
+    fake(:console)
+    fake(:config_repository)
+    let(:directory) { Pathname.new("/tmp") }
+    let(:audio_files_prefix) { "audio_files" }
+    let(:rss_files_prefix) { "rss" }
+    let(:feeds_prefix) { "feeds" }
+    let(:data_files_prefix) { "data" }
+    let(:items_prefix) { "items" }
+    let(:initialize_project) { isolate(InitializeProject) }
+
+    before do
+      FileUtils.rm_rf("/tmp/foo")
+    end
+
+    it "creates the project directory" do
+      initialize_project.run(project_dir: "foo")
+
+      expect(File.exists?("/tmp/foo")).to be(true)
+    end
+
+    it "creates a directory for the feeds" do
+      initialize_project.run(project_dir: "foo")
+
+      expect(File.exists?("/tmp/foo/feeds")).to be(true)
+    end
+
+    it "creates a directory for the audio_files" do
+      initialize_project.run(project_dir: "foo")
+
+      expect(File.exists?("/tmp/foo/audio_files")).to be(true)
+    end
+
+    it "creates a directory for rss files" do
+      initialize_project.run(project_dir: "foo")
+
+      expect(File.exists?("/tmp/foo/rss")).to be(true)
+    end
+
+    it "creates a directory for data files" do
+      initialize_project.run(project_dir: "foo")
+
+      expect(File.exists?("/tmp/foo/data")).to be(true)
+    end
+  end
+end

data/spec/audio_feed_manager/cli/list_feeds_spec.rb

@@ -0,0 +1,27 @@
+module AudioFeedManager
+  describe ListFeeds do
+    fake(:feed_repository)
+    let(:console) { FakeConsole.new }
+
+    let(:list_feeds) { isolate(ListFeeds) }
+
+    it "returns a formatted list of feeds" do
+      feeds = [Feed.new(id: "feeds/hello", title: "Hello!"),
+               Feed.new(id: "feeds/foo-bar", title: "Foo Bar")]
+      stub(feed_repository).list { feeds }
+
+      list_feeds.run
+
+      expect(console.out).to (include("1.\tfeeds/hello\tHello!"))
+      expect(console.out).to (include("2.\tfeeds/foo-bar\tFoo Bar"))
+    end
+
+    it "prints a helpful message when no feeds exist" do
+      stub(feed_repository).list { [] }
+
+      list_feeds.run
+
+      expect(console.out).to (include("No feeds yet."))
+    end
+  end
+end

data/spec/audio_feed_manager/cli/show_feed_spec.rb

@@ -0,0 +1,41 @@
+module AudioFeedManager
+  describe ShowFeed do
+    let(:feed) { Feed.new(id: "feeds/hello", title: "Hello!") }
+    fake(:feed_repository)
+    fake(:feed_items_repository, list: [])
+    fake(:url_maker, feed_url: "http://example.com/feeds/abc.xml")
+    let(:console) { FakeConsole.new }
+
+    let(:show_feed) { isolate(ShowFeed) }
+
+    it "returns detailes information about the feed" do
+      stub(feed_repository).fetch("feeds/foo") { feed }
+      audio_file = AudioFile.new(id: "audio_files/bar", title: "Some audio file")
+      stub(feed_items_repository).list(feed) { [audio_file] }
+
+      show_feed.run(feed: "feeds/foo")
+
+      expect(console.out).to (include("Hello!"))
+      expect(console.out).to (include("http://example.com/feeds/abc.xml"))
+      expect(console.out).to (include("Some audio file"))
+    end
+
+    it "prints a helpful message when feed was not found" do
+      stub(feed_repository).fetch("feeds/foo") { raise FeedNotFound.for_id("feeds/foo") }
+
+      show_feed.run(feed: "feeds/foo")
+
+      expect(console.out).to (include("not found"))
+    end
+
+    it "prints a helpful message when there are no audio files" do
+      stub(feed_repository).fetch("feeds/foo") { feed }
+      stub(feed_items_repository).list(feed) { [] }
+
+      show_feed.run(feed: "feeds/foo")
+
+      expect(console.out).to (include("No audio files"))
+    end
+  end
+end
+