monofile 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5eec75976cf450820db212178fd4d692c36d9b3b
-  data.tar.gz: bd1ba77e17a11d9689c7141e0139d325e44820b8
+  metadata.gz: b40761cdf41323e67c0f31dc5322ae1d33a73a40
+  data.tar.gz: 69eebef7b4e3a036eaf45c2888fdaaaaae0b0dc8
 SHA512:
-  metadata.gz: 82ece3e26bc0184c4c1d49fa2250782fc8dc39a95534022423d82c2338662f7035daed5dfe13512b2e56ecc4b04f2859b00f910b05b42f8726bd7581d09f62ba
-  data.tar.gz: dbe0a1ee9f96652bdd2aba052526d666ce7f2e736788e278877ff3ed26990c5b5df0ce2f021b2fa830d0081762b9a1313ac7512fb3455805d197c41caa2e2ea2
+  metadata.gz: b35816490aff623a84368d646fdb68ba9c999009210a613c6731f1636b0b00a7d23e6d5a99e9041700c067f4d929b54d1b780fa6081512d99b297a40c9db73f8
+  data.tar.gz: dd939bbab36398a63340e2810f86774a077676f0bad3a91bee3220a9ecceb7f6a7828df64f2da41b5369249117424b5857d37a774da46aaecb2e9d6c18a3fa22

data/Manifest.txt

@@ -4,4 +4,8 @@ README.md
 Rakefile
 bin/monofile
 lib/monofile.rb
+lib/monofile/monofile.rb
+lib/monofile/mononame.rb
 lib/monofile/version.rb
+test/helper.rb
+test/test_names.rb

data/lib/monofile.rb

@@ -20,6 +20,8 @@ require 'optparse'
 #####################
 # our own code
 require 'monofile/version'   # note: let version always go first
+require 'monofile/mononame'
+require 'monofile/monofile'
 
 
 
@@ -64,240 +66,11 @@ end  ## module Mono
 
 
 
-
-
-class Monofile
-  ## holds a list of projects
-
-  ## nested class
-  class Project
-
-    ## use some different names / attributes ??
-    attr_reader :org,    ## todo/check: find a different name (or add alias e.g. login/user/etc.)
-                :name
-
-    ## todo/fix:
-    ##  - use *args  and than split if args==2 or args==1 etc.
-    def initialize( *args )
-      if args.size == 2 && args[0].is_a?(String) && args[1].is_a?(String)
-        ## assume [org, name]
-        @org  = args[0]
-        @name = args[1]
-      elsif args.size == 1 && args[0].is_a?( String )
-        ## todo/fix:  use norm_name parser or such!!!!
-        parts = args[0].split( '/' )
-        @org  = parts[0][1..-1]   ## cut-off leading @ (always assume for now!!)
-        @name = parts[1]
-      else
-        raise ArgumentError, "[Monorepo::Project] one or two string args expected; got: #{args.pretty_inspect}"
-      end
-    end
-
-    def to_s()    "@#{org}/#{name}"; end
-    def to_path() "#{org}/#{name}"; 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
-  ## - logos
-  ## yorobot:
-  ## - auto
-  ## - backup
-  ## - football.json
-  ## - logs
-  ##
-  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
-
-
+###
+## add some convenience alias for alternate spelling (CamelCase)
+MonoName = Mononame
+MonoPath = Monopath
+MonoFile = Monofile
 
 
 
@@ -305,6 +78,9 @@ class Monofile
 class Tool
   def self.main( args=ARGV )
 
+    ## todo/fix:
+    ##   check args - if any, use/read monofiles in args!!!
+
     path = Monofile.find
     if path.nil?
       puts "!! ERROR: no mono configuration file found; looking for #{Monofile::NAMES.join(', ')} in (#{Dir.getwd})"
@@ -332,5 +108,6 @@ end # (nested) class Tool
 end # class Monofile
 
 
+
 Mono::Module::Monofile.banner
 

data/lib/monofile/monofile.rb

