hubdate 0.0.01

data/bin/hubdate

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'hubdate.rb'))
+
+options = {}
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: rd COMMAND [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Commands"
+  opt.separator  "     init: initialize a new rudoo file architecture"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-u", "--username USERNAME", "username of the github account you would like to monitor") do |username|
+    options[:username] = username
+  end
+
+  opt.on("-p", "--password PASSWORD", "password for the github account you would like to monitor") do |password|
+    options[:password] = password
+  end
+
+  opt.on("-t", "--time TIME", "time you would like to wait between polls (Minimum of 70s)") do |time|
+    options[:time] = time
+  end
+end
+
+opt_parser.parse!
+
+username = options[:username] || nil
+password = options[:password] || nil
+time = options[:time] || 70
+
+if username.nil?
+  puts "A username must be specified!"
+elsif password.nil?
+  puts "A password must be specified!"
+else
+  begin
+    run(username, password, time.to_i)
+  rescue
+    puts "Invalid credentials!"
+  end
+end
+
+

data/hubdate.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tommy Schaefer"]
+  gem.email         = ["me@tommyschaefer.net"]
+  gem.description   = %q{A ruby program that polls github for updates and sends them to notification center.}
+  gem.summary       = %q{Hubdate is a console executed program that polls github for updates (notifications, stars, and watchers). Any new updates will be sent to notification center.}
+  gem.homepage      = "https://github.com/tommyschaefer/hubdate"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "hubdate"
+  gem.version       = Hubdate::VERSION
+  gem.add_dependency "terminal-notifier"
+end

data/lib/.rudoo/config.yml

@@ -0,0 +1,4 @@
+---
+:person_token: ! '@'
+:tag_token: ^
+:project_token: ! '*'

data/lib/.rudoo/list.yml

@@ -0,0 +1,14 @@
+---
+!binary "MDQxMDIz": !ruby/object:Rudoo::Task
+  todo: Upload initial commit
+  priority: 0
+!binary "ODgxNDMw": !ruby/object:Rudoo::Task
+  todo: Add executable
+  priority: 0
+!binary "MWRhMzM0": !ruby/object:Rudoo::Task
+  todo: Fix bug that occurs when creating files for the first time and move execution
+    into executable :done
+  priority: 0
+!binary "NmJmODEx": !ruby/object:Rudoo::Task
+  todo: Gemify program :wkng
+  priority: 0

data/lib/hubdate.rb

@@ -0,0 +1,36 @@
+require "rubygems"
+require "terminal-notifier"
+
+require 'json'
+require 'yaml'
+require 'net/http'
+require 'net/https'
+require 'fileutils'
+
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "base"))
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "user"))
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "repository"))
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "notification"))
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "connection"))
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "storage"))
+require File.expand_path(File.join(File.dirname(__FILE__), "hubdate", "checker"))
+
+def run(user, password, time)
+  if !Storage.dir_initialized?(File.join(Dir.home, ".hubdate"))
+    Storage.generate_files
+  else
+    Storage.generate_follow if !Storage.file_initialized?(File.join(Dir.home, ".hubdate", "followers.yaml"))
+    Storage.generate_star if !Storage.file_initialized?(File.join(Dir.home, ".hubdate", "stargazers.yaml"))
+    Storage.generate_watch if !Storage.file_initialized?(File.join(Dir.home, ".hubdate", "watchers.yaml"))
+  end
+
+  connection = Github::Connection.new({:user => user, :pass => password})
+
+  loop do
+    Checker.check_notifications(connection)
+    Checker.check_followers(connection)
+    Checker.check_watchers(:stargazer, connection)
+    Checker.check_watchers(:watcher, connection)
+    sleep time
+  end
+end

data/lib/hubdate/base.rb

@@ -0,0 +1,20 @@
+class Github
+  module Base
+    attr_reader :response, :connection
+
+    # Initialize module by gathering JSON hash and connection
+    def initialize(responseHash, conn = Github::Connection.new)
+      @connection = conn
+      @response = responseHash
+    end
+
+    # If method doesnt exist, check if the id is a response key and if so return the value
+    def method_missing(id, *args)
+      unless @response && @response.keys.include?(id.id2name)
+        raise NoMethodError.new("Undefined method #{id.id2name} for #{self}: #{self.class}.")
+      end
+
+      @response[id.id2name]
+    end
+  end
+end

