monofile 0.0.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e88cadf8ec729be545293368f620f16c44ceac5f
-  data.tar.gz: 966d876e5864c7573dae3c97978ec9a14b94f34f
+  metadata.gz: 547a6deaf1db0ea792b640dcf686fa5788d0de30
+  data.tar.gz: 01fdcf2b3cfc5ddb70eb68dec8a808f0a1edd2e1
 SHA512:
-  metadata.gz: d74e05bce8932503f5a524d7dde003226ff6798f2406085b0011de019f21809cb926c5e36b33df06fb89af647e48c8bf105168ca34df9b4a175c29a0af7fe2dc
-  data.tar.gz: e97ef22bd907e3cf08f60eb9d25dd8a1f9180bda845daed17d2312cd88e46659d0b8ec63d218c5fcbbf54903cd9a5f4c5e90e98ea6d23c9cc58ae4f701711faa
+  metadata.gz: e3358beae7a3a96107e13e4b01d0fa065acb629b131acca5031168b85331ff88463a8f9e5f7fac09de0e28eb18f2380322e6e481857a8ec077cb4e4355240298
+  data.tar.gz: 7c100f51fb8cb143202016b7d129b80fcf20acea7301c117263b09efec99fdf9ffede2ecb0d47cef266d86489e07de0053b6c586c8d572a0d720fb815d395534

data/Manifest.txt

@@ -2,4 +2,11 @@ CHANGELOG.md
 Manifest.txt
 README.md
 Rakefile
+bin/monofile
 lib/monofile.rb
+lib/monofile/monofile.rb
+lib/monofile/mononame.rb
+lib/monofile/tool.rb
+lib/monofile/version.rb
+test/helper.rb
+test/test_names.rb

data/README.md

@@ -1,7 +1,7 @@
-# monofile - read in/ parse mono (source) tree defintions with git (and github) projects, and more
+# monofile - read in / parse monorepo / mono source tree definitions - a list of git (and github) projects, and more
 
