publify_core 9.0.0.pre1

data/lib/spam_protection.rb

@@ -0,0 +1,101 @@
+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}")
+      return 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)
+    uri_list = string.scan(/(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?
+    if uris.size > limit
+      throw :hit, "Hard URL Limit hit: #{uris.size} > #{limit}"
+    end
+  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 host =~ Format::IP_ADDRESS
+
+      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 response =~ /^127\.0\.0\./
+            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/stateful.rb

@@ -0,0 +1,106 @@
+module Stateful
+  class State
+    def initialize(model)
+      @model = model
+    end
+
+    def to_s
+      self.class.to_s.demodulize
+    end
+
+    def exit_hook(_target_state)
+      ::Rails.logger.debug("#{model} leaving state #{self}")
+    end
+
+    def enter_hook
+      ::Rails.logger.debug("#{model} entering state #{self}")
+    end
+
+    def method_missing(predicate, *args)
+      if predicate.to_s.last == '?'
+        self.class.to_s.demodulize.underscore == predicate.to_s.chop
+      else
+        super
+      end
+    end
+
+    def ==(other)
+      self.class == other.class
+    end
+
+    def hash
+      self.class.hash
+    end
+
+    private
+
+    attr_reader :model
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def has_state(field, options = {})
+      options.assert_valid_keys(:valid_states, :handles, :initial_state)
+
+      unless (states = options[:valid_states])
+        raise 'You must specify at least one state'
+      end
+
+      states = states.map(&:to_sym)
+      delegations = Set.new(options[:handles]) + states.map { |value| "#{value}?" }
+      initial_state = options[:initial_state] || states.first
+
+      state_writer_method(field, states, initial_state)
+      state_reader_method(field, states, initial_state)
+
+      delegations.each do |value|
+        delegate value, to: field
+      end
+    end
+
+    def state_reader_method(name, states, initial_state)
+      module_eval <<-end_meth
+        def #{name}(force_reload = false)
+          if @#{name}_obj.nil? || force_reload
+            memento = read_attribute(#{name.inspect}) || #{initial_state.inspect}
+            unless #{states.inspect}.include? memento.to_sym
+              raise \"Invalid state: \#{memento} in the database.\"
+            end
+            @#{name}_obj = self.class.class_eval(memento.to_s.classify).new(self)
+          end
+          @#{name}_obj
+        end
+      end_meth
+    end
+
+    def state_writer_method(name, states, _initial_state)
+      module_eval <<-end_meth
+        def #{name}=(state)
+          case state
+          when Symbol
+            set_#{name}_from_symbol state
+          when String
+            set_#{name}_from_symbol state.to_sym
+          else
+            raise "You must set the state with a symbol or a string"
+          end
+        end
+
+        def set_#{name}_from_symbol(memento)
+          unless #{states.inspect}.include?(memento)
+            raise "Invalid state: " + memento
+          end
+          self[:#{name}] = memento.to_s
+          new_state = self.class.class_eval(memento.to_s.classify).new(self)
+          @#{name}_obj.exit_hook(new_state) if @#{name}_obj
+          @#{name}_obj = new_state
+          @#{name}_obj.enter_hook
+          @#{name}_obj
+        end
+      end_meth
+    end
+  end
+end

data/lib/tasks/publify_core_tasks.rake

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

data/lib/text_filter_plugin.rb

@@ -0,0 +1,182 @@
+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 ||= 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 = /<publify:#{short_name}(?:[ \t][^>]*)?\/>/
+    regex2 = /<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 @@
+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'
+      if File.exist? "#{view_path}/layouts/pages.html.erb"
+        return 'layouts/pages'
+      end
+    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,45 @@
+# coding: utf-8
+# 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:_-]+/
+  TYPO_ATTRIBUTE_VALUE = /(?:[A-Za-z0-9]+|(?:'[^']*?'|"[^"]*?"))/
+  TYPO_ATTRIBUTE = /(?:#{TYPO_ATTRIBUTE_KEY}(?:\s*=\s*#{TYPO_ATTRIBUTE_VALUE})?)/
+  TYPO_ATTRIBUTES = /(?:#{TYPO_ATTRIBUTE}(?:\s+#{TYPO_ATTRIBUTE})*)/
+  TAG = %r{<[!/?\[]?(?:#{TYPO_TAG_KEY}|--)(?:\s+#{TYPO_ATTRIBUTES})?\s*(?:[!/?\]]+|--)?>}
+  def strip_html
+    gsub(TAG, '').gsub(/\s+/, ' ').strip
+  end
+end