@@ -0,0 +1,226 @@
+
+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
+  ## - logos
+  ## yorobot:
+  ## - auto
+  ## - backup
+  ## - football.json
+  ## - logs
+  ##
+  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,132 @@
+#####
+#  mononame (e.g. @org/hello) machinery
+#  turn
+#  - @yorobot/stage/one
+#  - one@yorobot/stage
+#  - stage/one@yorobot
+#      => into
+#  - yorobot/stage/one
+
+
+
+
+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
+
+
+
+  ## 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
+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
+
+  ## 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
+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/version.rb

@@ -4,8 +4,8 @@ module Module
 module Monofile
 
   MAJOR = 0    ## todo: namespace inside version or something - why? why not??
-  MINOR = 1
-  PATCH = 1
+  MINOR = 2
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

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,96 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_names.rb
+
+
+require 'helper'
+
+
+class TestNames < MiniTest::Test
+
+def test_parse
+  %w[
+    @yorobot/stage
+    stage@yorobot
+  ].each do |line|
+    mono = Mononame.parse( line )
+
+    assert_equal '@yorobot/stage', mono.to_s
+    assert_equal 'yorobot/stage',  mono.to_path
+
+    assert_equal 'yorobot',            mono.org
+    assert_equal 'stage',              mono.name
+  end
+
+
+  %w[
+    @yorobot/stage/one
+    one@yorobot/stage
+    stage/one@yorobot
+  ].each do |line|
+    mono = Monopath.parse( line )
+
+    assert_equal '@yorobot/stage/one', mono.to_s
+    assert_equal 'yorobot/stage/one',  mono.to_path
+
+    assert_equal 'yorobot',            mono.org
+    assert_equal 'stage',              mono.name
+    assert_equal 'one',                mono.path
+  end
+
+  %w[
+    @yorobot/stage/one/hello.txt
+    hello.txt@yorobot/stage/one
+    stage/one/hello.txt@yorobot
+  ].each do |line|
+    mono = Monopath.parse( line )
+
+    assert_equal '@yorobot/stage/one/hello.txt', mono.to_s
+    assert_equal 'yorobot/stage/one/hello.txt',  mono.to_path
+
+    assert_equal 'yorobot',            mono.org
+    assert_equal 'stage',              mono.name
+    assert_equal 'one/hello.txt',      mono.path
+  end
+end   # method test_parse
+
+
+def test_init
+  mono = Mononame.new( 'yorobot','stage' )
+
+  assert_equal '@yorobot/stage', mono.to_s
+  assert_equal 'yorobot/stage',  mono.to_path
+
+  assert_equal 'yorobot',            mono.org
+  assert_equal 'stage',              mono.name
+
+
+  mono = Monopath.new( 'yorobot', 'stage', 'one' )
+
+  assert_equal '@yorobot/stage/one', mono.to_s
+  assert_equal 'yorobot/stage/one',  mono.to_path
+
+  assert_equal 'yorobot',            mono.org
+  assert_equal 'stage',              mono.name
+  assert_equal 'one',                mono.path
+
+
+  ## !!!!todo/check/fix!!!!!:
+  ##   - support 'one', 'hello.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( 'yorobot', 'stage', 'one/hello.txt' )
+
+  assert_equal '@yorobot/stage/one/hello.txt', mono.to_s
+  assert_equal 'yorobot/stage/one/hello.txt',  mono.to_path
+
+  assert_equal 'yorobot',            mono.org
+  assert_equal 'stage',              mono.name
+  assert_equal 'one/hello.txt',      mono.path
+end   # method test_init
+
+
+
+end # class TestNames

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monofile
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Gerald Bauer
@@ -61,7 +61,11 @@ files:
 - Rakefile
 - bin/monofile
 - lib/monofile.rb
+- lib/monofile/monofile.rb
+- lib/monofile/mononame.rb
 - lib/monofile/version.rb
+- test/helper.rb
+- test/test_names.rb
 homepage: https://github.com/rubycoco/git
 licenses:
 - Public Domain