podrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f36c1361363872269b583988f8f458d5ddf6fb69c937c9e2833e9a33273d6a5
+  data.tar.gz: f7134ddd6f79bd836b1c62dfdf903a2dc69821831b8e8aab14f0f405dc0205cf
+SHA512:
+  metadata.gz: 9a64836ce14be0068c5dad6317745caf62668350008dbc84d8b7a67d66375778e11504bdf79cae647661bcaaf775e4a24b0ff2c18c35133333ffd06af9d5b085
+  data.tar.gz: 15640e0610b45b9177fdcd471050d549b093282fea329d31740201e4ad627edf94782ac18ac234aabe00dd1e8ee29aa7867ff944c4e8f39461f42d9c61a0cb8f

data/exe/podrb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "podrb"
+
+Podrb::CLI.start

data/lib/podrb/cli.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "commands"
+require_relative "infrastructure/storage/sql"
+require_relative "infrastructure/shell_interface"
+
+module Podrb
+  class CLI < Thor
+    # https://github.com/rails/thor/issues/728#issuecomment-642798887
+    def self.exit_on_failure?
+      true
+    end
+
+    def self.start(given_args = ARGV, config = {})
+      command = given_args.first
+      does_not_require_config = %w[version -V --version init].include?(command)
+      podrb_initialized = Dir.exist?(ENV["HOME"] + "/.config/podrb")
+      if does_not_require_config || podrb_initialized
+        super
+      else
+        puts "Missing config files. Run `podrb init` first."
+      end
+    end
+
+    desc "version", "Displays the podrb version"
+    map %w[-V --version] => :version
+    def version
+      puts VERSION
+    end
+
+    desc "init", "Creates the podrb config files"
+    def init
+      puts "Creating config files..."
+
+      result = Podrb::Commands::Init::Runner.call
+
+      puts Podrb::Commands::Init::Output.call(result)
+    end
+
+    desc "add FEED", "Adds a podcast to the Podrb database"
+    method_option :sync_url, type: :string, default: "", desc: "Podrb will use this URL to sync the podcast."
+    def add(feed)
+      puts "Adding the podcast..."
+
+      result = Podrb::Commands::Add::Runner.call(feed, options)
+
+      puts Podrb::Commands::Add::Output.call(result)
+    end
+
+    desc "podcasts", "List the podcast records"
+    method_option :fields, type: :array, default: [], desc: "Select the fields that will be displayed."
+    def podcasts
+      result = Podrb::Commands::Podcasts::Runner.call(options)
+
+      puts Podrb::Commands::Podcasts::Output.call(result)
+    end
+
+    desc "episodes PODCAST_ID", "List the podcast episodes"
+    method_option :fields, type: :array, default: [], desc: "Select the fields that will be displayed."
+    method_option :order_by, type: :string, default: "id", desc: "Choose how podrb will order the episodes."
+    method_option :all, type: :boolean, default: false, desc: "List archived episodes too."
+    def episodes(podcast_id)
+      result = Podrb::Commands::Episodes::Runner.call(podcast_id, options)
+
+      puts Podrb::Commands::Episodes::Output.call(result)
+    end
+
+    desc "open EPISODE_ID", "Open a episode in the browser"
+    method_option :browser, type: :string, default: "firefox", desc: "Choose the browser."
+    method_option :archive, type: :boolean, default: false, desc: "Archive the episode."
+    def open(episode_id)
+      result = Podrb::Commands::Open::Runner.call(episode_id, options)
+
+      Infrastructure::ShellInterface.call(result[:metadata])
+
+      puts Podrb::Commands::Open::Output.call(result)
+    end
+
+    desc "archive EPISODE_ID", "Archive the episode"
+    def archive(episode_id)
+      result = Podrb::Commands::Archive::Runner.call(episode_id)
+
+      puts Podrb::Commands::Archive::Output.call(result)
+    end
+
+    desc "dearchive EPISODE_ID", "Dearchive the episode."
+    def dearchive(episode_id)
+      result = Podrb::Commands::Dearchive::Runner.call(episode_id)
+
+      puts Podrb::Commands::Dearchive::Output.call(result)
+    end
+
+    desc "delete PODCAST_ID", "Delete the podcast from podrb's database."
+    def delete(podcast_id)
+      result = Podrb::Commands::Delete::Runner.call(podcast_id)
+
+      puts Podrb::Commands::Delete::Output.call(result)
+    end
+
+    desc "sync PODCAST_ID", "Sync the podcast."
+    def sync(podcast_id)
+      result = Podrb::Commands::Sync::Runner.call(podcast_id)
+
+      puts Podrb::Commands::Sync::Output.call(result)
+    end
+
+    desc "update PODCAST_ID", "Update the podcast attributes."
+    method_option :feed, type: :string, default: "", desc: "Define the podcast feed."
+    def update(podcast_id)
+      result = Podrb::Commands::Update::Runner.call(podcast_id, options)
+
+      puts Podrb::Commands::Update::Output.call(result)
+    end
+  end
+end

