jekyll-devto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5de7210b54c1eeda3f3930fd529ab2acb06d08578b098be5b0bcc9389f2decbb
+  data.tar.gz: af15eb800bd515a2554b93c431a054edabc161883108301e6f542d10eefa0d43
+SHA512:
+  metadata.gz: 6bf236df31a78ac816447e7fc62f5424cf369e4e1f94287b618e18b16ca15e18e6f629b11b62313e046f8e808ffe4d45bf792ae61979c5c64e96345229ce27d0
+  data.tar.gz: e30ab831596ed0880e33bac1eeec3874adf4da9fe2670a67cbc48dc215366fc34955f315f6d92d48ec7175424106d7d4450a41a81591b59efbad465ec74b03a5

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 (2026-10-01)
+
+
+### Features
+
+* add jekyll-devto to cross-post a Jekyll blog to dev.to ([b9b0356](https://github.com/JuanVqz/jekyll-devto/commit/b9b0356ddf7bb767670140195dc3e0991fd4ba84))

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juan Vásquez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# jekyll-devto
+
+Cross-post a Jekyll blog to [dev.to](https://dev.to), complete, through dev.to's own RSS import.
+
+dev.to can import posts from your feed, but with a typical Jekyll feed you get:
+
+- **Cut-off posts.** Feeds that carry a summary, or an empty `<content src="...">` link (the
+  [Chirpy](https://github.com/cotes2020/jekyll-theme-chirpy) theme's feed does this), import as the
+  summary only.
+- **Line numbers inside the code.** Rouge with `line_numbers: true`, or a `{% highlight ruby linenos %}` tag, renders the code as a table with a gutter, and dev.to's HTML to Markdown conversion keeps the numbers as code.
+- **Broken links and images.** Root-relative URLs point nowhere once the post lives on dev.to.
+- **Drafts you publish by hand.** dev.to always imports as drafts.
+
+This gem fixes all four:
+
+1. A generator that adds `/devto.xml`, an RSS feed with the full rendered post, plain code blocks and absolute URLs.
+2. A `jekyll-devto publish` command that publishes the imported drafts once their post is live on your site.
+
+It works from the HTML Jekyll already rendered, so anything your theme and Kramdown support comes through. It never edits your posts.
+
+## Install
+
+```ruby
+# Gemfile
+gem 'jekyll-devto'
+```
+
+```yaml
+# _config.yml
+url: "https://example.com" # required: links in the feed are absolute
+plugins:
+  - jekyll-devto
+```
+
+Build, and the feed is at `https://example.com/devto.xml`.
+
+On dev.to, go to **Settings → Extensions → Publishing to DEV Community from RSS**, set the feed URL
+to your `devto.xml`, and turn on **Mark the RSS source as canonical URL by default** so search
+engines treat your site as the original.
+
+## Configuration
+
+All optional.
+
+```yaml
+devto:
+  path: "/devto.xml" # where the feed is written
+  limit: 20          # newest posts to include (default: all)
+```
+
+To keep a post off dev.to, set `devto: false` in its front matter.
+
+## Publishing the drafts
+
+```sh
+export DEVTO_API_KEY=... # https://dev.to/settings/extensions, "DEV Community API Keys"
+
+bundle exec jekyll-devto publish             # dry run: prints what it would publish
+bundle exec jekyll-devto publish --publish   # publishes
+bundle exec jekyll-devto publish --days 14 --feed https://example.com/devto.xml
+```
+
+It reads your **live** feed (`url` + `devto.path` from `_config.yml`, or `--feed`), keeps the posts
+published in the last `--days` days (7 by default, never future-dated ones), finds the draft dev.to
+imported from each one, and publishes it.
+
+- Drafts are matched by `canonical_url` first, then by title.
+- Older drafts are left alone on purpose. The feed carries your whole archive, and publishing every
+  match would push years of old posts to dev.to at once.
+- A post dev.to rejects is reported and the run moves on. Afterwards the drafts are listed again, and
+  any post still among them fails the run. The command exits 1 if anything failed.
+
+### On a schedule with GitHub Actions
+
+[`examples/devto-publish.yml`](examples/devto-publish.yml) runs it after each deploy and once a day.
+Add the key as a repository secret:
+
+```sh
+gh secret set DEVTO_API_KEY
+```
+
+## dev.to behaviour worth knowing
+
+Checked against [Forem's source](https://github.com/forem/forem), the software dev.to runs:
+
+- **Drafts match on title or link.** dev.to skips a feed entry when you already have an article with
+  the same title or link (`Feeds::CheckItemPreviouslyImported`). A deleted draft is imported again on
+  the next fetch while its post is still in the feed.
+- **The imported body says `published: false` in its own front matter**, and that wins over the
+  API's `published` field (`Article#evaluate_front_matter`). The publish command flips it inside the
+  body. A plain `published: true` request leaves the post a draft.
+- **Code blocks arrive without a language.** dev.to removes every `class` attribute before
+  converting (`Feeds::CleanHtml`), so syntax highlighting is lost on import whatever the feed says.
+- **Only the first four tags are kept**, stripped to letters and digits.
+- **"Replace self-referential links with DEV-specific links"** rewrites links between your posts to
+  their dev.to articles at import time, drafts included. Publish the linked post first, or leave
+  that option off.
+- **The one-time "Import from XML" box** takes at most 25 entries and 500 KB
+  (`Feeds::ImportFromXml`). Use `devto.limit` if you need it.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake test
+```
+
+The feed tests build a fixture site and replay dev.to's import (Feedjira, Forem's class stripping,
+ReverseMarkdown) to check what dev.to would store.
+
+## Releases
+
+`jekyll-devto` follows [Semantic Versioning](https://semver.org), and releases are automated with [release-please](https://github.com/googleapis/release-please) from [Conventional Commits](https://www.conventionalcommits.org):
+
+- `fix:` bumps the **PATCH** version, and so do `perf:`, `refactor:` and `docs:`
+- `feat:` bumps the **MINOR** version
+- `BREAKING CHANGE:` in the commit footer bumps the **MAJOR** version (the MINOR one while the version is `0.x`)
+- `test:`, `ci:` and `chore:` are left out of the CHANGELOG and do not trigger a release on their own
+
+### Steps to release a new version
+
+1. Merge pull requests to `main` with Conventional Commit titles (`fix(html): ...`, `feat(publisher): ...`)
+2. release-please keeps a `chore(main): release x.y.z` pull request open with the version bump in `lib/jekyll/devto/version.rb` and the new `CHANGELOG.md` entries
+3. Review and merge that pull request
+4. The `Release` workflow tags `vx.y.z`, creates the GitHub release, runs the tests, and pushes the gem to RubyGems with [trusted publishing](https://guides.rubygems.org/trusted-publishing/), so no API key or MFA code is needed
+
+## License
+
+MIT

data/examples/devto-publish.yml

@@ -0,0 +1,50 @@
+# Copy to .github/workflows/devto-publish.yml and set the DEVTO_API_KEY
+# repository secret (https://dev.to/settings/extensions).
+name: "Publish to dev.to"
+on:
+  # Right after a deploy, so a post goes out on dev.to the day it goes live.
+  # Use the `name:` of your deploy workflow.
+  workflow_run:
+    workflows: ["Build and Deploy"]
+    types: [completed]
+    branches: [main]
+
+  # dev.to imports the feed on its own schedule, so the draft may not exist
+  # yet when the deploy finishes. Retry once a day; posts already published
+  # are skipped, so repeated runs change nothing.
+  schedule:
+    - cron: "0 21 * * *"
+
+  workflow_dispatch:
+    inputs:
+      days:
+        description: "Publish drafts of posts published in the last N days"
+        default: "7"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: "devto-publish"
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    if: github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    env:
+      DEVTO_API_KEY: ${{ secrets.DEVTO_API_KEY }}
+      # Passed through env, never interpolated into the script: a value typed
+      # into the manual trigger would otherwise run as shell code.
+      DAYS: ${{ inputs.days || '7' }}
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: Publish dev.to drafts
+        if: env.DEVTO_API_KEY != ''
+        run: bundle exec jekyll-devto publish --publish --days "$DAYS"

data/exe/jekyll-devto

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Publishes the dev.to drafts of posts that are live on the site.
+#
+#   jekyll-devto publish                 # dry run, prints the plan
+#   jekyll-devto publish --publish       # publishes
+#   jekyll-devto publish --days 14 --feed https://example.com/devto.xml
+#
+# The API key comes from the DEVTO_API_KEY environment variable
+# (https://dev.to/settings/extensions).
+
+require 'optparse'
+require 'yaml'
+require_relative '../lib/jekyll/devto/version'
+require_relative '../lib/jekyll/devto/client'
+require_relative '../lib/jekyll/devto/publisher'
+
+def default_feed
+  config = File.exist?('_config.yml') ? YAML.safe_load_file('_config.yml', aliases: true) || {} : {}
+  url = config['url'].to_s
+  return nil if url.empty?
+
+  path = config.dig('devto', 'path') if config['devto'].is_a?(Hash)
+  "#{url.chomp('/')}#{config['baseurl']}/#{(path || 'devto.xml').sub(%r{\A/}, '')}"
+end
+
+options = { days: 7, publish: false, feed: nil }
+parser = OptionParser.new do |o|
+  o.banner = 'Usage: jekyll-devto publish [options]'
+  o.on('--publish', 'Publish the drafts (default: dry run)') { options[:publish] = true }
+  o.on('--days N', Integer, 'Only posts published in the last N days (default: 7)') { |n| options[:days] = n }
+  o.on('--feed URL_OR_PATH', 'The dev.to feed (default: url + devto.xml from _config.yml)') { |f| options[:feed] = f }
+  o.on('-v', '--version', 'Print the version') { puts Jekyll::Devto::VERSION; exit }
+end
+begin
+  parser.parse!
+rescue OptionParser::ParseError => e
+  abort "#{e.message}\n#{parser}"
+end
+command = ARGV.shift
+
+abort parser.banner unless command == 'publish'
+
+feed = options[:feed] || default_feed
+abort 'No feed: pass --feed, or run from a site whose _config.yml sets url.' unless feed
+
+begin
+  failures = Jekyll::Devto::Publisher.new(
+    feed: feed,
+    client: Jekyll::Devto::Client.new(ENV.fetch('DEVTO_API_KEY', nil)),
+    days: options[:days],
+    publish: options[:publish]
+  ).run
+rescue Jekyll::Devto::Client::Error => e
+  abort e.message
+end
+
+exit(failures.zero? ? 0 : 1)

data/lib/jekyll/devto/client.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'openssl'
+require_relative 'version'
+
+module Jekyll
+  module Devto
+    # Minimal dev.to (Forem) API client: the two calls the publisher needs.
+    class Client
+      API = URI('https://dev.to/api/')
+      PER_PAGE = 1000
+
+      Error = Class.new(StandardError)
+
+      # What a request can raise before there is a response to look at. Each
+      # is turned into Error, so the CLI reports it instead of crashing.
+      NETWORK_ERRORS = [SystemCallError, SocketError, IOError, Timeout::Error,
+                        OpenSSL::SSL::SSLError, Net::HTTPBadResponse, Net::ProtocolError].freeze
+
+      def initialize(api_key)
+        raise Error, 'DEVTO_API_KEY is not set' if api_key.to_s.empty?
+
+        @api_key = api_key
+      end
+
+      def drafts
+        (1..).each_with_object([]) do |page, all|
+          batch = request(Net::HTTP::Get, "articles/me/unpublished?per_page=#{PER_PAGE}&page=#{page}")
+          all.concat(batch)
+          break all if batch.size < PER_PAGE
+        end
+      end
+
+      def update(id, article)
+        request(Net::HTTP::Put, "articles/#{id}", { article: article })
+      end
+
+      private
+
+      def request(verb, path, body = nil)
+        uri = API + path
+        req = verb.new(uri)
+        req['api-key'] = @api_key
+        req['Accept'] = 'application/vnd.forem.api-v1+json'
+        req['Content-Type'] = 'application/json'
+        req['User-Agent'] = "jekyll-devto/#{VERSION}"
+        req.body = JSON.generate(body) if body
+
+        res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
+        raise Error, "#{req.method} #{uri.path} failed: #{res.code} #{res.body}" unless res.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(res.body)
+      rescue *NETWORK_ERRORS, JSON::ParserError => e
+        raise Error, "#{verb::METHOD} #{uri.path} failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/jekyll/devto/feed.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+{%- assign devto = site.devto | default: empty -%}
+{%- comment -%} Not site.url + baseurl: links in content already carry baseurl (relative_url adds it). {%- endcomment -%}
+{%- assign site_url = site.url -%}
+{%- assign posts = site.posts | where_exp: "post", "post.devto != false" -%}
+{%- if devto.limit %}{% assign posts = posts | slice: 0, devto.limit %}{% endif %}
+<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>{{ site.title | default: site.name | xml_escape }}</title>
+    <link>{{ "/" | absolute_url }}</link>
+    <description>{{ site.description | xml_escape }}</description>
+    {%- if site.lang %}
+    <language>{{ site.lang }}</language>
+    {%- endif %}
+    <lastBuildDate>{{ site.time | date_to_rfc822 }}</lastBuildDate>
+    <atom:link href="{{ page.url | absolute_url }}" rel="self" type="application/rss+xml" />
+{%- for post in posts %}
+  {%- assign post_url = post.url | absolute_url %}
+    <item>
+      <title>{{ post.title | strip_html | strip | xml_escape }}</title>
+      <link>{{ post_url }}</link>
+      <guid isPermaLink="true">{{ post_url }}</guid>
+      <pubDate>{{ post.date | date_to_rfc822 }}</pubDate>
+    {%- assign tags = post.tags | default: post.categories %}
+    {%- for tag in tags %}
+      <category>{{ tag | xml_escape }}</category>
+    {%- endfor %}
+      <description>{{ post.description | default: post.excerpt | strip_html | strip_newlines | truncatewords: 60 | xml_escape }}</description>
+      <content:encoded>{{ post.content | devto_html: site_url | xml_escape }}</content:encoded>
+    </item>
+{%- endfor %}
+  </channel>
+</rss>

data/lib/jekyll/devto/generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Devto
+    # Adds the dev.to feed to the site as a page, the same way jekyll-feed adds
+    # its own. Posts render before pages, so `post.content` in the template is
+    # the final HTML.
+    class Generator < Jekyll::Generator
+      safe true
+      priority :lowest
+
+      DEFAULT_PATH = 'devto.xml'
+      TEMPLATE = File.expand_path('feed.xml', __dir__)
+
+      def generate(site)
+        path = feed_path(site)
+        if site.pages.any? { |page| page.url == "/#{path}" }
+          Jekyll.logger.warn 'jekyll-devto:', "a page already lives at /#{path}, not generating the feed"
+          return
+        end
+
+        site.pages << feed_page(site, path)
+      end
+
+      private
+
+      def feed_path(site)
+        config = site.config['devto']
+        path = config.is_a?(Hash) ? config['path'] : nil
+        (path || DEFAULT_PATH).sub(%r{\A/}, '')
+      end
+
+      def feed_page(site, path)
+        PageWithoutAFile.new(site, __dir__, File.dirname(path).sub(/\A\.\z/, ''), File.basename(path)).tap do |page|
+          page.content = File.read(TEMPLATE)
+          page.data['layout'] = nil
+          page.data['sitemap'] = false
+          page.data['permalink'] = "/#{path}"
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/devto/html.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Devto
+    # Turns a rendered post body into HTML that survives dev.to's RSS import.
+    #
+    # dev.to strips every class attribute and converts the HTML to Markdown
+    # (Forem's Feeds::CleanHtml, then ReverseMarkdown). Two things break on the
+    # way:
+    #
+    # - Rouge with `line_numbers: true`, or a `{% highlight lang linenos %}` tag,
+    #   renders the code as a table with a gutter, and the gutter numbers end
+    #   up inside the code.
+    # - Root-relative links and images point nowhere once the post lives on
+    #   dev.to.
+    module HTML
+      # Kramdown block options such as {: .nolineno } or {: file="..." } add
+      # classes and attributes to the wrapper, so the class is matched anywhere
+      # in the tag.
+      ROUGE_BLOCK = %r{
+        <div\b[^>]*\bclass="[^"]*\bhighlighter-rouge\b[^"]*"[^>]*>\s*
+        <div\ class="highlight">\s*<pre\ class="highlight"><code>
+        (?<body>.*?)
+        </code></pre>\s*</div>\s*</div>
+      }mx
+
+      # What the {% highlight %} Liquid tag renders.
+      HIGHLIGHT_TAG = %r{
+        <figure\ class="highlight"><pre><code\b[^>]*>
+        (?<body>.*?)
+        </code></pre></figure>
+      }mx
+
+      # Kramdown names the cells rouge-gutter and rouge-code; the highlight tag
+      # names them gutter and code.
+      GUTTER = %r{<table class="rouge-table">.*?<td class="(?:rouge-)?code"><pre>(?<code>.*?)</pre>}m
+
+      # Real tags only. Code samples reach the HTML escaped (&lt;img src="/x"&gt;),
+      # so they never match and are left exactly as written.
+      TAG = /<[a-zA-Z][^>]*>/
+      ROOT_RELATIVE = %r{\b(src|href)="/(?!/)}
+
+      module_function
+
+      def convert(html, base_url)
+        html.to_s
+          .gsub(ROUGE_BLOCK) { plain_code(Regexp.last_match[:body]) }
+          .gsub(HIGHLIGHT_TAG) { plain_code(Regexp.last_match[:body]) }
+          .gsub(TAG) { |tag| tag.gsub(ROOT_RELATIVE, %(\\1="#{base_url.to_s.chomp('/')}/)) }
+      end
+
+      # The language is not kept: dev.to strips every class before converting,
+      # so it would never arrive.
+      def plain_code(body)
+        body = Regexp.last_match[:code] if body =~ GUTTER
+
+        "<pre><code>#{body.gsub(/<[^>]+>/, '')}</code></pre>"
+      end
+    end
+
+    # Liquid filter for the feed template.
+    module Filters
+      def devto_html(html, base_url)
+        HTML.convert(html, base_url)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::Devto::Filters)

data/lib/jekyll/devto/publisher.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'rexml/document'
+require 'time'
+require_relative 'client'
+
+module Jekyll
+  module Devto
+    # Publishes the dev.to drafts of posts that are live on the site.
+    #
+    # dev.to's RSS import always creates drafts. This reads the site's dev.to
+    # feed, keeps the posts published in the last `days` days, finds the draft
+    # imported from each one, and publishes it. Older drafts are left alone on
+    # purpose: the feed carries the whole archive, and publishing every match
+    # would push years of old posts to dev.to at once.
+    class Publisher
+      MAX_REDIRECTS = 5
+
+      Post = Struct.new(:title, :link, :date, keyword_init: true)
+
+      def initialize(feed:, client:, days: 7, publish: false, now: Time.now, out: $stdout, err: $stderr)
+        @feed = feed
+        @client = client
+        @days = days
+        @publish = publish
+        @now = now
+        @out = out
+        @err = err
+      end
+
+      # Returns the number of posts that failed to publish.
+      def run
+        posts = due_posts
+        @out.puts "Posts live in the last #{@days} days: #{posts.size}"
+        return 0 if posts.empty?
+
+        drafts = @client.drafts
+        @out.puts "Drafts on dev.to: #{drafts.size}"
+
+        sent = {}
+        failures = []
+        posts.each do |post|
+          draft = find_draft(drafts, post)
+          next report_missing(post, drafts) unless draft
+
+          unless @publish
+            @out.puts "  would publish #{post.title.inspect} -> dev.to draft #{draft['id']}"
+            next
+          end
+
+          # One rejected post must not stop the rest, or every retry would stop at it.
+          begin
+            result = @client.update(draft['id'], published: true, body_markdown: self.class.published_body(draft['body_markdown']))
+            sent[draft['id']] = post
+            @out.puts "  sent    #{post.title.inspect} -> #{result['url']}"
+          rescue StandardError => e
+            failures << post
+            @err.puts "  FAILED  #{post.title.inspect}: #{e.message}"
+          end
+        end
+
+        failures.concat(still_drafts(sent))
+        @err.puts "#{failures.size} post(s) failed to publish" if failures.any?
+        failures.size
+      end
+
+      # The imported body carries `published: false` in its own front matter,
+      # and dev.to applies that over the request's `published` field, so it is
+      # flipped inside the body as well.
+      def self.published_body(markdown)
+        # Only inside the front matter: up to the first closing ---, so a
+        # "published: false" line in the post body is left alone.
+        markdown.to_s.sub(/\A---\r?\n.*?^---[ \t]*\r?$/m) do |front_matter|
+          front_matter.sub(/^published:[ \t]*false[ \t]*(?=\r?$)/, 'published: true')
+        end
+      end
+
+      def due_posts
+        REXML::Document.new(read_feed).get_elements('//item').filter_map do |item|
+          date = Time.rfc2822(item.elements['pubDate'].text)
+          next if date > @now || date < @now - (@days * 86_400)
+
+          Post.new(title: item.elements['title'].text.to_s.strip, link: item.elements['link'].text.to_s.strip, date: date)
+        end
+      end
+
+      private
+
+      # Follows redirects (http to https, apex to www), which Net::HTTP does not.
+      def read_feed
+        return File.read(@feed) unless @feed.match?(%r{\Ahttps?://})
+
+        uri = URI(@feed)
+        MAX_REDIRECTS.succ.times do
+          res = Net::HTTP.get_response(uri)
+          return res.body if res.is_a?(Net::HTTPSuccess)
+          raise Client::Error, "could not read #{@feed}: #{res.code}" unless res.is_a?(Net::HTTPRedirection)
+
+          uri = URI.join(uri, res['location'])
+        end
+        raise Client::Error, "could not read #{@feed}: more than #{MAX_REDIRECTS} redirects"
+      rescue *Client::NETWORK_ERRORS => e
+        raise Client::Error, "could not read #{@feed}: #{e.message}"
+      end
+
+      # canonical_url first: dev.to sets it to the post's link when the feed
+      # source has "Mark the RSS source as canonical URL" on. Title otherwise.
+      def find_draft(drafts, post)
+        drafts.find { |d| d['canonical_url'].to_s.chomp('/') == post.link.chomp('/') } ||
+          drafts.find { |d| d['title'].to_s.strip == post.title }
+      end
+
+      def report_missing(post, drafts)
+        @out.puts "  skip    #{post.title.inspect}: no dev.to draft (not imported yet, or already published)"
+        near = drafts.map { |d| d['title'].to_s }.find { |t| t.downcase.include?(post.title.downcase[0, 20]) }
+        @out.puts "          closest draft title: #{near.inspect}" if near
+      end
+
+      # The PUT response does not say whether the article is published, so ask
+      # dev.to again: anything still in the drafts list did not go out.
+      def still_drafts(sent)
+        return [] if sent.empty?
+
+        ids = @client.drafts.map { |d| d['id'] } & sent.keys
+        ids.map { |id| sent[id] }.each { |post| @err.puts "  STILL A DRAFT: #{post.title.inspect}" }
+      rescue Client::Error => e
+        # The PUTs already went out, so say which posts could not be confirmed
+        # rather than losing the summary.
+        @err.puts "  could not confirm #{sent.size} post(s) went out: #{e.message}"
+        sent.values
+      end
+    end
+  end
+end

data/lib/jekyll/devto/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Devto
+    VERSION = '0.1.0'
+  end
+end

data/lib/jekyll-devto.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'jekyll'
+require_relative 'jekyll/devto/version'
+require_relative 'jekyll/devto/html'
+require_relative 'jekyll/devto/generator'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-devto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Juan Vásquez
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  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'
+description: |
+  Generates a feed dev.to imports with the full post (code blocks without
+  Rouge line numbers, absolute links and images), and a command that
+  publishes the imported drafts once their post is live on your site.
+email:
+- juan@ombulabs.com
+executables:
+- jekyll-devto
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- examples/devto-publish.yml
+- exe/jekyll-devto
+- lib/jekyll-devto.rb
+- lib/jekyll/devto/client.rb
+- lib/jekyll/devto/feed.xml
+- lib/jekyll/devto/generator.rb
+- lib/jekyll/devto/html.rb
+- lib/jekyll/devto/publisher.rb
+- lib/jekyll/devto/version.rb
+homepage: https://github.com/JuanVqz/jekyll-devto
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/JuanVqz/jekyll-devto
+  changelog_uri: https://github.com/JuanVqz/jekyll-devto/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Cross-post a Jekyll blog to dev.to, complete, through its RSS import.
+test_files: []