fastreader 1.0.0

data/lib/htmlentities/legacy.rb

@@ -0,0 +1,27 @@
+class HTMLEntities
+  class << self
+    
+    #
+    # Legacy compatibility class method allowing direct encoding of XHTML1 entities.
+    # See HTMLEntities#encode for description of parameters.
+    #
+    def encode_entities(*args)
+      xhtml1_entities.encode(*args)
+    end
+    
+    #
+    # Legacy compatibility class method allowing direct decoding of XHTML1 entities.
+    # See HTMLEntities#decode for description of parameters.
+    #
+    def decode_entities(*args)
+      xhtml1_entities.decode(*args)
+    end
+    
+  private
+  
+    def xhtml1_entities
+      @xhtml1_entities ||= new('xhtml1')
+    end
+    
+  end
+end

data/lib/htmlentities/string.rb

@@ -0,0 +1,26 @@
+require 'htmlentities'
+
+#
+# This file extends the String class with methods to allow encoding and decoding of
+# HTML/XML entities from/to their corresponding UTF-8 codepoints.
+#
+class String
+
+  #
+  # Decode XML and HTML 4.01 entities in a string into their UTF-8
+  # equivalents.
+  #
+  def decode_entities
+    return HTMLEntities.decode_entities(self)
+  end
+  
+  #
+  # Encode codepoints in a string into their corresponding entities. See
+  # the documentation of HTMLEntities.encode_entities for a list of possible
+  # instructions.
+  #
+  def encode_entities(*instructions)
+    return HTMLEntities.encode_entities(self, *instructions)
+  end
+
+end

data/lib/htmlentities/xhtml1.rb