data/lib/hubdate/checker.rb

@@ -0,0 +1,78 @@
+class Checker
+  def self.check_notifications(connection)
+    notifications = Github::User.fetch(connection).notifications.reverse
+
+    notifications.each do |notif|
+      TerminalNotifier.notify("#{notif.message}", :title => "#{notif.reason[0] = notif.reason[0].capitalize; notif.reason}: #{notif.type}")
+    end
+  end
+
+  def self.check_watchers(type, connection)
+    watchers_file = File.join(Dir.home, ".hubdate", "stargazers.yaml") if type == :stargazer
+    watchers_file = File.join(Dir.home, ".hubdate", "watchers.yaml") if type == :watcher
+
+    watchers = Github::User.fetch(connection).watchers(type)
+
+    begin
+      file_watchers = YAML.load_file(watchers_file)
+    rescue
+      Storage.write_file(watchers, watchers_file)
+    end
+
+    if file_watchers != watchers 
+      new_gazers = {}
+
+      watchers.each do |repo, gazers|
+        begin
+          added = (gazers - file_watchers[repo])
+        rescue
+          added = []
+        end
+
+        new_gazers[repo] = added
+      end
+
+      new_gazers.each do |repo, logins|
+        if logins != []
+          case type
+          when :stargazer
+            action = "Starred"
+            message_action = "starred"
+          when :watcher
+            action = "Now Being Watched"
+            message_action = "now watching"
+          end
+          TerminalNotifier.notify("", :title => "Repository #{action}!", :subtitle => "#{logins.join(", ")} #{message_action} your repository \"#{repo}\"!")
+        end
+      end
+
+      Storage.write_file(watchers, watchers_file)
+    end
+  end
+
+  def self.check_followers(connection)
+    followers_file = File.join(Dir.home, ".hubdate", "followers.yaml")
+    
+    followers = Github::User.fetch(connection).followers.map {|follower| follower.login}
+
+    begin
+      file_followers = YAML.load_file(followers_file)
+    rescue
+      Storage.write_file(followers, followers_file)
+    end
+
+    if file_followers != followers 
+      begin
+        added = (followers - file_followers)
+      rescue
+        added = []
+      end
+      
+      added.each do |login|
+        TerminalNotifier.notify("", :title => 'New Follower!', :subtitle => "#{login} is now following you!")
+      end
+
+      Storage.write_file(followers, followers_file)
+    end
+  end
+end

data/lib/hubdate/connection.rb

