hubba 0.4.0 → 0.6.1

data/lib/hubba/reports.rb

@@ -0,0 +1,249 @@
+module Hubba
+
+
+class Report
+  def initialize( stats_or_hash_or_path=Hubba.stats )
+    ## puts "[debug] Report#initialize:"
+    ## pp  stats_or_hash_or_path   if stats_or_hash_or_path.is_a?( String )
+
+    @stats = if stats_or_hash_or_path.is_a?( String ) ||
+                stats_or_hash_or_path.is_a?( Hash )
+                  hash_or_path = stats_or_hash_or_path
+                  Hubba.stats( hash_or_path )
+             else
+                  stats_or_hash_or_path  ## assume Summary/Stats - todo/fix: double check!!!
+             end
+  end
+
+  def save( path )
+    buf = build
+    puts "writing report >#{path}< ..."
+    File.open( path, "w:utf-8" ) do |f|
+      f.write( buf )
+    end
+  end
+end  ## class Report
+
+
+
+class ReportSummary < Report
+
+def build
+## create a (summary report)
+##
+##  add stars, last_updates, etc.
+##  org description etc??
+
+## note: orgs is orgs+users e.g. geraldb, yorobot etc
+buf = String.new('')
+buf << "# #{@stats.repos.size} repos @ #{@stats.orgs.size} orgs\n"
+buf << "\n"
+
+
+@stats.orgs.each do |org|
+  name  = org[0]
+  repos = org[1]
+  buf << "### #{name} _(#{repos.size})_\n"
+  buf << "\n"
+
+  ### add stats for repos
+  entries = []
+  repos.each do |repo|
+    entries << "**#{repo.name}** ★#{repo.stats.stars} (#{repo.stats.size} kb)"
+  end
+
+  buf << entries.join( ' · ' )   ## use interpunct? - was: • (bullet)
+  buf << "\n"
+  buf << "\n"
+end
+
+buf
+end  # method build
+end  # class ReportSummary
+
+
+
+class ReportStars < Report
+
+def build
+
+##  add stars, last_updates, etc.
+##  org description etc??
+
+## note: orgs is orgs+users e.g. geraldb, yorobot etc
+buf = String.new('')
+buf << "# #{@stats.repos.size} repos @ #{@stats.orgs.size} orgs\n"
+buf << "\n"
+
+
+repos = @stats.repos.sort do |l,r|
+  ## note: use reverse sort (right,left) - e.g. most stars first
+  r.stats.stars <=> l.stats.stars
+end
+
+## pp repos
+
+repos.each_with_index do |repo,i|
+  buf << "#{i+1}. ★#{repo.stats.stars} **#{repo.full_name}** (#{repo.stats.size} kb)\n"
+end
+
+buf
+end  # method build
+end  # class ReportStars
+
+
+
+class ReportTimeline < Report
+
+def build
+## create a (timeline report)
+
+## note: orgs is orgs+users e.g. geraldb, yorobot etc
+buf = String.new('')
+buf << "# #{@stats.repos.size} repos @ #{@stats.orgs.size} orgs\n"
+buf << "\n"
+
+
+repos = @stats.repos.sort do |l,r|
+  ## note: use reverse sort (right,left) - e.g. most stars first
+  ## r[:stars] <=> l[:stars]
+
+  ## sort by created_at (use julian days)
+  r.stats.created.jd <=> l.stats.created.jd
+end
+
+
+## pp repos
+
+
+last_year  = -1
+last_month = -1
+
+repos.each_with_index do |repo,i|
+  year       = repo.stats.created.year
+  month      = repo.stats.created.month
+
+  if last_year != year
+    buf << "\n## #{year}\n\n"
+  end
+
+  if last_month != month
+    buf << "\n### #{month}\n\n"
+  end
+
+  last_year  = year
+  last_month = month
+
+  buf << "- #{repo.stats.created_at.strftime('%Y-%m-%d')} ★#{repo.stats.stars} **#{repo.full_name}** (#{repo.stats.size} kb)\n"
+end
+
+buf
+end  # method build
+end  # class ReportTimeline
+
+
+
+class ReportTrending < Report
+
+def build
+
+## note: orgs is orgs+users e.g. geraldb, yorobot etc
+buf = String.new('')
+buf << "# #{@stats.repos.size} repos @ #{@stats.orgs.size} orgs\n"
+buf << "\n"
+
+###
+## todo:
+##   use calc per month (days: 30)
+##   per week is too optimistic (e.g. less than one star/week e.g. 0.6 or something)
+
+repos = @stats.repos.sort do |l,r|
+  ## note: use reverse sort (right,left) - e.g. most stars first
+  ## r[:stars] <=> l[:stars]
+
+  ## sort by created_at (use julian days)
+  ## r[:created_at].to_date.jd <=> l[:created_at].to_date.jd
+
+  res = r.diff <=> l.diff
+  res = r.stats.stars <=> l.stats.stars  if res == 0
+  res = r.stats.created.jd <=> l.stats.created.jd  if res == 0
+  res
+end
+
+
+## pp repos
+
+
+repos.each_with_index do |repo,i|
+  if repo.diff == 0
+    buf << "-  -/- "
+  else
+    buf << "- #{repo.diff}/month "
+  end
+
+  buf <<  " ★#{repo.stats.stars} **#{repo.full_name}** (#{repo.stats.size} kb) - "
+  buf <<  "#{repo.stats.history_str}\n"
+end
+
+
+buf
+end  # method build
+end  # class ReportTrending
+
+
+
+class ReportUpdates < Report
+
+def build
+
+## note: orgs is orgs+users e.g. geraldb, yorobot etc
+buf = String.new('')
+buf << "# #{@stats.repos.size} repos @ #{@stats.orgs.size} orgs\n"
+buf << "\n"
+
+repos = @stats.repos.sort do |l,r|
+  r.stats.committed.jd <=> l.stats.committed.jd
+end
+
+## pp repos
+
+
+buf << "committed / pushed / updated / created\n\n"
+
+today = Date.today
+
+repos.each_with_index do |repo,i|
+
+  days_ago = today.jd - repo.stats.committed.jd
+
+  diff1 = repo.stats.committed.jd - repo.stats.pushed.jd
+  diff2 = repo.stats.committed.jd - repo.stats.updated.jd
+  diff3 = repo.stats.pushed.jd    - repo.stats.updated.jd
+
+  buf <<  "- (#{days_ago}d) **#{repo.full_name}** ★#{repo.stats.stars} - "
+  buf <<  "#{repo.stats.committed} "
+  buf <<  "("
+  buf <<  (diff1==0 ? '=' : "#{diff1}d")
+  buf <<  "/"
+  buf <<  (diff2==0 ? '=' : "#{diff2}d")
+  buf <<  ")"
+  buf <<  " / "
+  buf <<  "#{repo.stats.pushed} "
+  buf <<  "("
+  buf <<  (diff3==0 ? '=' : "#{diff3}d")
+  buf <<  ")"
+  buf <<  " / "
+  buf <<  "#{repo.stats.updated} / "
+  buf <<  "#{repo.stats.created} - "
+  buf <<  "‹#{repo.stats.last_commit_message}›"
+  buf <<  " (#{repo.stats.size} kb)"
+  buf <<  "\n"
+end
+
+
+buf
+end  # method build
+end  # class ReportUpdates
+
+
+end # module Hubba

