quik 0.1.1 → 1.0.0

data/lib/quik/cli/opts.rb

@@ -1,33 +1,33 @@
-# encoding: utf-8
-
-module Quik
-
-class Opts
-
-  def merge_gli_options!( options = {} )
-    @test    = true     if options[:test]    == true
-    @verbose = true     if options[:verbose] == true
-  end
-
-
-  def verbose=(boolean)   # add: alias for debug ??
-    @verbose = boolean
-  end
-
-  def verbose?
-    return false if @verbose.nil?   # default verbose/debug flag is false
-    @verbose == true
-  end
-
-  def test=(boolean)
-    @test = boolean
-  end
-
-  def test?
-    return false if @test.nil?   # default test/dry-run flag is false
-    @test == true
-  end
-
-end # class Opts
-
-end # module Quik
+# encoding: utf-8
+
+module Quik
+
+class Opts
+
+  def merge_gli_options!( options = {} )
+    @test    = true     if options[:test]    == true
+    @verbose = true     if options[:verbose] == true
+  end
+
+
+  def verbose=(boolean)   # add: alias for debug ??
+    @verbose = boolean
+  end
+
+  def verbose?
+    return false if @verbose.nil?   # default verbose/debug flag is false
+    @verbose == true
+  end
+
+  def test=(boolean)
+    @test = boolean
+  end
+
+  def test?
+    return false if @test.nil?   # default test/dry-run flag is false
+    @test == true
+  end
+
+end # class Opts
+
+end # module Quik