data/lib/podrb/commands/add/output.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Add
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :successfully_added
+            <<~OUTPUT
+              Podcast successfully added to the database!
+            OUTPUT
+          when :already_added
+            <<~OUTPUT
+              Podcast already exists in the database.
+            OUTPUT
+          when :badly_formatted
+            <<~OUTPUT
+              The podcast feed is badly formatted or unsupported.
+            OUTPUT
+          when :missing_sync_url
+            <<~OUTPUT
+              This podcast feed doesn't provide a sync url. Please, use the --sync-url option to set this data manually.
+              Ex: `podrb add FEED --sync-url=SYNC_URL`
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/add/runner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/feed_parser"
+
+module Podrb
+  module Commands
+    module Add
+      class Runner < Podrb::Commands::BaseRunner
+        def call(feed, options = {})
+          parsed_feed = Infrastructure::FeedParser.call(feed)
+          parsed_options = parse_options(options)
+
+          if missing_data?(parsed_feed)
+            return build_failure_response(details: :badly_formatted)
+          end
+
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          db.transaction do
+            podcast = parsed_feed.podcast
+            podcast_feed = parsed_options["sync_url"] || podcast.feed
+            return build_failure_response(details: :missing_sync_url) if podcast_feed.nil?
+
+            db.execute <<-SQL
+              insert into podcasts
+              (name, description, feed, website)
+              values (
+                "#{escape_double_quotes(podcast.name)}",
+                "#{escape_double_quotes(podcast.description)}",
+                "#{escape_double_quotes(podcast_feed)}",
+                "#{escape_double_quotes(podcast.website)}"
+              );
+            SQL
+
+            inserted_podcast_id = db.query("select id from podcasts order by id desc limit 1;").first.id
+            parsed_feed.episodes.each do |e|
+              db.execute <<-SQL
+                insert into episodes
+                (title, release_date, podcast_id, duration, link, external_id)
+                values (
+                  "#{escape_double_quotes(e.title)}",
+                  "#{escape_double_quotes(e.release_date)}",
+                  #{inserted_podcast_id},
+                  "#{escape_double_quotes(e.duration)}",
+                  "#{escape_double_quotes(e.link)}",
+                  "#{e.external_id}"
+                );
+              SQL
+            end
+          end
+
+          build_success_response(details: :successfully_added)
+        rescue Infrastructure::Storage::Exceptions::ConstraintViolation
+          build_failure_response(details: :already_added)
+        end
+
+        private
+
+        def missing_data?(feed)
+          feed.podcast.nil? || feed.episodes.nil?
+        end
+
+        def escape_double_quotes(str)
+          str.gsub("\"", "\"\"")
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/archive/output.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Archive
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :episode_archived
+            <<~OUTPUT
+              Episode successfully archived!
+            OUTPUT
+          when :not_found
+            <<~OUTPUT
+              Episode not found
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/archive/runner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Archive
+      class Runner < Podrb::Commands::BaseRunner
+        def call(episode_id)
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+
+          if db.query("select id from episodes where id = #{episode_id}").empty?
+            return build_failure_response(details: :not_found)
+          end
+
+          sql_code = <<~SQL
+            update episodes
+            set archived_at = '#{Time.now.iso8601}'
+            where id = #{episode_id};
+          SQL
+          db.execute(sql_code)
+
+          build_success_response(details: :episode_archived)
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/base_output.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "tabulo"
+
+module Podrb
+  module Commands
+    class BaseOutput
+      def self.call(context = {})
+        new(context).call
+      end
+
+      def initialize(context)
+        @context = context
+      end
+
+      private
+
+      def generate_text_table(data:, columns:)
+        Tabulo::Table.new(data, *columns.map(&:to_sym), row_divider_frequency: 1).pack
+      end
+    end
+  end
+end