data/lib/hubba/reposet.rb

@@ -0,0 +1,170 @@
+module Hubba
+
+
+def self.update_stats( host_or_path='./repos.yml' )  ## move to reposet e.g. Reposet#update_status!!!!
+  h = if hash_or_path.is_a?( String )    ## assume it is a file path!!!
+        path = hash_or_path
+        YAML.load_file( path )
+      else
+        hash_or_path  # assume its a hash / reposet already!!!
+      end
+
+  gh = Github.new
+  gh.update_stats( h )
+end
+
+
+def self.stats( hash_or_path='./repos.yml' )   ## use read_stats or such - why? why not?
+  h = if hash_or_path.is_a?( String )    ## assume it is a file path!!!
+        path = hash_or_path
+        YAML.load_file( path )
+      else
+        hash_or_path  # assume its a hash / reposet already!!!
+      end
+
+  Summary.new( h )  ## wrap in "easy-access" facade / wrapper
+end
+
+
+
+class Summary    # todo/check: use a different name e.g (Data)Base, Census, Catalog, Collection, Index, Register or such???
+
+class Repo  ## (nested) class
+
+  attr_reader :owner,
+              :name
+
+  def initialize( owner, name )
+    @owner = owner   ## rename to login, username - why? why not?
+    @name  = name    ## rename to reponame ??
+  end
+
+  def full_name() "#{owner}/#{name}"; end
+
+  def stats
+    ## note: load stats on demand only (first access) for now - why? why not?
+    @stats ||= begin
+                 stats = Stats.new( full_name )
+                 stats.read
+                 stats
+               end
+  end
+
+  def diff
+    @diff ||= stats.calc_diff_stars( samples: 3, days: 30 )
+  end
+end  # (nested) class Repo
+
+
+attr_reader :orgs, :repos
+
+def initialize( hash )
+  @orgs     = []    # orgs and users -todo/check: use better name - logins or owners? why? why not?
+  @repos    = []
+  add( hash )
+
+  puts "#{@repos.size} repos @ #{@orgs.size} orgs"
+end
+
+#############
+## private helpes
+def add( hash )   ## add repos.yml set
+  hash.each do |org_with_counter, names|
+    ## remove optional number from key e.g.
+    ##   mrhydescripts (3)    =>  mrhydescripts
+    ##   footballjs (4)       =>  footballjs
+    ##   etc.
+    org = org_with_counter.sub( /\([0-9]+\)/, '' ).strip
+    repos = []
+    names.each do |name|
+      repo = Repo.new( org, name )
+      repos << repo
+    end
+    @orgs << [org, repos]
+    @repos += repos
+  end
+end
+end  # class Summary
+
+
+
+## orgs  - include repos form org(anizations) too
+## cache - save json response to cache_dir   - change to/use debug/tmp_dir? - why? why not?
+def self.reposet( *users, orgs: true,
+                          cache: false )
+  # users = [users]   if users.is_a?( String )  ### wrap in array if single user
+
+  gh = Hubba::Github.new
+
+  forks = []
+
+  h = {}
+  users.each do |user|
+    res = gh.user_repos( user )
+    save_json( "#{config.cache_dir}/users~#{user}~repos.json", res.data )  if cache
+
+    repos = []
+    ####
+    #  check for forked repos (auto-exclude personal by default)
+    #   note: forked repos in orgs get NOT auto-excluded!!!
+    res.data.each do |repo|
+      fork = repo['fork']
+      if fork
+        print "FORK "
+        forks << "#{repo['full_name']} (AUTO-EXCLUDED)"
+      else
+        print "     "
+        repos << repo['name']
+      end
+      print repo['full_name']
+      print "\n"
+    end
+
+
+    h[ "#{user} (#{repos.size})" ] = repos.sort
+  end
+
+
+  ## all repos from orgs
+  ##  note: for now only use first (primary user) - why? why not?
+  if orgs
+    user = users[0]
+    res = gh.user_orgs( user )
+    save_json( "#{config.cache_dir}/users~#{user}~orgs.json", res.data )  if cache
+
+
+    logins = res.logins.each do |login|
+       ## next if ['xxx'].include?( login )      ## add orgs here to skip
+
+       res = gh.org_repos( login )
+       save_json( "#{config.cache_dir}/orgs~#{login}~repos.json", res.data )  if cache
+
+       repos = []
+       res.data.each do |repo|
+         fork = repo['fork']
+         if fork
+           print "FORK "
+           forks << repo['full_name']
+           repos << repo['name']
+         else
+           print "     "
+           repos << repo['name']
+         end
+         print repo['full_name']
+         print "\n"
+       end
+
+       h[ "#{login} (#{repos.size})" ] = repos.sort
+    end
+  end
+
+  if forks.size > 0
+    puts
+    puts "#{forks.size} fork(s):"
+    puts forks
+  end
+
+  h
+end  ## method reposet
+end # module Hubba
+