@@ -0,0 +1,96 @@
+class Github
+  class Connection
+    attr_accessor :user # Allows us to call for the connections user later
+    attr_reader :pass, :token
+   
+    # Check for argument errors and format credentials
+    def initialize(args={})
+      raise ArgumentError.new("Github::Connection does not take any arguments of type #{args.class}.") unless args.is_a?(Hash)
+      
+      args.keys.each do |key|
+        raise ArgumentError.new("Unknown option '#{key}'.") unless [:user, :pass, :token].include? key
+      end
+
+      if args.keys.include?(:user) || args.keys.include?(:pass)
+        unless args.keys.include?(:user) && args.keys.include?(:pass)
+          raise ArgumentError.new("When using basic authentication, both :user and :pass are required.")
+        end
+      end
+
+      if args.keys.include?(:token)
+        if args.keys.include?(:user) || args.keys.include?(:pass)
+          raise ArgumentError.new("Both OAuth parameters and basic authenctication parameters have been previded.")
+        end
+      end
+
+      @user = args[:user]
+      @pass = args[:pass]
+      @token = args[:token]
+
+      @server = "api.github.com"
+
+      if !@token.nil?
+        @creds = {:token => @token}
+      elsif !@user.nil?
+        @creds = {:user => @user, :pass => @pass}
+      elsif @token.nil? && @user.nil?
+        @creds = {}
+      end
+    end
+
+    # Check is user is authenticated
+    def authenticated?
+      if (user && pass) || token
+        true
+      else
+        false
+      end
+    end
+    
+    # Send HTTP Get request
+    def get(path, params = {}, creds = @creds, server = @server)
+      path = linkPath(path, params) if params != {}
+      path = linkPath(path, params, creds[:token]) if params != {} && creds.keys.include?(:token)
+
+      http = Net::HTTP.new(server, 443)
+      req = Net::HTTP::Get.new(path)
+      http.use_ssl = true
+      req.basic_auth creds[:user], creds[:pass] if creds.keys.include?(:user)
+      response = http.request(req)
+      return JSON.parse(response.body)
+    end
+
+    def post(path, params={}, creds = @creds, server = @server)
+      path = linkPath(path, params, creds[:token]) if params != {} && creds.keys.include?(:token)
+      
+      http = Net::HTTP.new(server, 443)
+      req = Net::HTTP::Post.new(path)
+      http.use_ssl = true
+      req.body = params.to_json
+      req.basic_auth creds[:user], creds[:pass] if creds.keys.include?(:user)
+      response = http.request(req)
+      return JSON.parse(response.body)
+    end
+
+    def edit
+    end
+
+    def delete
+    end
+
+    private
+
+      # Method used to link multiple parameters with a base path
+    def linkPath(path, params, token = nil)
+      param1 = params.shift
+      paramString = "?#{param1[0].to_s}=#{param1[1]}"
+
+      params.each do |name, value|
+        paramString += "&&#{name.to_s}=#{value}"
+      end
+
+      paramString += "&&#{token}" unless token.nil?
+      paramString = path + paramString
+    end
+  end
+end

data/lib/hubdate/notification.rb

@@ -0,0 +1,33 @@
+class Github
+  class Notification
+    include Github::Base
+
+    # Generate JSON hash and create new Github::Repository object through Github::Base
+    def self.fetch(conn = Github::Connection.new)
+      raise ArgumentError.new("You must be authenticated to retrieve this information!") if !connection.authenticated?
+
+      responseHash = conn.get("/notifications")
+      new(responseHash, conn)
+    end
+
+    def message
+      subject["title"]
+    end
+
+    def type
+      subject["type"]
+    end
+
+    # Do some argument checking and then return an array of repository objects
+    def self.list(params = {}, conn = Github::Connection.new)
+      conn = params if params.class == Github::Connection
+      params = {} if params.class == Github::Connection
+
+      notifications = conn.get("/notifications", params)
+
+      notifications.map do |notification|
+        new(notification, conn)
+      end
+    end
+  end
+end

data/lib/hubdate/repository.rb

@@ -0,0 +1,35 @@
+class Github
+  class Repository
+    include Github::Base
+
+    # Generate JSON hash and create new Github::Repository object through Github::Base
+    def self.fetch(user, name, conn = Github::Connection.new)
+      raise ArgumentError.new("Username must be provided. Call user.repo(*) for an authenticated user's repository.") if user.nil?
+      raise ArgumentError.new("Repository name must be provided.") if name.nil?
+
+      responseHash = conn.get("/repos/#{user}/#{name}")
+      new(responseHash, conn)
+    end
+
+    # Do some argument checking and then return an array of repository objects
+    def self.list(login, account_type, params = {}, conn = Github::Connection.new)
+      conn = params if params.class == Github::Connection
+      params = {} if params.class == Github::Connection
+
+      case account_type
+      when "User"
+        baseUrl = "users"
+      when "Organization"
+        baseUrl = "orgs"
+      else
+        raise ArgumentError.new("Unknown account type: #{account_type}.")
+      end
+
+      repositories = conn.get("/#{baseUrl}/#{login}/repos", params)
+
+      repositories.map do |repo|
+        new(repo, conn)
+      end
+    end
+  end
+end

data/lib/hubdate/storage.rb