data/lib/quik/colors.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+### todo: move to textutils for (re)use - why? why not??
+###   todo add some references to alternative color gems
+##
+##  e.g. https://github.com/fazibear/colorize
+##       http://github.com/ssoroka/ansi
+##       http://flori.github.com/term-ansicolor/
+##       http://github.com/sickill/rainbow
+##       https://github.com/janlelis/paint
+
+
+## move to core_ext.rb - why? why not??
+
+###
+## fix: use css style
+##  e.g. color( :red )
+##       color( :blue )
+##       background_color( :red )
+##       font_style( :bold )  -- why? why not??
+
+class String
+
+  def self.use_colors?
+    @@use_color ||=  true
+    ##  todo/fix: check for windows on load (set to false;otherwise true)
+    @@use_color
+  end
+
+  def self.use_colors=(value)
+    @@use_color = value
+  end
+
+
+  def red()      colorize(31); end
+  def green()    colorize(32); end
+  def yellow()   colorize(33); end   ## note: more brown-ish (if not used w/ bold/bright mode) ??
+  def blue()     colorize(34); end
+  def magenta()  colorize(35); end   ## pink ??
+  def cyan()     colorize(36); end   ## light blue ?? 
+
+  def bold()     colorize(1); end    ## just use 0 clear for now; instead of BOLD_OFF (22) code; use bright as an alias??
+
+private
+  def colorize(code)
+    if self.class.use_colors?
+      "\e[#{code}m#{self}\e[0m"
+    else
+      self
+    end
+  end
+
+
+   ## todo - add modes e.g. bold/underscore/etc.
+=begin
+class String
+def black;          "\e[30m#{self}\e[0m" end
+def red;            "\e[31m#{self}\e[0m" end
+def green;          "\e[32m#{self}\e[0m" end
+def brown;          "\e[33m#{self}\e[0m" end
+def blue;           "\e[34m#{self}\e[0m" end
+def magenta;        "\e[35m#{self}\e[0m" end
+def cyan;           "\e[36m#{self}\e[0m" end
+def gray;           "\e[37m#{self}\e[0m" end
+
+def on_black;       "\e[40m#{self}\e[0m" end
+def on_red;         "\e[41m#{self}\e[0m" end
+def on_green;       "\e[42m#{self}\e[0m" end
+def on_brown;       "\e[43m#{self}\e[0m" end
+def on_blue;        "\e[44m#{self}\e[0m" end
+def on_magenta;     "\e[45m#{self}\e[0m" end
+def on_cyan;        "\e[46m#{self}\e[0m" end
+def on_gray;        "\e[47m#{self}\e[0m" end
+
+def bold;           "\e[1m#{self}\e[21m" end
+def italic;         "\e[3m#{self}\e[23m" end
+def underline;      "\e[4m#{self}\e[24m" end
+def blink;          "\e[5m#{self}\e[25m" end
+def reverse_color;  "\e[7m#{self}\e[27m" end
+
+use Ansi constants - why? why not? e.g.:
+//foreground color
+public static final String BLACK_TEXT()   { return "\033[30m";}
+public static final String RED_TEXT()     { return "\033[31m";}
+public static final String GREEN_TEXT()   { return "\033[32m";}
+public static final String BROWN_TEXT()   { return "\033[33m";}
+public static final String BLUE_TEXT()    { return "\033[34m";}
+public static final String MAGENTA_TEXT() { return "\033[35m";}
+public static final String CYAN_TEXT()    { return "\033[36m";}
+public static final String GRAY_TEXT()    { return "\033[37m";}
+
+//background color
+public static final String BLACK_BACK()   { return "\033[40m";}
+public static final String RED_BACK()     { return "\033[41m";}
+public static final String GREEN_BACK()   { return "\033[42m";}
+public static final String BROWN_BACK()   { return "\033[43m";}
+public static final String BLUE_BACK()    { return "\033[44m";}
+public static final String MAGENTA_BACK() { return "\033[45m";}
+public static final String CYAN_BACK()    { return "\033[46m";}
+public static final String WHITE_BACK()   { return "\033[47m";}
+
+//ANSI control chars
+public static final String RESET_COLORS() { return "\033[0m";}
+public static final String BOLD_ON()      { return "\033[1m";}
+public static final String BLINK_ON()     { return "\033[5m";}
+public static final String REVERSE_ON()   { return "\033[7m";}
+public static final String BOLD_OFF()     { return "\033[22m";}
+public static final String BLINK_OFF()    { return "\033[25m";}
+public static final String REVERSE_OFF()  { return "\033[27m";}
+end
+
+Code 	Effect
+0 	Turn off all attributes
+1 	Set bright mode
+4 	Set underline mode
+5 	Set blink mode
+7 	Exchange foreground and background colors
+8 	Hide text (foreground color would be the same as background)
+30 	Black text
+31 	Red text
+32 	Green text
+33 	Yellow text
+34 	Blue text
+35 	Magenta text
+36 	Cyan text
+37 	White text
+39 	Default text color
+40 	Black background
+41 	Red background
+42 	Green background
+43 	Yellow background
+44 	Blue background
+45 	Magenta background
+46 	Cyan background
+47 	White background
+49 	Default background color
+
+note:
+puts "\e[31m" # set format (red foreground)
+puts "\e[0"   # clear format
+puts "green-#{"red".red}-green".green # will be green-red-normal, because of \e[0
+e.g. for now colors can NOT get nested
+     plus if you bold/italic/etc. use it before the color e.g.
+      bold.red etc.
+=end
+
+
+end # class String

data/lib/quik/config.rb

