fastreader 1.0.0

data/lib/feeds_controller.rb

@@ -0,0 +1,240 @@
+module FeedsController
+
+  def show_feeds(feeds=[])
+    @all_feeds ||= feeds
+    # So we can redisplay them after exiting a search subset
+    begin 
+
+      @command_window = CommandWindow.new(@scr)
+      @items = @all_feeds
+
+      @scr.refresh # or else the initial screen is blank, I don't know why yet
+
+      @content_area = MenuWindow.new("Your Feeds", @scr, @all_feeds, @current_feed_index || 0)
+      @command_window.help_prompt
+
+      loop do
+        parse_feeds_list_command
+      end
+    end
+  end
+
+  def parse_feeds_list_command
+    c = @scr.getch
+    # store number in buffer, vim style
+    c, buffer = key_buffer(c)
+    multiplier = buffer.empty? ? 1 : buffer.join.to_i
+    LOGGER.debug("Char: #{c}")
+    LOGGER.debug("Multiplier: #{multiplier}")
+
+    case c
+    when ?\? # help
+      show_help(CursesController::FEEDS_MENU_COMMANDS)
+      # Any key restores the menu
+      redraw
+
+    when ?\u # UPDATE FEEDS
+
+      @current_feed = @items[@content_area.current_index]
+      num = @command_window.feed_update_progress(@current_feed)
+     
+      if num > 0
+        @scr.getch
+        redraw
+      end
+
+    when ?\U # UPDATE FEEDS, forcing update even if soon after last update
+
+      @current_feed = @items[@content_area.current_index]
+      num = @command_window.feed_update_progress(@current_feed, true)
+      
+      if num > 0
+        @scr.getch
+        redraw
+      end
+
+    when control_key('U') # UPDATE ALL FEEDS
+
+      num = 0
+      @all_feeds.each do |feed| 
+        num += (@command_window.feed_update_progress(feed) || 0)
+      end
+      @command_window.message("#{num} new items.")
+
+    when ?\d # delete feed
+
+      @current_feed = @items[@content_area.current_index]
+      if @current_feed.is_a?(VirtualFeed)
+        @command_window.command_line = "You can't delete a virtual feed!"
+        @command_window.draw
+        return
+      end
+
+      if @command_window.confirm_delete_feed(@current_feed) == ?\y
+        title = @current_feed.title
+        @current_feed.destroy
+        @command_window.command_line = "The #{title} feed has been deleted"
+
+        @current_index = @content_area.current_index - 1
+        feeds = Feed.feeds_list
+        redraw(feeds)
+      else
+        @command_window.command_line = "Canceled."
+      end
+      @command_window.draw
+
+    when 97 # ?\a # add feed
+
+      if (new_feed = @command_window.add_feed)
+
+        # redraw feeds list
+        feed_list = Feed.feeds_list
+        @current_index = feed_list.index(new_feed)
+        redraw(feed_list)
+      end
+      @command_window.draw
+
+    when ?\q
+      # cancel search
+      # TODO change
+      if @command_window && @command_window.command_line == 'Press q to cancel search.'
+        cancel_search
+      else
+        exit
+      end
+    # SEARCH. This is a global search that generates a virtual feed
+    when ?\/
+
+      @command_window ||= CommandWindow.new( @scr ) 
+
+      @global_search_string = @command_window.get_search_string
+      if @global_search_string == '' || @global_search_string =~ /^\W*$/
+        @command_window.command_line = "Found no matches"
+      end
+
+      matches = search_feeds(@global_search_string.strip)
+      if matches.nil? || matches.empty?
+        @command_window.command_line = "Found no matches"
+      end
+ 
+      if matches
+        # create a virtual feed
+        @items = @current_entries = matches
+
+        @entries_list_matches = nil
+
+        @current_entry_index = 0
+        @content_area.close
+        @content_area = nil
+        show_entries
+
+      else
+        @command_window.draw
+      end
+      
+    when Key::LEFT, Key::UP, ?k, ?p
+      @content_area.prev_item(multiplier)
+    when Key::DOWN, ?j, ?\s, ?n
+      @content_area.next_item(multiplier)
+    when Key::RESIZE
+      redraw(false)
+    when Key::RIGHT, ?l, 10 # Enter key
+
+      # You can type a number and press enter or right arrow to select a feed by
+      # number.
+      unless buffer && buffer.empty? 
+        selection = buffer.join.to_i
+        # set feed
+        @current_feed = @items[selection - 1]
+        @current_feed_index = selection - 1
+        @content_area.current_index = selection - 1
+
+      else
+        @current_feed = @items[@content_area.current_index]
+        @current_feed_index = @content_area.current_index
+      end
+      # set current entry index to 0
+      @current_entry_index = 0
+
+      LOGGER.debug("Selected feed #{@current_feed.title}")
+
+      # Regular Feeds and Virtual Feeds have same interface 
+      @items = @current_entries = @current_feed.is_a?(VirtualFeed) ? @current_feed.entries : 
+        @current_feed.entries.find(:all, :include => :feed)
+
+      # Show the entry content
+
+      @entries_list_matches = nil
+      @current_entry_index = 0
+      @content_area.close
+      @content_area = nil
+      show_entries
+
+    when 'M'[0] # middle of screen
+      @content_area.middle
+    when 'L'[0] # bottom of screen
+      @content_area.bottom
+    when 'H'[0] # top of screen
+      @content_area.top
+    when 'G'[0] # beginning or end of list
+      if buffer.last == 1
+        @content_area.end
+      else
+        @content_area.beginning
+      end
+    when control_key('F')
+      @content_area.next_page
+    when control_key('B')
+      @content_area.prev_page
+    else
+      # don't do anything
+    end
+  end
+
+  # This reloads the feeds (if items are provided) and redraws the content window
+  def redraw(new_items =nil)
+    @items = new_items ? (@all_feeds = new_items) : @content_area.items 
+    unless new_items
+      @current_index = @content_area.current_index 
+    end
+    @content_area.close
+    @content_area = MenuWindow.new("Your Feeds", @scr, @items, @current_index)
+  end
+
+  # This is a global search of all feed entries 
+  def search_feeds(global_search_string)
+    if global_search_string == ''
+      @command_window.clear
+      return
+    end
+    
+    # maybe change this to ferret or something later
+    # TODO
+    LOGGER.debug("search query: title LIKE '%#{global_search_string}%' or content LIKE '%#{global_search_string}%'")
+    matches = Entry.find(:all,
+                         :include => :feed,
+                        :conditions => "title LIKE '%#{global_search_string}%'",
+                         :order => "id desc")
+
+    # We give priority to title matches
+    matches.concat Entry.find(:all, 
+                             :include => :feed,
+                               :conditions => "content LIKE '%#{global_search_string}%'",
+                               :order => "id desc")
+    # There might very well be duplicates, so compress
+    matches.uniq!
+    if matches.empty?
+      @command_window.command_line = "Found no matches for search string '#{global_search_string}'"
+      @command_window.draw
+      nil
+    else
+      @command_window.command_line = "Found #{matches.size} entries for search string '#{global_search_string}'. Displaying..." 
+      @command_window.draw
+      sleep 1
+
+      matches
+    end
+  end
+
+end
+