@@ -0,0 +1,258 @@
+class HTMLEntities
+  MAPPINGS = {} unless defined? MAPPINGS
+  MAPPINGS['xhtml1'] = {
+    'Aacute' => 193,
+    'aacute' => 225,
+    'Acirc' => 194,
+    'acirc' => 226,
+    'acute' => 180,
+    'AElig' => 198,
+    'aelig' => 230,
+    'Agrave' => 192,
+    'agrave' => 224,
+    'alefsym' => 8501,
+    'Alpha' => 913,
+    'alpha' => 945,
+    'amp' => 38,
+    'and' => 8743,
+    'ang' => 8736,
+    'apos' => 39,
+    'Aring' => 197,
+    'aring' => 229,
+    'asymp' => 8776,
+    'Atilde' => 195,
+    'atilde' => 227,
+    'Auml' => 196,
+    'auml' => 228,
+    'bdquo' => 8222,
+    'Beta' => 914,
+    'beta' => 946,
+    'brvbar' => 166,
+    'bull' => 8226,
+    'cap' => 8745,
+    'Ccedil' => 199,
+    'ccedil' => 231,
+    'cedil' => 184,
+    'cent' => 162,
+    'Chi' => 935,
+    'chi' => 967,
+    'circ' => 710,
+    'clubs' => 9827,
+    'cong' => 8773,
+    'copy' => 169,
+    'crarr' => 8629,
+    'cup' => 8746,
+    'curren' => 164,
+    'Dagger' => 8225,
+    'dagger' => 8224,
+    'dArr' => 8659,
+    'darr' => 8595,
+    'deg' => 176,
+    'Delta' => 916,
+    'delta' => 948,
+    'diams' => 9830,
+    'divide' => 247,
+    'Eacute' => 201,
+    'eacute' => 233,
+    'Ecirc' => 202,
+    'ecirc' => 234,
+    'Egrave' => 200,
+    'egrave' => 232,
+    'empty' => 8709,
+    'emsp' => 8195,
+    'ensp' => 8194,
+    'Epsilon' => 917,
+    'epsilon' => 949,
+    'equiv' => 8801,
+    'Eta' => 919,
+    'eta' => 951,
+    'ETH' => 208,
+    'eth' => 240,
+    'Euml' => 203,
+    'euml' => 235,
+    'euro' => 8364,
+    'exist' => 8707,
+    'fnof' => 402,
+    'forall' => 8704,
+    'frac12' => 189,
+    'frac14' => 188,
+    'frac34' => 190,
+    'frasl' => 8260,
+    'Gamma' => 915,
+    'gamma' => 947,
+    'ge' => 8805,
+    'gt' => 62,
+    'hArr' => 8660,
+    'harr' => 8596,
+    'hearts' => 9829,
+    'hellip' => 8230,
+    'Iacute' => 205,
+    'iacute' => 237,
+    'Icirc' => 206,
+    'icirc' => 238,
+    'iexcl' => 161,
+    'Igrave' => 204,
+    'igrave' => 236,
+    'image' => 8465,
+    'infin' => 8734,
+    'int' => 8747,
+    'Iota' => 921,
+    'iota' => 953,
+    'iquest' => 191,
+    'isin' => 8712,
+    'Iuml' => 207,
+    'iuml' => 239,
+    'Kappa' => 922,
+    'kappa' => 954,
+    'Lambda' => 923,
+    'lambda' => 955,
+    'lang' => 9001,
+    'laquo' => 171,
+    'lArr' => 8656,
+    'larr' => 8592,
+    'lceil' => 8968,
+    'ldquo' => 8220,
+    'le' => 8804,
+    'lfloor' => 8970,
+    'lowast' => 8727,
+    'loz' => 9674,
+    'lrm' => 8206,
+    'lsaquo' => 8249,
+    'lsquo' => 8216,
+    'lt' => 60,
+    'macr' => 175,
+    'mdash' => 8212,
+    'micro' => 181,
+    'middot' => 183,
+    'minus' => 8722,
+    'Mu' => 924,
+    'mu' => 956,
+    'nabla' => 8711,
+    'nbsp' => 160,
+    'ndash' => 8211,
+    'ne' => 8800,
+    'ni' => 8715,
+    'not' => 172,
+    'notin' => 8713,
+    'nsub' => 8836,
+    'Ntilde' => 209,
+    'ntilde' => 241,
+    'Nu' => 925,
+    'nu' => 957,
+    'Oacute' => 211,
+    'oacute' => 243,
+    'Ocirc' => 212,
+    'ocirc' => 244,
+    'OElig' => 338,
+    'oelig' => 339,
+    'Ograve' => 210,
+    'ograve' => 242,
+    'oline' => 8254,
+    'Omega' => 937,
+    'omega' => 969,
+    'Omicron' => 927,
+    'omicron' => 959,
+    'oplus' => 8853,
+    'or' => 8744,
+    'ordf' => 170,
+    'ordm' => 186,
+    'Oslash' => 216,
+    'oslash' => 248,
+    'Otilde' => 213,
+    'otilde' => 245,
+    'otimes' => 8855,
+    'Ouml' => 214,
+    'ouml' => 246,
+    'para' => 182,
+    'part' => 8706,
+    'permil' => 8240,
+    'perp' => 8869,
+    'Phi' => 934,
+    'phi' => 966,
+    'Pi' => 928,
+    'pi' => 960,
+    'piv' => 982,
+    'plusmn' => 177,
+    'pound' => 163,
+    'Prime' => 8243,
+    'prime' => 8242,
+    'prod' => 8719,
+    'prop' => 8733,
+    'Psi' => 936,
+    'psi' => 968,
+    'quot' => 34,
+    'radic' => 8730,
+    'rang' => 9002,
+    'raquo' => 187,
+    'rArr' => 8658,
+    'rarr' => 8594,
+    'rceil' => 8969,
+    'rdquo' => 8221,
+    'real' => 8476,
+    'reg' => 174,
+    'rfloor' => 8971,
+    'Rho' => 929,
+    'rho' => 961,
+    'rlm' => 8207,
+    'rsaquo' => 8250,
+    'rsquo' => 8217,
+    'sbquo' => 8218,
+    'Scaron' => 352,
+    'scaron' => 353,
+    'sdot' => 8901,
+    'sect' => 167,
+    'shy' => 173,
+    'Sigma' => 931,
+    'sigma' => 963,
+    'sigmaf' => 962,
+    'sim' => 8764,
+    'spades' => 9824,
+    'sub' => 8834,
+    'sube' => 8838,
+    'sum' => 8721,
+    'sup' => 8835,
+    'sup1' => 185,
+    'sup2' => 178,
+    'sup3' => 179,
+    'supe' => 8839,
+    'szlig' => 223,
+    'Tau' => 932,
+    'tau' => 964,
+    'there4' => 8756,
+    'Theta' => 920,
+    'theta' => 952,
+    'thetasym' => 977,
+    'thinsp' => 8201,
+    'THORN' => 222,
+    'thorn' => 254,
+    'tilde' => 732,
+    'times' => 215,
+    'trade' => 8482,
+    'Uacute' => 218,
+    'uacute' => 250,
+    'uArr' => 8657,
+    'uarr' => 8593,
+    'Ucirc' => 219,
+    'ucirc' => 251,
+    'Ugrave' => 217,
+    'ugrave' => 249,
+    'uml' => 168,
+    'upsih' => 978,
+    'Upsilon' => 933,
+    'upsilon' => 965,
+    'Uuml' => 220,
+    'uuml' => 252,
+    'weierp' => 8472,
+    'Xi' => 926,
+    'xi' => 958,
+    'Yacute' => 221,
+    'yacute' => 253,
+    'yen' => 165,
+    'Yuml' => 376,
+    'yuml' => 255,
+    'Zeta' => 918,
+    'zeta' => 950,
+    'zwj' => 8205,
+    'zwnj' => 8204
+  }
+end