@@ -1,60 +1,60 @@
-#encoding: utf-8
-
-module Quik
-
-##
-# used for config block
-#   lets you access props (even nested) that don't yet exist
-#    and all props get stored in a hash
-#
-#  e.g
-#  c = OpenConfig.new
-#  c.title        = 'title'
-#  c.author.name  = 'name'
-
-#  c.quik.last_updated = Time.now
-#  c.quik.title        = 'title'
-#  c.quik.name         = 'name'
-#  c.quik.theme        = 'theme'
-
-class OpenConfig
-
-  def initialize
-    @h = {}
-  end
-
-  def to_h
-    h = {}
-    @h.each do |k,v|
-      if v.is_a? OpenConfig
-        h[ k ] = v.to_h
-      else
-        h[ k ] = v  ## just pass along as is
-      end
-    end
-    h
-  end
-
-  def method_missing( m, *args, &block)
-    if m.to_s =~ /^(.*)=$/   ## setter
-      puts "config lookup (setter) >#{m}< #{m.class.name}, #{args.inspect}"
-      key = m[0..-2].to_s  ## cut off trailing =
-      @h[ key ] = args[0].to_s    # note: assume first arg is value for setter
-                                # note: for now all values are strings (always use to_s)
-    else       ## assume getter
-      ## fix: add check for args??  must be 0 for getters??
-      ##       use else super to delegate non-getters??
-      puts "config lookup (getter) >#{m}< #{m.class.name}"
-      key = m.to_s
-      value = @h[ key ]
-      if value.nil?
-        puts "  config add (nested) hash"
-        value = @h[ key ] = OpenConfig.new
-      end
-      value
-    end  
-  end # method_missing
-
-end # class OpenConfig
-   
-end  # module Quik
+#encoding: utf-8
+
+module Quik
+
+##
+# used for config block
+#   lets you access props (even nested) that don't yet exist
+#    and all props get stored in a hash
+#
+#  e.g
+#  c = OpenConfig.new
+#  c.title        = 'title'
+#  c.author.name  = 'name'
+
+#  c.quik.last_updated = Time.now
+#  c.quik.title        = 'title'
+#  c.quik.name         = 'name'
+#  c.quik.theme        = 'theme'
+
+class OpenConfig
+
+  def initialize
+    @h = {}
+  end
+
+  def to_h
+    h = {}
+    @h.each do |k,v|
+      if v.is_a? OpenConfig
+        h[ k ] = v.to_h
+      else
+        h[ k ] = v  ## just pass along as is
+      end
+    end
+    h
+  end
+
+  def method_missing( m, *args, &block)
+    if m.to_s =~ /^(.*)=$/   ## setter
+      puts "config lookup (setter) >#{m}< #{m.class.name}, #{args.inspect}"
+      key = m[0..-2].to_s  ## cut off trailing =
+      @h[ key ] = args[0].to_s    # note: assume first arg is value for setter
+                                # note: for now all values are strings (always use to_s)
+    else       ## assume getter
+      ## fix: add check for args??  must be 0 for getters??
+      ##       use else super to delegate non-getters??
+      puts "config lookup (getter) >#{m}< #{m.class.name}"
+      key = m.to_s
+      value = @h[ key ]
+      if value.nil?
+        puts "  config add (nested) hash"
+        value = @h[ key ] = OpenConfig.new
+      end
+      value
+    end  
+  end # method_missing
+
+end # class OpenConfig
+   
+end  # module Quik

data/lib/quik/merger.rb