-* home  :: [github.com/rubycoco/git](https://github.com/rubycoco/git)
-* bugs  :: [github.com/rubycoco/git/issues](https://github.com/rubycoco/git/issues)
+* home  :: [github.com/rubycoco/monos](https://github.com/rubycoco/monos)
+* bugs  :: [github.com/rubycoco/monos/issues](https://github.com/rubycoco/monos/issues)
 * gem   :: [rubygems.org/gems/monofile](https://rubygems.org/gems/monofile)
 * rdoc  :: [rubydoc.info/gems/monofile](http://rubydoc.info/gems/monofile)
 
@@ -9,7 +9,127 @@
 
 ## Usage
 
-To be done
+
+Use `Monofile.read` to read in / parse monorepo / mono source tree definitions - supporting a ruby or a yaml format.
+
+
+Example - `Monofile`:
+``` ruby
+project "@openfootball/england"
+project "@openfootball/world-cup"
+project "@geraldb/austria"
+project "@geraldb/geraldb.github.io"
+
+project "geraldb", "catalog"
+project "openfootball", "europe"
+project "openfootball", "south-america"
+```
+
+or
+
+Example - `monofile.yml`:
+
+``` yaml
+geraldb:
+- austria
+- catalog
+- geraldb.github.io
+
+openfootball:
+- england
+- europe
+- south-america
+- world-cup
+```
+
+
+To read use.
+
+``` ruby
+monofile = Monofile.read( "./Monofile" )
+# -or-
+monofile = Monofile.read( "./monofile.yml" )
+pp monofile.to_a
+#=> ["@openfootball/england",
+#    "@openfootball/world-cup",
+#    "@geraldb/austria",
+#    "@geraldb/geraldb.github.io",
+#    "@geraldb/catalog",
+#    "@openfootball/europe"]
+#    "@openfootball/south-america"]
+
+pp monofile.to_h
+#=> {"openfootball"=>["england", "world-cup", "europe", "south-america"],
+#    "geraldb"     =>["austria", "geraldb.github.io", "catalog"]}
+
+monofile.each do |proj|
+  puts "  #{proj}"
+end
+#=> @openfootball/england
+#   @openfootball/world-cup
+#   @geraldb/austria
+#   @geraldb/geraldb.github.io
+#   @geraldb/catalog
+#   @openfootball/europe
+#   @openfootball/south-america
+
+monofile.size
+#=> 7
+```
+
+and so on.  That's it for now.
+
+
+
+### Troubleshooting / Debugging
+
+Use the `monofile` command line tool to test reading in of
+monorepo / mono source tree definitions.
+Example:
+
+```  shell
+# option 1) try to find default name (e.g. Monofile, Monofile.rb, etc.)
+$ monofile
+
+# option 2) pass in monofiles
+$ monofile ./Monofile
+$ monofile ./monfile.yml
+# ...
+```
+
+Printing the normalized / canonical names of the repo sources. Example.
+
+```
+@openfootball/england
+@openfootball/world-cup
+@geraldb/austria
+@geraldb/geraldb.github.io
+@geraldb/catalog
+@openfootball/europe
+@openfootball/south-america
+```
+
+
+
+
+## Real-World Usage
+
+See the [`monos`](https://github.com/rubycoco/monos/tree/master/monos) package that incl. the `mono` (or short `mo`)
+command line tool lets you run
+git commands on multiple repo(sitories) with a single command.
+
+
+## Installation
+
+Use
+
+    gem install monofile
+
+or add to your Gemfile
+
+    gem 'monofile'
+
+
 
 ## License
 

data/Rakefile

@@ -1,13 +1,15 @@
 require 'hoe'
+require './lib/monofile/version.rb'
+
 
 Hoe.spec 'monofile' do
 
-  self.version = '0.0.1'   # note: for now add version inline
+  self.version = Mono::Module::Monofile::VERSION
 
-  self.summary = "monofile - read in/ parse mono (source) tree defintions with git (and github) projects, and more"
+  self.summary = "monofile - read in / parse monorepo / mono source tree definitions - a list of git (and github) projects, and more"
   self.description = summary
 
-  self.urls = { home: 'https://github.com/rubycoco/git' }
+  self.urls = { home: 'https://github.com/rubycoco/monos' }
 
   self.author = 'Gerald Bauer'
   self.email = 'opensport@googlegroups.com'

data/bin/monofile

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+###################
+# DEV TIPS:
+#
+# For local testing run like:
+#
+#    ruby -Ilib bin/monofile
+#
+# Set the executable bit in Linux. Example:
+#
+#    % chmod a+x bin/monofile
+#
+
+require 'monofile'
+
+Monofile::Tool.main

data/lib/monofile.rb

@@ -1,2 +1,64 @@
-# to be done
+##
+## "prelude / prolog " add some common used stdlibs
+##   add more - why? why not?
+require 'pp'
+require 'time'
+require 'date'
+require 'json'
+require 'yaml'
+require 'fileutils'
+
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+
+require 'optparse'    ## used by monofile (built-in test/debug) command line tool
+
+
+
+#####################
+# our own code
+require 'monofile/version'   # note: let version always go first
+require 'monofile/mononame'
+require 'monofile/monofile'
+require 'monofile/tool'
+
+
+
+module Mono
+
+  def self.root   ## root of single (monorepo) source tree
+    @@root ||= begin
+        ## todo/fix:
+        ##  check if windows - otherwise use /sites
+        ##  check if root directory exists?
+        if ENV['MOPATH']
+          ## use expand path to make (assure) absolute path - why? why not?
+          File.expand_path( ENV['MOPATH'] )
+        elsif Dir.exist?( 'C:/Sites' )
+          'C:/Sites'
+        else
+          '/sites'
+        end
+    end
+  end
+
+  def self.root=( path )
+    ## use expand path to make (assure) absolute path - why? why not?
+    @@root = File.expand_path( path )
+  end
+end  ## module Mono
+
+
+
+
+###
+## add some convenience alias for alternate spelling (CamelCase)
+MonoName = Mononame
+MonoPath = Monopath
+MonoFile = Monofile
+
+
+puts Mono::Module::Monofile.banner   ## say hello
 

data/lib/monofile/monofile.rb

@@ -0,0 +1,225 @@
+
+class Monofile
+  ## holds a list of projects
+
+  ## nested class
+  class Project    ## todo/fix: change to Monoproject/MonoProject - why? why not?
+    def initialize( *args )
+      if args.size == 2 && args[0].is_a?(String) && args[1].is_a?(String)
+        ## assume [org, name]
+        @name = Mononame.new( *args )
+      elsif args.size == 1 && args[0].is_a?( String )
+        @name = Mononame.parse( args[0] )
+      else
+        raise ArgumentError, "[MonoProject] one or two string args expected; got: #{args.pretty_inspect}"
+      end
+    end
+
+    def org()     @name.org; end
+    def name()    @name.name; end
+
+    def to_path() @name.to_path; end
+    def to_s()    @name.to_s; end
+
+    ## add clone_ssh_url  or such too!!!!
+  end  ## (nested) class Project
+
+
+
+  class Builder     ## "clean room" pattern/spell - keep accessible methods to a minimum (by eval in "cleanroom")
+    def initialize( monofile )
+      @monofile = monofile
+    end
+
+    def project( *args )
+      project = Project.new( *args )
+      @monofile.projects << project
+    end
+  end  # (nested) class Builder
+
+
+
+  RUBY_NAMES = ['monofile',
+                'Monofile',
+                'monofile.rb',
+                'Monofile.rb',
+               ]
+
+  TXT_NAMES  = ['monofile.txt',
+                'monotree.txt',  ## keep monotree - why? why not?
+                'monorepo.txt',
+                'repos.txt']
+
+  ## note: yaml always requires an extension
+  YML_NAMES = ['monofile.yml',   'monofile.yaml',
+                'monotree.yml',   'monotree.yaml',  ## keep monotree - why? why not?
+                'monorepo.yml',   'monorepo.yaml',
+                'repos.yml',      'repos.yaml',
+               ]    ## todo/check: add mono.yml too - why? why not?
+
+  NAMES = RUBY_NAMES + TXT_NAMES + YML_NAMES
+
+
+  def self.find
+    RUBY_NAMES.each do |name|
+      return "./#{name}"  if File.exist?( "./#{name}")
+    end
+
+    TXT_NAMES.each do |name|
+      return "./#{name}"  if File.exist?( "./#{name}")
+    end
+
+    YML_NAMES.each do |name|
+      return "./#{name}"  if File.exist?( "./#{name}")
+    end
+
+    nil  ## no monofile found; return nil
+  end
+
+
+  def self.read( path )
+      txt  = File.open( path, 'r:utf-8') { |f| f.read }
+
+      ## check for yml or yaml extension;
+      ##    or for txt extension; otherwise assume ruby
+      extname = File.extname( path ).downcase
+      if ['.yml', '.yaml'].include?( extname )
+        hash = YAML.load( txt )
+        new( hash )
+      elsif ['.txt'].include?( extname )
+        new( txt )
+      else  ## assume ruby code (as text in string)
+        new().load( txt )
+      end
+  end
+
+
+
+  def self.load( code )
+    monofile = new
+    monofile.load( code )
+    monofile
+  end
+
+  def self.load_file( path )  ## keep (or add load_yaml to or such) - why? why not?
+    code  = File.open( path, 'r:utf-8') { |f| f.read }
+    load( code )
+  end
+
+
+  ### attr readers
+  def projects() @projects; end
+  def size()     @projects.size; end
+
+
+  def initialize( obj={} )    ## todo/fix: change default to obj=[]
+    @projects = []
+
+    ## puts "[debug] obj.class=#{obj.class.name}"
+    add( obj )
+  end
+
+  def load( code )  ## note: code is text as a string
+    builder = Builder.new( self )
+    builder.instance_eval( code )
+    self  ## note: for chaining always return self
+  end
+
+
+  def add( obj )
+    ## todo/check: check for proc too! and use load( proc/block ) - possible?
+    if obj.is_a?( String )
+      puts "sorry add String - to be done!!!"
+      exit 1
+    elsif obj.is_a?( Array )
+      puts "sorry add Array- to be done!!!"
+      exit 1
+    elsif obj.is_a?( Hash )
+      add_hash( obj )
+    else  ## assume text (evaluate/parse)
+      puts "sorry add Text - to be done!!!"
+      exit 1
+    end
+    self ## note: return self for chaining
+  end
+
+
+  def add_hash( hash )
+    hash.each do |org_with_counter, names|
+
+      ## remove optional number from key e.g.
+      ##   mrhydescripts (3)    =>  mrhydescripts
+      ##   footballjs (4)       =>  footballjs
+      ##   etc.
+
+      ## todo/check: warn about duplicates or such - why? why not?
+
+      org = org_with_counter.sub( /\([0-9]+\)/, '' ).strip.to_s
+
+      names.each do |name|
+        @projects << Project.new( org, name )
+      end
+    end
+
+    self  ## note: return self for chaining
+  end
+
+
+
+  def each( &block )
+      ## puts "[debug] arity: #{block.arity}"
+
+      ## for backwards compatibility support "old" each with/by org & names
+      ##   add deprecated warnings and use to_h or such - why? why not?
+      if block.arity == 2
+        puts "!! DEPRECATED  - please, use Monofile#to_h or Monofile.each {|proj| ...}"
+        to_h.each do |org, names|
+          block.call( org, names )
+        end
+      else
+        ## assume just regular
+        @projects.each do |project|
+          block.call( project )
+        end
+      end
+  end # method each
+
+  def each_with_index( &block )
+    @projects.each_with_index do |project,i|
+       block.call( project, i )
+    end
+  end
+
+
+
+  ### for backward compat(ibility) add a hash in the form e.g:
+  ##
+  ## geraldb:
+  ## - austria
+  ## - catalog
+  ## - geraldb.github.io
+  ## openfootball:
+  ## - england
+  ## - europe
+  ## - south-america
+  ## - world-cup
+  ##
+  def to_h
+    h = {}
+    @projects.each do |project|
+      h[ project.org ] ||= []
+      h[ project.org ] << project.name
+    end
+    h
+  end
+
+  def to_a
+    ## todo/check:
+    ##   - sort all entries a-z - why? why not?
+    ##   - always start name with @ marker - why? why not?
+    @projects.map {|project| project.to_s }
+  end
+end # class Monofile
+
+
+

data/lib/monofile/mononame.rb

@@ -0,0 +1,176 @@
+#####
+#  mononame (e.g. @org/hello) machinery
+#  turn
+#  - @openfootball/england/2020-21
+#  - 2020-21@openfootball/england
+#  - england/2020-21@openfootball
+#      => into
+#  - openfootball/england/2020-21
+
+
+
+
+module Mono
+  ## shared parse/norm helper (for Name/Path)
+  ##  - find something better - why? why not?
+  def self.parse_name( line )
+    if line.is_a?( String )
+      parts = line.split( '@' )
+      raise ArgumentError, "[Mononame] no @ found BUT required in name; got >#{line}<"               if parts.size == 1
+      raise ArgumentError, "[Mononame] too many @ found (#{parts.size-1}) in name; got >#{line}<"    if parts.size > 2
+
+      ## pass 1) rebuild (normalized) name/path
+      name = String.new('')
+      name << parts[1]  ## add orgs path first - w/o leading @ - gets removed by split :-)
+      if parts[0].length > 0   ## has leading repo name (w/ optional path)
+        name << '/'
+        name << parts[0]
+      end
+
+      ## pass 2) split (normalized) name/path into components (org/name/path)
+      parts = name.split( '/' )
+
+      args = [parts[0], parts[1]]
+
+      more_parts = parts[2..-1]  ## check for any extra (optional) path parts
+      args << more_parts.join( '/' )    if more_parts.size > 0
+
+      args
+    else
+      raise ArgumentError, "[Mononame] string with @ expected; got: #{line.pretty_inspect} of type #{line.class.name}"
+    end
+  end
+end  # module Mono
+
+
+
+class Mononame
+  def self.parse( line )
+    values = Mono.parse_name( line )
+    raise ArgumentError, "[Mononame] expected two parts (org/name); got #{values.pretty_inspect}"   if values.size != 2
+    new( *values )
+  end
+
+  def self.real_path( line )
+    ## add one-time (quick) usage convenience shortcut
+    mononame = parse( line )
+    mononame.real_path
+  end
+
+
+  ## note: org and name for now required
+  ##   - make name optional too - why? why not?!!!
+  ## use some different names / attributes ??
+  attr_reader :org,     ## todo/check: find a different name (or add alias e.g. login/user/etc.)
+              :name
+
+  def initialize( org, name )
+    if org.is_a?(String) && name.is_a?(String)
+      @org  = org
+      @name = name
+    else
+      raise ArgumentError, "[Mononame] expected two strings (org, name); got >#{org}< of type #{org.class.name}, >#{name}< of type #{name.class.name}"
+    end
+  end
+
+  def to_path()   "#{@org}/#{@name}"; end
+  def to_s()      "@#{to_path}"; end
+
+  def real_path() "#{Mono.root}/#{to_path}"; end
+end # class Mononame
+
+
+
+####
+## todo/check:
+##   use as shared Mono/nomen/resource or such
+#   shared base class for Mononame & Monopath - why? why not?
+#
+#  Monoloc  (for location)
+#  Monores  (for resource)
+#  Mono__ ??
+#
+#  name components:
+#    - better name for path?  - use filepath, relpath, ...
+
+
+
+class Monopath
+  def self.parse( line )
+    values = Mono.parse_name( line )
+    raise ArgumentError, "[Monopath] expected three parts (org/name/path); got #{values.pretty_inspect}"   if values.size != 3
+    new( *values )
+  end
+
+  def self.real_path( line )
+    monopath = parse( line )
+    monopath.real_path
+  end
+
+
+  ## note: org and name AND path for now required
+  ##   - make name path optional too - why? why not?!!!
+  attr_reader :org, :name, :path
+
+  def initialize( org, name, path )
+     ## support/check for empty path too - why? why not?
+
+    if org.is_a?(String) && name.is_a?(String) && path.is_a?(String)
+    ## assume [org, name, path?]
+    ##  note: for now assumes proper formatted strings
+    ##   e.g. no leading @ or combined @hello/text in org
+    ##   or name or such
+    ##  - use parse/norm_name here too - why? why not?
+      @org  = org
+      @name = name
+      @path = path
+    else
+      raise ArgumentError, "[Monopath] expected three strings (org, name, path); got >#{org}< of type #{org.class.name}, >#{name}< of type #{name.class.name}, >#{path}< of type #{path.class.name}"
+    end
+  end
+
+  def to_path()   "#{@org}/#{@name}/#{@path}"; end
+  def to_s()      "@#{to_path}"; end
+
+  def real_path() "#{Mono.root}/#{to_path}"; end
+
+
+  ## some File-like convenience helpers
+  ##   e.g. File.exist?   => Monopath.exist?
+  ##        File.open     => Monopath.open( ... ) { block }
+  ##   etc.
+  def self.exist?( line )
+     File.exist?( real_path( line ) )
+  end
+
+
+  ## path always relative to Mono.root
+  ##   todo/fix:  use File.expand_path( path, Mono.root ) - why? why not?
+  ##    or always enfore "absolut" path e.g. do NOT allow ../ or ./ or such
+  def self.open( line, mode='r:utf-8', &block )
+    path = real_path( line )
+    ## make sure path exists if we open for writing/appending - why? why not?
+    if mode[0] == 'w' || mode[0] == 'a'
+      FileUtils.mkdir_p( File.dirname( path ) )  ## make sure path exists
+    end
+
+    File.open( path, mode ) do |file|
+      block.call( file )
+    end
+  end
+
+  def self.read_utf8( line )
+    open( line, 'r:utf-8') { |file| file.read }
+  end
+end  # class Monopath
+## note: use Monopath   - avoid confusion with Monofile (a special file with a list of mono projects)!!!!
+
+
+
+
+
+## todo/check: add a (global) Mono/Mononame converter - why? why not?
+##
+## module Kernel
+##  def Mono( *args ) Mononame.parse( *args ); end
+## end

data/lib/monofile/tool.rb

@@ -0,0 +1,59 @@
+class Monofile
+class Tool
+  def self.main( args=ARGV )
+
+    options = {}
+    OptionParser.new do |parser|
+      ## note:
+      ##  you can add many/multiple modules
+      ##  e.g. -r gitti -r mono etc.
+      parser.on( '-r NAME', '--require NAME') do |name|
+        options[:requires] ||= []
+        options[:requires] << name
+      end
+      ## todo/fix:
+      ##    add --verbose
+      ##    add -d/--debug
+    end.parse!( args )
+
+
+    if args.size == 0   ## auto-add default arg (monofile)
+      monofile_path = Monofile.find
+      if monofile_path.nil?
+        puts "!! ERROR: no mono configuration file found; looking for #{Monofile::NAMES.join(', ')} in (#{Dir.getwd})"
+        exit 1
+      end
+      args << monofile_path
+    end
+
+
+    ## add check for auto-require (e.g. ./config.rb)
+    if options[:requires]  ## use custom (auto-)requires
+      options[:requires].each do |path|
+        puts "[monofile] auto-require >#{path}<..."
+        require( path )
+      end
+    else  ## use/try defaults
+      config_path = "./config.rb"
+      if File.exist?( config_path )
+        puts "[monofile] auto-require (default) >#{config_path}<..."
+        require( config_path )
+      end
+    end
+
+
+    args.each do |path|
+      puts "[monofile] reading >#{path}<..."
+      monofile=Monofile.read( path )
+      pp monofile
+
+      ## print one project per line
+      puts "---"
+      monofile.each do |proj|
+        puts proj.to_s
+      end
+    end
+  end # method self.main
+end # (nested) class Tool
+end # class Monofile
+

data/lib/monofile/version.rb

@@ -0,0 +1,28 @@
+
+module Mono
+module Module
+module Monofile
+
+  MAJOR = 0    ## todo: namespace inside version or something - why? why not??
+  MINOR = 2
+  PATCH = 2
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "monofile/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+  end
+
+  ## note: move root to its own namespace to avoid
+  ##   conflict with Mono.root!!!!
+  def self.root
+    File.expand_path( File.dirname(File.dirname(__FILE__) ))
+  end
+
+end # module Monofile
+end # module Module
+end # module Mono
+

data/test/helper.rb

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

data/test/test_names.rb

@@ -0,0 +1,97 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_names.rb
+
+
+require 'helper'
+
+
+class TestNames < MiniTest::Test
+
+def test_parse
+  %w[
+    @openfootball/england
+    england@openfootball
+  ].each do |line|
+    mono = Mononame.parse( line )
+
+    assert_equal '@openfootball/england', mono.to_s
+    assert_equal 'openfootball/england',  mono.to_path
+
+    assert_equal 'openfootball',          mono.org
+    assert_equal 'england',               mono.name
+  end
+
+
+  %w[
+    @openfootball/england/2020-21
+    2020-21@openfootball/england
+    england/2020-21@openfootball
+  ].each do |line|
+    mono = Monopath.parse( line )
+
+    assert_equal '@openfootball/england/2020-21', mono.to_s
+    assert_equal 'openfootball/england/2020-21',  mono.to_path
+
+    assert_equal 'openfootball',            mono.org
+    assert_equal 'england',                 mono.name
+    assert_equal '2020-21',                 mono.path
+  end
+
+  %w[
+    @openfootball/england/2020-21/premierleague.txt
+    2020-21/premierleague.txt@openfootball/england
+    england/2020-21/premierleague.txt@openfootball
+  ].each do |line|
+    mono = Monopath.parse( line )
+
+    assert_equal '@openfootball/england/2020-21/premierleague.txt', mono.to_s
+    assert_equal 'openfootball/england/2020-21/premierleague.txt',  mono.to_path
+
+    assert_equal 'openfootball',              mono.org
+    assert_equal 'england',                   mono.name
+    assert_equal '2020-21/premierleague.txt', mono.path
+  end
+end   # method test_parse
+
+
+
+def test_init
+  mono = Mononame.new( 'openfootball','england' )
+
+  assert_equal '@openfootball/england', mono.to_s
+  assert_equal 'openfootball/england',  mono.to_path
+
+  assert_equal 'openfootball',            mono.org
+  assert_equal 'england',              mono.name
+
+
+  mono = Monopath.new( 'openfootball', 'england', '2020-21' )
+
+  assert_equal '@openfootball/england/2020-21', mono.to_s
+  assert_equal 'openfootball/england/2020-21',  mono.to_path
+
+  assert_equal 'openfootball',            mono.org
+  assert_equal 'england',                 mono.name
+  assert_equal '2020-21',                 mono.path
+
+
+  ## !!!!todo/check/fix!!!!!:
+  ##   - support '2020-21', 'premierleague.txt' too (or only) - why? why not?
+  ##
+  ##  todo/check/fix:
+  ##    find a better name for path/path? component / part - why? why not?
+  ##      to_path and path/path? to confusing!!!
+  mono = Monopath.new( 'openfootball', 'england', '2020-21/premierleague.txt' )
+
+  assert_equal '@openfootball/england/2020-21/premierleague.txt', mono.to_s
+  assert_equal 'openfootball/england/2020-21/premierleague.txt',  mono.to_path
+
+  assert_equal 'openfootball',              mono.org
+  assert_equal 'england',                   mono.name
+  assert_equal '2020-21/premierleague.txt', mono.path
+end   # method test_init
+
+
+
+end # class TestNames

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monofile
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-29 00:00:00.000000000 Z
+date: 2020-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -44,10 +44,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.22'
-description: monofile - read in/ parse mono (source) tree defintions with git (and
-  github) projects, and more
+description: monofile - read in / parse monorepo / mono source tree definitions -
+  a list of git (and github) projects, and more
 email: opensport@googlegroups.com
-executables: []
+executables:
+- monofile
 extensions: []
 extra_rdoc_files:
 - CHANGELOG.md
@@ -58,8 +59,15 @@ files:
 - Manifest.txt
 - README.md
 - Rakefile
+- bin/monofile
 - lib/monofile.rb
-homepage: https://github.com/rubycoco/git
+- lib/monofile/monofile.rb
+- lib/monofile/mononame.rb
+- lib/monofile/tool.rb
+- lib/monofile/version.rb
+- test/helper.rb
+- test/test_names.rb
+homepage: https://github.com/rubycoco/monos
 licenses:
 - Public Domain
 metadata: {}
@@ -84,6 +92,6 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: monofile - read in/ parse mono (source) tree defintions with git (and github)
-  projects, and more
+summary: monofile - read in / parse monorepo / mono source tree definitions - a list
+  of git (and github) projects, and more
 test_files: []