gitti 0.1.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47d89819b39043972c9b7eb001c6295640482f6f
-  data.tar.gz: 9ab6759b243dd50d6bf6cc84f598f013a896e838
+  metadata.gz: 22e1840beecff16feb5247fa52e7c6c5ce7deaa3
+  data.tar.gz: 70495a4374a990460a505c3b927f3501b91c74a5
 SHA512:
-  metadata.gz: 6f345ee2b66cd374cd1e7969235ed65324a1c34e814f40126e7f8be9ff7eab29dc3c484fc5eb95cc4aaf88ab4989b48f4cee8f68f28fb623ff1de9a5f5660d7e
-  data.tar.gz: c8657d76b2919817ce5f90fa34b31d4a595ee8ac3db39d6398ee5c4d700e6ef993a7adc33001f489267da781446e7c62824e0f946977ce041ffb5126377ed507
+  metadata.gz: 196886378c5879ff3ac790e25e017cd0c48af5d8c15f2073f99b2d25caca2ec878e81a073da1ca2cbf4f2fd40e76317b7e01a2a7fb4268d325db4a36f1e58bad
+  data.tar.gz: b15e3d0bbcdfa562ee4ac600fd8b2acd6d72d52c331e124defe04d12cb5e944844f28ba042c3390f7de8cfa5aabea702f2cbce6ed4baacd9c058d60a28662281

data/Manifest.txt

@@ -1,7 +1,13 @@
-HISTORY.md
+CHANGELOG.md
 Manifest.txt
 README.md
 Rakefile
 lib/gitti.rb
-lib/gitti/lib.rb
+lib/gitti/base.rb
+lib/gitti/git.rb
+lib/gitti/mirror.rb
+lib/gitti/project.rb
+lib/gitti/reposet.rb
 lib/gitti/version.rb
+test/helper.rb
+test/test_base.rb

data/README.md

@@ -1,16 +1,162 @@
 # gitti
 
-gitti gem - (yet) another (lite) git command line wrapper / library
+gitti gem - (yet) another (lite) git command line helper / wrapper
 