@@ -1,202 +1,207 @@
-# encoding: utf-8
-
-module Quik
-
-class Merger
-
-
-
-  def find_files( root_dir )
-    tree = []
-
-    files =  Dir.entries( root_dir )
-    files = files.sort
-    puts "#{root_dir}:"
-    pp files
-
-    files.each do |file|
-      if File.directory?( "#{root_dir}/#{file}" )
-        ## note: skip directory if it starts with dot e.g. . or .. or .git etc.
-        if file.start_with?( '.' )
-          puts "skipping directory >#{file}< (#{root_dir})"
-          next
-        end
-        subtree = find_files( "#{root_dir}/#{file}" )
-        tree << [ file, subtree ]
-      else
-        ## just a "regular" file
-        tree << file
-      end
-    end
-    tree
-  end
-
-
-  def merge_filenames( root_dir, hash, opts={} )  ## flags e.g. noop, verbose, etc. see FileUtils
-    tree = find_files( root_dir )
-    pp tree
-
-    flags = {     ## always use verbose mode for now
-      verbose: true
-    }
-
-    ## todo/check: move opts={} to initialize e.g. Merger.new( opts={}) why? why not??
-
-    ## check for noop e.g. test mode/dry run
-    flags[ :noop ] = true  if opts[:test] || opts[:dry_run] || opts[:noop]
-
-    puts "walk tree:"
-    merge_filenames_worker_step1( root_dir, hash, tree, flags )
-    merge_filenames_worker_step2( root_dir, hash, tree, flags )
-  end
-
-  def merge_filenames_worker_step1( root_dir, hash, tree, flags )
-    ## note:  step 1 move all files
-    ##        step 2 move all dirs
-
-    tree.each do |node|
-      if node.is_a? Array ## assume it's a directory
-        merge_filenames_worker_step1( "#{root_dir}/#{node[0]}", hash, node[1], flags )
-      else  ## assume it's a file
-        old_name = node
-        new_name = merge_path( old_name, hash )
-        if old_name == new_name
-           puts "  keep file #{node} (#{root_dir})"
-        else
-           puts "  *** move file #{old_name} => #{new_name} (#{root_dir})"
-           src_path  = "#{root_dir}/#{old_name}"
-           dest_path = "#{root_dir}/#{new_name}"
-           FileUtils.mv( src_path, dest_path, flags )
-        end
-      end
-    end
-  end
-
-  def merge_filenames_worker_step2( root_dir, hash, tree, flags )
-    ## note:  step 1 move all files
-    ##        step 2 move all dirs
-
-    tree.each do |node|
-      if node.is_a? Array ## assume it's a directory
-        merge_filenames_worker_step2( "#{root_dir}/#{node[0]}", hash, node[1], flags )
-        old_name = node[0]
-        new_name = merge_path( old_name, hash )
-        if old_name == new_name
-           puts "  keep dir #{node[0]} (#{root_dir})"
-        else
-           puts "  *** move dir #{old_name} => #{new_name} (#{root_dir})"
-           src_path  = "#{root_dir}/#{old_name}"
-           dest_path = "#{root_dir}/#{new_name}"
-           FileUtils.mv( src_path, dest_path, flags )
-        end
-      end
-    end
-  end
-
-
-
-  def merge_files( root_dir, hash, opts={} )
-    ## note: rescan files (after renames)
-    tree = find_files( root_dir )
-    pp tree
-
-    puts "walk tree:"
-    merge_files_worker( root_dir, '', hash, tree, opts )
-  end
-
-  def merge_files_worker( root_dir, relative_dir, hash, tree, opts )
-    tree.each do |node|
-      if node.is_a? Array ## assume it's a directory
-        if relative_dir.empty?   # e.g. just add w/o leading slash e.g. 'lib' and not '/lib'
-          new_relative_dir = node[0].dup  # note: create a new string; just in case
-        else
-          new_relative_dir = "#{relative_dir}/#{node[0]}"
-        end
-        merge_files_worker( root_dir, new_relative_dir, hash, node[1], opts )
-      else  ## assume it's a file
-        if relative_dir.empty?
-          relative_path = node
-        else
-          relative_path = "#{relative_dir}/#{node}"
-        end
-
-        src_path = "#{root_dir}/#{relative_path}"
-        
-        ## note: for now assume always assume text files/utf8
-        ##  fix: change to File.read_utf8 ??
-        old_text = File.read( src_path )
-        new_text = merge_text( old_text, hash )
-
-        if opts[:o]
-          dest_root = opts[:o]
-          dest_path = "#{dest_root}/#{relative_path}"
-          ## make sure dest_path exists
-          dest_dir = File.dirname( dest_path )
-          FileUtils.mkdir_p( dest_dir ) unless Dir.exists?( dest_dir )
-        else
-          dest_root = root_dir
-          dest_path = "#{dest_root}/#{relative_path}"
-        end
-
-        if old_text == new_text
-           if opts[:o]  ## for testing copy file 1:1
-             puts "  copy file 1:1 #{node} (#{relative_dir}) in (#{dest_root})"
-             FileUtils.cp( src_path, dest_path, verbose: true )
-           else
-             puts "  skip file #{node} (#{relative_dir})"
-           end
-        else
-           puts "  *** update file #{node} (#{relative_dir}) in (#{dest_root})"
-           File.open( dest_path, 'w' ) do |f|
-             f.write new_text
-           end
-        end
-      end
-    end
-  end
-
-
-
-  def merge_path( path, hash )
-    ## e.g. allow
-    ##  __filename__  or
-    ##  $filename$   for now
-    path.gsub( /(__|\$)([a-z]+)\1/i ) do |_|
-      key   = $2.to_s
-      value = hash[ key ]
-      puts "   [path] replacing #{key} w/ >#{value}< in (#{path})"
-      value
-    end
-  end
-
-  def merge_text( text, hash )
-    ## e.g. allow
-    ##  $filename$  for now only in text
-    ##  note: must include leading and trailing word boundry (/B)
-    ##   e.g. hello$test$ will not match only "free-standing $test
-    ##  or in quote e.g. "$test$"
-    ##  e.g. no letters or digits allowed before or after $ to match
-
-    ## pp text
-
-    text.gsub( /\B\$([a-z]+)\$\B/i ) do |_|
-      key   = $1.to_s
-      value = hash[ key ]
-      puts "   [text] replacing #{key} w/ >#{value}<"
-      value
-    end
-  end
-
-
-
-  def merge( root_dir, hash, opts={} )
-    puts "  merge #{root_dir}, #{hash.inspect}"
-
-    merge_filenames( root_dir, hash, opts )
-    merge_files( root_dir, hash, opts )
-  end
-
-end # class Merger
-
-end # module Quik
-
+# encoding: utf-8
+
+module Quik
+
+class Merger
+
+
+
+  def find_files( root_dir )
+    tree = []
+
+    files =  Dir.entries( root_dir )
+    files = files.sort
+    puts "#{root_dir}:"
+    pp files
+
+    files.each do |file|
+      if File.directory?( "#{root_dir}/#{file}" )
+        ## note: skip directory if it starts with dot e.g. . or .. or .git etc.
+        if file.start_with?( '.' )
+          puts "skipping directory >#{file}< (#{root_dir})"
+          next
+        end
+        subtree = find_files( "#{root_dir}/#{file}" )
+        tree << [ file, subtree ]
+      else
+        ## just a "regular" file
+        tree << file
+      end
+    end
+    tree
+  end
+
+
+  def merge_filenames( root_dir, hash, opts={} )  ## flags e.g. noop, verbose, etc. see FileUtils
+    tree = find_files( root_dir )
+    pp tree
+
+    flags = {     ## always use verbose mode for now
+      verbose: true
+    }
+
+    ## todo/check: move opts={} to initialize e.g. Merger.new( opts={}) why? why not??
+
+    ## check for noop e.g. test mode/dry run
+    flags[ :noop ] = true  if opts[:test] || opts[:dry_run] || opts[:noop]
+
+    puts "walk tree:"
+    merge_filenames_worker_step1( root_dir, hash, tree, flags )
+    merge_filenames_worker_step2( root_dir, hash, tree, flags )
+  end
+
+  def merge_filenames_worker_step1( root_dir, hash, tree, flags )
+    ## note:  step 1 move all files
+    ##        step 2 move all dirs
+
+    tree.each do |node|
+      if node.is_a? Array ## assume it's a directory
+        merge_filenames_worker_step1( "#{root_dir}/#{node[0]}", hash, node[1], flags )
+      else  ## assume it's a file
+        old_name = node
+        new_name = merge_path( old_name, hash )
+        if old_name == new_name
+           puts "  keep file #{node} (#{root_dir})"
+        else
+           puts "  *** move file #{old_name} => #{new_name} (#{root_dir})"
+           src_path  = "#{root_dir}/#{old_name}"
+           dest_path = "#{root_dir}/#{new_name}"
+           ## note: make sure subpath exists (e.g. replacement might include new (sub)dirs too)
+           FileUtils.mkdir_p( File.dirname( dest_path ), flags )  unless Dir.exist?( File.dirname( dest_path ))
+           FileUtils.mv( src_path, dest_path, flags )
+        end
+      end
+    end
+  end
+
+  def merge_filenames_worker_step2( root_dir, hash, tree, flags )
+    ## note:  step 1 move all files
+    ##        step 2 move all dirs
+
+    tree.each do |node|
+      if node.is_a? Array ## assume it's a directory
+        merge_filenames_worker_step2( "#{root_dir}/#{node[0]}", hash, node[1], flags )
+        old_name = node[0]
+        new_name = merge_path( old_name, hash )
+        if old_name == new_name
+           puts "  keep dir #{node[0]} (#{root_dir})"
+        else
+           puts "  *** move dir #{old_name} => #{new_name} (#{root_dir})"
+           src_path  = "#{root_dir}/#{old_name}"
+           dest_path = "#{root_dir}/#{new_name}"
+           ## note: make sure subpath exists (e.g. replacement might include new (sub)dirs too)
+           FileUtils.mkdir_p( File.dirname( dest_path ), flags )  unless Dir.exist?( File.dirname( dest_path ))
+           FileUtils.mv( src_path, dest_path, flags )
+        end
+      end
+    end
+  end
+
+
+
+  def merge_files( root_dir, hash, opts={} )
+    ## note: rescan files (after renames)
+    tree = find_files( root_dir )
+    pp tree
+
+    puts "walk tree:"
+    merge_files_worker( root_dir, '', hash, tree, opts )
+  end
+
+  def merge_files_worker( root_dir, relative_dir, hash, tree, opts )
+    tree.each do |node|
+      if node.is_a? Array ## assume it's a directory
+        if relative_dir.empty?   # e.g. just add w/o leading slash e.g. 'lib' and not '/lib'
+          new_relative_dir = node[0].dup  # note: create a new string; just in case
+        else
+          new_relative_dir = "#{relative_dir}/#{node[0]}"
+        end
+        merge_files_worker( root_dir, new_relative_dir, hash, node[1], opts )
+      else  ## assume it's a file
+        if relative_dir.empty?
+          relative_path = node
+        else
+          relative_path = "#{relative_dir}/#{node}"
+        end
+
+        src_path = "#{root_dir}/#{relative_path}"
+
+        ## note: for now assume always assume text files/utf8
+        old_text = File.open( src_path, 'r:utf-8' ) { |f| f.read }
+        new_text = merge_text( old_text, hash )
+
+        if opts[:o]
+          dest_root = opts[:o]
+          dest_path = "#{dest_root}/#{relative_path}"
+          ## make sure dest_path exists
+          dest_dir = File.dirname( dest_path )
+          FileUtils.mkdir_p( dest_dir ) unless Dir.exist?( dest_dir )
+        else
+          dest_root = root_dir
+          dest_path = "#{dest_root}/#{relative_path}"
+        end
+
+        if old_text == new_text
+           if opts[:o]  ## for testing copy file 1:1
+             puts "  copy file 1:1 #{node} (#{relative_dir}) in (#{dest_root})"
+             FileUtils.cp( src_path, dest_path, verbose: true )
+           else
+             puts "  skip file #{node} (#{relative_dir})"
+           end
+        else
+           puts "  *** update file #{node} (#{relative_dir}) in (#{dest_root})"
+           File.open( dest_path, 'w:utf-8' ) do |f|
+             f.write( new_text )
+           end
+        end
+      end
+    end
+  end
+
+
+
+  def merge_path( path, hash )
+    ## e.g. allow
+    ##  __filename__  or
+    ##  $filename$   for now
+    ##   note: allow underline too  e.g $file_name$ etc.
+    path.gsub( /(__|\$)([a-z_]+)\1/i ) do |_|
+      key   = $2.to_s
+      value = hash[ key ]
+      puts "   [path] replacing #{key} w/ >#{value}< in (#{path})"
+      value
+    end
+  end
+
+  def merge_text( text, hash )
+    ## e.g. allow
+    ##  $filename$  for now only in text
+    ##  note: must include leading and trailing word boundry (/B)
+    ##   e.g. hello$test$ will not match only "free-standing $test
+    ##  or in quote e.g. "$test$"
+    ##  e.g. no letters or digits allowed before or after $ to match
+    ##  note: allow underline too e.g. $test_klass$ etc.
+
+    ## pp text
+
+    text.gsub( /\B\$([a-z_]+)\$\B/i ) do |_|
+      key   = $1.to_s
+      value = hash[ key ]
+      puts "   [text] replacing #{key} w/ >#{value}<"
+      value
+    end
+  end
+
+
+
+  def merge( root_dir, hash, opts={} )
+    puts "  merge #{root_dir}, #{hash.inspect}"
+
+    merge_filenames( root_dir, hash, opts )
+    merge_files( root_dir, hash, opts )
+  end
+
+end # class Merger
+
+end # module Quik
+