HornsAndHooves-publify_core 10.0.0

data/lib/sidebar_field.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+class SidebarField
+  attr_accessor :key
+  attr_accessor :options
+  attr_accessor :default
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+
+  def initialize(key, default, options = {})
+    @key = key.to_s
+    @default = default
+    @options = options
+  end
+
+  def label
+    options[:label] || key.humanize.gsub(/url/i, "URL")
+  end
+
+  def label_html(_sidebar)
+    content_tag("label", label)
+  end
+
+  def input_html(sidebar)
+    text_field_tag(input_name(sidebar), current_value(sidebar), class: "form-control")
+  end
+
+  def line_html(sidebar)
+    content_tag(:div, label_html(sidebar) + input_html(sidebar), class: "form-group")
+  end
+
+  def input_name(sidebar)
+    "configure[#{sidebar.id}][#{key}]"
+  end
+
+  def canonicalize(value)
+    value
+  end
+
+  def current_value(sidebar)
+    canonicalize(sidebar.config[key])
+  end
+
+  class SelectField < self
+    def input_html(sidebar)
+      select_tag(input_name(sidebar),
+                 options_for_select(options[:choices], current_value(sidebar)),
+                 options)
+    end
+  end
+
+  class TextAreaField < self
+    def input_html(sidebar)
+      html_options = { "rows" => "10", "class" => "form-control" }.
+        update(options.stringify_keys)
+      text_area_tag(input_name(sidebar), current_value(sidebar), html_options)
+    end
+  end
+
+  class RadioField < self
+    def input_html(sidebar)
+      choices = options[:choices].map do |choice|
+        value = value_for(choice)
+        radio_button = radio_button_tag(input_name(sidebar),
+                                        value,
+                                        value == current_value(sidebar),
+                                        options)
+        content_tag("div", content_tag("label", radio_button + label_for(choice)),
+                    class: "radio")
+      end
+      safe_join(choices)
+    end
+
+    def label_for(choice)
+      choice.is_a?(Array) ? choice.last : choice.to_s.humanize
+    end
+
+    def value_for(choice)
+      choice.is_a?(Array) ? choice.first : choice
+    end
+  end
+
+  class CheckBoxField < self
+    def line_html(sidebar)
+      content = hidden_field_tag(input_name(sidebar), 0) +
+        content_tag("label",
+                    check_box_tag(input_name(sidebar), 1,
+                                  current_value(sidebar), options) + label)
+      content_tag("div", content, class: "checkbox")
+    end
+
+    def canonicalize(value)
+      case value
+      when "0"
+        false
+      else
+        true
+      end
+    end
+  end
+
+  def self.build(key, default, options)
+    class_for(options).new(key, default, options)
+  end
+
+  def self.class_for(options)
+    case options[:input_type]
+    when :text_area
+      TextAreaField
+    when :textarea
+      TextAreaField
+    when :radio
+      RadioField
+    when :checkbox
+      CheckBoxField
+    when :select
+      SelectField
+    else
+      if options[:choices]
+        SelectField
+      else
+        self
+      end
+    end
+  end
+end

data/lib/sidebar_registry.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class SidebarRegistry
+  class << self
+    def register_sidebar(klass_name)
+      registered_sidebars << klass_name.to_s
+    end
+
+    def available_sidebars
+      registered_sidebars.sort.map(&:constantize)
+    end
+
+    def available_sidebar_types
+      registered_sidebars.sort
+    end
+
+    def register_sidebar_directory(plugins_root, paths)
+      separator = plugins_root.include?("/") ? "/" : '\\'
+
+      Dir.glob(File.join(plugins_root, "*_sidebar")).select do |file|
+        plugin_name = file.split(separator).last
+        register_sidebar plugin_name.classify
+        # TODO: Move Sidebars to app/models, and views to app/views so this can
+        # be simplified.
+        paths << File.join(plugins_root, plugin_name, "lib")
+      end
+    end
+
+    private
+
+    def registered_sidebars
+      @registered_sidebars ||= Set.new
+    end
+  end
+end