data/lib/menu_pager.rb

@@ -0,0 +1,71 @@
+# This is initialized with the screen area of the window of screen, and then
+# handles showing the visible area of content for menus.
+
+class MenuPager
+  include CharacterCleaner
+
+  def initialize(window_height, window_width)
+    @window_height = window_height
+    @window_width = window_width
+  end
+
+  # Pass in an array of lines or a string. Returns an array of hashes.
+  # Each hash has a key :item that holds the item object and a key :text that
+  # holds the text for the item.
+  #
+  # We don't do anything with the matches parameters yet. 
+  # May use it later for highlighting. But then we would also need to
+  # pass in the search term.
+  # 
+  def create_page(items, current_index, matches=nil, options={})
+    out = []
+    pages = []
+    items.each_slice(@window_height) do |slice|
+      pages << slice
+    end
+    page = calculate_page_for_index( current_index ) 
+    items_on_page = pages[page] 
+
+    items_on_page.each_with_index do |x, i|
+      # Space on the left for the arrow
+      # Truncate title if it is longer than the width of the window
+
+      if x.is_a?(Entry)
+        title = process_entities_and_utf(x.title).strip
+      else
+        # Put in a line number if this is a Feed in the Feed Menu
+        index = items.index(x)
+        title = "%2d " % (index + 1) + x.title 
+        title = process_entities_and_utf(title)
+      end
+
+      title = "   " + title
+      if x.is_a?(Feed) # put the feed count 
+        title += " (#{x.entries.count})" 
+
+      elsif x.is_a?(VirtualFeed) # put the feed count 
+        title += " (#{x.entry_count})"
+      end
+#      if x.respond_to?(:categories) and !x.categories.empty?
+#        title += " - [#{x.categories.join(', ')}]"
+#      end
+
+      maxwidth = @window_width - 18 
+      full_title = [title]
+      full_title << x.feed.title if options[:show_feed_titles]
+      full_title << time_ago_in_words(x.date_published) if x.is_a?(Entry)
+      excess = full_title.join(" ").length - maxwidth
+      if excess > 0
+        title = title[0, title.length - excess] + "..."
+      end
+      out << {:item => x, :text => title}
+    end
+
+    # page 0 is the first page
+    [page, out]
+  end
+
+  def calculate_page_for_index( index )
+    index / @window_height 
+  end
+end

