mastodon-social 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 73810aa00a8d27299a5c9446c3cc0a239d5b0076a104688255bac6d70ee203a4
+  data.tar.gz: dde89d4d59683de3b0c971dce6139cab466135dbb2c77f4d6265d0422b5468e8
+SHA512:
+  metadata.gz: 656f21b8a566eac6f97802ad179521a05710ff071abcfd2066b778821f170362b2ca342ab7cbda02e65847d47dc046aac23cf35eea1fb323ae5209d32d878b7e
+  data.tar.gz: 43587680e329dc2b0fd6ed335fd70d8b39a65091109211af7fb0c5c29a13cfa7f050fcaaa6be46ad9957335e06672e50150348397eb4ead81939b42425967e2d

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in mastodon-social.gemspec
+gemspec
+
+# We require the latest mastodon-api, since it updated its http dependency to 4.0, but it hasn't been published
+gem "mastodon-api", :git => "git://github.com/mastodon/mastodon-api"
+
+gem "rake", "~> 13.0"
+
+gem "rubocop", "~> 1.21"
+gem "debug"

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    mastodon-social (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    debug (1.7.1)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
+    io-console (0.6.0)
+    irb (1.6.2)
+      reline (>= 0.3.0)
+    json (2.6.3)
+    parallel (1.22.1)
+    parser (3.2.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.1)
+    reline (0.3.2)
+      io-console (~> 0.5)
+    rexml (3.2.5)
+    rubocop (1.43.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.24.1)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  debug
+  mastodon-social!
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.3.15

data/README.md

@@ -0,0 +1,151 @@
+# Mastodon::Social
+
+A Jekyll plugin to create links to Mastodon for your posts.
+
+## Installation
+
+In your `Gemfile` add:
+```ruby
+ group :jekyll_plugins do
+   # (other jekyll plugins)
+   gem 'mastodon-api'
+ end
+```
+
+## Usage
+
+The plugin will add a new `mastodon` command to your jekyll setup:
+```sh
+$ be jekyll help
+jekyll 3.9.2 -- Jekyll is a blog-aware, static site generator in Ruby
+
+Usage:
+
+  jekyll <subcommand> [options]
+
+...
+
+Subcommands:
+  ...
+  mastodon              Connect your blog with the Fediverse
+$
+```
+
+Running `jekyll mastodon help` shows the subcommands:
+```sh
+jekyll mastodon [command]
+
+Commands:
+  setup:     Initial setup authorizing this plugin to post to your account
+  authorize: Enter your password to authorize this plugin to post to your Mastodon account
+  mark:      Mark all posts as published (to Mastodon)
+  post:      Publish any new posts to Mastodon
+  clean:     Erase all cached mastodon data
+```
+
+To use the plugin, you need to add a Mastodon tag somewhere in your page layout. Then use the `setup` and `authorize`
+commands to link the plugin to your Mastodon account. Those are all one-time actions.
+
+Whenever you rebuild your blog, you will then need to run the `post` command to send a new status post to Mastodon
+with a link to your new entry.
+
+### Mastodon Link
+
+The plugin creates a new tag called `{% mastodon_social %}` You can add that tag to any page and it will create
+a link to the Mastodon status post for this page (assuming it exists). To put a text anchor for the link, add text in 
+the block, like so:
+```html
+{% mastodon_social %}
+Boost this on Mastodon!
+{% end_mastodon_social %}
+```
+
+### Setup and Authorization
+
+Next, you need to tell the plugin which Mastodon instance you use as your home instance. It will connect there
+to make the new status posts. In your `_config.yml` file, add this section:
+
+```yaml
+mastodon-syndication:
+  server: https://your.mastodon-server.org
+```
+
+Once you have the gem installed and your config set up, run:
+```
+jekyll mastodon setup
+```
+This establishes the plugin as an application on your Mastodon instance.
+
+Next, run:
+```
+jekyll mastodon authorize
+```
+This will prompt you for your Mastodon password, to authorize the plugin to post on your behalf. The plugin does
+not save your password anywhere; however, it does save the token it uses to login. It's saved in 
+`.jekyll-cache/mastodon.yml`. You should protect this; in theory anyone who has that token can use it to post
+mastodon toots as you. You can see the token by loggin in to to Mastodon, then going to 
+Preferences > Account > Authorized Apps. You can revoke the token if it is compromised, but then you will need
+to redo the setup and authorization steps again. As long as you don't revoke the token, it's permanent and
+you don't need to run the setup or authorization again.
+
+### Posting to Mastodon
+
+There are three commands used to sync your blog with mastodon: mark, clear, and post. For the most part, you
+will only use post.
+
+```
+jekyll mastodon post
+```
+will sync your mastodon account and your blog. The plugin keeps track of every post that's been sent to Mastodon.
+When you issue the `post` command, it checks for new posts on your blog and makes a toot for each one. That means
+you can run `post` again and if you haven't made any new posts since last time, it won't do anything.
+
+```
+jekyll mastodon clear
+```
+This will cause the plugin to forget all the Mastodon posts its made. The next time you run `post` it will send
+everything. Unless your blog is new you probably don't want to do this.
+
+```
+jekyll mastodon mark
+```
+This will mark every post on your blog as having been sent. If you have a lot of posts on your blog you will want
+to do this before your very first sync; otherwise, the plugin will sent a toot for every one of your old posts (and
+probably hit a rate limit).
+
+### Chicken and Egg Problem
+
+There's one issue with posting to Mastodon. When you have a link in your toot like the ones the plugin creates,
+Mastodon will visit the link to create a Link Card. This is a nicely-formatted card with things like a title,
+description, and even an image if you have the Open Graph metadata in your post. However, Mastodon can't generate
+the card if your post doesn't exist yet (obviously).
+
+This leads to a chicken-and-egg problem. The jekyll plugin that renders links to your mastodon post won't render
+properly if the post isn't there on mastodon, but the Mastodon post won't have its Link Card if the post isn't
+there yet. Each one needs the other to exist.
+
+If you aren't using the `mastodon_social` tag in your layout, this isn't a problem. You can post a link
+every time you build your blog by adding one step into your normal posting routine:
+
+1. Create a post and build your blog with `jekyll build`
+2. Make your new post visible online.
+3. Post it to Mastodon with `jekyll mastodon post`
+
+However, if you're using the `mastodon_social` tag to create links to your mastodon toot (so people can click it
+and boost your post) then you'll need to build your blog *twice*:
+
+1. Create a post and build your blog with `jekyll build`
+2. Make your new post visible online (so the link card will render properly)
+3. Post it to Mastodon with `jekyll mastodon post`
+4. Build your blog again with `jekyll build`. This build will have the proper link.
+5. Make the new build visible.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/reiterate-app/mastodon-social.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/lib/jekyll/commands/mastodon-social.rb