data/lib/spam_protection.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "format"
+
+class SpamProtection
+  IP_RBLS = ["opm.blitzed.us", "bsb.empty.us"].freeze
+  HOST_RBLS = ["multi.surbl.org", "bsb.empty.us"].freeze
+  SECOND_LEVEL = %w(co com net org gov).freeze
+
+  attr_accessor :this_blog
+
+  def initialize(a_blog)
+    self.this_blog = a_blog
+  end
+
+  def is_spam?(string)
+    return false unless this_blog.sp_global
+    return false if string.blank?
+
+    reason = catch(:hit) do
+      case string
+      when Format::IP_ADDRESS then scan_ip(string)
+      when Format::HTTP_URI then scan_uris([string])
+      else scan_text(string)
+      end
+    end
+
+    if reason
+      logger.info("[SP] Hit: #{reason}")
+      true
+    end
+  end
+
+  protected
+
+  def scan_ip(ip_address)
+    logger.info("[SP] Scanning IP #{ip_address}")
+    query_rbls(IP_RBLS, ip_address.split(".").reverse.join("."))
+  end
+
+  def scan_text(string)
+    # FIXME: Unify HTTP URI matchers
+    uri_list = string.scan(%r{(http://[^\s"]+)}m).flatten
+
+    check_uri_count(uri_list)
+    scan_uris(uri_list)
+
+    false
+  end
+
+  def check_uri_count(uris)
+    limit = this_blog.sp_url_limit
+    return if limit.to_i.zero?
+
+    throw :hit, "Hard URL Limit hit: #{uris.size} > #{limit}" if uris.size > limit
+  end
+
+  def scan_uris(uris = [])
+    uris.each do |uri|
+      host = begin
+               URI.parse(uri).host
+             rescue URI::InvalidURIError
+               next
+             end
+      return scan_ip(host) if Format::IP_ADDRESS.match?(host)
+
+      host_parts = host.split(".").reverse
+      domain = []
+
+      # Check for two level TLD
+      (SECOND_LEVEL.include?(host_parts[1]) ? 3 : 2).times do
+        domain.unshift(host_parts.shift)
+      end
+
+      logger.info("[SP] Scanning domain #{domain.join(".")}")
+      query_rbls(HOST_RBLS, host, domain.join("."))
+      logger.info("[SP] Finished domain scan #{domain.join(".")}")
+      return false
+    end
+  end
+
+  def query_rbls(rbls, *subdomains)
+    rbls.each do |rbl|
+      subdomains.uniq.each do |d|
+        begin
+          response = IPSocket.getaddress([d, rbl].join("."))
+          if /^127\.0\.0\./.match?(response)
+            throw :hit,
+                  "#{rbl} positively resolved subdomain #{d} => #{response}"
+          end
+        rescue SocketError
+          # NXDOMAIN response => negative:  d is not in RBL
+          next
+        end
+      end
+    end
+    false
+  end
+
+  def logger
+    @logger ||= ::Rails.logger || Logger.new(STDOUT)
+  end
+end

data/lib/tasks/i18n.rake

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+namespace :i18n do
+  desc "Check translation health"
+  task :health do
+    `i18n-tasks health`
+    abort("Translation problems found") unless $CHILD_STATUS.success?
+  end
+end

data/lib/tasks/manifest.rake

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+namespace :manifest do
+  def gemmable_files
+    `git ls-files -z`.split("\x0").reject do |file|
+      file.match(%r{^(bin|spec)/}) ||
+        file.match(%r{/\.keep$}) ||
+        file.match(/^\./) ||
+        %w(Manifest.txt Gemfile Rakefile publify_core.gemspec).include?(file)
+    end
+  end
+
+  def manifest_files
+    File.open("Manifest.txt").readlines.map(&:chomp)
+  end
+
+  desc "Create manifest"
+  task :create do
+    File.open("Manifest.txt", "w") do |manifest|
+      gemmable_files.each { |file| manifest.puts file }
+    end
+  end
+
+  desc "Check manifest"
+  task :check do
+    unless gemmable_files == manifest_files
+      raise "Manifest check failed, try recreating the manifest"
+    end
+  end
+end

data/lib/tasks/publify_core_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :publify_core do
+#   # Task goes here
+# end

data/lib/text_filter_plugin.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "publify_plugins"
+
+class TextFilterPlugin
+  class << self
+    include PublifyPlugins
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::TagHelper
+  end
+
+  @@filter_map = {}
+  def self.inherited(sub)
+    if sub.to_s =~ /^Plugin/ || sub.to_s =~ /^PublifyApp::Textfilter/
+      name = sub.short_name
+      @@filter_map[name] = sub
+    end
+  end
+
+  def self.filter_map
+    @@filter_map
+  end
+
+  def self.available_filters
+    filter_map.values
+  end
+
+  def self.available_filter_types
+    unless @cached_filter_types
+      types = { "macropre" => [],
+                "macropost" => [],
+                "markup" => [],
+                "postprocess" => [],
+                "other" => [] }
+
+      available_filters.each { |filter| types[filter.filter_type].push(filter) }
+
+      @cached_filter_types = types
+    end
+    @cached_filter_types
+  end
+
+  def self.macro_filters
+    available_filters.select { |filter| TextFilterPlugin::Macro > filter }
+  end
+
+  plugin_display_name "Unknown Text Filter"
+  plugin_description "Unknown Text Filter Description"
+
+  def self.reloadable?
+    false
+  end
+
+  # The name that needs to be used when refering to the plugin's
+  # controller in render statements
+  def self.component_name
+    if to_s =~ /::([a-zA-Z]+)$/
+      "plugins/textfilters/#{Regexp.last_match[1]}".downcase
+    else
+      raise "I don't know who I am: #{self}"
+    end
+  end
+
+  # The name that's stored in the DB.  This is the final chunk of the
+  # controller name, like 'markdown' or 'smartypants'.
+  def self.short_name
+    component_name.split(%r{/}).last
+  end
+
+  def self.filter_type
+    "other"
+  end
+
+  def self.default_config
+    {}
+  end
+
+  def self.help_text
+    ""
+  end
+
+  def self.sanitize(*args)
+    (@sanitizer ||= Rails::Html::WhiteListSanitizer.new).sanitize(*args)
+  end
+
+  def self.default_helper_module!; end
+
+  # Look up a config paramater, falling back to the default as needed.
+  def self.config_value(params, name)
+    params[:filterparams][name] || default_config[name][:default]
+  end
+
+  def self.logger
+    @logger ||= ::Rails.logger || Logger.new(STDOUT)
+  end
+end
+
+class TextFilterPlugin::PostProcess < TextFilterPlugin
+  def self.filter_type
+    "postprocess"
+  end
+end
+
+class TextFilterPlugin::Macro < TextFilterPlugin
+  # Utility function -- hand it a XML string like <a href="foo" title="bar">
+  # and it'll give you back { "href" => "foo", "title" => "bar" }
+  def self.attributes_parse(string)
+    attributes = {}
+
+    string.gsub(/([^ =]+="[^"]*")/) do |match|
+      key, value = match.split(/=/, 2)
+      attributes[key] = value.delete('"')
+    end
+
+    string.gsub(/([^ =]+='[^']*')/) do |match|
+      key, value = match.split(/=/, 2)
+      attributes[key] = value.delete("'")
+    end
+
+    attributes
+  end
+
+  def self.filtertext(text)
+    regex1 = %r{<publify:#{short_name}(?:[ \t][^>]*)?/>}
+    regex2 = %r{<publify:#{short_name}([ \t][^>]*)?>(.*?)</publify:#{short_name}>}m
+
+    new_text = text.gsub(regex1) do |match|
+      macrofilter(attributes_parse(match))
+    end
+
+    new_text = new_text.gsub(regex2) do |_match|
+      macrofilter(attributes_parse(Regexp.last_match[1].to_s), Regexp.last_match[2].to_s)
+    end
+
+    new_text
+  end
+end
+
+class TextFilterPlugin::MacroPre < TextFilterPlugin::Macro
+  def self.filter_type
+    "macropre"
+  end
+end
+
+class TextFilterPlugin::MacroPost < TextFilterPlugin::Macro
+  def self.filter_type
+    "macropost"
+  end
+end
+
+class TextFilterPlugin::Markup < TextFilterPlugin
+  def self.filter_type
+    "markup"
+  end
+end
+
+class PublifyApp
+  class Textfilter
+    class MacroPost < TextFilterPlugin
+      plugin_display_name "MacroPost"
+      plugin_description "Macro expansion meta-filter (post-markup)"
+
+      def self.filtertext(text)
+        macros = TextFilterPlugin.available_filter_types["macropost"]
+        macros.reduce(text) do |new_text, macro|
+          macro.filtertext(new_text)
+        end
+      end
+    end
+
+    class MacroPre < TextFilterPlugin
+      plugin_display_name "MacroPre"
+      plugin_description "Macro expansion meta-filter (pre-markup)"
+
+      def self.filtertext(text)
+        macros = TextFilterPlugin.available_filter_types["macropre"]
+        macros.reduce(text) do |new_text, macro|
+          macro.filtertext(new_text)
+        end
+      end
+    end
+  end
+end

data/lib/theme.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class Theme
+  attr_accessor :name, :path, :description_html
+
+  def initialize(name, path)
+    @name = name
+    @path = path
+  end
+
+  def layout(action = :default)
+    if action.to_s == "view_page"
+      return "layouts/pages" if File.exist? "#{view_path}/layouts/pages.html.erb"
+    end
+    "layouts/default"
+  end
+
+  def description
+    about_file = "#{path}/about.markdown"
+    if File.exist? about_file
+      File.read about_file
+    else
+      "### #{name}"
+    end
+  end
+
+  def view_path
+    "#{path}/views"
+  end
+
+  # Find a theme, given the theme name
+  def self.find(name)
+    registered_themes[name]
+  end
+
+  # List all themes
+  def self.find_all
+    registered_themes.values
+  end
+
+  def self.register_theme(path)
+    theme = theme_from_path(path)
+    registered_themes[theme.name] = theme
+  end
+
+  def self.register_themes(themes_root)
+    search_theme_directory(themes_root).each do |path|
+      register_theme path
+    end
+  end
+
+  # Private
+
+  def self.registered_themes
+    @registered_themes ||= {}
+  end
+
+  def self.theme_from_path(path)
+    name = path.scan(/[-\w]+$/i).flatten.first
+    new(name, path)
+  end
+
+  def self.search_theme_directory(themes_root)
+    glob = "#{themes_root}/[a-zA-Z0-9]*"
+    Dir.glob(glob).select do |file|
+      File.readable?("#{file}/about.markdown")
+    end.compact
+  end
+
+  private_class_method :search_theme_directory,
+                       :theme_from_path, :registered_themes
+end

data/lib/transforms.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# FIXME: Replace with helpers and/or methods provided by Rails
+class String
+  ACCENTS = { %w(á à â ä ã Ã Ä Â À) => "a",
+              %w(é è ê ë Ë É È Ê) => "e",
+              %w(í ì î ï I Î Ì) => "i",
+              %w(ó ò ô ö õ Õ Ö Ô Ò) => "o",
+              ["œ"] => "oe",
+              ["ß"] => "ss",
+              %w(ú ù û ü U Û Ù) => "u",
+              %w(ç Ç) => "c" }.freeze
+
+  def to_permalink
+    string = self
+    ACCENTS.each do |key, value|
+      string = string.tr(key.join, value)
+    end
+    string = string.tr("'", "-")
+    string.gsub(/<[^>]*>/, "").to_url
+  end
+
+  # Returns a-string-with-dashes when passed 'a string with dashes'.
+  # All special chars are stripped in the process
+  def to_url
+    return if nil?
+
+    s = downcase.tr("\"'", "")
+    s = s.gsub(/\P{Word}/, " ")
+    s.strip.tr_s(" ", "-").tr(" ", "-").sub(/^$/, "-")
+  end
+
+  def to_title(item, settings, params)
+    TitleBuilder.new(self).build(item, settings, params)
+  end
+
+  # Strips any html markup from a string
+  TYPO_TAG_KEY = TYPO_ATTRIBUTE_KEY = /[\w:_-]+/.freeze
+  TYPO_ATTRIBUTE_VALUE = /(?:[A-Za-z0-9]+|(?:'[^']*?'|"[^"]*?"))/.freeze
+  TYPO_ATTRIBUTE = /(?:#{TYPO_ATTRIBUTE_KEY}(?:\s*=\s*#{TYPO_ATTRIBUTE_VALUE})?)/.freeze
+  TYPO_ATTRIBUTES = /(?:#{TYPO_ATTRIBUTE}(?:\s+#{TYPO_ATTRIBUTE})*)/.freeze
+  TAG =
+    %r{<[!/?\[]?(?:#{TYPO_TAG_KEY}|--)(?:\s+#{TYPO_ATTRIBUTES})?\s*(?:[!/?\]]+|--)?>}.freeze
+  def strip_html
+    gsub(TAG, "").gsub(/\s+/, " ").strip
+  end
+end

data/themes/plain/about.markdown

@@ -0,0 +1,4 @@
+#### Plain theme for Publify
+
+Plain is a theme for Publify consisting only of the default templates and a
+sprinkle of CSS to make it look nice.

data/themes/plain/stylesheets/theme.css

@@ -0,0 +1,57 @@
+/* Fonts and colors */
+body {
+  font-family: sans-serif;
+}
+h1 a, h2 a {
+  text-decoration: none;
+  color: black;
+}
+h1 a:hover, h2 a:hover {
+  text-decoration: underline;
+}
+div.header, div.footer {
+  text-align: center;
+}
+#errors {
+  border: red 1px solid;
+  border-radius: 0.5rem;
+  background-color: #f88;
+  padding: 1rem;
+}
+
+/*
+ * Simple horizontal layout based on a 20 4 20 4 20 grid
+ */
+div.container {
+  max-width: 44rem;
+  margin-left: auto;
+  margin-right: auto;
+}
+div.sidebar {
+  max-width: 20rem;
+  display: inline-block;
+}
+div.content, div.sidebar {
+  margin-bottom: 2rem;
+}
+
+@media(min-width: 68rem) {
+  div.container {
+    max-width: 68rem;
+  }
+  div.content {
+    width: 44rem;
+    float: left;
+  }
+  div.sidebar {
+    margin-left: 4rem;
+  }
+}
+div.footer {
+  clear: both;
+}
+
+/* Admin tools */
+.admintools {
+  float: right;
+}