hubba 0.3.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 990a81f63411ae5b97cd3ae1e6892cb8e8f788d3
-  data.tar.gz: 1061e2b8963f97072cbdcedb5c6ba8c23ac3b691
+  metadata.gz: 63505774303ed6881c5650478eb76a1df7a3d412
+  data.tar.gz: 517173da9e008bd5d9ea74d2e9d8d1622edf7fdf
 SHA512:
-  metadata.gz: 05efa27d809de02a2e5582abe3c0d9b8f70629246d6d973d640b3fbb648365d7e0c6ecf32359837b06a83b2607d1ed4d9b5799af9c0f27d4244cce4dfe235a23
-  data.tar.gz: 9ad616f2209a6f1c566b895d0e908b5a1cc5706d85626eb0519bb74117d4a6b4dc2f71c40eac2adb3e7caa1cfe4af33cfd1f7de57d96dd2d2390126a99e58899
+  metadata.gz: 8a806d4ee314cc13c1605781cbc6af7192600d2c34ec9ebccc949541a800a41d93d43def28600aa0d27e7526a47afa1e319bc2184ec4cee1c917196cc080ca91
+  data.tar.gz: bcc42747f508c0acab55a8f652be1103afef20d9409172081bba34a530a9bbc441a2d5ec109bcd4b43e3049a3b3f74fc1c478d17e9c84a7e7ce41e7dabd11014

data/Manifest.txt

@@ -1,16 +1,18 @@
-HISTORY.md
+CHANGELOG.md
 Manifest.txt
 README.md
 Rakefile
 lib/hubba.rb
-lib/hubba/cache.rb
 lib/hubba/client.rb
+lib/hubba/config.rb
 lib/hubba/github.rb
 lib/hubba/stats.rb
 lib/hubba/version.rb
-test/cache/users~geraldb~orgs.json
-test/cache/users~geraldb~repos.json
 test/helper.rb
-test/test_cache.rb
+test/stats/jekyll~minima.json
+test/stats/openblockchains~awesome-blockchains.json
+test/stats/opendatajson~factbook.json.json
+test/stats/poole~hyde.json
 test/test_config.rb
 test/test_stats.rb
+test/test_stats_tmp.rb

data/README.md