@@ -0,0 +1,61 @@
+class Storage
+  def self.write_file(contents, destination)
+    File.open(destination, "w") do |file|
+      file << contents.to_yaml
+    end
+  end
+
+  def self.clear_files(dir)
+    raise StandardError.new("Unable to delete folder.") unless FileUtils.rm_rf(dir)
+  end
+
+  def self.make_file(dir, file)
+    f = File.new(File.join(dir, file), "w+")
+
+    raise StandardError.new("Unable to make file.") unless f
+
+    f.close
+  end
+
+  def self.make_folder(dir)
+    folder = FileUtils.mkdir(dir)
+
+    raise StandardError.new("Unable to create directory.") unless folder
+  end
+
+  def self.dir_initialized?(dir)
+    if File.directory?(dir)
+      return true
+    else
+      return false
+    end
+  end  
+
+  def self.file_initialized?(file)
+    if File.exists?(file)
+      return true
+    else
+      return false
+    end
+  end  
+
+  def self.generate_follow
+    Storage.make_file(File.join(Dir.home, ".hubdate") , "followers.yaml")
+  end
+
+  def self.generate_star
+    Storage.make_file(File.join(Dir.home, ".hubdate"), "stargazers.yaml")
+  end
+
+  def self.generate_watch
+    Storage.make_file(File.join(Dir.home, ".hubdate"), "watchers.yaml")
+  end
+
+  def self.generate_files
+    Storage.make_folder(File.join(Dir.home, ".hubdate"))
+
+    self.generate_follow
+    self.generate_star
+    self.generate_watch
+  end 
+end

data/lib/hubdate/user.rb

@@ -0,0 +1,70 @@
+class Github
+  class User
+    include Github::Base
+
+    # Generate JSON hash and create new Github::User object through Github::Base
+    def self.fetch(user = nil, conn = Github::Connection.new)
+      conn = user if user.class == Github::Connection
+      user = nil if user.class == Github::Connection
+      if user.nil?
+        raise ArgumentError.new("Authenticated request required when making calls on logged in user.") unless conn.authenticated?
+        responseHash = conn.get("/user")
+      else
+        responseHash = conn.get("/users/#{user}")
+      end
+      
+      new(responseHash, conn)
+    end
+
+    # Define ID because its reserved by ruby
+    def id
+      @response['id']
+    end
+
+    # Define type because its reserved by ruby
+    def type
+      @response['type']
+    end
+
+    # Return a Github::User object for each follower
+    def followers
+      result = connection.get("/users/#{login}/followers")
+
+      result.map do |follower|
+        self.class.new(follower, connection)
+      end
+    end
+
+    def notifications(params = {})
+      Github::Notification.list(params, connection)
+    end
+
+    def repos(params = {})
+      Github::Repository.list(login, type, params, connection)
+    end
+
+    def watchers(type)
+
+      case type
+      when :stargazer
+        type = "stargazers"
+      when :watcher
+        type = "subscribers"
+      else
+        raise StandardError.new("Watcher type must be either :stargazer or :watcher!")
+      end
+
+      stargazers_hash = {}
+      repos = self.repos.map {|repo| repo.name}
+
+      repos.each do |repo|
+        stargazers = connection.get("/repos/#{login}/#{repo}/#{type}")
+        stargazers_array = stargazers.map {|gazer| gazer["login"]}
+
+        stargazers_hash[repo.to_s] = stargazers_array
+      end
+
+      return stargazers_hash
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Hubdate
+  VERSION = "0.0.01"
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: hubdate
+version: !ruby/object:Gem::Version
+  version: 0.0.01
+  prerelease: 
+platform: ruby
+authors:
+- Tommy Schaefer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby program that polls github for updates and sends them to notification
+  center.
+email:
+- me@tommyschaefer.net
+executables:
+- hubdate
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/hubdate
+- hubdate.gemspec
+- lib/.rudoo/config.yml
+- lib/.rudoo/list.yml
+- lib/hubdate.rb
+- lib/hubdate/base.rb
+- lib/hubdate/checker.rb
+- lib/hubdate/connection.rb
+- lib/hubdate/notification.rb
+- lib/hubdate/repository.rb
+- lib/hubdate/storage.rb
+- lib/hubdate/user.rb
+- lib/version.rb
+homepage: https://github.com/tommyschaefer/hubdate
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Hubdate is a console executed program that polls github for updates (notifications,
+  stars, and watchers). Any new updates will be sent to notification center.
+test_files: []