data/lib/hubba/stats.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Hubba
 
   ####
@@ -12,39 +10,95 @@ module Hubba
     def initialize( full_name )
       @data = {}
       @data['full_name'] = full_name  # e.g. poole/hyde etc.
+
+      @cache = {}
     end
 
 
-    def full_name() @full_name ||= @data['full_name']; end
+    def full_name() @data['full_name']; end
+
 
     ## note: return datetime objects (NOT strings); if not present/available return nil/null
-    def created_at() @created_at ||= @data['created_at'] ? DateTime.strptime( @data['created_at'], '%Y-%m-%dT%H:%M:%S') : nil; end
-    def updated_at() @updated_at ||= @data['updated_at'] ? DateTime.strptime( @data['updated_at'], '%Y-%m-%dT%H:%M:%S') : nil; end
-    def pushed_at()  @pushed_at  ||= @data['pushed_at']  ? DateTime.strptime( @data['pushed_at'],  '%Y-%m-%dT%H:%M:%S') : nil; end
+    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
 
-    def history()    @history ||= @data['history'] ? build_history( @data['history'] ) : nil; 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)
-      @size ||= @data['size'] || 0   ## return 0 if not found - why? why not? (return nil - why? why not??)
+      @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)
-      @stars ||= history ? history[0].stars : 0
+      @cache['stars'] ||= history ? history[0].stars : 0
     end
 
-    def reset_cache
-      ## reset (invalidate) cached values from data hash
-      ##   use after reading or fetching
-      @full_name  = nil
-      @created_at = @updated_at = @pushed_at = nil
-      @history    = nil
-      @size       = nil
-      @stars      = nil
+
+    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)
 
@@ -56,6 +110,7 @@ module Hubba
       def initialize( date:, stars: )
         @date  = date
         @stars = stars
+        @next  = nil
       end
 
       ## link items (append item at the end/tail)
@@ -134,12 +189,13 @@ module Hubba
       ##  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
+      ##  puts "diff=#{diff}:#{diff.class.name}"    ## check if it's a float
       (diff.to_f/1000.0)
     end
   end
 
-  def history_str
+
+  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}]: "
@@ -166,12 +222,13 @@ module Hubba
   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'] )
@@ -196,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 = {
@@ -204,6 +260,10 @@ 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']
       }
 
@@ -212,15 +272,21 @@ module Hubba
 
       pp @data
 
-      reset_cache
+      ## 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 stats 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
@@ -228,17 +294,22 @@ module Hubba
     end
 
 
-    def read( data_dir: './data' )
+    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 stats 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_cache
+
+        ## reset (invalidate) cached values from data hash
+        ##   use after reading or fetching
+        @cache = {}
       else
-        puts "skipping reading stats from #{basename} -- file not found"
+        puts "!! WARN: - skipping reading stats from #{basename} -- file not found"
       end
       self   ## return self for (easy chaining)
     end