@@ -0,0 +1,132 @@
+require 'mastodon'
+require 'io/console'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'debug'
+
+module Jekyll
+  module MastodonSocial
+    class MastodonSetup < Jekyll::Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:mastodon) do |c|
+            c.syntax('mastodon')
+            c.description("Connect your blog with the Fediverse")
+            c.action do |args, opts|
+              if args.empty?
+                do_help
+              else
+                case args[0]
+                when /setup/
+                  create_client_id opts
+                when /mark/
+                  mark opts
+                when /post/
+                  post opts
+                when /clean/
+                  clean
+                when /help/
+                  do_help
+                when /auth/
+                  get_token
+                else
+                  puts "Error, try 'mastodon help'"
+                end
+              end
+            end
+          end
+        end
+
+        def create_client_id(options = {})
+          client = get_client()
+          app = client.create_app("jekyll-social", MastodonSocial.site.config["url"], 'read write')
+          MastodonSocial.client_id = app.client_id
+          MastodonSocial.client_secret = app.client_secret
+          MastodonSocial.save_config()
+        end
+
+        def get_token
+          puts "Enter your Mastodon credentials for the account you want to post to"
+          print "Account email: "
+          email = STDIN.cooked(&:gets).chomp
+          print "Account password: "
+          password = STDIN.noecho(&:gets).chomp
+
+          client = get_client()
+          auth_uri = URI.parse("#{MastodonSocial.config['server']}/oauth/token")
+          Net::HTTP.start(auth_uri.host, auth_uri.port, :use_ssl => auth_uri.scheme == 'https') do |http|
+            request = Net::HTTP::Post.new(auth_uri, 'Content-Type' => 'application/json')
+            request.body = {
+              'client_id': MastodonSocial.client_id,
+              'client_secret': MastodonSocial.client_secret,
+              'grant_type': 'password',
+              'username': email,
+              'password': password,
+              'scope': 'read write'
+            }.to_json
+            response = http.request request
+            json_response = JSON.parse(response.body)
+            MastodonSocial.bearer_token = json_response['access_token']
+          end
+          MastodonSocial.save_config()
+        end
+
+        def mark(options = {})
+          client = get_client()
+          # Scan through all posts and see which ones need to be posted to Mastodon
+          for post_url in MastodonSocial.mastodon_status.keys
+            MastodonSocial.mark_as_published(post_url, true)
+          end
+          MastodonSocial.save_config()
+        end
+
+        def clean
+          client = get_client()
+          MastodonSocial.clear_status()
+          MastodonSocial.save_config()          
+        end
+
+        def get_client(options = {})
+          options = configuration_from_options(options)
+          site = Jekyll::Site.new(options)
+          MastodonSocial.setup(site)
+          return Mastodon::REST::Client.new(base_url: MastodonSocial.config["server"], bearer_token: MastodonSocial.bearer_token)
+        end
+
+        # Look for any blog posts that haven't been sent to Mastodon, and post a status for each
+        def post(options = {})
+          client = get_client()
+          for post_url, status in MastodonSocial.mastodon_status
+            next if status[:mastodon_status]
+            puts "Publishing #{post_url} to Mastodon"
+            msg_text = <<~ENDMSG
+            #{status[:excerpt].gsub("\n", '')}
+
+            #{MastodonSocial.site.config["url"]}#{post_url}
+            ENDMSG
+            msg_text += ("\n#" + status[:hashtags].join(' #')) if status[:hashtags]
+            status_result = client.create_status(msg_text)
+            new_status = {id: status_result.id, url: status_result.url}
+            MastodonSocial.mark_as_published(post_url, new_status)
+          end
+          MastodonSocial.save_config()
+        end
+        
+        def do_help
+          puts <<-END_HELP
+jekyll mastodon [command]
+
+Commands:
+  setup:     Initial setup authorizing this plugin to post to your account
+  authorize: Enter your password to authorize this plugin to post to your Mastodon account
+  mark:      Mark all posts as published (to Mastodon)
+  post:      Publish any new posts to Mastodon
+  clean:     Erase all cached mastodon data
+          END_HELP
+        end
+      end
+    end
+  end
+end
+

