jekyll-rp_logs 0.1.3

data/lib/jekyll/rp_logs/parse_weechat.rb

@@ -0,0 +1,46 @@
+module Jekyll
+  module RpLogs
+
+    class WeechatParser < RpLogs::Parser
+
+      # Add this class to the parsing dictionary
+      FORMAT_STR = 'weechat'
+      RpLogs::RpLogGenerator.add self
+
+      # Stuff
+      class << self
+        MODE = /([+%@&~!]?)/
+        NICK = /([\w\-\\\[\]\{\}\^\`\|]+)/
+        DATE_REGEXP = /(\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d)/
+
+        FLAGS = /((?:![A-Z]+ )*)/
+        JUNK =  /#{DATE_REGEXP}\t<?-->?\t.*$/
+        EMOTE = /^#{FLAGS}#{DATE_REGEXP}\t \*\t#{NICK}\s+([^\n]*)$/
+        TEXT  = /^#{FLAGS}#{DATE_REGEXP}\t#{MODE}#{NICK}\t([^\n]*)$/
+
+        TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
+
+        def parse_line(line, options = {}) 
+          case line
+          when JUNK
+            return nil
+          when EMOTE
+            date = DateTime.strptime($2, TIMESTAMP_FORMAT)
+            return Parser::LogLine.new(date, options, sender: $3, contents: $4, \
+              flags: $1, type: :rp)
+          when TEXT
+            date = DateTime.strptime($2, TIMESTAMP_FORMAT)
+            mode = if $3 != '' then $3 else ' ' end
+            return Parser::LogLine.new(date, options, sender: $4, contents: $5, \
+              flags: $1, type: :ooc, mode: mode)
+          else
+            # Only put text and emotes in the log
+            return nil
+          end
+        end
+      end
+
+    end  
+
+  end
+end

data/lib/jekyll/rp_logs/rp_arcs.rb

@@ -0,0 +1,69 @@
+# Largely inspired by http://brizzled.clapper.org/blog/2010/12/20/some-jekyll-hacks/
+
+module Jekyll
+  module RpLogs
+
+    # Holds arc information
+    class Arc
+
+      attr_accessor :name, :rps
+
+      def initialize(name)
+        # inspect types
+        name.strip!
+        @name = name
+
+        @rps = []
+        # potential future idea: directories for each arc
+      end
+
+      def <<(rp_page) 
+        @rps << rp_page
+      end
+
+      def start_date
+        @rps.map { |rp_page| rp_page.data['start_date'] }.min
+      end
+
+      def end_date
+        @rps.map { |rp_page| rp_page.data['last_post_time'] }.max
+      end
+
+      def is_arc?
+        true
+      end
+
+      def to_s
+        self.name
+      end
+
+      def eql?(arc)
+        self.class.equal?(arc.class) && (self.name == arc.name) && (self.rps.equal?(arc.rps))
+      end
+
+      def hash
+        self.name.hash
+      end
+
+      # actually by... start.. date?
+      def <=>(o)
+        if self.class == o.class 
+          self.name <=> o.name 
+        else
+          nil
+        end
+      end
+
+      def inspect
+        self.class.name + "[" + @name + "]"
+      end
+
+      def to_liquid
+        # Liquid wants a hash, not an object.
+
+        { "name" => @name, "rps" => @rps }
+      end
+
+    end
+  end
+end

data/lib/jekyll/rp_logs/rp_log_converter.rb

@@ -0,0 +1,202 @@
+require_relative 'rp_parser'
+require_relative 'rp_arcs'
+require_relative 'rp_tags'
+
+module Jekyll
+  module RpLogs
+
+    # Consider renaming since it is more of a converter in practice
+    class RpLogGenerator < Jekyll::Generator
+      safe true
+      priority :normal
+
+      RP_KEY = "rps"
+
+      @@parsers = {}
+
+      def RpLogGenerator.add(parser) 
+        @@parsers[parser::FORMAT_STR] = parser
+      end
+
+      def initialize(config)
+        config['rp_convert'] ||= true
+      end
+
+      def skip_page(page, message)
+        @site.collections[RP_KEY].docs.delete page
+        print "\nSkipping #{page.path}: #{message}"
+      end
+
+      def has_errors?(page)
+        # Verify that formats are specified
+        if page.data['format'].nil? || page.data['format'].length == 0 then 
+          skip_page(page, "No formats specified")
+          return true
+        else
+          # Verify that the parser for each format exists
+          page.data['format'].each { |format| 
+            if @@parsers[format].nil? then
+              skip_page(page, "Format #{format} does not exist.")
+              return true
+            end
+          }
+        end
+
+        # Verify that tags exist 
+        if page.data['rp_tags'].nil? then
+          skip_page(page, "No tags specified")
+          return true
+        # Verify that arc names are in the proper format
+        elsif not (page.data['arc_name'].nil? || page.data['arc_name'].respond_to?('each')) then
+          skip_page(page, "arc_name must be blank or a YAML list")
+          return true
+        end
+
+        false
+      end
+
+      def generate(site)
+        return unless site.config['rp_convert']
+        @site = site
+
+        # Directory of RPs
+        index = site.pages.detect { |page| page.data['rp_index'] }
+        index.data['rps'] = {'canon' => [], 'noncanon' => []}
+
+        # Arc-style directory
+        arc_page = site.pages.detect { |page| page.data['rp_arcs'] }
+
+        site.data['menu_pages'] = [index, arc_page]
+
+        arcs = Hash.new { |hash, key| hash[key] = Arc.new(key) }
+        no_arc_rps = []
+
+        # Convert all of the posts to be pretty
+        # Also build up our hash of tags
+        site.collections[RP_KEY].docs.select { true }
+          .each { |page|
+            # because we're iterating over a selected array, we can delete from the original
+            begin
+              next if has_errors? page
+
+              page.data['rp_tags'] = page.data['rp_tags'].split(',').map { |t| Tag.new t }
+
+              # Skip if something goes wrong
+              next unless convertRp page
+
+              key = if page.data['canon'] then 'canon' else 'noncanon' end
+              # Add key for canon/noncanon
+              index.data['rps'][key] << page
+              # Add tag for canon/noncanon
+              page.data['rp_tags'] << (Tag.new key)
+              page.data['rp_tags'].sort!
+
+              arc_name = page.data['arc_name']
+              if arc_name then
+                arc_name.each { |n| arcs[n] << page }
+              else
+                no_arc_rps << page
+              end
+            rescue 
+              # Catch all for any other exception encountered when parsing a page
+              skip_page(page, "Error parsing #{page.path}: " + $!.inspect)
+              # Raise exception, so Jekyll prints backtrace if run with --trace
+              raise $!
+            end
+          }
+
+        arcs.each_key { |key| sort_chronologically! arcs[key].rps } 
+        combined_rps = no_arc_rps.map { |x| ['rp', x] } + arcs.values.map { |x| ['arc', x] }
+        combined_rps.sort_by! { |type,x|
+          case type
+          when 'rp'
+            x.data['start_date']
+          when 'arc'
+            x.start_date 
+          end
+        }.reverse!
+        arc_page.data['rps'] = combined_rps 
+
+        sort_chronologically! index.data['rps']['canon']
+        sort_chronologically! index.data['rps']['noncanon']
+      end
+
+      def sort_chronologically!(pages) 
+        pages.sort_by! { |p| p.data['start_date'] }.reverse!
+      end
+
+      def convertRp(page)
+        options = get_options page
+
+        compiled_lines = []
+        page.content.each_line { |raw_line| 
+          page.data['format'].each { |format| 
+            log_line = @@parsers[format].parse_line(raw_line, options)
+            if log_line then
+              compiled_lines << log_line 
+              break
+            end
+          }
+        }
+
+        if compiled_lines.length == 0 then 
+          skip_page(page, "No lines were matched by any format.")
+          return false
+        end
+
+        merge_lines! compiled_lines
+        stats = extract_stats compiled_lines
+
+        split_output = compiled_lines.map { |line| line.output }
+
+        page.content = split_output.join("\n")
+
+        if page.data['infer_char_tags'] then
+          # Turn the nicks into characters
+          nick_tags = stats[:nicks].map! { |n| Tag.new('char:' + n) }
+          page.data['rp_tags'] = (nick_tags.merge page.data['rp_tags']).to_a.sort
+        end
+
+        page.data['end_date'] = stats[:end_date]
+        page.data['start_date'] ||= stats[:start_date]
+
+        true
+      end
+
+      def get_options(page)
+        { :strict_ooc => page.data['strict_ooc'],
+          :merge_text_into_rp => page.data['merge_text_into_rp'] }
+      end
+
+      def merge_lines!(compiled_lines)
+        last_line = nil
+        compiled_lines.reject! { |line| 
+          if last_line == nil then
+            last_line = line
+            false
+          elsif last_line.mergeable_with? line then
+            last_line.merge! line
+            # Delete the current line from output and maintain last_line 
+            # in case we need to merge multiple times.
+            true 
+          else
+            last_line = line
+            false
+          end
+        }
+      end
+
+      def extract_stats(compiled_lines) 
+        nicks = Set.new
+        compiled_lines.each { |line| 
+          nicks << line.sender if line.output_type == :rp
+        }
+
+        { :nicks => nicks,
+          :end_date => compiled_lines[-1].timestamp,
+          :start_date => compiled_lines[0].timestamp }
+      end
+    end
+
+  end
+end

data/lib/jekyll/rp_logs/rp_parser.rb

@@ -0,0 +1,114 @@
+module Jekyll
+  module RpLogs
+
+    class Parser
+      FORMAT_STR = nil
+
+      class LogLine
+        MAX_SECONDS_BETWEEN_POSTS = 3
+        RP_FLAG = '!RP'
+        OOC_FLAG = '!OOC'
+
+        attr :timestamp, :mode, :sender, :contents
+        attr :flags
+        # Some things depend on the original type of the line (nick format)
+        attr :base_type
+        attr :output_type
+        attr :options
+
+        attr :last_merged_timestamp
+
+        def initialize(timestamp, options = {}, sender:, contents:, flags:, type:, mode: ' ') 
+          @timestamp = timestamp
+          # Initialize to be the same as @timestamp
+          @last_merged_timestamp = timestamp
+          @mode = mode
+          @sender = sender
+          @contents = contents
+          @flags = flags.split(' ')
+
+          @base_type = type
+          @output_type = type
+
+          @options = options
+
+          # This makes it RP by default
+          @output_type = :rp if options[:strict_ooc]
+
+          # Check the contents for (
+          @output_type = :ooc if contents.strip[0] == '('
+          
+          # Flags override our assumptions, always
+          if flags.include? RP_FLAG then
+            @output_type = :rp
+          elsif flags.include? OOC_FLAG then
+            @output_type = :ooc
+          end
+        end
+
+        def output
+          # String used for the timestamp anchors
+          anchor = @timestamp.strftime('%Y-%m-%d_%H:%M:%S')
+          # String used when hovering over timestamps (friendly long-form)
+          title = @timestamp.strftime('%H:%M:%S %B %-d, %Y')
+          # String actually displayed on page
+          display = @timestamp.strftime('%H:%M')
+          ts_out = "<a name=\"#{anchor}\" title=\"#{title}\" href=\"##{anchor}\">#{display}</a>"
+
+          sender_out = nil
+          case @base_type
+          when :rp
+            sender_out = "  * #{@sender}"
+          when :ooc
+            sender_out = " &lt;#{@mode}#{@sender}&gt;"
+          else
+            # Explode.
+            throw "No known type: #{@base_type}"
+          end
+
+          tag_class = nil
+          tag_close = "</p>"
+          case @output_type
+          when :rp 
+            tag_class = "rp"
+          when :ooc
+            tag_class = "ooc"
+          else
+            # Explode.
+            throw "No known type: #{@output_type}"
+          end
+          tag_open = "<p class=\"#{tag_class}\">"
+
+          "#{tag_open}#{ts_out}#{sender_out} #{@contents}#{tag_close}"
+        end
+
+        def mergeable_with?(next_line)
+          # Only merge posts close enough in time
+          # The difference in time between the post merged into this one, and the next post, must be less than the limit
+          close_enough_time = (next_line.timestamp - @last_merged_timestamp) * 24 * 60 * 60 <= MAX_SECONDS_BETWEEN_POSTS
+          # Only merge posts with same sender
+          same_sender = @sender == next_line.sender
+          # Only merge rp lines
+          is_rp = @output_type == :rp
+          # Merge if next post is rp, or sender has split_to_normal_text property
+          # Only merge if the base type was OOC... otherwise you couldn't force not merging
+          # Maybe a job for !NOTMERGE flag, or similar
+          next_line_is_rp = next_line.output_type == :rp || \
+            (@options[:merge_text_into_rp].include?(@sender) && next_line.base_type == :ooc)
+
+          close_enough_time && same_sender && is_rp && next_line_is_rp
+        end
+
+        def merge!(next_line)
+          @contents += ' ' + next_line.contents
+          @last_merged_timestamp = next_line.timestamp
+        end
+
+        def inspect()
+          "<#{@mode}#{@sender}> (#{@base_type} -> #{@output_type}) #{@content}"
+        end
+      end
+    end
+
+  end
+end

data/lib/jekyll/rp_logs/rp_tag_index.rb

@@ -0,0 +1,56 @@
+# Again largely inspired by http://brizzled.clapper.org/blog/2010/12/20/some-jekyll-hacks/
+
+module Jekyll
+  module RpLogs
+
+    class TagIndex < Jekyll::Page
+      def initialize(site, base, dir, tag, pages)
+        @site = site
+        @base = base
+        @dir = dir
+        @name = 'index.html'
+
+        self.process(@name)
+        # Get tag_index filename
+        tag_index = (site.config['rp_tag_index_layout'] || 'tag_index') + '.html'
+        self.read_yaml(File.join(base, '_layouts'), tag_index)
+        self.data['tag'] = tag # Set which tag this index is for
+        # Sort tagged RPs by their start date
+        self.data['pages'] = pages.sort_by { |p| p.data['start_date'] }
+        tag_title_prefix = site.config['rp_tag_title_prefix'] || 'Tag: '
+        self.data['title'] = "#{tag_title_prefix}#{tag}"
+      end
+    end
+
+    class TagIndexGenerator < Jekyll::Generator
+      safe true
+      # Needs to run after RpLogGenerator
+      priority :low
+
+      def initialize(config) 
+        config['rp_tag_index'] ||= true
+        config['rp_tag_dir'] ||= '/tags'
+      end
+
+      def generate(site)
+        return unless site.config['rp_tag_index']
+        
+        dir = site.config['rp_tag_dir']
+        tags = rps_by_tag(site)
+        tags.each_pair { |tag, pages| 
+          site.pages << TagIndex.new(site, site.source, File.join(dir, tag.dir), tag, pages)
+        }
+      end
+
+      # Returns a hash of tags => [pages with tag]
+      def rps_by_tag(site) 
+        tag_ref = Hash.new { |hash, key| hash[key] = Set.new }
+        site.collections[RpLogGenerator::RP_KEY].docs.each { |page| 
+            page.data['rp_tags'].each { |tag| tag_ref[tag] << page }
+          }
+        return tag_ref
+      end
+
+    end
+  end
+end

data/lib/jekyll/rp_logs/rp_tags.rb

@@ -0,0 +1,107 @@
+# Largely inspired by http://brizzled.clapper.org/blog/2010/12/20/some-jekyll-hacks/
+
+module Jekyll
+  module RpLogs
+
+    TAG_NAME_MAP = {
+      "#"  => "sharp",
+      "/"  => "slash",
+      "\\" => "backslash",
+      " "  => "_"
+    }
+
+    # Holds tag information
+    class Tag
+
+      attr_accessor :dir, :name, :type
+
+      TYPES = [:meta, :character, :general]
+      CHAR_FLAG = /char:(.*)/
+      META_TAGS = /(safe|questionable|explicit|canon|noncanon|complete|incomplete)/
+
+      TYPE_CLASSES = {
+        :character => ['rp-tag-character'],
+        :meta => ['rp-tag-meta'],
+        :general => []
+      }
+
+      def initialize(name)
+        # inspect types
+        name.strip!
+        if (name =~ CHAR_FLAG) == 0 then
+          @name = $1
+          @type = :character
+        else
+          @name = name.downcase
+          @type = @name =~ META_TAGS ? :meta : :general
+        end
+
+        @dir = name_to_dir(@name)
+      end
+
+      def to_s
+        self.name
+      end
+
+      def eql?(tag)
+        self.class.equal?(tag.class) && (self.name == tag.name && self.type == tag.type)
+      end
+
+      def hash
+        self.name.hash
+      end
+
+      def <=>(o)
+        if self.class == o.class && self.type == o.type
+          self.name <=> o.name 
+        elsif self.type == :character
+          -1
+        elsif o.type == :character
+          1 
+        elsif self.type == :meta
+          -1
+        elsif o.type == :meta
+          1
+        else
+          nil
+        end
+      end
+
+      def inspect
+        self.class.name + "[" + @name + ", " + @dir + "]"
+      end
+
+      def to_liquid
+        # Liquid wants a hash, not an object.
+
+        { "name" => @name, "dir" => @dir, "classes" => self.classes }
+      end
+
+      def classes      
+        TYPE_CLASSES[@type].join ' '
+      end
+
+      private
+
+      # Map a tag to its directory name. Certain characters are escaped,
+      # using the TAG_NAME_MAP constant, above.
+      def name_to_dir(name)
+        s = ""
+        name.each_char do |c|
+          if (c =~ /[-A-Za-z0-9_|\[\]]/) != nil
+            s += c
+          else
+            c2 = TAG_NAME_MAP[c]
+            if not c2
+              msg = "Bad character '#{c}' in tag '#{name}'"
+              puts("*** #{msg}")
+              raise Exception.new(msg)
+            end
+            s += "#{c2}"
+          end
+        end
+        s
+      end
+    end
+  end
+end

data/lib/jekyll/rp_logs/rp_tasks.rb

@@ -0,0 +1,57 @@
+require 'rake'
+
+module Jekyll
+  module RpLogs
+    class RpTasks
+      include Rake::DSL if defined? Rake::DSL
+
+      def copy_unless_exist(from, to, message = nil)
+        unless File.exist?(to)
+          puts message if message
+          cp from, to
+        end
+      end
+
+      # Octopress
+      def get_stdin(message)
+        print message
+        STDIN.gets.chomp
+      end
+
+      # Octopress
+      def ask(message, valid_options)
+        if valid_options
+          answer = get_stdin("#{message} #{valid_options.to_s.gsub(/"/, '').gsub(/, /,'/')} ") while !valid_options.include?(answer)
+        else
+          answer = get_stdin(message)
+        end
+        answer
+      end
+
+      def install_tasks
+        namespace :rp_logs do
+
+          directory '_rps'
+
+          desc 'Create a new Jekyll site for RP logs, with the default theme'
+          task :new do |args|
+            if File.directory?("_sass")
+              abort("rake aborted!") if ask("A theme is already installed, proceeding will overwrite existing non-custom files. Are you sure?", ['y', 'n']) == 'n'
+            end
+
+            Rake::Task[:_rps].invoke
+            # allow directory specification
+
+            gem_root = Gem::Specification.find_by_name("jekyll-rp_logs").gem_dir
+            cp_r Dir["#{gem_root}/.themes/default/source/*"], "./"
+            copy_unless_exist("_config.yml.default", "_config.yml")
+            touch "_sass/_custom-vars.scss"
+            touch "_sass/_custom-rules.scss"
+          end
+        end
+      end
+    end
+  end
+end
+
+Jekyll::RpLogs::RpTasks.new.install_tasks

data/lib/jekyll/rp_logs/version.rb

@@ -0,0 +1,5 @@
+module Jekyll
+  module RpLogs
+    VERSION = "0.1.3"
+  end
+end

data/lib/jekyll/rp_logs.rb

@@ -0,0 +1,18 @@
+require "jekyll/rp_logs/version"
+require 'jekyll'
+
+module Jekyll
+  module RpLogs
+
+  end
+end
+
+# Require the main converter plugin first
+require 'jekyll/rp_logs/rp_log_converter'
+require 'jekyll/rp_logs/rp_tag_index'
+
+# Now require all of the parsers
+Gem.find_files("jekyll/rp_logs/parse*.rb").each { |path| require path }
+
+# Require the rake tasks
+require 'jekyll/rp_logs/rp_tasks'