data/lib/podrb/commands/base_runner.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    class BaseRunner
+      def self.call(*args)
+        command = new
+        if command.method(:call).parameters.empty?
+          command.call
+        else
+          command.call(*args)
+        end
+      end
+
+      private
+
+      def build_success_response(details:, metadata: nil)
+        {status: :success, details: details, metadata: metadata}
+      end
+
+      def build_failure_response(details:, metadata: nil)
+        {status: :failure, details: details, metadata: metadata}
+      end
+
+      def home_dir
+        ENV["HOME"]
+      end
+
+      def podrb_config_dir
+        home_dir + "/.config/podrb"
+      end
+
+      def podrb_db_dir
+        "#{podrb_config_dir}/podrb.db"
+      end
+
+      def parse_options(opts)
+        opts.select { |k, v| v != "" && v != [] }
+      end
+
+      def escape_double_quotes(str)
+        str.gsub("\"", "\"\"")
+      end
+    end
+  end
+end

data/lib/podrb/commands/dearchive/output.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Dearchive
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :episode_dearchived
+            <<~OUTPUT
+              Episode successfully dearchived!
+            OUTPUT
+          when :not_found
+            <<~OUTPUT
+              Episode not found
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/dearchive/runner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Dearchive
+      class Runner < Podrb::Commands::BaseRunner
+        def call(episode_id)
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+
+          if db.query("select id from episodes where id = #{episode_id}").empty?
+            return build_failure_response(details: :not_found)
+          end
+
+          sql_code = <<~SQL
+            update episodes
+            set archived_at = null
+            where id = #{episode_id};
+          SQL
+          db.execute(sql_code)
+
+          build_success_response(details: :episode_dearchived)
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/delete/output.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Delete
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :podcast_deleted
+            <<~OUTPUT
+              Podcast successfully deleted!
+            OUTPUT
+          when :not_found
+            <<~OUTPUT
+              Podcast not found
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/delete/runner.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Delete
+      class Runner < Podrb::Commands::BaseRunner
+        def call(podcast_id)
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+
+          if db.query("select id from podcasts where id = #{podcast_id}").empty?
+            return build_failure_response(details: :not_found)
+          end
+
+          sql_code = <<~SQL
+            delete from episodes
+            where podcast_id = #{podcast_id};
+          SQL
+          db.execute(sql_code)
+
+          sql_code = <<~SQL
+            delete from podcasts
+            where id = #{podcast_id};
+          SQL
+          db.execute(sql_code)
+
+          build_success_response(details: :podcast_deleted)
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/episodes/output.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Episodes
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :records_found
+            text_table = generate_text_table(
+              data: @context[:metadata][:records],
+              columns: @context[:metadata][:columns]
+            )
+            <<~OUTPUT
+              #{text_table}
+            OUTPUT
+          when :not_found
+            <<~OUTPUT
+              No episodes was found.
+            OUTPUT
+          when :invalid_column
+            <<~OUTPUT
+              This field is invalid: #{@context[:metadata][:invalid_column]}
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/episodes/runner.rb

