quora_notify 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2e83b718291fe349330076b9e419979994700fc
+  data.tar.gz: ce758c4e070950ce22d476fe8528832b547eb685
+SHA512:
+  metadata.gz: b07cbb3b8a2a6a80c15cd1c0d3489b3ecf574b95cdc66a2aac699f4ecf046c912015fbe8dfe1649bba73392eb895312beb6613f7bfd2e3a161254de640e04491
+  data.tar.gz: 9bff482d70fd30f821cfb0f0e3396bce26d09cfe8027eb630048469b93d913db9ad1afa281785b4d83bce31475d813f92c0a1d69fcc7be9b1e42fce326d38b2e

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ..gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    quora_notify (0.0.6)
+      htmlentities
+      sqlite3
+      terminal-notifier
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    htmlentities (4.3.1)
+    metaclass (0.0.1)
+    mocha (0.13.3)
+      metaclass (~> 0.0.1)
+    sqlite3 (1.3.7)
+    terminal-notifier (1.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  quora_notify!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joey Carmello
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# QuoraNotify
+
+Receive quora.com notifications in Notification Center on OSX Mountain Lion.
+
+## Installation
+
+Install a launchAgent to poll Quora for notifications
+
+    $ gem install quora_notify
+    
+    $ quora_notify --install
+
+
+Uninstall with:
+
+    $ quora_notify --uninstall
+
+### Or use it as a library in your ruby project:
+
+Add this line to your application's Gemfile:
+
+    gem 'quora_notify'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quora_notify
+
+## Usage
+
+Fetch notifications and send them to Notification Center:
+
+    QuoraNotify.run!
+
+
+List the current Quora notifications:
+  
+    QuoraNotify::Notification.list
+
+Clear the current Quora notifications:
+  
+    QuoraNotify::Notification.clear!
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+require "bundler/gem_tasks"
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run all tests"
+task :default => :test

data/bin/quora_notify

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'quora_notify'
+rescue LoadError
+  require 'rubygems'
+  require 'quora_notify'
+end
+
+require 'optparse'
+
+command = nil
+
+op = OptionParser.new do |opts|
+  opts.program_name = __FILE__
+  opts.banner = "Use Quora API notifications in Notification Center."
+  opts.on("-h", "--help") { command = :help }
+  opts.on("-i", "--install", "Installs the LaunchAgent") { command = :install }
+  opts.on("-u", "--uninstall", "Uninstalls the LaunchAgent") { command = :uninstall }
+  opts.on("-r", "--run", "Run once") { command = :run }
+end
+
+op.parse!
+
+case command
+when :install
+  QuoraNotify::Install.run!
+when :uninstall
+  QuoraNotify::Install.uninstall!
+when :run
+  QuoraNotify.run!
+when :help 
+  puts op
+end

data/lib/quora_notify/base.rb

@@ -0,0 +1,63 @@
+require 'time'
+require 'json'
+require 'terminal-notifier'
+
+module QuoraNotify
+
+  API_NOTIFICATION_PATH = 'http://api.quora.com/api/logged_in_user?fields=notifs'
+  TMP_COOKIE_PATH = '/tmp/quora_notifier'
+
+  class << self
+    def quora_notifications
+      cookies = quora_cookies_for_browser(:default)
+      write_cookies_to_file(cookies, TMP_COOKIE_PATH)
+      
+      notification_response = `curl #{API_NOTIFICATION_PATH} -b #{TMP_COOKIE_PATH}`.sub('while(1);', '')
+      JSON.parse(notification_response)
+    end
+
+    def run!
+      notifications = begin
+                        quora_notifications
+                      rescue JSON::ParserError
+                        []
+                      end
+      process notifications
+    end
+
+    private
+
+      def process(notifications)
+        return [] if notifications.empty? || notifications['notifs']['unseen_count'] == 0
+
+        existing_notifs = Notification.list.map{ |n| n[:group] }
+        quora_notifs = notifications['notifs']['unseen'].map{ |notif| Notification.new(notif) }
+        (quora_notifs - existing_notifs).each { |notification| notification.notify }
+      end
+    
+      def write_cookies_to_file(cookies, file)
+        File.open(file, 'w') do |file|
+          cookies.each do |cookie|
+            # TODO: could be in to_s for cookie object
+            file.puts "#{cookie.domain}\tTRUE\t#{cookie.path}\tFALSE\t#{cookie.expires}\t#{cookie.name}\t#{cookie.value}"
+          end
+        end
+      end
+
+      def quora_cookies_for_browser(browser)
+        readers = [ 
+          CookieReaders::ChromeCookieReader.new, 
+          CookieReaders::SafariCookieReader.new
+        ]
+
+        readers.collect do |reader|
+          begin
+            reader.read_cookies
+          rescue => e
+            []
+          end
+        end.flatten.uniq.select { |cookie| cookie.domain == '.quora.com' }
+      end
+  end
+end
+

data/lib/quora_notify/cookie_readers/chrome_cookie_reader.rb

@@ -0,0 +1,56 @@
+require 'sqlite3'
+require 'quora_notify/cookie_readers/cookie'
+
+class ChromeCookieReaderException < StandardError; end
+
+class QuoraNotify::CookieReaders::ChromeCookieReader
+
+  DEFAULT_CHROME_COOKIE_PATH = "#{ENV['HOME']}/Library/Application Support/Google/Chrome/Default/Cookies"
+
+  # Accepts:
+  #   cookie_file_path: Use default cookie file if nil (default)
+  def initialize(file_path = nil)
+    @cookie_file_path = file_path
+  end
+
+  # Returns an array of Cookie objects
+  # Raises: binarycookieReaderException
+  def read_cookies
+    raise ChromeCookieReaderException 'No cookie file found' unless File.exists?(cookie_file_path)
+
+    cookies = []
+    db = SQLite3::Database.new(cookie_file_path)
+    db.execute('SELECT name, value, host_key, path, secure, httponly, expires_utc, creation_utc FROM cookies') do |row|
+      cookies << cookie_for_row(row)
+    end
+
+    cookies
+  end
+
+  private
+
+    def cookie_for_row(row)
+#      CREATE TABLE cookies (creation_utc INTEGER NOT NULL UNIQUE PRIMARY KEY,host_key TEXT NOT NULL,name TEXT NOT NULL,value TEXT NOT NULL,path TEXT NOT NULL,expires_utc INTEGER N      OT NULL,secure INTEGER NOT NULL,httponly INTEGER NOT NULL,last_access_utc INTEGER NOT NULL, has_expires INTEGER NOT NULL DEFAULT 1, persistent INTEGER NOT NULL DEFAULT 1);
+      name = row[0]
+      value = row[1]
+      domain = row[2]
+      path = row[3]
+      flag = flag(row[4], row[5])
+      expires = row[6]
+      created = row[7]
+
+      QuoraNotify::CookieReaders::Cookie.new(name: name, value: value, domain: domain, path: path, flag: flag, expires: expires, created: created)
+    end
+
+    def flag(secure, httponly)
+      return 'Secure: HttpOnly' if secure == 1 && httponly == 1
+      return 'Secure' if secure == 1
+      return 'HttpOnly' if httponly == 1
+      'Unknown'
+    end
+
+    # Defaults to the standard safari cookie system path
+    def cookie_file_path
+      @cookie_file_path || DEFAULT_CHROME_COOKIE_PATH
+    end
+end

data/lib/quora_notify/cookie_readers/cookie.rb

@@ -0,0 +1,14 @@
+
+class QuoraNotify::CookieReaders::Cookie
+  attr_reader :name, :value, :domain, :path, :flag, :expires, :created
+
+  def initialize(opts = {})
+    @name    = opts[:name]
+    @value   = opts[:value]
+    @domain  = opts[:domain]
+    @path    = opts[:path]
+    @flag    = opts[:flag]
+    @expires = opts[:expires]
+    @created = opts[:created]
+  end
+end

data/lib/quora_notify/cookie_readers/safari_cookie_reader.rb

@@ -0,0 +1,107 @@
+
+require 'stringio'
+require 'quora_notify/cookie_readers/cookie'
+
+class SfariCookieReaderException < StandardError; end
+
+class QuoraNotify::CookieReaders::SafariCookieReader
+
+  class CookieIO < StringIO
+    def next
+      self.read(4)
+    end
+
+    def next_as_int
+      self.next.unpack('l<')[0]
+    end
+
+    def read_as_flag
+      case self.next_as_int
+        when 0; ''
+        when 1; 'Secure'
+        when 4; 'HttpOnly'
+        when 5; 'Secure: HttpOnly'
+        else; 'Unknown'
+      end
+    end
+
+    def read_as_date
+      epoch = self.read(8).unpack('E')[0] + 978307200
+      Time.at(epoch).strftime('%a, %d %b %Y')
+    end
+  end
+
+  DEFAULT_SAFARI_COOKIE_PATH = "#{ENV['HOME']}/Library/Cookies/Cookies.binarycookies"
+
+  # Accepts:
+  #   cookie_file_path: Use default cookie file if nil (default)
+  def initialize(file_path = nil)
+    @cookie_file_path = file_path
+  end
+
+  # Returns an array of Cookie objects
+  # Raises: binarycookieReaderException
+  def read_cookies
+    raise SafariCookieReaderException 'No cookie file found' unless File.exists?(cookie_file_path)
+
+    File.open(cookie_file_path, 'rb') do |cookie_file|
+      process_file cookie_file
+    end
+  end
+
+  def process_file(cookie_file)
+    header = cookie_file.read(4)
+    raise SafariCookieReaderException 'Not recognized as a binarycookie file' unless header == 'cook'
+
+    n_pages = cookie_file.read(4).unpack('l>')[0]
+    sizes = (0..n_pages - 1).collect { |page| cookie_file.read(4).unpack('l>')[0] }
+    pages = sizes.collect { |size| cookie_file.read(size) }
+
+    cookie_groups = pages.collect do |page|
+      page = CookieIO.new(page); page.next
+
+      n_items = page.next_as_int
+      cookie_offsets = (0..n_items - 1).collect { |item| page.next_as_int }
+
+      page.next
+
+      cookie_offsets.collect do |offset| 
+        page.seek(offset)                                               # Move to the start of the next page of cookies
+        cookie_for_data CookieIO.new(page.read(page.next_as_int))       # Pulls each cookie out of the page
+      end
+    end
+
+    cookie_groups.flatten
+  end
+
+  def cookie_for_data(cookie)
+    cookie.next; flag = cookie.read_as_flag; cookie.next
+
+    domain_off, name_off, path_off, value_off = 4.times.map { cookie.next_as_int }
+
+    cookie.next; cookie.next
+
+    expires, created = 2.times.map { cookie.read_as_date }
+
+    domain, name, path, value = [domain_off, name_off, path_off, value_off].collect do |offset|
+      cookie.seek(offset - 4)
+
+      data = ''
+      while char = cookie.read(1)
+        new_data = char.unpack('c')[0]
+        break if new_data == 0
+        data << new_data
+      end
+
+      data
+    end
+
+    QuoraNotify::CookieReaders::Cookie.new(name: name, value: value, domain: domain, path: path, flag: flag, expires: expires, created: created)
+  end
+
+  # Defaults to the standard safari cookie system path
+  def cookie_file_path
+    @cookie_file_path || DEFAULT_SAFARI_COOKIE_PATH
+  end
+
+end

data/lib/quora_notify/cookie_readers.rb

@@ -0,0 +1,5 @@
+module QuoraNotify::CookieReaders
+end
+
+require 'quora_notify/cookie_readers/safari_cookie_reader'
+require 'quora_notify/cookie_readers/chrome_cookie_reader'

data/lib/quora_notify/install.rb

@@ -0,0 +1,49 @@
+require "fileutils"
+require 'erb'
+
+class QuoraNotify::Install
+
+  INSTALL_PATH = File.join(ENV["HOME"], "Library", "LaunchAgents")
+  LAUNCHD_PROCESS_NAME = "com.joeycarmello.quora_notify"
+  LAUNCHD_FILE_NAME = "#{LAUNCHD_PROCESS_NAME}.plist"
+  LAUNCHD_FILE_PATH = File.join("lib", "quora_notify", "config", LAUNCHD_FILE_NAME)
+
+  class << self
+    def run!
+      uninstall!
+      gem_path = ENV['GEM_HOME']
+      ruby_path = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
+      bin_path = `which quora_notify`.chomp
+      template = ERB.new File.read(erb_path)
+      File.write(install_file_path, template.result(binding))
+      start
+    end
+
+    def uninstall!
+      if File.exists?(install_file_path)
+        stop
+        File.delete install_file_path 
+      end
+    end
+
+    private
+
+      def stop
+        system %Q[launchctl stop #{LAUNCHD_PROCESS_NAME}]
+        system %Q[launchctl unload #{install_file_path}]
+      end
+
+      def start
+        system %Q[launchctl load #{install_file_path}]
+        system %Q[launchctl start #{LAUNCHD_PROCESS_NAME}]
+      end
+
+      def erb_path
+        "#{LAUNCHD_FILE_PATH}.erb"
+      end
+    
+      def install_file_path
+        File.join(INSTALL_PATH, LAUNCHD_FILE_NAME)
+      end
+  end
+end

data/lib/quora_notify/notification.rb

@@ -0,0 +1,51 @@
+require 'htmlentities'
+
+class QuoraNotify::Notification
+
+  NOTIFICATION_GROUP = 'com.joeycarmello.quora_notify'
+  NOTIFICATION_TITLE = 'New Notification'
+
+  class << self
+    def list
+      notifs = TerminalNotifier.list('ALL') || []
+      notifs.select { |n| n[:group] =~ /^#{NOTIFICATION_GROUP}/ }
+    end
+
+    def clear!
+      list.each { |notif| TerminalNotifier.remove(notif[:group]) }
+      list.size
+    end
+
+    def cleanse_text(text)
+      coder = HTMLEntities.new
+      coder.decode text.gsub(/<.*?>/, '')
+    end
+  end
+
+  attr_reader :text, :links
+
+  def id
+    "#{NOTIFICATION_GROUP} - #{@text}"
+  end
+
+  # Allows for fun things like [a, b] - [a] = [b]
+  def hash
+    self.id.hash
+  end
+
+  def initialize(notif)
+    @text = self.class.cleanse_text(notif)
+    @links = notif.scan(/href="(.*?)"/).flatten
+  end
+
+  def notify
+    TerminalNotifier.notify(@text, title: NOTIFICATION_TITLE, open: @links.last, group: self.id)
+  end
+
+  def ==(other)
+    other.kind_of?(QuoraNotify::Notification) ? id == other.id : other == id
+  end
+
+  alias :eql? :==
+end
+

data/lib/quora_notify/version.rb

@@ -0,0 +1,3 @@
+module QuoraNotify
+  VERSION = '0.0.7'
+end

data/lib/quora_notify.rb

@@ -0,0 +1,5 @@
+require 'quora_notify/base'
+require 'quora_notify/install'
+require 'quora_notify/cookie_readers'
+require 'quora_notify/notification'
+

data/test/test_quora_notify.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'quora_notify'
+
+class QuoraNotifyTest < Test::Unit::TestCase
+  def test_can_parse_quora_api_response
+    assert_nothing_raised do
+      notifications = QuoraNotify.quora_notifications
+      assert_not_nil notifications['notifs']['unseen_count'], 'Cannot access notifications from response'
+    end
+  end
+
+  def test_run_will_add_notifications_to_notification_center
+    QuoraNotify::Notification.clear!  # start empty
+    fill_with_mocks
+    # list real local notifs
+    notifications = QuoraNotify::Notification.list
+    assert_equal mock_notifications['notifs']['unseen_count'], notifications.size
+  end
+
+  def test_run_will_not_repeat_existing_notifications
+    QuoraNotify::Notification.clear!  # start empty
+    existing_notifs = fill_with_mocks # add some notifications
+    new_notifs = fill_with_mocks      # add the same ones again
+    assert_equal 0, new_notifs.size
+    assert_equal existing_notifs.size + new_notifs.size, QuoraNotify::Notification.list.size
+  end
+
+  def test_clear_will_remove_all_notifications_from_notification_center
+    fill_with_mocks
+    QuoraNotify::Notification.clear!
+    assert_equal 0, QuoraNotify::Notification.list.size
+  end
+
+  def test_run_will_process_if_notifications_are_present
+    QuoraNotify.expects(:process).once
+    fill_with_mocks
+  end
+
+  private
+
+    def fill_with_mocks
+      # create some notifications
+      QuoraNotify.expects(:quora_notifications).returns(mock_notifications)
+      # go fetch for the fake ones, creating real local notifs
+      QuoraNotify.run!
+    end
+
+    def mock_notifications
+      {
+        'notifs' => {
+          'unseen_count' => 2,
+          'unseen' => [
+            '<a href="http://quora.com">Some text</a>',
+            '<a href="http://quora.com">Some text 2</a>'
+          ]
+        }
+      }
+    end
+
+    def mock_empty_notifications
+      {
+        'notifs' => {
+          'unseen_count' => 0,
+          'unseen' => []
+        }
+      }
+    end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: quora_notify
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- Joey Carmello
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      QuoraNotify provides basic access to one of the few API's Quora.com has opened to the public.
+      It uses local quora cookies to access this API as a logged-in user.
+
+      See https://www.quora.com/Edmond-Lau/Edmond-Laus-Posts/Quora-Extension-API for more information about this Alpha API.
+email: joeycarmello@me.com
+executables:
+- quora_notify
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/quora_notify/base.rb
+- lib/quora_notify/cookie_readers/chrome_cookie_reader.rb
+- lib/quora_notify/cookie_readers/cookie.rb
+- lib/quora_notify/cookie_readers/safari_cookie_reader.rb
+- lib/quora_notify/cookie_readers.rb
+- lib/quora_notify/install.rb
+- lib/quora_notify/notification.rb
+- lib/quora_notify/version.rb
+- lib/quora_notify.rb
+- bin/quora_notify
+- test/test_quora_notify.rb
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- Rakefile
+- README.md
+homepage: http://github.com/joeycarmello/QuoraNotifier
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Displays Quora notifications in OSX Mountain Lion's Notification Center
+test_files: []