markdownr 0.6.17 → 0.7.0

data/lib/markdown_server/helpers/search_helpers.rb

@@ -0,0 +1,157 @@
+module MarkdownServer
+  module Helpers
+    module SearchHelpers
+      BINARY_EXTENSIONS = %w[
+        .png .jpg .jpeg .gif .bmp .ico .svg .webp
+        .pdf .epub .mobi
+        .zip .gz .tar .bz2 .7z .rar
+        .exe .dll .so .dylib .o
+        .mp3 .mp4 .avi .mov .wav .flac .ogg
+        .woff .woff2 .ttf .eot .otf
+        .pyc .class .beam
+        .sqlite .db
+      ].freeze
+
+      MAX_SEARCH_FILES = 100
+      MAX_FILE_READ_BYTES = 512_000  # 500KB
+      CONTEXT_LINES = 2  # lines before/after match to send
+      MAX_LINE_DISPLAY = 200  # chars before truncating a line
+
+      def search_single_file(file_path, regexes)
+        base = File.realpath(root_dir)
+        begin
+          content = File.binread(file_path, MAX_FILE_READ_BYTES)
+        rescue
+          return []
+        end
+        content.force_encoding("utf-8")
+        return [] unless content.valid_encoding?
+        return [] unless regexes.all? { |re| re.match?(content) }
+
+        relative = file_path.sub("#{base}/", "")
+        lines = content.lines
+        matches = collect_matching_lines(lines, regexes)
+        [{ path: relative, matches: matches }]
+      end
+
+      def search_files(dir_path, regexes)
+        results = []
+        base = File.realpath(root_dir)
+
+        catch(:search_limit) do
+          walk_directory(dir_path) do |file_path|
+            throw :search_limit if results.length >= MAX_SEARCH_FILES
+
+            content = File.binread(file_path, MAX_FILE_READ_BYTES) rescue next
+            content.force_encoding("utf-8")
+            next unless content.valid_encoding?
+
+            # All regexes must match somewhere in the file
+            next unless regexes.all? { |re| re.match?(content) }
+
+            relative = file_path.sub("#{base}/", "")
+            lines = content.lines
+            matches = collect_matching_lines(lines, regexes)
+
+            results << { path: relative, matches: matches }
+          end
+        end
+
+        results
+      end
+
+      def walk_directory(dir_path, &block)
+        Dir.entries(dir_path).sort.each do |entry|
+          next if entry.start_with?(".") || EXCLUDED.include?(entry)
+          full = File.join(dir_path, entry)
+
+          if File.directory?(full)
+            walk_directory(full, &block)
+          elsif File.file?(full)
+            ext = File.extname(entry).downcase
+            next if BINARY_EXTENSIONS.include?(ext)
+            block.call(full)
+          end
+        end
+      end
+
+      def collect_matching_lines(lines, regexes)
+        match_indices = Set.new
+        lines.each_with_index do |line, i|
+          if regexes.any? { |re| re.match?(line) }
+            match_indices << i
+          end
+        end
+
+        # Build context groups
+        groups = []
+        sorted = match_indices.sort
+
+        sorted.each do |idx|
+          range_start = [idx - CONTEXT_LINES, 0].max
+          range_end = [idx + CONTEXT_LINES, lines.length - 1].min
+
+          if groups.last && range_start <= groups.last[:end] + 1
+            groups.last[:end] = range_end
+          else
+            groups << { start: range_start, end: range_end }
+          end
+        end
+
+        groups.map do |g|
+          context_lines = (g[:start]..g[:end]).map do |i|
+            distance = match_indices.include?(i) ? 0 : match_indices.map { |m| (m - i).abs }.min
+            { number: i + 1, text: lines[i].to_s.chomp, distance: distance }
+          end
+          { lines: context_lines }
+        end
+      end
+
+      def highlight_search_line(text, regexes, is_match)
+        # Build a combined regex with non-greedy quantifiers for shorter highlights
+        combined = Regexp.union(regexes.map { |r|
+          Regexp.new(r.source.gsub(/(?<!\\)([*+}])(?!\?)/, '\1?'), r.options)
+        })
+
+        # Truncate long lines, centering around the first match
+        prefix_trunc = false
+        suffix_trunc = false
+        if text.length > MAX_LINE_DISPLAY
+          if is_match && (m = combined.match(text))
+            center = m.begin(0) + m[0].length / 2
+            half = MAX_LINE_DISPLAY / 2
+            start = [[center - half, 0].max, [text.length - MAX_LINE_DISPLAY, 0].max].min
+          else
+            start = 0
+          end
+          prefix_trunc = start > 0
+          suffix_trunc = (start + MAX_LINE_DISPLAY) < text.length
+          text = text[start, MAX_LINE_DISPLAY]
+        end
+
+        html = ""
+        html << '<span class="truncated">...</span>' if prefix_trunc
+        if is_match
+          pieces = text.split(combined)
+          matches = text.scan(combined)
+          pieces.each_with_index do |piece, i|
+            html << h(piece)
+            html << %(<span class="highlight-match">#{h(matches[i])}</span>) if matches[i]
+          end
+        else
+          html << h(text)
+        end
+        html << '<span class="truncated">...</span>' if suffix_trunc
+        html
+      end
+
+      def compile_regexes(query)
+        words = query.split(/\s+/).reject(&:empty?)
+        return nil if words.empty?
+        words.map { |w| Regexp.new(w, Regexp::IGNORECASE) }
+      rescue RegexpError => e
+        raise RegexpError, e.message
+      end
+    end
+  end
+end

data/lib/markdown_server/plugin.rb

@@ -26,7 +26,13 @@ module MarkdownServer
     def transform_markdown(text) text end
 
     # Hook: transform raw HTML (runs on .html files before popup injection)
-    def transform_html(html) html end
+    def transform_html(html, app = nil) html end
+
+    # Hook: claim a /fetch URL — return { title:, html: } hash or nil to pass
+    def process_fetch(url, html, app) nil end
+
+    # Hook: post-process rendered markdown HTML (runs after render_markdown)
+    def post_render(html, meta, app) html end
   end
 
   class PluginRegistry
@@ -39,7 +45,13 @@ module MarkdownServer
         registered << klass unless registered.include?(klass)
       end
 
-      def load_plugins(root_dir, cli_overrides = {})
+      def load_plugins(root_dir, cli_overrides = {}, plugin_dirs: [])
+        # Discover and require plugins from external directories
+        plugin_dirs.each do |dir|
+          expanded = File.expand_path(dir)
+          Dir[File.join(expanded, "*", "plugin.rb")].sort.each { |f| require f }
+        end
+
         config = resolve_config(root_dir, cli_overrides)
         registered.filter_map do |klass|
           plugin_config = config.fetch(klass.plugin_name, {})

data/lib/markdown_server/plugins/bible_citations/helpers.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+module MarkdownServer
+  module Plugins
+    class BibleCitations
+      module Helpers
+        # Server-side Strong's dictionary cache
+        @@strongs_cache = nil
+        @@strongs_cache_url = nil
+        @@strongs_fetched_at = nil
+        DICTIONARY_TTL = 3600 # 1 hour
+
+        # ── Strong's Dictionary ───────────────────────────────────────────────
+
+        def strongs_map
+          url = settings.dictionary_url
+          return {} unless url
+
+          now = Time.now
+          if @@strongs_cache && @@strongs_cache_url == url && @@strongs_fetched_at
+            if url.match?(/\Ahttps?:\/\//i)
+              return @@strongs_cache if (now - @@strongs_fetched_at) < DICTIONARY_TTL
+            else
+              path = File.expand_path(url, root_dir)
+              mtime = File.mtime(path) rescue nil
+              return @@strongs_cache if mtime && mtime <= @@strongs_fetched_at
+            end
+          end
+
+          begin
+            raw = if url.match?(/\Ahttps?:\/\//i)
+              uri = URI.parse(url)
+              http = Net::HTTP.new(uri.host, uri.port)
+              http.use_ssl = (uri.scheme == "https")
+              http.open_timeout = FetchHelpers::FETCH_TIMEOUT
+              http.read_timeout = 10
+              req = Net::HTTP::Get.new(uri.request_uri)
+              req["Accept"] = "application/json"
+              resp = http.request(req)
+              return @@strongs_cache || {} unless resp.is_a?(Net::HTTPSuccess)
+              resp.body
+            else
+              path = File.expand_path(url, root_dir)
+              return @@strongs_cache || {} unless File.exist?(path)
+              File.read(path, encoding: "utf-8")
+            end
+
+            data = JSON.parse(raw)
+            url_tpl = data["url"] || ""
+            map = {}
+            %w[greek hebrew].each do |lang|
+              stems = data.dig("stems", lang)
+              next unless stems.is_a?(Hash)
+              stems.each_value do |entry|
+                sn = entry["strongs"].to_s.strip.upcase
+                next if sn.empty?
+                map[sn] = url_tpl.gsub("{filename}", entry["filename"].to_s)
+              end
+            end
+            @@strongs_cache = map
+            @@strongs_cache_url = url
+            @@strongs_fetched_at = now
+            map
+          rescue StandardError
+            @@strongs_cache || {}
+          end
+        end
+
+        def strongs_popup_url(strongs)
+          sn = strongs.to_s.strip.upcase
+          return nil unless sn.match?(/\A[GH]\d+\z/)
+          url = strongs_map[sn]
+          return url if url
+          prefix = sn.start_with?("H") ? "wlc" : "tr"
+          "https://www.blueletterbible.org/lexicon/#{sn.downcase}/nasb20/#{prefix}/0-1/"
+        end
+
+        def inject_strongs_urls(html)
+          return html unless settings.dictionary_url
+          html = html.gsub(/<span\s+class="subst"([^>]*data-strongs="([^"]+)"[^>]*)>/) do
+            attrs, strongs = $1, $2
+            popup_url = strongs_popup_url(strongs)
+            if popup_url && !attrs.include?("data-popup-url")
+              %(<span class="subst" data-popup-url="#{h(popup_url)}"#{attrs}>)
+            else
+              $&
+            end
+          end
+          html.gsub(/<span\s+class="word"([^>]*data-strongs="([^"]+)"[^>]*)>/) do
+            attrs, strongs = $1, $2
+            dict_url = strongs_map[strongs.strip.upcase]
+            if dict_url && !attrs.include?("data-popup-url")
+              %(<span class="word" data-popup-url="#{h(dict_url)}"#{attrs}>)
+            else
+              $&
+            end
+          end
+        end
+
+        # ── Blue Letter Bible ─────────────────────────────────────────────────
+
+        BLB_BASE = "https://www.blueletterbible.org"
+
+        def blueletterbible_html(html, url)
+          info_html = extract_blb_info(html, url)
+          infl_html = extract_blb_inflections(html, info_html[:word])
+          usage_html = extract_blb_usage(html)
+          conc_html = extract_blb_concordance(html)
+
+          info_html[:table] + infl_html + usage_html + conc_html
+        end
+
+        # ── Scripture Pages ───────────────────────────────────────────────────
+
+        def scrip_html(html, source_url = nil)
+          content = html[/<div\s+class="passage-text[^"]*"[^>]*>([\s\S]*)<\/div>\s*(?:<nav|<script|<style|\z)/im, 1] || ""
+          return page_html(html, source_url) if content.empty?
+
+          content = content.gsub(/<sup class="verse-number">(\d+)[^<]*<\/sup>/) do
+            %(<sup class="verse-number" data-verse="#{$1}">#{$1} </sup>)
+          end
+
+          css_blocks = inline_external_css(html, source_url)
+          content = inject_strongs_urls(content)
+          css_blocks + '<div style="font-family:Georgia,serif;line-height:1.7">' + content + "</div>"
+        end
+
+        def markdownr_html(html)
+          content = html[/<div[^>]+class="md-content"[^>]*>([\s\S]*?)<\/div>\s*(?:<div\s+class="frontmatter"|<\/div>\s*<\/div>|\z)/im, 1]
+          return page_html(html) unless content && content.length > 10
+
+          fm = html[/<div\s+class="frontmatter">([\s\S]*?)<\/div>\s*<\/div>/im, 0] || ""
+          result = content.strip
+          result += "\n#{fm}" unless fm.empty?
+          result.length > 15_000 ? result[0, 15_000] : result
+        end
+
+        # ── Pronunciation Icons ───────────────────────────────────────────────
+
+        def inject_pronunciation_icon(html, meta)
+          return html unless meta.is_a?(Hash) && meta["strongs"] && meta["language"]
+          strongs = meta["strongs"].to_s.strip
+          lang = meta["language"].to_s.strip.downcase
+          return html unless strongs.match?(/\A[GH]\d+\z/i) && %w[hebrew greek].include?(lang)
+
+          sn = strongs.upcase
+          blb_audio_url = "/pronunciation?strongs=#{sn}"
+          blb_btn = audio_button(blb_audio_url, "Blue Letter Bible", lazy_fetch: true, data_strongs: sn)
+
+          sl_lang = lang == "hebrew" ? "hebrew" : "greek"
+          sl_num = sn.sub(/\A[HG]/, "")
+          sl_url = "https://www.studylight.org/multi-media/audio/lexicons/eng/#{sl_lang}.html?n=#{sl_num}"
+          sl_btn = audio_button(sl_url, "StudyLight")
+
+          html.sub(%r{</h2>}) { " #{blb_btn}#{sl_btn}</h2>" }
+        end
+
+        private
+
+        # ── Shared Helpers ────────────────────────────────────────────────────
+
+        def audio_button(url, source, lazy_fetch: false, data_strongs: nil)
+          data_attr = data_strongs ? %( data-strongs="#{h(data_strongs)}") : ""
+          style = "background:none;border:none;cursor:pointer;padding:0 0 0 4px;font-size:1.1em;vertical-align:middle;line-height:1;color:#888;"
+          if lazy_fetch
+            onclick = "(function(btn){if(btn._loading)return;var a=btn._audio;if(a){a.currentTime=0;a.play();return;}" \
+              "btn._loading=true;btn.style.opacity='0.4';" \
+              "fetch('#{h(url)}').then(function(r){return r.json()}).then(function(d){" \
+              "if(d.audio){a=new Audio(d.audio);btn._audio=a;a.play();}btn._loading=false;btn.style.opacity='1';}).catch(function(){" \
+              "btn._loading=false;btn.style.opacity='1';});})(this)"
+          else
+            onclick = "var a=this._a||(this._a=new Audio('#{h(url)}'));a.currentTime=0;a.play();"
+          end
+          %(<button class="pronunciation-btn"#{data_attr} title="Play pronunciation (#{h(source)})" style="#{style}" onclick="#{onclick}">&#128266;</button>)
+        end
+
+        def inline_external_css(html, source_url)
+          return "" unless source_url
+          css_blocks = ""
+          base_uri = URI.parse(source_url) rescue nil
+          return "" unless base_uri
+
+          html.scan(/<link[^>]+rel=["']stylesheet["'][^>]*>/i).each do |tag|
+            href = tag[/href=["']([^"']+)["']/i, 1]
+            next unless href
+            abs = (URI.join(base_uri, href).to_s rescue nil)
+            next unless abs
+            css_body = fetch_css(abs)
+            if css_body
+              css_dir = abs.sub(%r{/[^/]*\z}, "/")
+              css_body = css_body.gsub(/@import\s+url\(["']?([^"')]+)["']?\)\s*;/) do
+                import_url = (URI.join(css_dir, $1).to_s rescue nil)
+                import_url ? (fetch_css(import_url) || "") : ""
+              end
+              css_blocks += "<style>#{css_body}</style>\n"
+            end
+          end
+          css_blocks
+        end
+
+        # ── Blue Letter Bible Section Extractors ──────────────────────────────
+
+        def extract_blb_info(html, url)
+          word = html[/<h6[^>]+class="lexTitle(?:Gk|Hb)"[^>]*>(.*?)<\/h6>/im, 1]
+                   &.gsub(/<[^>]+>/, "")&.strip || ""
+          transliteration = html[/<div[^>]+id="lexTrans".*?<em>(.*?)<\/em>/im, 1]&.strip || ""
+          pronunciation = html[/class="[^"]*lexicon-pronunc[^"]*"[^>]*>\s*([^\n<]{1,50})/i, 1]&.strip || ""
+          pos = html[/<div[^>]+id="lexPart".*?small-text-right"[^>]*>(.*?)<\/div>/im, 1]
+                 &.gsub(/<[^>]+>/, "")&.strip || ""
+
+          audio_buttons = build_blb_audio_buttons(html, url)
+
+          rows = [
+            ["Word",            h(word)],
+            ["Transliteration", "<em>#{h(transliteration)}</em>"],
+            ["Pronunciation",   "#{h(pronunciation)}#{audio_buttons}"],
+            ["Part of Speech",  h(pos)],
+          ]
+          table = %(<table class="blb-table">) +
+            rows.map { |label, v|
+              %(<tr><th class="blb-th">#{h(label)}</th><td>#{v}</td></tr>)
+            }.join + "</table>"
+
+          { table: table, word: word }
+        end
+
+        def build_blb_audio_buttons(html, url)
+          buttons = ""
+          data_pronunc = html[/data-pronunc="([a-fA-F0-9]{20,})"/i, 1] || ""
+          if data_pronunc.length > 10
+            au = "#{BLB_BASE}/lang/lexicon/lexPronouncePlayer.cfm?skin=#{data_pronunc}"
+            buttons += audio_button(au, "Blue Letter Bible")
+          end
+
+          sl_match = url.to_s.match(%r{/lexicon/([hg])(\d+)/}i)
+          if sl_match
+            sl_lang = sl_match[1].downcase == "h" ? "hebrew" : "greek"
+            sl_url = "https://www.studylight.org/multi-media/audio/lexicons/eng/#{sl_lang}.html?n=#{sl_match[2]}"
+            buttons += audio_button(sl_url, "StudyLight")
+          end
+          buttons
+        end
+
+        def extract_blb_inflections(html, word)
+          m = html.match(/<div\s[^>]*id="greek-tr-inflections"[^>]*>/im)
+          return "" unless m
+
+          after_infl = html[m.end(0)..]
+          stop = after_infl.index(/<div\s[^>]*id="greek-(?:mgnt|lxx)-inflections"/i) || after_infl.length
+          infl_section = after_infl[0...stop]
+
+          inflections = []
+          infl_section.scan(/<div\s[^>]*class="greekInflection"[^>]*>(.*?)<\/div>\s*<\/div>/im) do |mv|
+            chunk = mv[0]
+            href = chunk[/href="([^"]+)"/i, 1]
+            gk = chunk[/<span[^>]+class="Gk"[^>]*>(.*?)<\/span>/im, 1]&.gsub(/<[^>]+>/, "")&.strip || ""
+            freq = chunk[/&#8212;\s*(\d+)x<\/a>/i, 1]&.to_i || 0
+            next if gk.empty? || freq.zero?
+            inflections << { word: gk, freq: freq,
+                             href: href ? BLB_BASE + href.gsub("&amp;", "&") : nil }
+          end
+          return "" if inflections.empty?
+
+          inflections.sort_by! { |i| -i[:freq] }
+          rows = inflections.map { |i|
+            match = i[:word] == word
+            cls = match ? ' class="blb-match"' : ""
+            link = i[:href] ? %(<a href="#{h(i[:href])}" target="_blank" rel="noopener">#{h(i[:word])}</a>) : h(i[:word])
+            %(<tr><td#{cls}>#{link}</td><td class="blb-right">#{i[:freq]}x</td></tr>)
+          }.join
+
+          %(<h4 class="blb-heading">Inflections</h4>) +
+            %(<table class="blb-table"><thead><tr><th class="blb-th">Form</th>) +
+            %(<th class="blb-th blb-right">Count</th></tr></thead><tbody>#{rows}</tbody></table>)
+        end
+
+        def extract_blb_usage(html)
+          um = html.match(/<div[^>]+id="outlineBiblical"[^>]*>/im)
+          return "" unless um
+
+          after_usage = html[um.end(0)..]
+          inner = after_usage.match(/\A\s*<div>([\s\S]*?)<\/div>\s*<\/div>/im)
+          return "" unless inner
+
+          cleaned = inner[1]
+            .gsub(/<(\/?)(\w+)[^>]*>/) { "<#{$1}#{$2.downcase}>" }
+            .gsub(/[ \t]+/, " ")
+            .strip
+          %(<h4 class="blb-heading">Biblical Usage</h4><div class="blb-usage">#{cleaned}</div>)
+        end
+
+        def extract_blb_concordance(html)
+          trans_name = html[/id="bibleTable"[^>]+data-translation="([^"]+)"/i, 1] || ""
+          chunks = html.split(/<div\s[^>]*id="bVerse_\d+"[^>]*>/).drop(1)
+          return "" if chunks.empty?
+
+          verses = chunks.filter_map { |chunk| extract_blb_verse(chunk) }
+          return "" if verses.empty?
+
+          heading = trans_name.empty? ? "Concordance" : "Concordance (#{h(trans_name)})"
+          rows = verses.map { |v|
+            link = v[:href] ? %(<a href="#{h(v[:href])}" target="_blank" rel="noopener">#{h(v[:cite])}</a>) : h(v[:cite])
+            %(<tr><td class="blb-nowrap">#{link}</td><td>#{v[:verse_html]}</td></tr>)
+          }.join
+          %(<h4 class="blb-heading">#{heading}</h4>) +
+            %(<table class="blb-table"><tbody>#{rows}</tbody></table>)
+        end
+
+        def extract_blb_verse(chunk)
+          cite_href = chunk[/tablet-order-2[^>]*>[\s\S]{0,400}?href="([^"]+)"/im, 1] || ""
+          cite = chunk[/tablet-order-2[^>]*>[\s\S]{0,400}?<a[^>]*>(.*?)<\/a>/im, 1]
+                   &.gsub(/<[^>]+>/, "")&.strip || ""
+
+          raw_html = chunk[/class="EngBibleText[^"]*"[^>]*>([\s\S]*?)<\/div>/im, 1] || ""
+          verse_html = clean_blb_verse_html(raw_html, cite)
+
+          return nil if cite.empty? || verse_html.empty?
+          full_href = cite_href.empty? ? nil : (cite_href.start_with?("http") ? cite_href : BLB_BASE + cite_href)
+          { cite: cite, verse_html: verse_html, href: full_href }
+        end
+
+        def clean_blb_verse_html(raw_html, cite)
+          raw_html = raw_html.dup
+          raw_html.gsub!(/<img[^>]*>/, "")
+          raw_html.gsub!(/<a[^>]*class="hide-for-tablet"[^>]*>[\s\S]*?<\/a>/im, "")
+          raw_html.gsub!(/<span[^>]*class="hide-for-tablet"[^>]*>[\s\S]*?<\/span>/im, "")
+
+          # Mark criteria words with control-char placeholders so they survive tag stripping
+          text = raw_html.gsub(/<span\s[^>]*class="word-phrase"[^>]*>([\s\S]*?)<\/span>/im) do
+            inner = $1
+            word = inner.sub(/<sup[\s\S]*/im, "").gsub(/<[^>]+>/, "").gsub(/&nbsp;/i, " ").strip
+            inner.match?(/<sup[^>]*class="[^"]*strongs criteria[^"]*"/i) ?
+              "\x02#{word}\x03" : word
+          end
+
+          # Fallback for translations without word-phrase spans (NASB, ESV, etc.)
+          unless text.include?("\x02")
+            text.gsub!(/([\w]+[,;:.!?'"]*)\s*<sup[^>]*class="[^"]*strongs criteria[^"]*"[\s\S]*?<\/sup>/im) do
+              "\x02#{$1}\x03"
+            end
+          end
+
+          # Strip remaining HTML tags and decode entities
+          text.gsub!(/<sup[^>]*>[\s\S]*?<\/sup>/im, "")
+          text.gsub!(/<[^>]+>/, "")
+          text.gsub!(/&nbsp;/i, " ")
+          text.gsub!(/&#(\d+);/)         { [$1.to_i].pack("U")      rescue " " }
+          text.gsub!(/&#x([\da-f]+);/i)  { [$1.to_i(16)].pack("U") rescue " " }
+          text.gsub!(/&amp;/, "&")
+          text.gsub!(/&lt;/, "<")
+          text.gsub!(/&gt;/, ">")
+          text.gsub!(/\s+/, " ")
+          text.strip!
+
+          # Strip mobile citation prefix left by hide-for-tablet removal
+          text.sub!(/\A#{Regexp.escape(cite)}\s*-\s*/i, "")
+
+          # Restore placeholders as highlighted spans
+          text.gsub!(/\x02([^\x03]*)\x03/) { %(<span class="blb-match">#{h($1.strip)}</span>) }
+          text
+        end
+      end
+    end
+  end
+end

data/lib/markdown_server/plugins/bible_citations/plugin.rb

@@ -2,6 +2,7 @@
 
 require "cgi"
 require_relative "citations"
+require_relative "helpers"
 require_relative "../../plugin"
 
 module MarkdownServer
@@ -9,11 +10,13 @@ module MarkdownServer
     class BibleCitations
       include MarkdownServer::Plugin
 
-      def self.enabled_by_default? = true
+      def self.enabled_by_default? = false
 
       def setup(config)
         @version = config.fetch("version", Citations::DEFAULT_VERSION)
         @link_target = config.fetch("link_target", "scrip")
+        MarkdownServer::App.set :dictionary_url, config["dictionary_url"] if config["dictionary_url"]
+        MarkdownServer::App.helpers(Helpers)
       end
 
       def transform_markdown(text)
@@ -22,11 +25,32 @@ module MarkdownServer
         end
       end
 
-      def transform_html(html)
-        Citations.link_citations_html(html) do |canonical, verse, citation|
+      def transform_html(html, app = nil)
+        html = Citations.link_citations_html(html) do |canonical, verse, citation|
           url = citation_url(canonical, verse)
           %(<a href="#{CGI.escapeHTML(url)}">#{CGI.escapeHTML(citation)}</a>)
         end
+        html = app.inject_strongs_urls(html) if app.respond_to?(:inject_strongs_urls)
+        html
+      end
+
+      def process_fetch(url, html, app)
+        if url.match?(/blueletterbible\.org\/lexicon\//i)
+          raw = app.page_title(html)
+          title = raw.match(/^([GH]\d+ - \w+)/i)&.[](1)&.sub(" - ", " – ") ||
+                  raw.sub(/ [-–] .*/, "").strip
+          { title: title, html: app.blueletterbible_html(html, url) }
+        elsif url.match?(%r{/definitions/[^/]+\.md(\?|#|\z)}i)
+          title = app.page_title(html).sub(/ [-–] .*/, "").strip
+          { title: title, html: app.markdownr_html(html) }
+        elsif url.match?(/scrip\.risensavior\.com/i) || html.match?(/<div\s+class="passage-text/i)
+          title = app.page_title(html).sub(/ [-–] .*/, "").strip
+          { title: title, html: app.scrip_html(html, url) }
+        end
+      end
+
+      def post_render(html, meta, app)
+        app.inject_pronunciation_icon(html, meta)
       end
 
       private

data/lib/markdown_server/version.rb

@@ -1,3 +1,3 @@
 module MarkdownServer
-  VERSION = "0.6.17"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markdownr
 version: !ruby/object:Gem::Version
-  version: 0.6.17
+  version: 0.7.0
 platform: ruby
 authors:
 - Brian Dunn
@@ -105,8 +105,15 @@ files:
 - bin/markdownr
 - lib/markdown_server.rb
 - lib/markdown_server/app.rb
+- lib/markdown_server/helpers/admin_helpers.rb
+- lib/markdown_server/helpers/fetch_helpers.rb
+- lib/markdown_server/helpers/formatting_helpers.rb
+- lib/markdown_server/helpers/markdown_helpers.rb
+- lib/markdown_server/helpers/path_helpers.rb
+- lib/markdown_server/helpers/search_helpers.rb
 - lib/markdown_server/plugin.rb
 - lib/markdown_server/plugins/bible_citations/citations.rb
+- lib/markdown_server/plugins/bible_citations/helpers.rb
 - lib/markdown_server/plugins/bible_citations/plugin.rb
 - lib/markdown_server/version.rb
 - views/admin_login.erb