data/lib/jekyll/generators/gather_posse.rb

@@ -0,0 +1,16 @@
+require "debug"
+
+module Jekyll
+  module MastodonSocial
+    class GatherPosse < Generator
+      def generate(site)
+        MastodonSocial.setup(site)
+        for post in site.posts.docs
+          # If we've never processed this post, add it to the db as unpublished
+          MastodonSocial.mark_as_published(post, nil) unless MastodonSocial.mastodon_status[post.url]
+        end
+        MastodonSocial.save_config()
+      end
+    end
+  end
+end

data/lib/jekyll/tags/mastodon-link.rb

@@ -0,0 +1,14 @@
+require 'mastodon-social'
+
+module Jekyll
+  class MastodonLinkTagBlock < Liquid::Block
+
+    def render(context)
+      text = super
+      url = MastodonSocial.syndication_info(context["page"]["url"])
+      "<a href='#{url}'>#{text}</a>"
+    end
+  end
+end
+
+Liquid::Template.register_tag('mastodon_social', Jekyll::MastodonLinkTagBlock)

data/lib/mastodon-social.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "jekyll"
+require_relative "version"
+require 'nokogiri'
+
+module Jekyll
+  module MastodonSocial
+    class Error < StandardError; end
+
+    class << self
+
+      attr_accessor :client_id, :client_secret, :bearer_token
+      attr_reader :config, :site, :mastodon_status
+
+      # Load state from cache dir. Setup cache dir if it doesn't exist
+      def setup(site)
+        @site = site
+        @jekyll_config = site.config
+        @config = @jekyll_config["mastodon-syndication"] || {}
+
+        # Set up the cache folder & files
+        setup_config
+        cache_data = YAML.load_file(@mastodon_cachefile)
+        @mastodon_status = cache_data[:posts]
+        @bearer_token = cache_data[:bearer_token]
+        @client_id = cache_data[:client_id]
+        @client_secret = cache_data[:client_secret]
+
+        @mastodon_client = Mastodon::REST::Client.new(base_url: @config["server"],
+          bearer_token: @bearer_token)
+      end
+
+      def setup_config
+        @cache_folder = @site.in_source_dir(@config["cache-folder"] || ".jekyll-cache")
+        unless File.exist?(@cache_folder)
+          Dir.mkdir(@cache_folder)
+        end
+        file = Jekyll.sanitized_path(@cache_folder, "mastodon.yml")
+        File.open(file, "wb") { |f| f.puts YAML.dump(Hash.new) } unless File.exist? file
+        @mastodon_cachefile = file
+      end
+
+      def save_config
+        state = {
+          posts: @mastodon_status || {},
+          bearer_token: @bearer_token,
+          client_id: @client_id,
+          client_secret: @client_secret
+        }
+        File.open(@mastodon_cachefile, "wb") { |f|
+          f.puts YAML.dump(state)
+        }
+      end
+
+      # mastodon_status is one of:
+      # nil: this post has not been sent to mastodon
+      # true: This post has been sent as a status, but we have no url
+      # url: The Mastodon URL for the status linking this post
+      def mark_as_published(post, mastodon_status)
+        if post.kind_of? String
+          post_url = post
+          excerpt = ''
+          hashtags = nil
+        else
+          # Don't do anything with posts that are in _drafts
+          return if post.path.include? '_drafts'
+
+          post_url = post.url
+          excerpt_html = post.data['excerpt'].to_s
+          excerpt = Nokogiri::HTML(excerpt_html).text.strip
+          hashtags = post.data['hashtags']
+          hashtags = hashtags.split if hashtags.is_a? String
+        end
+        status = @mastodon_status[post_url]
+        if status.nil?
+          @mastodon_status[post_url] = { 
+            mastodon_status: mastodon_status,
+            excerpt: excerpt,
+            hashtags: hashtags
+          }
+        else
+          status[:mastodon_status] = mastodon_status
+          @mastodon_status[post_url] = status
+        end
+      end
+
+      def clear_status
+        @mastodon_status = {}
+      end
+
+      def syndication_info(url)
+        status = @mastodon_status[url]
+        return nil unless (status.kind_of? Hash and status[:mastodon_status].kind_of? Hash)
+        status[:mastodon_status]
+      end
+    end
+
+  end
+end
+
+def require_all(group)
+  Dir[File.expand_path("#{group}/*.rb", __dir__)].each do |file|
+    require file
+  end
+end
+
+require_all "jekyll/commands"
+require_all "jekyll/generators"
+require_all "jekyll/tags"
+
+Jekyll::Hooks.register :site, :after_init do |site|
+  Jekyll::MastodonSocial.setup(site)
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module MastodonSocial
+  VERSION = "0.1.0"
+end

data/sig/mastodon-social.rbs

@@ -0,0 +1,6 @@
+module Mastodon
+  module Social
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: mastodon-social
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Meckler
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mastodon-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Add mastodon social links
+email:
+- rattroupe@reiterate-app.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/jekyll/commands/mastodon-social.rb
+- lib/jekyll/generators/gather_posse.rb
+- lib/jekyll/tags/mastodon-link.rb
+- lib/mastodon-social.rb
+- lib/version.rb
+- sig/mastodon-social.rbs
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Create links for a Jekyll blog that allow reposting on Mastodon
+test_files: []