@@ -0,0 +1,45 @@
+module Podrb
+  module Commands
+    module Episodes
+      class Runner < Podrb::Commands::BaseRunner
+        ALL_COLUMNS = %w[id title release_date duration link].freeze
+        private_constant :ALL_COLUMNS
+
+        def call(podcast_id, options = {})
+          parsed_options = parse_options(options)
+
+          columns = parsed_options["fields"] || ALL_COLUMNS
+          sql_code = <<~SQL
+            select #{columns.join(", ")}
+            from episodes
+            where podcast_id = #{podcast_id}
+          SQL
+
+          unless parsed_options["all"]
+            sql_code << "and archived_at is null\n"
+          end
+
+          order_by = parsed_options["order_by"] || "id"
+          sql_code << "order by #{order_by};\n"
+
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          records = db.query(sql_code)
+
+          build_success_response(
+            details: records.empty? ? :not_found : :records_found,
+            metadata: {records: records, columns: columns}
+          )
+        rescue Infrastructure::Storage::Exceptions::WrongSyntax => exc
+          cause = exc.message
+          if cause.include?("no such column")
+            invalid_column = cause.delete_prefix("no such column: ")
+            build_failure_response(
+              details: :invalid_column,
+              metadata: {invalid_column: invalid_column}
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/init/output.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Init
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :already_initialized
+            <<~OUTPUT
+              Podrb already was initialized!
+            OUTPUT
+          when :successfully_initialized
+            <<~OUTPUT
+              Podrb successfully initialized!
+            OUTPUT
+          when :home_not_found
+            <<~OUTPUT
+              It seems that $HOME is empty. Is your home directory set up correctly?
+            OUTPUT
+          when :cannot_create_initial_config
+            <<~OUTPUT
+              Podrb couldn't create the config files.
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/init/runner.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Podrb
+  module Commands
+    module Init
+      class Runner < Podrb::Commands::BaseRunner
+        def call
+          return build_failure_response(details: :home_not_found) if home_dir.nil?
+
+          return build_failure_response(details: :already_initialized) if Dir.exist?(podrb_config_dir)
+
+          FileUtils.mkdir_p(podrb_config_dir)
+
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          db.execute <<-SQL
+            create table podcasts (
+              id integer primary key,
+              name text not null,
+              description text,
+              feed text not null unique,
+              website text
+            );
+          SQL
+          db.execute <<-SQL
+            create table episodes (
+              id integer primary key,
+              title text not null,
+              release_date text,
+              duration text,
+              link text not null,
+              archived_at text,
+              external_id string unique,
+              podcast_id integer not null,
+              foreign key(podcast_id) references podcasts(id)
+            );
+          SQL
+
+          build_success_response(details: :successfully_initialized)
+        rescue SystemCallError, Infrastructure::Storage::Exceptions::CantStartConnection
+          build_failure_response(details: :cannot_create_initial_config)
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/open/output.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Open
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :not_found
+            <<~OUTPUT
+              The episode was not found.
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/open/runner.rb

@@ -0,0 +1,24 @@
+module Podrb
+  module Commands
+    module Open
+      class Runner < Podrb::Commands::BaseRunner
+        def call(episode_id, options = {})
+          parsed_options = parse_options(options)
+
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          episode = db.query("select link from episodes where id = #{episode_id}")[0]
+          return build_failure_response(details: :not_found) if episode.nil?
+
+          browser = parsed_options["browser"] || "firefox"
+          cmd = "#{browser} #{episode.link}"
+          cmd << " && bundle exec podrb archive #{episode_id}" if parsed_options["archive"]
+
+          build_success_response(
+            details: :episode_found,
+            metadata: {cmd: cmd}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/podcasts/output.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Podcasts
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :records_found
+            text_table = generate_text_table(
+              data: @context[:metadata][:records],
+              columns: @context[:metadata][:columns]
+            )
+            <<~OUTPUT
+              #{text_table}
+            OUTPUT
+          when :empty_table
+            <<~OUTPUT
+              No podcasts yet.
+            OUTPUT
+          when :invalid_column
+            <<~OUTPUT
+              This field is invalid: #{@context[:metadata][:invalid_column]}
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/podcasts/runner.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Podcasts
+      class Runner < Podrb::Commands::BaseRunner
+        ALL_COLUMNS = %w[id name description feed website].freeze
+        private_constant :ALL_COLUMNS
+
+        def call(options = {})
+          parsed_options = parse_options(options)
+          columns = parsed_options["fields"] || ALL_COLUMNS
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          records = db.query("select #{columns.join(", ")} from podcasts")
+          build_success_response(
+            details: records.empty? ? :empty_table : :records_found,
+            metadata: {records: records, columns: columns}
+          )
+        rescue Infrastructure::Storage::Exceptions::WrongSyntax => exc
+          cause = exc.message
+          if cause.include?("no such column")
+            invalid_column = cause.delete_prefix("no such column: ")
+            build_failure_response(
+              details: :invalid_column,
+              metadata: {invalid_column: invalid_column}
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/sync/output.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Sync
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :podcast_synchronized
+            <<~OUTPUT
+              Podcast successfully synchronized!
+            OUTPUT
+          when :not_found
+            <<~OUTPUT
+              Podcast not found
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/sync/runner.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../infrastructure/feed_parser"
+
+module Podrb
+  module Commands
+    module Sync
+      class Runner < Podrb::Commands::BaseRunner
+        def call(podcast_id)
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          podcast = db.query("select feed from podcasts where id = #{podcast_id}").first
+          return build_failure_response(details: :not_found) if podcast.nil?
+
+          parsed_feed = Infrastructure::FeedParser.call(podcast.feed)
+          parsed_feed.episodes.each do |e|
+            db.execute <<-SQL
+              insert or ignore into episodes
+              (title, release_date, podcast_id, duration, link, external_id)
+              values (
+                "#{escape_double_quotes(e.title)}",
+                "#{escape_double_quotes(e.release_date)}",
+                #{podcast_id},
+                "#{escape_double_quotes(e.duration)}",
+                "#{escape_double_quotes(e.link)}",
+                "#{e.external_id}"
+              );
+            SQL
+          end
+          build_success_response(details: :podcast_synchronized)
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/update/output.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Update
+      class Output < ::Podrb::Commands::BaseOutput
+        def call
+          case @context[:details]
+          when :podcast_updated
+            <<~OUTPUT
+              Podcast successfully updated!
+            OUTPUT
+          when :invalid_options
+            <<~OUTPUT
+              Invalid options. Check the documentation `podrb help update`.
+            OUTPUT
+          when :not_found
+            <<~OUTPUT
+              Podcast not found.
+            OUTPUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands/update/runner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Podrb
+  module Commands
+    module Update
+      class Runner < Podrb::Commands::BaseRunner
+        def call(podcast_id, options = {})
+          parsed_options = parse_options(options)
+          return build_failure_response(details: :invalid_options) if parsed_options.empty?
+
+          db = Infrastructure::Storage::SQL.new(db: podrb_db_dir)
+          if db.query("select id from podcasts where id = #{podcast_id}").empty?
+            return build_failure_response(details: :not_found)
+          end
+
+          sql_code = <<~SQL
+            update podcasts
+            set feed = '#{options["feed"]}'
+            where id = #{podcast_id};
+          SQL
+          db.execute(sql_code)
+          build_success_response(details: :podcast_updated)
+        end
+      end
+    end
+  end
+end

data/lib/podrb/commands.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "commands/base_runner"
+require_relative "commands/base_output"
+require_relative "commands/add/runner"
+require_relative "commands/add/output"
+require_relative "commands/archive/runner"
+require_relative "commands/archive/output"
+require_relative "commands/dearchive/runner"
+require_relative "commands/dearchive/output"
+require_relative "commands/delete/runner"
+require_relative "commands/delete/output"
+require_relative "commands/episodes/runner"
+require_relative "commands/episodes/output"
+require_relative "commands/init/runner"
+require_relative "commands/init/output"
+require_relative "commands/open/runner"
+require_relative "commands/open/output"
+require_relative "commands/podcasts/runner"
+require_relative "commands/podcasts/output"
+require_relative "commands/sync/runner"
+require_relative "commands/sync/output"
+require_relative "commands/update/runner"
+require_relative "commands/update/output"
+
+module Podrb
+  module Commands; end
+end

data/lib/podrb/infrastructure/dto.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Infrastructure
+  class DTO
+    def initialize(attrs)
+      @attrs = attrs
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      @attrs.key?(symbol) || super
+    end
+
+    def method_missing(symbol, *args)
+      @attrs[symbol]
+    end
+  end
+end

data/lib/podrb/infrastructure/feed_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "feedjira"
+
+require_relative "dto"
+
+module Infrastructure
+  module FeedParser
+    def self.call(feed)
+      content = if File.exist?(feed)
+        File.new(feed).read
+      else
+        Net::HTTP.get(URI(feed))
+      end
+      parsed_content = Feedjira.parse(content)
+
+      podcast = Infrastructure::DTO.new(
+        name: parsed_content.title,
+        description: parsed_content.description,
+        feed: parsed_content.itunes_new_feed_url,
+        website: parsed_content.url
+      )
+
+      episodes = parsed_content.entries.map do |e|
+        Infrastructure::DTO.new(
+          title: e.title,
+          release_date: e.published.iso8601,
+          duration: e.itunes_duration,
+          link: e.url,
+          external_id: e.entry_id
+        )
+      end
+
+      # The #reverse is necessary to put the oldest episodes on the top of the feed.
+      Infrastructure::DTO.new(podcast: podcast, episodes: episodes.reverse)
+    rescue NoMethodError
+      Infrastructure::DTO.new(podcast: nil, episodes: nil)
+    end
+  end
+end

data/lib/podrb/infrastructure/shell_interface.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Infrastructure
+  module ShellInterface
+    def self.call(args)
+      return if args.nil? || args[:cmd].nil?
+
+      `#{args[:cmd]}`
+    end
+  end
+end

data/lib/podrb/infrastructure/storage/sql.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require_relative "../dto"
+
+module Infrastructure
+  module Storage
+    class SQL
+      def initialize(db:)
+        @conn = SQLite3::Database.new(db)
+      rescue SQLite3::CantOpenException
+        raise Exceptions::CantStartConnection
+      end
+
+      def execute(sql)
+        result = @conn.execute(sql)
+
+        # SQLite3 #execute always return an Array when the
+        # statement was successfully executed, and sometimes,
+        # the array will be empty, which isn't useful for us.
+        result.empty? ? true : result
+      rescue SQLite3::SQLException => exc
+        raise Exceptions::WrongSyntax, exc.message
+      rescue SQLite3::ConstraintException => exc
+        raise Exceptions::ConstraintViolation, exc.message
+      end
+
+      def query(sql)
+        parsed_result = []
+
+        @conn.query(sql) do |result|
+          result.each_hash do |row|
+            parsed_result << Infrastructure::DTO.new(row.transform_keys(&:to_sym))
+          end
+        end
+
+        parsed_result
+      rescue SQLite3::SQLException => exc
+        raise Exceptions::WrongSyntax, exc.message
+      end
+
+      # Reference
+      # https://github.com/sparklemotion/sqlite3-ruby/blob/v1.5.4/lib/sqlite3/database.rb#L632
+      def transaction(mode = :deferred, &block)
+        @conn.transaction(mode, &block)
+      end
+    end
+
+    module Exceptions
+      class Exception < ::StandardError; end
+
+      class CantStartConnection < Exception; end
+
+      class WrongSyntax < Exception; end
+
+      class ConstraintViolation < Exception; end
+    end
+  end
+end

data/lib/podrb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Podrb
+  VERSION = "0.1.0"
+end

data/lib/podrb.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "podrb/version"
+require_relative "podrb/cli"
+
+module Podrb
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: podrb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gustavo Ribeiro
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: feedjira
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: tabulo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description:
+email:
+- grdev@tutanota.com
+executables:
+- podrb
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/podrb
+- lib/podrb.rb
+- lib/podrb/cli.rb
+- lib/podrb/commands.rb
+- lib/podrb/commands/add/output.rb
+- lib/podrb/commands/add/runner.rb
+- lib/podrb/commands/archive/output.rb
+- lib/podrb/commands/archive/runner.rb
+- lib/podrb/commands/base_output.rb
+- lib/podrb/commands/base_runner.rb
+- lib/podrb/commands/dearchive/output.rb
+- lib/podrb/commands/dearchive/runner.rb
+- lib/podrb/commands/delete/output.rb
+- lib/podrb/commands/delete/runner.rb
+- lib/podrb/commands/episodes/output.rb
+- lib/podrb/commands/episodes/runner.rb
+- lib/podrb/commands/init/output.rb
+- lib/podrb/commands/init/runner.rb
+- lib/podrb/commands/open/output.rb
+- lib/podrb/commands/open/runner.rb
+- lib/podrb/commands/podcasts/output.rb
+- lib/podrb/commands/podcasts/runner.rb
+- lib/podrb/commands/sync/output.rb
+- lib/podrb/commands/sync/runner.rb
+- lib/podrb/commands/update/output.rb
+- lib/podrb/commands/update/runner.rb
+- lib/podrb/infrastructure/dto.rb
+- lib/podrb/infrastructure/feed_parser.rb
+- lib/podrb/infrastructure/shell_interface.rb
+- lib/podrb/infrastructure/storage/sql.rb
+- lib/podrb/version.rb
+homepage: https://github.com/gustavothecoder/podrb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gustavothecoder/podrb
+  source_code_uri: https://github.com/gustavothecoder/podrb
+  changelog_uri: https://github.com/gustavothecoder/podrb/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.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: 4
+summary: Minimalist CLI to manage podcasts
+test_files: []