-* home  :: [github.com/rubylibs/gitti](https://github.com/rubylibs/gitti)
-* bugs  :: [github.com/rubylibs/gitti/issues](https://github.com/rubylibs/gitti/issues)
+* home  :: [github.com/rubycoco/gitti](https://github.com/rubycoco/gitti)
+* bugs  :: [github.com/rubycoco/gitti/issues](https://github.com/rubycoco/gitti/issues)
 * gem   :: [rubygems.org/gems/gitti](https://rubygems.org/gems/gitti)
 * rdoc  :: [rubydoc.info/gems/gitti](http://rubydoc.info/gems/gitti)
 
 
+
 ## Usage
 
-TBD
+`Git` • `GitProject` • `GitMirror`
+
+
+### `Git` Class
+
+Use the `Git` class for "low-level / to the metal" git commands
+that run in your current working directory.
+Example:
+
+``` ruby
+
+###############
+## "setup" starter git commands
+
+Git.clone( "https://github.com/rubycoco/gitti.git" )
+Git.clone( "https://github.com/rubycoco/gitti.git", "gitti-clone" )
+# -or-    -- if you have write / commit access use ssh
+Git.clone( "git@github.com:rubycoco/gitti.git" )
+Git.clone( "git@github.com:rubycoco/gitti.git", "gitti-clone" )
+
+Git.mirror( "https://github.com/rubycoco/gitti.git" )  ## same as  git clone --mirror
+
+#################
+## standard git commands
+
+Git.version                 ## same as  git --version
+Git.status
+Git.status( short: true )   ## same as Git.changes
+Git.changes                 ## same as  git status --short
+
+#####################
+## status helpers
+
+Git.clean?
+Git.changes?
+Git.dirty?      ## alias for changes?
+
+#######
+## more (major) git commands
+
+Git.fetch
+Git.pull
+Git.fast_forward      ## same as  git pull --ff-only
+Git.ff                ## alias for fast_forward
+Git.push
+Git.add( "pathspec" )
+Git.add_all           ## same as  git --all
+Git.commit( "message" )
+
+Git.files                       ## same as  git ls-tree --full-tree --name-only -r HEAD
+
+Git.check                       ## same as  git fsck
+Git.fsck                        ## alias for check
+Git.checksum                    ## another alias for check
+
+Git.master?          ## on master branch
+Git.main?            ## on main branch
+
+Git.origin           ## same as   git remote show origin
+Git.upstream         ## same as   git remote show upstream
+Git.origin?
+Git.upstream?
+
+Git.config( "user.name" )                    ## use --get option
+Git.config( "user.name", show_origin: true ) ## add --show-origin flag
+Git.config( "user.name", show_scope: true )  ## add --show-scope flag
+
+Git.config( /user/ )                     ## use --get-regexp option
+Git.config( /user/, show_origin: true )  ## add --show-origin flag
+Git.config( /user/, show_scope: true )   ## add --show-scope flag
+```
+
+
+
+### `GitProject` Class
+
+Use the `GitProject` class for existing git repo(sitories)
+with workspace. Example:
+
+``` ruby
+GitProject.open( "rubycoco/gitti" ) do |proj|
+  proj.status
+  proj.status( short: true )
+  proj.changes
+  proj.clean?
+  proj.changes?
+  proj.dirty?
+
+  proj.fetch
+  proj.pull
+  proj.fast_forward
+  proj.ff
+
+  proj.push
+
+  proj.add( "pathspec" )
+  proj.add_all
+  proj.commit( "message" )
+
+  proj.files
+
+  proj.master?
+  proj.main?
+
+  proj.origin
+  proj.upstream
+  proj.origin?
+  proj.upstream?
+end
+```
+
+
+### `GitMirror` Class
+
+Use the `GitMirror` class for existing mirrored (bare) git repo(sitories)
+without workspace. Example:
+
+``` ruby
+GitMirror.open( "rubycoco/gitti.git" ) do |mirror|
+  mirror.update     # sames as  git remote update
+end
+```
+
+
+
+That's it for now.
+
+
+
+## Real World Usage
+
+The [`monos`](https://github.com/rubycoco/monos) gem incl. some monorepo / mono source tree tools and (startup) scripts
+that let you run git commands on multiple repos.
+
+
+
+## Installation
+
+Use
+
+    gem install gitti
+
+or add to your Gemfile
+
+    gem 'gitti'
+
 
 
 ## License

data/Rakefile

@@ -3,28 +3,26 @@ require './lib/gitti/version.rb'
 
 Hoe.spec 'gitti' do
 
-  self.version = Gitti::VERSION
+  self.version = GittiCore::VERSION
 
-  self.summary = 'gitti - (yet) another (lite) git command line wrapper / library'
+  self.summary = 'gitti - (yet) another (lite) git command line helper / wrapper'
   self.description = summary
 
-  self.urls    = ['https://github.com/rubylibs/gitti']
+  self.urls    = { home: 'https://github.com/rubycoco/gitti' }
 
   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' ],
-  ]
+  self.extra_deps = []
 
   self.licenses = ['Public Domain']
 
   self.spec_extras = {
-   required_ruby_version: '>= 1.9.2'
+   required_ruby_version: '>= 2.2.2'
   }
 
 end

data/lib/gitti.rb

@@ -1,21 +1,7 @@
-# encoding: utf-8
+require_relative 'gitti/base'
 
-require 'net/http'
-require "net/https"
-require 'uri'
+## note: auto include Gitti; for "modular" version use ("Sinatra-style")
+##         require "gitti/base"
 
-require 'pp'
-require 'json'
-require 'yaml'
+include Gitti
 
-
-# 3rd party gems/libs
-require 'logutils'
-
-# our own code
-require 'gitti/version'   # note: let version always go first
-require 'gitti/lib'
-
-
-# say hello
-puts Gitti.banner    if defined?($RUBYLIBS_DEBUG)

data/lib/gitti/base.rb

@@ -0,0 +1,57 @@
+require 'pp'
+require 'time'
+require 'date'    ## e.g. Date.today etc.
+require 'yaml'
+require 'json'
+require 'uri'
+require 'net/http'
+require "net/https"
+require 'open3'
+require 'fileutils'    ## e.g. FileUtils.mkdir_p etc.
+
+
+
+# our own code
+require 'gitti/version'   # note: let version always go first
+require 'gitti/git'
+require 'gitti/project'
+require 'gitti/mirror'
+require 'gitti/reposet'
+
+
+
+module Gitti
+## todo: change to GitHubRepoRef or GitHubProject
+##   or Git::GitHub or Git::Source::GitHub or such - why? why not?
+class GitHubRepo
+  attr_reader :owner, :name
+
+  def initialize( owner, name )
+    @owner = owner    ## use/rename to login or something - why? why not??
+    @name  = name     #  e.g. "rubylibs/webservice"
+  end
+
+
+  def ssh_clone_url
+     ##  check: use https: as default? for github - http:// still supported? or redirected?
+     ## "http://github.com/#{@owner}/#{@name}"
+     "git@github.com:#{@owner}/#{@name}.git"
+  end
+
+  def http_clone_url   ## use clone_url( http: true )  -- why? why not?
+     ##  note: https is default for github - http:// gets redirected to https://
+     "http://github.com/#{@owner}/#{@name}"
+  end
+
+  def https_clone_url
+    "https://github.com/#{@owner}/#{@name}"
+  end
+
+
+end   ## class GitHubRepo
+end   ## module Gitti
+
+
+
+# say hello
+puts GittiCore.banner      ## if defined?( $RUBYCOCO_DEBUG )

data/lib/gitti/git.rb

@@ -0,0 +1,315 @@
+module Gitti
+
+## raised by Git::Shell.run -- check if top-level ShellError alread exists?
+##   use ShellError or RunError - why? why not?
+##   and make Git::Shell top-level e.g. Shell - why? why not?
+class GitError < StandardError
+end
+
+
+class Git   ## make Git a module - why? why not?
+
+  ###
+  ## todo/fix:  change opts=nil to *args or such - why? why not?
+
+
+  ###############
+  ## "setup" starter git commands
+
+  def self.clone( repo, name=nil, depth: nil )
+    cmd = "git clone #{repo}"
+    cmd << " #{name}"            unless name.nil? || name.empty?
+    cmd << " --depth #{depth}"   unless depth.nil?
+    Shell.run( cmd )
+  end
+
+  ###
+  ## What's the difference between git clone --mirror and git clone --bare
+  ##   see https://stackoverflow.com/questions/3959924/whats-the-difference-between-git-clone-mirror-and-git-clone-bare
+  ##
+  ##  The git clone help page has this to say about --mirror:
+  ##   > Set up a mirror of the remote repository. This implies --bare
+  ##
+  ##  The difference is that when using --mirror, all refs are copied as-is.
+  ##  This means everything: remote-tracking branches, notes, refs/originals/*
+  ## (backups from filter-branch). The cloned repo has it all.
+  ## It's also set up so that a remote update will re-fetch everything from the origin
+  ## (overwriting the copied refs). The idea is really to mirror the repository,
+  ## to have a total copy, so that you could for example host your central repo
+  ## in multiple places, or back it up. Think of just straight-up copying the repo,
+  ## except in a much more elegant git way.
+  ##
+  ## The new documentation pretty much says all this:
+  ##  see https://git-scm.com/docs/git-clone
+  ##
+  ##  --mirror
+  ## Set up a mirror of the source repository. This implies --bare.
+  ##  Compared to --bare, --mirror not only maps local branches of the source
+  ## to local branches of the target, it maps all refs
+  ## (including remote-tracking branches, notes etc.) and sets up a refspec configuration
+  ##  such that all these refs are overwritten by a git remote update
+  ## in the target repository.
+  ##
+  ## More Articles / Resources:
+  ##  https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/duplicating-a-repository
+
+
+  ## add -n  (--no-checkout)   -- needed - why? why not?
+  ## add --no-hardlinks        -- needed/recommended - why? why not?
+
+  def self.mirror( repo )
+    cmd = "git clone --mirror #{repo}"
+    Shell.run( cmd )
+  end
+
+
+  #################
+  ## standard git commands
+
+  def self.version
+    cmd = 'git --version'
+    Shell.run( cmd )
+  end
+
+  def self.status( short: false )
+    cmd = 'git status'
+    cmd << " --short"   if short
+    Shell.run( cmd )
+  end
+
+  def self.changes  ## same as git status --short  - keep shortcut / alias - why? why not?
+    ## returns changed files - one per line or empty if no changes
+    cmd = 'git status --short'
+    Shell.run( cmd )
+  end
+
+  #####################
+  ## status helpers
+
+  ## git status --short  returns empty stdout/list
+  def self.clean?()   changes.empty?; end
+
+  def self.changes?() clean? == false; end  ## reverse of clean?
+  class << self
+    alias_method :dirty?, :changes?  ## add alias
+  end
+
+
+  #######
+  ## more (major) git commands
+
+  def self.fetch
+    cmd = 'git fetch'
+    Shell.run( cmd )
+  end
+
+  def self.pull
+    cmd = 'git pull'
+    Shell.run( cmd )
+  end
+
+  def self.fast_forward
+    cmd = 'git pull --ff-only'
+    Shell.run( cmd )
+  end
+  class << self
+    alias_method :ff, :fast_forward   ## add alias
+  end
+
+
+  def self.push
+    cmd = 'git push'
+    Shell.run( cmd )
+  end
+
+  def self.add( *pathspecs )  ## e.g. git add .  or git add *.rb or such
+    cmd = 'git add'
+    pathspecs = ['.']   if pathspecs.size == 0
+    cmd << " #{pathspecs.join('')}"
+    Shell.run( cmd )
+  end
+
+  def self.add_all
+    cmd = 'git add --all'
+    Shell.run( cmd )
+  end
+
+  def self.commit( message )
+    ### todo/check: make message.nil? an ArgumentError - why? why not?
+    ###  if message.nil? || message.empty?
+
+    cmd = 'git commit'
+    cmd << %Q{ -m "#{message}"}
+
+    Shell.run( cmd )
+  end
+
+
+  #############
+  #  change git ls-files to git ls-tree ... - why? why not?
+  ##  - note: git ls-files will include stages files too
+  #                not only committed ones!!!
+  #
+  #  git ls-tree --full-tree --name-only -r HEAD
+  #   1)  --full-tree makes the command run as if you were in the repo's root directory.
+  #   2)  -r recurses into subdirectories. Combined with --full-tree, this gives you all committed, tracked files.
+  #   3)  --name-only removes SHA / permission info for when you just want the file paths.
+  #   4)  HEAD specifies which branch you want the list of tracked, committed files for.
+  #       You could change this to master or any other branch name, but HEAD is the commit you have checked out right now.
+  #
+  #   see https://stackoverflow.com/questions/15606955/how-can-i-make-git-show-a-list-of-the-files-that-are-being-tracked
+  #
+  #  was:
+
+  def self.files  ## was: e.g. git ls-files .  or git ls-files *.rb or such
+    ### todo/check: include --full-tree - why? why not?
+    ##   will ALWAYS list all files NOT depending on (current) working directory
+
+    cmd = 'git ls-tree --full-tree --name-only -r HEAD'  # was:  'git ls-files'
+    Shell.run( cmd )
+  end
+  ## add list_files or ls_files alias - why? why not?
+
+
+  ########
+  ## query git configuration helpers
+  def self.config( prop,
+                   show_origin: false,
+                   show_scope: false )  ## find a better name e.g. config_get? why? why not?
+    cmd = "git config"
+    cmd << " --show-origin"   if show_origin
+    cmd << " --show-scope"    if show_scope
+
+    if prop.is_a?( Regexp )
+      ## note: use Regexp#source
+      ##    Returns the original string of the pattern.
+      ##      e.g. /ab+c/ix.source #=> "ab+c"
+      ##    Note that escape sequences are retained as is.
+      ##    /\x20\+/.source  #=> "\\x20\\+"
+      cmd << " --get-regexp #{prop.source}"
+    else  ## assume string
+      cmd << " --get #{prop}"
+    end
+
+    Shell.run( cmd )
+  end
+
+
+  def self.branch
+    cmd = 'git branch'
+    Shell.run( cmd )
+  end
+
+  def self.master?
+    output = branch     ## check for '* master'
+    output.split( /\r?\n/ ).include?( '* master' )
+  end
+
+  def self.main?
+    output = branch     ## check for '* main'
+    output.split( /\r?\n/ ).include?('* main')
+  end
+
+## git remote update will update all of your branches
+##   set to track remote ones, but not merge any changes in.
+##
+## git fetch --all didn't exist at one time, so git remote update what more useful.
+##  Now that --all has been added to git fetch, git remote update is not really necessary.
+##
+## Differences between git remote update and fetch?
+##  Is git remote update the equivalent of git fetch?
+##   see https://stackoverflow.com/questions/1856499/differences-between-git-remote-update-and-fetch/17512004#17512004
+##
+##  git fetch learned --all and --multiple options,
+##   to run fetch from many repositories,
+##   and --prune option to remove remote tracking branches that went stale.
+##   These make git remote update and git remote prune less necessary
+##    (there is no plan to remove remote update nor remote prune, though).
+  def self.update
+    cmd = 'git remote update'
+    Shell.run( cmd )
+  end
+
+
+  def self.origin  ## e.g. git remote show origin
+    cmd = "git remote show origin"
+    Shell.run( cmd )
+  end
+
+  def self.upstream  ## e.g. git remote show origin
+    cmd = "git remote show upstream"
+    Shell.run( cmd )
+  end
+
+  def self.remote
+    cmd = "git remote"
+    Shell.run( cmd )
+  end
+
+  def self.origin?
+    output = remote     ## check for 'origin'
+    output.split( /\r?\n/ ).include?( 'origin' )
+  end
+
+  def self.upstream?
+    output = remote     ## check for 'upstream'
+    output.split( /\r?\n/ ).include?( 'upstream' )
+  end
+
+
+
+  def self.check  ## e.g. git fsck  - check/validate hash of objects
+    cmd = "git fsck"
+    Shell.run( cmd )
+  end
+  class << self
+    alias_method :fsck,     :check   ## add alias
+    alias_method :checksum, :check
+  end
+
+
+
+###
+#  use nested class for "base" for running commands - why? why not?
+class Shell
+def self.run( cmd )
+  print "cmd exec >#{cmd}<..."
+  stdout, stderr, status = Open3.capture3( cmd )
+
+  if status.success?
+    print " OK"
+    print "\n"
+  else
+    print " FAIL (#{status.exitstatus})"
+    print "\n"
+  end
+
+  unless stdout.empty?
+    puts stdout
+  end
+
+  unless stderr.empty?
+    ## todo/check: or use >2: or &2: or such
+    ##  stderr output not always an error (that is, exit status might be 0)
+    puts "2>"
+    puts stderr
+  end
+
+  if status.success?
+    stdout   # return stdout string
+  else
+    puts "!! ERROR: cmd exec >#{cmd}< failed with exit status #{status.exitstatus}:"
+    puts stderr
+
+    ### todo/fix:  do NOT use GitError here!!! make it more "general"
+    ###   use a Git::Shell.run() wrapper or such - why? why not?
+    ##   or use a Shell.git() or Shell.git_run() ???
+    ##   or pass in error class - why? why not?
+    raise GitError, "cmd exec >#{cmd}< failed with exit status #{status.exitstatus}<: #{stderr}"
+  end
+end
+end # class Git::Shell
+
+end # class Git
+
+end # module Gitti

data/lib/gitti/mirror.rb

@@ -0,0 +1,33 @@
+module Gitti
+
+class GitMirror
+  def self.open( path, &blk )
+    new( path ).open( &blk )
+  end
+
+  def self.update( path )    ### all-in-one convenience shortcut
+    new( path).open { |mirror| mirror.update }
+  end
+
+
+
+  def initialize( path )
+    raise ArgumentError, "dir >#{path}< not found; dir MUST already exist for GitMirror class - sorry"   unless Dir.exist?( path )
+    ## todo/check:  check for more dirs and files e.g.
+    ##  /info,/objects,/refs, /hooks, HEAD, config, description -- why? why not?
+    raise ArgumentError, "dir >#{path}/objects< not found; dir MUST already be initialized with git for GitMirror class - sorry"  unless Dir.exist?( "#{path}/objects" )
+    @path = path
+  end
+
+
+  def open( &blk )
+    Dir.chdir( @path ) do
+      blk.call( self )
+    end
+  end
+
+  def update()           Git.update; end
+
+end # class GitMirror
+end # module Gitti
+

data/lib/gitti/project.rb

@@ -0,0 +1,61 @@
+module Gitti
+
+class GitProject
+  def self.open( path, &blk )
+    new( path ).open( &blk )
+  end
+
+  def initialize( path )
+    raise ArgumentError, "dir >#{path}< not found; dir MUST already exist for GitProject class - sorry"   unless Dir.exist?( path )
+    raise ArgumentError, "dir >#{path}/.git< not found; dir MUST already be initialized with git for GitProject class - sorry"  unless Dir.exist?( "#{path}/.git" )
+    @path = path
+  end
+
+
+  def open( &blk )
+    ## puts "Dir.getwd: #{Dir.getwd}"
+    Dir.chdir( @path ) do
+      blk.call( self )
+    end
+    ## puts "Dir.getwd: #{Dir.getwd}"
+  end
+
+
+  def status( short: false )    Git.status( short: short ); end
+  def changes()                 Git.changes; end
+  def clean?()                  Git.clean?; end
+  def changes?()                Git.changes?; end
+  alias_method :dirty?, :changes?
+
+
+  def fetch()                   Git.fetch; end
+  def pull()                    Git.pull; end
+  def fast_forward()            Git.fast_forward; end
+  alias_method :ff, :fast_forward
+
+  def push()                    Git.push; end
+
+  def add( *pathspecs )         Git.add( *pathspecs ); end
+  def add_all()                 Git.add_all; end
+  def commit( message )         Git.commit( message ); end
+
+  def files()                   Git.files; end
+
+
+  ### remote show origin|upstream|etc.
+  def remote()                  Git.remote; end
+  def origin()                  Git.origin; end
+  def upstream()                Git.upstream; end
+  def origin?()                 Git.origin?; end
+  def upstream?()               Git.upstream?; end
+
+  ### branch management
+  def branch()                  Git.branch; end
+  def master?()                 Git.master?; end
+  def main?()                   Git.main?; end
+
+
+  def run( cmd )                Git::Shell.run( cmd ); end
+end # class GitProject
+end # module Gitti
+

data/lib/gitti/reposet.rb

@@ -0,0 +1,42 @@
+
+module Gitti
+
+
+class GitRepoSet  ## todo: rename to Hash/Dict/List/Map  or use GitHubRepoSet ??
+
+def self.read( path )
+  txt  = File.open( path, 'r:utf-8') { |f| f.read }
+  hash = YAML.load( txt )
+  new( hash )
+end
+
+
+def initialize( hash )
+  @hash = hash
+end
+
+def size
+  ## sum up total number of repos
+  @size ||=  @hash.reduce(0) {|sum,(_,names)| sum+= names.size; sum }
+end
+
+def each
+  @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
+
+    ## puts "  -- #{key_with_counter} [#{key}] --"
+
+    yield( org, names )
+  end
+end
+
+end ## class GitRepoSet
+
+end ## module Gitti
+

data/lib/gitti/version.rb

@@ -1,9 +1,14 @@
-# encoding: utf-8
 
-module Gitti
+### note: use a different module for version (meta) info
+###        that is, GittiCore and NOT Gitti
+###       why? do NOT "pollute" Gitti with MAJOR, MINOR, PATH, and
+###                                        self.banner, self.root, etc.
+
+
+module GittiCore    ## todo/check: rename GittiBase or GittiMeta or such - why? why not?
   MAJOR = 0    ## todo: namespace inside version or something - why? why not??
-  MINOR = 1
-  PATCH = 0
+  MINOR = 4
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version
@@ -17,5 +22,5 @@ module Gitti
   def self.root
     "#{File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )}"
   end
-end # module Gitti
+end # module GittiCore
 

data/test/helper.rb

@@ -0,0 +1,7 @@
+## minitest setup
+require 'minitest/autorun'
+
+
+## our own code
+require 'gitti'
+

data/test/test_base.rb

@@ -0,0 +1,43 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_base.rb
+
+require 'helper'
+
+class TestBase < MiniTest::Test
+
+  def test_branch
+    Git.branch
+    assert_equal true,  Git.master?
+    assert_equal false, Git.main?
+
+    Git.remote
+    assert_equal true,  Git.origin?
+    assert_equal false, Git.upstream?
+  end
+
+
+  def test_git_config
+    puts "---"
+    Git.config( 'user.name' )
+    Git.config( 'user.name', show_origin: true )
+    ## Git.config( 'user.name', show_scope: true )
+
+    puts "---"
+    Git.config( /user/ )   ## note: pass in regex for regex match/search
+    Git.config( /user/, show_origin: true )
+    ## Git.config( /user/, show_scope: true )
+
+    puts "---"
+    Git.config( /user\./ )   ## note: pass in regex for regex match/search
+
+    puts "---"
+    ## note: if NOT found Git.config will exit(1) !!!
+    ## Git.config( /proxy/, show_origin: true )
+    ## Git.config( /http/,  show_origin: true )
+
+    puts "---"
+  end
+
+end # class TestBase
+

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: gitti
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-17 00:00:00.000000000 Z
+date: 2020-09-21 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: logutils
-  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: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -44,31 +30,37 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.14'
+        version: '3.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.14'
-description: gitti - (yet) another (lite) git command line wrapper / library
+        version: '3.16'
+description: gitti - (yet) another (lite) git command line helper / wrapper
 email: ruby-talk@ruby-lang.org
 executables: []
 extensions: []
 extra_rdoc_files:
-- HISTORY.md
+- CHANGELOG.md
 - Manifest.txt
 - README.md
 files:
-- HISTORY.md
+- CHANGELOG.md
 - Manifest.txt
 - README.md
 - Rakefile
 - lib/gitti.rb
-- lib/gitti/lib.rb
+- lib/gitti/base.rb
+- lib/gitti/git.rb
+- lib/gitti/mirror.rb
+- lib/gitti/project.rb
+- lib/gitti/reposet.rb
 - lib/gitti/version.rb
-homepage: https://github.com/rubylibs/gitti
+- test/helper.rb
+- test/test_base.rb
+homepage: https://github.com/rubycoco/gitti
 licenses:
 - Public Domain
 metadata: {}
@@ -82,7 +74,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -90,8 +82,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: gitti - (yet) another (lite) git command line wrapper / library
+summary: gitti - (yet) another (lite) git command line helper / wrapper
 test_files: []

data/lib/gitti/lib.rb

@@ -1,83 +0,0 @@
-# encoding: utf-8
-
-
-module Gitti
-
-class GitError < StandardError 
-end
-
-class GitLib
-
-   def clone( repo, opts={} )
-     command( "clone #{repo}" )
-   end
-
-   def mirror( repo, opts={} )
-     command( "clone --mirror #{repo}" )
-   end
-
-   def pull( opts={} )
-     command( "pull" )
-   end
-
-   def remote_update( opts={} )
-     command( "remote update" )
-   end
-
-
-   ## todo/fix:
-   ##   add last_exit  or something ?? why? why not??
-
-   def command( cmd )
-      ## note: for now use Kernel#system for calling external git command
-      ##
-
-      cmdline = "git #{cmd}"
-      puts "  trying >#{cmdline}< in (#{Dir.pwd})..."
-      
-      result = nil
-      result = system( cmdline )
-
-      pp result
-
-      # note: Kernel#system returns
-      #  - true if the command gives zero exit status
-      #  - false for non zero exit status
-      #  - nil if command execution fails
-      #  An error status is available in $?.
-
-      if result.nil?
-        puts "*** error was #{$?}"
-        fail "[Kernel.system] command execution failed  >#{cmdline}< - #{$?}"   
-      elsif result   ## true => zero exit code (OK)
-        puts 'OK'  ## zero exit; assume OK
-        true   ## assume ok
-      else  ## false => non-zero exit code (ERR/NOK)
-        puts "*** error: non-zero exit - #{$?} !!"   ## non-zero exit (e.g. 1,2,3,etc.); assume error
-      
-        ## log error for now  ???
-        # File.open( './errors.log', 'a' ) do |f|
-        #  f.write "#{Time.now} -- repo #{@owner}/#{@name} - command execution failed - non-zero exit\n"
-        # end
-        raise GitError.new( "command execution failed >#{cmdline}< - non-zero exit (#{$?})" )
-      end
-   end  # method command
-end  # class Lib
-
-
-module Git
-  ## todo/fix: use "shared" singelton lib - why? why not??
-  def self.clone( repo, opts={} )    GitLib.new.clone( repo, opts );  end
-  def self.mirror( repo, opts={} )   GitLib.new.mirror( repo, opts );  end
-  
-  def self.pull( opts={} )           GitLib.new.pull( opts );  end
-  def self.remote_update( opts={} )  GitLib.new.remote_update( opts );  end
-end  # module Git
-
-end # module Gitti
-
-
-### convenience top level Git module - check if defined? make optional? why? why not??
-## Git = Gitti::Git
-
-#  for now use include Gitti - why? why not??