data/lib/htmlentities.rb

@@ -0,0 +1,165 @@
+require 'htmlentities/legacy'
+
+#
+# HTML entity encoding and decoding for Ruby
+#
+
+class HTMLEntities
+
+  VERSION = '4.0.0'
+  FLAVORS = %w[html4 xhtml1]
+  INSTRUCTIONS = [:basic, :named, :decimal, :hexadecimal]
+
+  class InstructionError < RuntimeError
+  end
+  class UnknownFlavor < RuntimeError
+  end
+
+  #
+  # Create a new HTMLEntities coder for the specified flavor.
+  # Available flavors are 'html4' and 'xhtml1' (the default).
+  # The only difference in functionality between the two is in the handling of the apos
+  # (apostrophe) named entity, which is not defined in HTML4.
+  #
+  def initialize(flavor='xhtml1')
+    @flavor = flavor.to_s.downcase
+    raise UnknownFlavor, "Unknown flavor #{flavor}" unless FLAVORS.include?(@flavor)
+  end
+
+  #
+  # Decode entities in a string into their UTF-8
+  # equivalents.  Obviously, if your string is not already in UTF-8, you'd
+  # better convert it before using this method, or the output will be mixed
+  # up.
+  #
+  # Unknown named entities will not be converted
+  #
+  def decode(source)
+    return source.to_s.gsub(named_entity_regexp) {
+      (cp = map[$1]) ? [cp].pack('U') : $&
+    }.gsub(/&#([0-9]{1,7});|&#x([0-9a-f]{1,6});/i) {
+      $1 ? [$1.to_i].pack('U') : [$2.to_i(16)].pack('U')
+    }
+  end
+
+  #
+  # Encode codepoints into their corresponding entities.  Various operations
+  # are possible, and may be specified in order:
+  #
+  # :basic :: Convert the five XML entities ('"<>&)
+  # :named :: Convert non-ASCII characters to their named HTML 4.01 equivalent
+  # :decimal :: Convert non-ASCII characters to decimal entities (e.g. &#1234;)
+  # :hexadecimal :: Convert non-ASCII characters to hexadecimal entities (e.g. # &#x12ab;)
+  #
+  # You can specify the commands in any order, but they will be executed in
+  # the order listed above to ensure that entity ampersands are not
+  # clobbered and that named entities are replaced before numeric ones.
+  #
+  # If no instructions are specified, :basic will be used.
+  #
+  # Examples:
+  #   encode_entities(str) - XML-safe
+  #   encode_entities(str, :basic, :decimal) - XML-safe and 7-bit clean
+  #   encode_entities(str, :basic, :named, :decimal) - 7-bit clean, with all
+  #   non-ASCII characters replaced with their named entity where possible, and
+  #   decimal equivalents otherwise.
+  #
+  # Note: It is the program's responsibility to ensure that the source
+  # contains valid UTF-8 before calling this method.
+  #
+  def encode(source, *instructions)
+    string = source.to_s.dup
+    if (instructions.empty?)
+      instructions = [:basic]
+    elsif (unknown_instructions = instructions - INSTRUCTIONS) != []
+      raise InstructionError,
+      "unknown encode_entities command(s): #{unknown_instructions.inspect}"
+    end
+    
+    basic_entity_encoder =
+    if instructions.include?(:basic) || instructions.include?(:named)
+      :encode_named
+    elsif instructions.include?(:decimal)
+      :encode_decimal
+    else instructions.include?(:hexadecimal)
+      :encode_hexadecimal
+    end
+    string.gsub!(basic_entity_regexp){ __send__(basic_entity_encoder, $&) }
+    
+    extended_entity_encoders = []
+    if instructions.include?(:named)
+      extended_entity_encoders << :encode_named
+    end
+    if instructions.include?(:decimal)
+      extended_entity_encoders << :encode_decimal
+    elsif instructions.include?(:hexadecimal)
+      extended_entity_encoders << :encode_hexadecimal
+    end
+    unless extended_entity_encoders.empty?
+      string.gsub!(extended_entity_regexp){
+        encode_extended(extended_entity_encoders, $&)
+      }
+    end
+    
+    return string
+  end
+
+private
+
+  def map
+    @map ||= (require "htmlentities/#{@flavor}"; HTMLEntities::MAPPINGS[@flavor])
+  end
+
+  def basic_entity_regexp
+    @basic_entity_regexp ||= (
+      case @flavor
+      when /^html/
+        /[<>"&]/
+      else
+        /[<>'"&]/
+      end
+    )
+  end
+  
+  def extended_entity_regexp
+    @extended_entity_regexp ||= (
+      regexp = '[\x00-\x1f]|[\xc0-\xfd][\x80-\xbf]+'
+      regexp += "|'" if @flavor == 'html4'
+      Regexp.new(regexp)
+    )
+  end
+
+  def named_entity_regexp
+    @named_entity_regexp ||= (
+      min_length = map.keys.map{ |a| a.length }.min
+      max_length = map.keys.map{ |a| a.length }.max
+      /&([a-z][a-z0-9]{#{min_length-1},#{max_length-1}});/i
+    )
+  end
+
+  def reverse_map
+    @reverse_map ||= map.invert
+  end
+
+  def encode_named(char)
+    cp = char.unpack('U')[0]
+    (e = reverse_map[cp]) && "&#{e};"
+  end
+
+  def encode_decimal(char)
+    "&##{char.unpack('U')[0]};"
+  end
+
+  def encode_hexadecimal(char)
+    "&#x#{char.unpack('U')[0].to_s(16)};"
+  end
+  
+  def encode_extended(encoders, char)
+    encoders.each do |encoder|
+      encoded = __send__(encoder, char)
+      return encoded if encoded
+    end
+    return char
+  end
+
+end

data/lib/htmlentities/html4.rb

@@ -0,0 +1,257 @@
+class HTMLEntities
+  MAPPINGS = {} unless defined? MAPPINGS
+  MAPPINGS['html4'] = {
+    '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,
+    '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