data/lib/menu_window.rb

@@ -0,0 +1,419 @@
+# Wraps a collection of objects into a menu window
+class MenuWindow
+  attr_accessor :items, :current_index, :search_string, :matches
+
+  # Matches are passed in when a search succeeds and certain items 
+  # need to be indicated as matches
+  # TODO This should be changed into a hash parameter with keys
+  def initialize(title, scr, items, current_index, matches=nil, options={})
+
+    @options = options
+    @matches = matches
+    @height = scr.maxy - 6
+    @width = scr.maxx - 2
+    scr.clear
+    scr.setpos(2, 5)
+    scr.refresh
+
+    @title = title
+    @title_box = Curses::Window.new(2, @width, 2, 5)
+
+    # @window is the main content window
+    
+    @window = Curses::Window.new(@height, @width, 4, 2)
+
+    @items = items 
+    if @items.empty?
+      @title_box.addstr(@title)
+      @title_box.refresh
+      @window.clear
+      @window.addstr("   No items")
+      @window.refresh
+      # need to disable some commands in the controller
+      return
+    end
+    @pager = MenuPager.new(@height, @width)
+    @current_index = current_index || 0
+
+    @window.clear if @window
+
+    # page_content is an array of hashes with keys :item and :text
+    @page_index, @page_content = create_page
+    
+    draw_menu(@page_content)
+
+    draw_title
+
+    draw_arrow
+    # draw pointer at current selection
+    @window.refresh
+  end
+
+  def create_page
+    @pager.create_page(@items, @current_index, @matches, @options)
+  end
+
+  # TODO put the date range of the items in the title
+  def draw_title
+    @title_box.clear
+    
+    # This handles a list of feeds, which don't really have a date range
+    unless @items.first && @items.first.respond_to?(:date_published)
+      @title_box.addstr(@title)
+      @title_box.refresh
+      return
+    end
+
+    # Get the date range from the items in the page content
+    dates = @page_content.map {|x| x[:item]}.map {|i| 
+      if i.respond_to?(:date_published)
+       i.date_published 
+      elsif i.respond_to?(:last_updated)
+       i.last_updated 
+      end
+    }
+    most_recent_date = dates.max.strftime('%B %d %Y')
+    oldest_date = dates.min.strftime('%B %d %Y')
+
+    if most_recent_date != oldest_date 
+      @title_box.addstr(@title + " | " + oldest_date + " - " + most_recent_date)
+    else
+      @title_box.addstr(@title + " | " + oldest_date)
+    end
+    @title_box.refresh
+  end
+
+  def highlight_matches(matches, search_string)
+    LOGGER.debug("setting matches to #{matches.inspect}")
+    @search_string = search_string
+    @matches = matches
+    draw_menu
+  end
+
+  def highlight_global_matches(matches, search_string)
+    LOGGER.debug("setting matches to #{matches.inspect}")
+    @global_search_string = search_string
+    @global_matches = matches
+    draw_menu
+  end
+   
+  def cancel_search # Cancels local search only
+    @matches = nil
+    @search_string = nil
+    draw_menu
+  end
+
+  # Draws the actual menu on the screen, with appropriate color highlighting
+  # The color of the highlighting is determined by the model. The item should
+  # have a :color attribute that returns the appropriate color as a symbol,
+  # which will be looked up on the Curses::Color table.
+  def draw_menu(items=@page_content)
+    @window.setpos(0, 0)
+    items.each do |x|
+      draw_line(x[:text], x[:item])
+    end
+    draw_arrow
+    @window.refresh
+  end
+
+  def draw_line(text, item)
+    if item.is_a?(Entry)
+
+      color = case 
+              when item.respond_to?(:flagged) && item.flagged && !@options[:turn_off_flagged_color] 
+                :red
+#                when item.respond_to?(:is_new?) && item.is_new?
+#                  :green
+
+              else
+                nil
+              end
+      
+      # local matches take precedence
+      matches = @matches || @global_matches
+      search_string = @search_string || @global_search_string
+
+      if matches && !matches.empty? && matches.include?( @items.index(item) )
+        LOGGER.debug("matching line detected : search string #{search_string} : text: #{text}")
+        text = text.gsub(/(#{search_string})/i, '%%%\1%%%') 
+        text.split(/%%%/).each_with_index do |chunk, index|
+          if index % 2 == 0
+            @window.addstr(chunk, color)
+          else 
+            @window.addstr(chunk, :yellow)
+          end
+        end
+      else
+        @window.addstr(text, color)
+      end
+
+      if @options[:show_feed_titles]  # put the feed title in the title
+        @window.addstr(" #{item.feed.title}", :cyan)
+      end
+
+      item_date = case 
+        when @options[:feed_title] == "All Entries"
+          item.created_at
+        when @options[:feed_title] == "Flagged Entries"
+          item.flagged
+        else
+          item.date_published
+        end
+      if item_date 
+        item_date = " #{time_ago_in_words(item_date)} ago"
+      else
+        item_date = ''
+      end
+      @window.addstr(item_date, :magenta)
+      
+      @window.addstr("\n")
+
+    # a feed or virtual feed
+    else 
+
+      color = case 
+              when item.is_a?(VirtualFeed) && text =~ /Flagged Entries/
+                :red
+              else
+                nil
+              end
+      @window.addstr(text, color)
+
+      # May not be the case with some virtual feeds
+      # Add a column to feed that cached this attribute after an feed
+      # update_self
+      if item.is_a?(VirtualFeed) && item.title == "All Entries"
+        # Use the created_at of the last entry
+        entry = Entry.find(:first, :order => "id desc")
+        last_updated = entry ? "#{time_ago_in_words(entry.created_at)} ago\n" : "\n"
+
+        @window.addstr(" " + last_updated, :magenta)
+
+      elsif item.is_a?(VirtualFeed) && item.title == "Flagged Entries"
+        # Use the flagged timetamp of the last entry
+        entry = Entry.find(:first, :conditions => "flagged IS NOT NULL", :order => "flagged desc")
+        last_updated = entry ? "#{time_ago_in_words(entry.flagged)} ago\n" : "\n"
+        @window.addstr(" " + last_updated , :magenta)
+
+      elsif item.last_updated 
+        most_recent_entry = item.entries.first
+        last_updated = (most_recent_entry && most_recent_entry.date_published) ? 
+          most_recent_entry.date_published : item.last_updated
+        if last_updated
+          last_updated = time_ago_in_words(last_updated) + " ago\n"
+        else
+          last_updated = ''
+        end
+        @window.addstr(" " + last_updated , :magenta)
+      else 
+        @window.addstr("\n")
+      end
+    end
+  end
+
+  def redraw_menu
+    LOGGER.debug("Redrawing menu")
+    @window.clear
+    draw_menu(@page_content)
+    draw_arrow
+    draw_title
+    @window.refresh
+  end
+
+  def draw_arrow
+    # calculate where arrow should be drawn
+    LOGGER.debug("Drawing arrow. Current index: #{@current_index}, Page index: #{@page_index}, Height: #{@height}")
+    y = (@current_index - @page_index * @height) 
+    x = 0
+    LOGGER.debug "Drawing arrow at y #{y}"
+    @window.setpos(y, x)
+    @window.addstr("->")
+    # move the cursor 
+    #@window.setpos(0,0)
+  end
+
+  # TODO change this to coloring the line
+  def toggle_flag
+    item = @items[@current_index]
+    if item.flagged 
+      item.update_attribute(:flagged, nil)
+    else
+      item.update_attribute(:flagged, Time.now)
+    end
+
+    redraw_menu
+  end
+
+  def unflag_all
+    @items.each do |item|
+      item.update_attribute(:flagged, nil)
+
+    end
+  end
+  
+  def flag_all
+    @items.each do |item|
+      item.update_attribute(:flagged, Time.now)
+
+    end
+  end
+
+  def erase_arrow
+    # calculate where arrow should be drawn
+    y = (@current_index - @page_index * @height) 
+    x = 0
+    LOGGER.debug "Erasing arrow at y #{y}"
+    @window.setpos(y, x)
+    @window << "  "
+    return
+    @window.delch
+    @window.delch
+    @window.delch
+    @window.addstr
+  end
+
+  # Used to moved in constrainted way among a subset (search matches) of the
+  # larger set
+  def move_to_item(item_index)
+    # move arrow, or change page
+    erase_arrow
+    @current_index = item_index
+    move_arrow_or_page
+  end
+
+  # +set+ is a set of indexes to the original larger set
+  def move_to_next_item_in_set(set)
+    LOGGER.debug("set : #{set}")
+    LOGGER.debug("@current_index : #{@current_index}")
+    current_index = set.index( @current_index )
+    # move arrow, or change page
+    return if current_index == set.length - 1
+    LOGGER.debug("current_index : #{current_index}")
+    new_index = set[current_index + 1]
+    move_to_item(new_index)
+  end
+
+  def move_to_prev_item_in_set(set)
+    current_index = set.index( @current_index )
+    # move arrow, or change page
+    return if current_index == 0
+    new_index = set[current_index - 1]
+    move_to_item(new_index)
+  end
+
+
+  def next_item(multiplier)
+    # move arrow, or change page
+    new_index = @current_index + multiplier 
+    LOGGER.debug("New index is #{new_index}")
+    if new_index >= @items.size
+      new_index = @items.size - 1
+    end
+    erase_arrow
+    @current_index = new_index
+    move_arrow_or_page
+  end
+
+  def prev_item(multiplier)
+    # move arrow, or change page
+    new_index = @current_index - multiplier
+    if new_index < 0
+      new_index = 0
+    end
+    erase_arrow
+    @current_index = new_index
+    move_arrow_or_page
+  end
+
+  def next_page
+    new_index = (@page_index + 1) * @height
+    if new_index >= @items.size
+      new_index = @items.size - 1
+    end
+    erase_arrow
+    @current_index = new_index
+    move_arrow_or_page
+  end
+
+  def prev_page
+    if @page_index == 0
+      top
+      return
+    end
+    new_index = (@page_index - 1) * @height
+    if new_index < 0
+      new_index = 0
+    end
+    erase_arrow
+    @current_index = new_index
+    move_arrow_or_page
+    # need to put cursor at bottom unless this is already 1st page
+    bottom
+  end
+
+  def top
+    erase_arrow
+    @current_index = (@page_index * @height) 
+    move_arrow_or_page
+  end
+
+  def middle
+    new_index = (@page_index + 1) * (@height / 2)
+    # Don't want the cursor positioned in a void when the list is short
+    if new_index >= @items.size
+      new_index = @items.size - 1
+    end
+    erase_arrow
+    @current_index = new_index
+    move_arrow_or_page
+  end
+
+  def bottom
+    new_index = (@page_index + 1) * @height - 1 
+    if new_index >= @items.size
+      new_index = @items.size - 1
+    end
+    erase_arrow
+    @current_index = new_index
+    move_arrow_or_page
+  end
+
+  def end
+    erase_arrow
+    @current_index = 0
+    move_arrow_or_page
+  end
+
+  def beginning
+    erase_arrow
+    @current_index = @items.size - 1
+    move_arrow_or_page
+  end
+
+  def move_arrow_or_page
+    new_page_index = @pager.calculate_page_for_index(@current_index)
+    
+    LOGGER.debug("Current page: #{@page_index}; New Page number: #{new_page_index}")
+    if new_page_index == @page_index
+      LOGGER.debug("Moving arrow")
+      # move arrow
+      draw_arrow
+      @window.refresh
+    else
+      LOGGER.debug("Changing page")
+      # change page
+
+      # TODO  change this implementation
+      @page_index, @page_content = create_page
+
+      redraw_menu
+    end
+  end
+
+  def close
+    @window.clear
+    @window.refresh
+    @window.close
+  end
+end
+