@@ -1,20 +1,20 @@
-# hubba
-
-hubba gem - (yet) another (lite) GitHub HTTP API client / library
-
-* home  :: [github.com/gittiscripts/hubba](https://github.com/gittiscripts/hubba)
-* bugs  :: [github.com/gittiscripts/hubba/issues](https://github.com/gittiscripts/hubba/issues)
-* gem   :: [rubygems.org/gems/hubba](https://rubygems.org/gems/hubba)
-* rdoc  :: [rubydoc.info/gems/hubba](http://rubydoc.info/gems/hubba)
-
-
-## Usage
-
-TBD
-
-
-
-## License
-
-The `hubba` scripts are dedicated to the public domain.
-Use it as you please with no restrictions whatsoever.
+# hubba
+
+hubba gem - (yet) another (lite) GitHub HTTP API client / library
+
+* home  :: [github.com/rubycoco/git](https://github.com/rubycoco/git)
+* bugs  :: [github.com/rubycoco/git/issues](https://github.com/rubycoco/git/issues)
+* gem   :: [rubygems.org/gems/hubba](https://rubygems.org/gems/hubba)
+* rdoc  :: [rubydoc.info/gems/hubba](http://rubydoc.info/gems/hubba)
+
+
+## Usage
+
+TBD
+
+
+
+## License
+
+The `hubba` scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.

data/Rakefile

@@ -5,26 +5,26 @@ Hoe.spec 'hubba' do
 
   self.version = Hubba::VERSION
 
-  self.summary = 'hubba -  (yet) another (lite) GitHub HTTP API client / library'
+  self.summary = 'hubba - (yet) another (lite) GitHub HTTP API client / library'
   self.description = summary
 
-  self.urls    = ['https://github.com/gittiscripts/hubba']
+  self.urls    = { home: 'https://github.com/rubycoco/git' }
 
   self.author  = 'Gerald Bauer'
   self.email   = 'ruby-talk@ruby-lang.org'
 
   # switch extension to .markdown for gihub formatting
   self.readme_file  = 'README.md'
-  self.history_file = 'HISTORY.md'
+  self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
-    ['logutils' ],
+    ['webclient', '>= 0.1.1']
   ]
 
   self.licenses = ['Public Domain']
 
   self.spec_extras = {
-   required_ruby_version: '>= 2.3'
+   required_ruby_version: '>= 2.2.2'
   }
 
 end

data/lib/hubba.rb

@@ -1,25 +1,20 @@
-# encoding: utf-8
-
-require 'net/http'
-require "net/https"
-require 'uri'
-
-require 'pp'
-require 'json'
-require 'yaml'
-require 'time'
-
-
-# 3rd party gems/libs
-require 'logutils'
+# 3rd party (our own)
+require 'webclient'
 
 # our own code
 require 'hubba/version'   # note: let version always go first
-require 'hubba/cache'
+require 'hubba/config'
 require 'hubba/client'
 require 'hubba/github'
 require 'hubba/stats'
 
 
+############
+# add convenience alias for alternate spelling - why? why not?
+module Hubba
+  GitHub = Github
+end
+
+
 # say hello
-puts Hubba.banner    if defined?($RUBYLIBS_DEBUG)
+puts Hubba.banner    if defined?($RUBYCOCO_DEBUG)

data/lib/hubba/client.rb

@@ -1,53 +1,79 @@
-# encoding: utf-8
-
 module Hubba
 
 
 class Client
 
-def initialize( user: nil, password: nil )
-  uri = URI.parse( "https://api.github.com" )
-  @http = Net::HTTP.new(uri.host, uri.port)
-  @http.use_ssl = true
-  @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+BASE_URL = 'https://api.github.com'
+
+
+def initialize( token: nil,
+                user:  nil, password: nil )
+  ## add support for (personal access) token
+  @token     = token
 
   ## add support for basic auth - defaults to no auth (nil/nil)
+  ##   remove - deprecated (use token) - why? why not?
   @user      = user    ## use login like Oktokit - why? why not?
   @password  = password
 end # method initialize
 
+
+
 def get( request_uri )
   puts "GET #{request_uri}"
 
-  req = Net::HTTP::Get.new( request_uri )
-  ## req = Net::HTTP::Get.new( "/users/geraldb" )
-  ## req = Net::HTTP::Get.new( "/users/geraldb/repos" )
-  req["User-Agent"] = "ruby/hubba"                  ## required by GitHub API
-  req["Accept" ]    = "application/vnd.github.v3+json"  ## recommend by GitHub API
+  ## note: request_uri ALWAYS starts with leading /, thus use + for now!!!
+  #          e.g. /users/geraldb
+  #               /users/geraldb/repos
+  url = BASE_URL + request_uri
+
+  headers = {}
+  headers['User-Agent'] = 'ruby/hubba'                      ## required by GitHub API
+  headers['Accept']     = 'application/vnd.github.v3+json'  ## recommend by GitHub API
 
+  auth = []
   ## check if credentials (user/password) present - if yes, use basic auth
-  if @user && @password
+  if @token
+    puts "  using (personal access) token - starting with: #{@token[0..6]}**********"
+    headers['Authorization'] = "token #{@token}"
+    ## token works like:
+    ##  curl -H 'Authorization: token my_access_token' https://api.github.com/user/repos
+  elsif @user && @password
     puts "  using basic auth - user: #{@user}, password: ***"
-    req.basic_auth( @user, @password )
+    ## use credential auth "tuple" (that is, array with two string items) for now
+    ##  or use Webclient::HttpBasicAuth or something - why? why not?
+    auth = [@user, @password]
+    # req.basic_auth( @user, @password )
+  else
+    puts "  using no credentials (no token, no user/password)"
   end
 
-  res = @http.request(req)
+  res = Webclient.get( url,
+                       headers: headers,
+                       auth:    auth )
 
   # Get specific header
   # response["content-type"]
   # => "text/html; charset=UTF-8"
 
   # Iterate all response headers.
-  res.each_header do |key, value|
-    p "#{key} => #{value}"
+  puts "HTTP HEADERS:"
+  res.headers.each do |key, value|
+    puts "  #{key}: >#{value}<"
   end
+  puts
+
   # => "location => http://www.google.com/"
   # => "content-type => text/html; charset=UTF-8"
   # ...
 
-  json = JSON.parse( res.body )
-  ## pp json
-  json
+  if res.status.ok?
+    res.json
+  else
+    puts "!! HTTP ERROR: #{res.status.code} #{res.status.message}:"
+    pp res.raw
+    exit 1
+  end
 end  # methdo get
 
 end  ## class Client

data/lib/hubba/config.rb

@@ -0,0 +1,46 @@
+module Hubba
+
+class Configuration
+  def data_dir()         @data_dir || './data'; end
+  def data_dir=( value ) @data_dir = value;     end
+
+  # try default setup via ENV variables
+  def token()            @token || ENV[ 'HUBBA_TOKEN' ]; end
+  def token=( value )    @token = value;                 end
+
+  # todo/check: use HUBBA_LOGIN - why? why not?
+  def user()             @user     || ENV[ 'HUBBA_USER' ]; end
+  def password()         @password || ENV[ 'HUBBA_PASSWORD' ]; end
+  def user=( value )     @user     = value;                end
+  def password=( value ) @password = value;                end
+
+end  # class Configuration
+
+
+## lets you use
+##   Hubba.configure do |config|
+##      config.token    = 'secret'
+##        -or-
+##      config.user     = 'testdada'
+##      config.password = 'secret'
+##   end
+##
+##   move configure block to GitHub class - why? why not?
+##   e.g. GitHub.configure do |config|
+##          ...
+##        end
+
+
+def self.configuration
+ @configuration ||= Configuration.new
+end
+class << self
+  alias_method :config, :configuration
+end
+
+
+def self.configure
+ yield( configuration )
+end
+
+end # module Hubba

data/lib/hubba/github.rb

@@ -1,38 +1,5 @@
-# encoding: utf-8
-
 module Hubba
 
-class Configuration
-   attr_accessor :user
-   attr_accessor :password
-
-   def initialize
-     # try default setup via ENV variables
-     @user     = ENV[ 'HUBBA_USER' ]    ## use HUBBA_LOGIN - why? why not?
-     @password = ENV[ 'HUBBA_PASSWORD' ]
-   end
-end
-
-## lets you use
-##   Hubba.configure do |config|
-##      config.user     = 'testdada'
-##      config.password = 'secret'
-##   end
-##
-##   move configure block to GitHub class - why? why not?
-##   e.g. GitHub.configure do |config|
-##          ...
-##        end
-
-
-def self.configuration
-  @configuration ||= Configuration.new
-end
-
-def self.configure
-  yield( configuration )
-end
-
 
 class Resource
   attr_reader :data
@@ -53,25 +20,25 @@ class Orgs < Resource
     ## sort by name
     data.map { |item| item['login'] }.sort
   end
+  alias_method :names, :logins   ## add name alias - why? why not?
 end
 
 
 
 class Github
 
-def initialize( cache_dir: './cache' )
-   @cache  = Cache.new( cache_dir )
-   @client = Client.new( user:     Hubba.configuration.user,
-                         password: Hubba.configuration.password )
-
-   @offline = false
+def initialize
+   @client = if Hubba.configuration.token
+               Client.new( token: Hubba.configuration.token )
+             elsif Hubba.configuration.user &&
+                   Hubba.configuration.password
+               Client.new( user:     Hubba.configuration.user,
+                           password: Hubba.configuration.password )
+             else
+               Client.new
+             end
 end
 
-def offline!()  @offline = true; end   ## switch to offline  - todo: find a "better" way - why? why not?
-def online!()   @offline = false; end
-def offline?()  @offline == true; end
-def online?()   @offline == false; end
-
 
 def user( name )
   Resource.new( get "/users/#{name}" )
@@ -95,6 +62,7 @@ def user_orgs( name )
 end
 
 
+
 def org( name )
   Resource.new( get "/orgs/#{name}" )
 end
@@ -114,15 +82,28 @@ def repo_commits( full_name )
 end
 
 
-private
-def get( request_uri )
-  if offline?
-    @cache.get( request_uri )
+
+####
+# more
+def update( obj )
+  if obj.is_a?( Stats )
+    full_name = obj.full_name
+    puts "[update 1/2] fetching repo >#{full_name}<..."
+    repo    = repo( full_name )
+    puts "[update 2/2] fetching repo >#{full_name}< commits ..."
+    commits = repo_commits( full_name )
+
+    obj.update( repo, commits )
   else
-    @client.get( request_uri )
+    raise ArgumentError, "unknown source object passed in - expected Hubba::Stats; got #{obj.class.name}"
   end
 end
 
-end  # class Github
 
-end # module Hubba
+private
+def get( request_uri )
+  @client.get( request_uri )
+end
+
+end  # class Github
+end  # module Hubba

data/lib/hubba/stats.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Hubba
 
   ####
@@ -12,47 +10,225 @@ module Hubba
     def initialize( full_name )
       @data = {}
       @data['full_name'] = full_name  # e.g. poole/hyde etc.
+
+      @cache = {}
     end
 
-    def full_name()   @data['full_name']; end
 
-    def created_at()  @data['created_at']; end
-    def updated_at()  @data['updated_at']; end
-    def pushed_at()   @data['pushed_at']; end
+    def full_name() @data['full_name']; end
+
 
-    def history()     @data['history']; end
+    ## note: return datetime objects (NOT strings); if not present/available return nil/null
+    def created_at() @cache['created_at'] ||= parse_datetime( @data['created_at'] ); end
+    def updated_at() @cache['updated_at'] ||= parse_datetime( @data['updated_at'] ); end
+    def pushed_at()  @cache['pushed_at']  ||= parse_datetime( @data['pushed_at'] );  end
 
+    ## date (only) versions
+    def created() @cache['created'] ||= parse_date( @data['created_at'] ); end
+    def updated() @cache['updated'] ||= parse_date( @data['updated_at'] ); end
+    def pushed()  @cache['pushed']  ||= parse_date( @data['pushed_at'] ); end
 
     def size
       # size of repo in kb (as reported by github api)
       @data['size'] || 0   ## return 0 if not found - why? why not? (return nil - why? why not??)
     end
 
+
+    def history
+      @cache['history'] ||= begin
+                              if @data['history']
+                                build_history( @data['history'] )
+                              else
+                                nil
+                              end
+                            end
+    end
+
+
     def stars
       ## return last stargazers_count entry (as number; 0 if not found)
-       t1 = 0
+      @cache['stars'] ||= history ? history[0].stars : 0
+    end
+
+
+    def commits() @data['commits']; end
+
+    def last_commit   ## convenience shortcut; get first/last commit (use [0]) or nil
+      if @data['commits'] && @data['commits'][0]
+         @data['commits'][0]
+      else
+         nil
+      end
+    end
+
+
+    def committed   ## last commit date (from author NOT committer)
+      @cache['committed'] ||= parse_date( last_commit_author_date )
+    end
+
+    def committed_at()   ## last commit date (from author NOT committer)
+      @cache['committed_at'] ||= parse_datetime( last_commit_author_date )
+    end
+
+    def last_commit_author_date
+      h = last_commit
+      h ? h['author']['date'] : nil
+    end
+
+
+    def last_commit_message    ## convenience shortcut; last commit message
+      h = last_commit
+
+      committer_name = h['committer']['name']
+      author_name    = h['author']['name']
+      message        = h['message']
+
+      buf = ""
+      buf << message
+      buf << " by #{author_name}"
+
+      if committer_name != author_name
+        buf << " w/ #{committer_name}"
+      end
+    end  # method commit_message
+
+
+
+    ###
+    # helpers
+    def parse_datetime( str ) str ? DateTime.strptime( str, '%Y-%m-%dT%H:%M:%S') : nil; end
+    def parse_date( str )     str ? Date.strptime( str, '%Y-%m-%d') : nil; end
+
+########
+## build history items (structs)
+
+    class HistoryItem
+
+      attr_reader   :date, :stars    ## read-only attributes
+      attr_accessor :prev, :next     ## read/write attributes (for double linked list/nodes/items)
+
+      def initialize( date:, stars: )
+        @date  = date
+        @stars = stars
+        @next  = nil
+      end
+
+      ## link items (append item at the end/tail)
+      def append( item )
+        @next = item
+        item.prev = self
+      end
+
+      def diff_days
+        if @next
+          ## note: use jd=julian days for calculation
+          @date.jd - @next.date.jd
+        else
+          nil   ## last item (tail)
+        end
+      end
+
+      def diff_stars
+        if @next
+          @stars - @next.stars
+        else
+          nil   ## last item (tail)
+        end
+      end
+    end  ## class HistoryItem
+
+
+    def build_history( timeseries )
+      items = []
+
+      keys  = timeseries.keys.sort.reverse   ## newest (latest) items first
+      keys.each do |key|
+        h = timeseries[ key ]
+
+        item = HistoryItem.new(
+                 date:  Date.strptime( key, '%Y-%m-%d' ),
+                 stars: h['stargazers_count'] || 0 )
+
+        ## link items
+        last_item = items[-1]
+        last_item.append( item )   if last_item     ## if not nil? append (note first item has no prev item)
+
+        items << item
+      end
+
+      ## todo/check: return [] for empty items array (items.empty?) - why?? why not??
+      if items.empty?
+        nil
+      else
+        items
+      end
+    end  ## method build_history
 
-       if history
-            history_keys  = history.keys.sort.reverse
-            ## todo/fix: for now assumes one entry per week
-            ##    simple case [0] and [1] for a week later
-            ##   check actual date - why? why not?
-            stats_t1 = history_keys[0] ? history[ history_keys[0] ] : nil
-            if stats_t1
-              t1 = stats_t1['stargazers_count'] || 0
-            end
-       end
-       t1
-    end  # method stars
+
+
+  def calc_diff_stars( samples: 3, days: 30 )
+    ## samples: use n history item samples e.g. 3 samples
+    ## days e.g. 7 days (per week), 30 days (per month)
+
+    if history.nil?
+      nil   ## todo/check: return 0.0 too - why? why not?
+    elsif history.size == 1
+      ## just one item; CANNOT calc diff; return zero
+      0.0
+    else
+      idx   = [history.size, samples].min   ## calc last index
+      last  = history[idx-1]
+      first = history[0]
+
+      diff_days  = first.date.jd - last.date.jd
+      diff_stars = first.stars   - last.stars
+
+      ## note: use factor 1000 for fixed integer division
+      ##  converts to float at the end
+
+      ##  todo: check for better way (convert to float upfront - why? why not?)
+
+      diff = (diff_stars * days * 1000) / diff_days
+      puts "diff=#{diff}:#{diff.class.name}"    ## check if it's a float
+      (diff.to_f/1000.0)
+    end
+  end
+
+
+  def history_str  ## todo/check: rename/change to format_history or fmt_history - why? why not?
+    ## returns "pretty printed" history as string buffer
+    buf = ''
+    buf << "[#{history.size}]: "
+
+    history.each do |item|
+      buf << "#{item.stars}"
+
+      diff_stars = item.diff_stars
+      diff_days  = item.diff_days
+      if diff_stars && diff_days  ## note: last item has no diffs
+        if diff_stars > 0 || diff_stars < 0
+          if diff_stars > 0
+            buf << " (+#{diff_stars}"
+          else
+            buf << " (#{diff_stars}"
+          end
+          buf << " in #{diff_days}d) "
+        else  ## diff_stars == 0
+          buf << " (#{diff_days}d) "
+        end
+      end
+    end
+    buf
+  end # method history_str
 
 
 
 ###############################
 ## fetch / read / write methods
 
-    def fetch( gh )   ## update stats / fetch data from github via api
-      puts "fetching #{full_name}..."
-      repo = gh.repo( full_name )
+    def update( repo, commits )   ## update stats / fetch data from github via api
+      raise ArgumentError, "Hubba::Resource expected; got #{repo.class.name}"      unless repo.is_a?( Resource )
+      raise ArgumentError, "Hubba::Resource expected; got #{commits.class.name}"   unless commits.is_a?( Resource )
 
       ## e.g. 2015-05-11T20:21:43Z
       ## puts Time.iso8601( repo.data['created_at'] )
@@ -77,7 +253,6 @@ module Hubba
 
       ##########################
       ## also check / keep track of (latest) commit
-      commits = gh.repo_commits( full_name )
       puts "last commit/update:"
       ## pp commits
       commit = {
@@ -85,36 +260,58 @@ module Hubba
           'date' => commits.data[0]['commit']['committer']['date'],
           'name' => commits.data[0]['commit']['committer']['name']
         },
+        'author' => {
+          'date' => commits.data[0]['commit']['author']['date'],
+          'name' => commits.data[0]['commit']['author']['name']
+        },
         'message' => commits.data[0]['commit']['message']
       }
 
       ## for now store only the latest commit (e.g. a single commit in an array)
-      @data[ 'commits'] = [commit]
+      @data[ 'commits' ] = [commit]
 
       pp @data
+
+      ## reset (invalidate) cached values from data hash
+      ##   use after reading or fetching
+      @cache = {}
+
+      self   ## return self for (easy chaining)
     end
 
 
 
-    def write( data_dir: './data' )
+    def write
       basename = full_name.gsub( '/', '~' )   ## e.g. poole/hyde become poole~hyde
-      puts "writing (saving) to #{basename}..."
+      data_dir = Hubba.config.data_dir
+      puts "writing stats to #{basename} (#{data_dir})..."
+
+      ## todo/fix: add FileUtils.makepath_r or such!!!
       File.open( "#{data_dir}/#{basename}.json", 'w:utf-8' ) do |f|
           f.write JSON.pretty_generate( data )
       end
+      self   ## return self for (easy chaining)
     end
 
-    def read( data_dir: './data' )   ## note: use read instead of load (load is kind of keyword for loading code)
+
+    def read
       ## note: skip reading if file not present
       basename = full_name.gsub( '/', '~' )   ## e.g. poole/hyde become poole~hyde
-      filename = "#{data_dir}/#{basename}.json"
-      if File.exist?( filename )
-        puts "reading (loading) from #{basename}..."
-        json = File.open( filename, 'r:utf-8' ) { |file| file.read }   ## todo/fix: use read_utf8
+      data_dir = Hubba.config.data_dir
+      path = "#{data_dir}/#{basename}.json"
+
+      if File.exist?( path )
+        puts "reading stats from #{basename} (#{data_dir})..."
+        json = File.open( path, 'r:utf-8' ) { |f| f.read }
         @data = JSON.parse( json )
+
+        ## reset (invalidate) cached values from data hash
+        ##   use after reading or fetching
+        @cache = {}
       else
-        puts "skipping reading (loading) from #{basename} -- file not found"
+        puts "!! WARN: - skipping reading stats from #{basename} -- file not found"
       end
+      self   ## return self for (easy chaining)
     end
 
   end # class Stats