Merge pull request #34 from thoughtbot/mr/introduce-gold-nuggets

Introduce gold nuggets

lib/gold_miner.rb

@@ -16,10 +16,10 @@ def mine_in(slack_channel, slack_client: GoldMiner::Slack::Client, env_file: ".e
       .fmap { |client| explore(slack_channel, client) }
   end
 
-  def convert_messages_to_blogpost(channel, messages, blog_post_builder: GoldMiner::BlogPost)
+  def convert_messages_to_blogpost(channel, gold_nuggets, blog_post_builder: GoldMiner::BlogPost)
     blog_post_builder.new(
       slack_channel: channel,
-      messages: messages,
+      gold_nuggets: gold_nuggets,
       since: Helpers::Time.last_friday,
       writer: BlogPost::Writer.from_env
     )

lib/gold_miner/author.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GoldMiner
+  Author = Data.define(:id, :name, :link) do
+    alias_method :to_s, :name
+
+    def name_with_link_reference
+      "[#{name}][#{id}]"
+    end
+
+    def reference_link
+      "[#{id}]: #{link}"
+    end
+  end
+end

lib/gold_miner/blog_post.rb

@@ -4,9 +4,9 @@
 
 module GoldMiner
   class BlogPost
-    def initialize(slack_channel:, messages:, since:, writer: SimpleWriter.new)
+    def initialize(slack_channel:, gold_nuggets:, since:, writer: SimpleWriter.new)
       @slack_channel = slack_channel
-      @messages = messages
+      @gold_nuggets = gold_nuggets
       @since = since
       @writer = writer
     end
@@ -51,16 +51,16 @@ def tags
     end
 
     def highlights
-      @messages
-        .map { |message| Async { highlight_from(message) } }
+      @gold_nuggets
+        .map { |gold_nugget| Async { highlight_from(gold_nugget) } }
         .map(&:wait)
         .join("\n")
         .chomp("")
     end
 
-    def highlight_from(message)
-      title_task = Async { @writer.give_title_to(message) }
-      summary_task = Async { @writer.summarize(message) }
+    def highlight_from(gold_nugget)
+      title_task = Async { @writer.give_title_to(gold_nugget) }
+      summary_task = Async { @writer.summarize(gold_nugget) }
 
       <<~MARKDOWN
         ## #{title_task.wait}
@@ -80,19 +80,19 @@ def topic_tags
     end
 
     def topics
-      @topics ||= @messages
-        .map { |message| Async { topics_from(message) } }
+      @topics ||= @gold_nuggets
+        .map { |gold_nugget| Async { topics_from(gold_nugget) } }
         .flat_map(&:wait)
         .uniq
     end
 
-    def topics_from(message)
-      @writer.extract_topics_from(message)
+    def topics_from(gold_nugget)
+      @writer.extract_topics_from(gold_nugget)
     end
 
     def authors
-      @messages
-        .map { |message| message.author.name_with_link_reference }
+      @gold_nuggets
+        .map { |gold_nugget| gold_nugget.author.name_with_link_reference }
         .uniq
         .sort
         .then { |authors| Helpers::Sentence.from(authors) }

lib/gold_miner/blog_post/open_ai_writer.rb

@@ -10,35 +10,35 @@ def initialize(open_ai_api_token:, fallback_writer:, open_ai_client: OpenAI::Cli
         @fallback_writer = fallback_writer
       end
 
-      def extract_topics_from(message)
-        topics_json = ask_openai("Extract the 3 most relevant topics, if possible in one word, from this text as a single parseable JSON array: #{message[:text]}")
+      def extract_topics_from(gold_nugget)
+        topics_json = ask_openai("Extract the 3 most relevant topics, if possible in one word, from this text as a single parseable JSON array: #{gold_nugget.content}")
 
         if (topics = try_parse_json(topics_json))
           topics
         else
-          fallback_topics_for(message)
+          fallback_topics_for(gold_nugget)
         end
       end
 
-      def give_title_to(message)
-        title = ask_openai("Give a small title to this text: #{message[:text]}")
+      def give_title_to(gold_nugget)
+        title = ask_openai("Give a small title to this text: #{gold_nugget.content}")
         title = title&.delete_prefix('"')&.delete_suffix('"')
 
-        title || fallback_title_for(message)
+        title || fallback_title_for(gold_nugget)
       end
 
-      def summarize(message)
+      def summarize(gold_nugget)
         summary = ask_openai <<~PROMPT
           Summarize the following markdown message without removing the author's blog link. Return the summary as markdown.
 
           Message:
-          #{message.as_conversation}
+          #{gold_nugget.as_conversation}
         PROMPT
 
         if summary
-          "#{summary}\n\nSource: #{message[:permalink]}"
+          "#{summary}\n\nSource: #{gold_nugget.source}"
         else
-          fallback_summary_for(message)
+          fallback_summary_for(gold_nugget)
         end
       end
 
@@ -63,16 +63,16 @@ def ask_openai(prompt)
         nil
       end
 
-      def fallback_title_for(message)
-        @fallback_writer.give_title_to(message)
+      def fallback_title_for(gold_nugget)
+        @fallback_writer.give_title_to(gold_nugget)
       end
 
-      def fallback_summary_for(message)
-        @fallback_writer.summarize(message)
+      def fallback_summary_for(gold_nugget)
+        @fallback_writer.summarize(gold_nugget)
       end
 
-      def fallback_topics_for(message)
-        @fallback_writer.extract_topics_from(message)
+      def fallback_topics_for(gold_nugget)
+        @fallback_writer.extract_topics_from(gold_nugget)
       end
 
       def try_parse_json(json)

lib/gold_miner/blog_post/simple_writer.rb

@@ -7,16 +7,16 @@ def initialize(topic_extractor: TopicExtractor)
         @topic_extractor = topic_extractor
       end
 
-      def extract_topics_from(message)
-        @topic_extractor.call(message[:text])
+      def extract_topics_from(gold_nugget)
+        @topic_extractor.call(gold_nugget.content)
       end
 
-      def give_title_to(message)
-        message[:permalink]
+      def give_title_to(gold_nugget)
+        gold_nugget.source
       end
 
-      def summarize(message)
-        message[:text]
+      def summarize(gold_nugget)
+        gold_nugget.content
       end
     end
   end

lib/gold_miner/gold_nugget.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GoldMiner
+  GoldNugget = Data.define(:content, :author, :source) do
+    def as_conversation
+      <<~MARKDOWN
+        #{author.name_with_link_reference} says: #{content}
+
+        #{author.reference_link}
+      MARKDOWN
+    end
+  end
+end

lib/gold_miner/slack/client.rb

@@ -33,9 +33,22 @@ def auth_test
     def search_messages(query)
       @slack
         .search_messages(query:)
-        .tap { |response|
+        .then { |response|
           warn_on_multiple_pages(response)
           fetch_author_names(response)
+
+          response.messages.matches.map { |message|
+            Slack::Message.new(
+              id: message.id,
+              text: message.text,
+              user: Slack::User.new(
+                id: message.user,
+                name: message.author_real_name,
+                username: message.username
+              ),
+              permalink: message.permalink
+            )
+          }
         }
     end
 
@@ -71,7 +84,6 @@ def real_name_for(user_id)
           .user
           .profile
           .real_name
-      # .tap { |name| @user_name_cache[user_id] = name }
     end
 
     def user_info(user_id)

lib/gold_miner/slack/message.rb

@@ -2,16 +2,8 @@
 
 module GoldMiner
   module Slack
-    Message = Data.define(:text, :author, :permalink) do
+    Message = Data.define(:id, :text, :user, :permalink) do
       alias_method :[], :public_send
-
-      def as_conversation
-        <<~MARKDOWN
-          #{author.name_with_link_reference} says: #{text}
-
-          #{author.reference_link}
-        MARKDOWN
-      end
     end
   end
 end

lib/gold_miner/slack/user.rb

@@ -2,16 +2,6 @@
 
 module GoldMiner
   module Slack
-    User = Data.define(:id, :name, :username, :link) do
-      alias_method :to_s, :name
-
-      def name_with_link_reference
-        "[#{name}][#{username}]"
-      end
-
-      def reference_link
-        "[#{username}]: #{link}"
-      end
-    end
+    User = Data.define(:id, :name, :username)
   end
 end

lib/gold_miner/slack_explorer.rb

@@ -30,23 +30,22 @@ def interesting_messages_query(channel, start_on)
 
     def merge_messages(*search_tasks)
       search_tasks
-        .flat_map { |task| task.wait.messages.matches }
+        .flat_map(&:wait)
         .uniq { |message| message[:permalink] }
         .map { |message|
-          Slack::Message.new(
-            text: message.text,
+          GoldNugget.new(
+            content: message.text,
             author: author_of(message),
-            permalink: message.permalink
+            source: message.permalink
           )
         }
     end
 
     def author_of(message)
-      Slack::User.new(
-        name: message.author_real_name,
-        link: link_for(message.username),
-        id: message.user,
-        username: message.username
+      Author.new(
+        id: message.user.username,
+        name: message.user.name,
+        link: link_for(message.user.username)
       )
     end