falsework 2.1.1 → 3.0.0

data/lib/falsework/mould.rb

@@ -7,6 +7,17 @@ require 'yaml'
 require_relative 'cliutils'
 
 module Falsework
+  class MouldError < StandardError
+    def initialize msg
+      super msg
+    end
+
+    alias :orig_to_s :to_s
+    def to_s
+      "generator: #{orig_to_s}"
+    end
+  end
+
   # The directory with template may have files beginning with # char
   # which will be ignored in #project_seed (a method that creates a
   # shiny new project form a template).
@@ -37,22 +48,27 @@ module Falsework
   class Mould
     # Where @user, @email & @gecos comes from.
     GITCONFIG = '~/.gitconfig'
+    
     # The possible dirs for templates. The first one is system-wide.
-    @@template_dirs = [CliUtils::DIR_LIB_SRC + 'templates',
-                       Pathname.new(Dir.home) + ".#{Meta::NAME}" + 'templates']
+    @template_dirs = [CliUtils::DIR_LIB_SRC.parent.parent + 'templates',
+                      Pathname.new(Dir.home) + ".#{Meta::NAME}" + 'templates']
+    class << self
+      attr_reader :template_dirs
+    end
+    
     # The template used if user didn't select one.
     TEMPLATE_DEFAULT = 'ruby-cli'
     # A file name with configurations for the inject commands.
     TEMPLATE_CONFIG = '#config.yaml'
     # A list of files to ignore in any template.
     IGNORE_FILES = ['.gitignore']
+    # Note file name
+    NOTE = '.' + Meta::NAME
 
-    # A verbose level for -v CLO.
-    attr_accessor :verbose
-    # -b CLO.
-    attr_accessor :batch
     # A directory of a new generated project.
     attr_reader :project
+    # template configuration
+    attr_reader :conf
 
     # [project] A name of the future project; may include all crap with spaces.
     # [template] A name of the template for the project.
@@ -61,34 +77,33 @@ module Falsework
     # [gecos] A full author name from ~/.gitconfig.
     def initialize(project, template, user = nil, email = nil, gecos = nil)
       @project = Mould.name_project project
-      raise "invalid project name '#{project}'" if !Mould.name_valid? @project
+      fail MouldError, "invalid project name '#{project}'" unless Mould.name_valid?(@project)
       @camelcase = Mould.name_camelcase project
       @classy = Mould.name_classy project
       
-      @verbose = false
       @batch = false
-      @template = template
-      @dir_t = Mould.templates[@template || TEMPLATE_DEFAULT] || CliUtils.errx(1, "no such template: #{template}")
+      @template = template || TEMPLATE_DEFAULT
+      @dir_t = Mould.templates[@template] || fail(MouldError, "template '#{@template}' not found")
 
       # default config
       @conf = {
-        exe: [{
-                src: nil,
-                dest: 'bin/%s',
-                mode_int: 0744
-              }],
-        doc: [{
-                src: nil,
-                dest: 'doc/%s.rdoc',
-                mode_int: nil
-              }],
-        test: [{
-                 src: nil,
-                 dir: 'test/test_%s.rb',
-                 mode_int: nil
-               }]
+        'exe' => [{
+                    'src' => nil,
+                    'dest' => 'bin/%s',
+                    'mode_int' => 0744
+                  }],
+        'doc' => [{
+                    'src' => nil,
+                    'dest' => 'doc/%s.rdoc',
+                    'mode_int' => nil
+                  }],
+        'test' => [{
+                     'src' => nil,
+                     'dir' => 'test/test_%s.rb',
+                     'mode_int' => nil
+                   }]
       }
-      Mould.config_parse(@dir_t + '/' + TEMPLATE_CONFIG, [], @conf)
+      configParse
       
       gc = Git.global_config rescue gc = {}
       @user = user || gc['github.user']
@@ -98,7 +113,7 @@ module Falsework
       [['github.user', @user],
        ['user.email', @email],
        ['user.name', @gecos]].each {|i|
-        CliUtils.errx(1, "missing #{i.first} in #{GITCONFIG}") if i.last.to_s == ''
+        fail MouldError, "missing #{i.first} in #{GITCONFIG}" if i.last.to_s == ''
       }
     end
 
@@ -112,7 +127,7 @@ module Falsework
         if ! File.directory?(idx)
           CliUtils.warnx "invalid additional template directory: #{idx}"
         else
-          @@template_dirs << idx
+          @template_dirs << idx
         end
       }
     end
@@ -169,9 +184,9 @@ module Falsework
     # and corresponding directories.
     def self.templates
       r = {}
-      @@template_dirs.each {|i|
+      @template_dirs.each {|i|
         Dir.glob(i + '*').each {|j|
-          r[File.basename(j)] = j if File.directory?(j)
+          r[File.basename(j)] = Pathname.new(j) if File.directory?(j)
         }
       }
       r
@@ -180,35 +195,35 @@ module Falsework
     # Generate a new project in @project directory from @template.
     #
     # Return false if nothing was extracted.
-    def project_seed()
+    def project_seed
       uuid = Mould.uuidgen_fake # useful variable for the template
       
       # check for existing project
-      CliUtils.errx(1, "directory '#{@project}' is not empty") if Dir.glob(@project + '/*').size > 0
+      fail MouldError, "directory '#{@project}' is not empty" if Dir.glob(@project + '/*').size > 0
 
       Dir.mkdir @project unless File.directory?(@project)
-      puts "Project path: #{File.expand_path(@project)}" if @verbose
+      CliUtils.veputs 1, "Project path: #{File.expand_path(@project)}"
 
       r = false
-      puts "Template: #{@dir_t}" if @verbose
+      CliUtils.veputs 1, "Template: #{@dir_t}"
       symlinks = []
       Dir.chdir(@project) {
-        Mould.traverse(@dir_t) {|idx|
+        Mould.traverse(@dir_t.to_s) {|idx|
           file = idx.sub(/^#{@dir_t}\//, '')
           next if IGNORE_FILES.index {|i| file.match(/#{i}$/) }
 
           if File.symlink?(idx)
             # we'll process them later on
-            is_dir = File.directory?(@dir_t + '/' + File.readlink(idx))
-            symlinks << [Mould.get_filename(File.readlink(idx), binding),
-                         Mould.get_filename(file, binding)]
+#            is_dir = File.directory?(@dir_t + '/' + File.readlink(idx))
+            symlinks << [Mould.resolve_filename(File.readlink(idx), getBinding),
+                         Mould.resolve_filename(file, getBinding)]
           elsif File.directory?(idx)
-            puts "D: #{file}"  if @verbose
-            Dir.mkdir Mould.get_filename(file, binding)
+            CliUtils.veputs 1, "D: #{file}"
+            Dir.mkdir Mould.resolve_filename(file, getBinding)
           else
-            puts "N: #{file}" if @verbose
-            to = Mould.get_filename(file, binding)
-            Mould.extract(idx, binding, to)
+            CliUtils.veputs 1, "N: #{file}"
+            to = Mould.resolve_filename file, getBinding
+            Mould.extract idx, binding, to # 'binding' to include local uuid
           end
           r = true
         }
@@ -217,8 +232,8 @@ module Falsework
         symlinks.each {|idx|
           src = idx[0]
           dest = idx[1]
-          puts "L: #{dest} => #{src}" if @verbose
-          File.symlink(src, dest)
+          CliUtils.veputs 1, "L: #{dest} => #{src}"
+          File.symlink src, dest
         }
       }
       
@@ -227,33 +242,33 @@ module Falsework
 
     # Parse a config. Return false on error.
     #
-    # [file] A file to parse.
-    # [rvars] A list of variable names which must be in the config.
-    # [hash] a hash to merge results with
-    def self.config_parse(file, rvars, hash)
-      r = true
-      
+    # [rvars]  A list of variable names which must be in the config.
+    def configParse rvars = []
+      r = false
+
+      file = @dir_t + TEMPLATE_CONFIG
       if File.readable?(file)
         begin
-          myconf = YAML.load_file(file)
+          myconf = YAML.load_file file
+          myconf[:file] = file
+          myconf['version'] = '1.0.0' unless myconf['version']
+          r = true
         rescue
           CliUtils.warnx "cannot parse #{file}: #{$!}"
           return false
         end
         rvars.each { |i|
-          CliUtils.warnx "missing or nil '#{i}' in #{file}" if ! myconf.key?(i.to_sym) || ! myconf[i.to_sym]
-          r = false
+          CliUtils.warnx "missing or nil '#{i}' in #{file}" if ! myconf.key?(i) || ! myconf[i]
+          return false
         }
-        
-        hash.merge!(myconf) if r && hash
-      else
-        r = false
+
+        @conf.merge!(myconf) if r
       end
       
       r
     end
     
-    # Add an executable or a test from the template.
+    # Add a file from the template.
     #
     # [mode] Is either 'exe', 'doc' or 'test'.
     # [target] A test/doc/exe file to create.
@@ -269,21 +284,25 @@ module Falsework
     def add(mode, target)
       target_orig = target
       target = Mould.name_project target_orig
-      raise "invalid target name '#{target_orig}'" if !Mould.name_valid? target
+      fail MouldError, "invalid target name '#{target_orig}'" if !Mould.name_valid? target
       target_camelcase = Mould.name_camelcase target_orig
       target_classy = Mould.name_classy target_orig
       uuid = Mould.uuidgen_fake
       
       created = []
 
-      return [] unless @conf[mode.to_sym][0][:src]
+      unless @conf[mode] && @conf[mode][0]['src']
+        CliUtils.warnx "hash '#{mode}' is empty in #{@conf[:file]}"
+        return []
+      end
 
-      @conf[mode.to_sym].each {|idx|
-        to = idx[:dest] % target
+      @conf[mode].each {|idx|
+        to = idx['dest'] % target
 
         begin
-          Mould.extract(@dir_t + '/' + idx[:src], binding, to)
-          File.chmod(idx[:mode_int], to) if idx[:mode_int]
+          # 'binding' to include local vars
+          Mould.extract @dir_t + idx['src'], binding, to
+          File.chmod(idx['mode_int'], to) if idx['mode_int']
         rescue
           CliUtils.warnx "failed to create '#{to}' (check your #config.yaml): #{$!}"
         else
@@ -315,159 +334,69 @@ module Falsework
     
     # Extract file @from into @to.
     #
-    # [binding] A binding for eval.
-    def self.extract(from, binding, to)
-      t = ERB.new(File.read(from))
-      t.filename = from # to report errors relative to this file
+    # [bng] A binding for eval.
+    def self.extract from, bng, to
+      t = ERB.new File.read(from.to_s)
+      t.filename = from.to_s # to report errors relative to this file
       begin
-        output = t.result(binding)
+        output = t.result bng
         md5_system = Digest::MD5.hexdigest(output)
       rescue Exception
-        CliUtils.errx(1, "bogus template file '#{from}': #{$!}")
+        fail MouldError, "bogus template file '#{from}': #{$!}"
       end
 
-      if ! File.exists?(to)
+      unless File.exists?(to)
         # write a skeleton
         begin
+          FileUtils.mkdir_p File.dirname(to)
           File.open(to, 'w+') { |fp| fp.puts output }
           # transfer the exec bit to the generated result
-          File.chmod(0744, to) if File.stat(from).executable?
+          File.chmod(0744, to) if !defined?(FakeFS) && File.stat(from.to_s).executable?
         rescue
-          CliUtils.errx(1, "cannot generate: #{$!}")
+          fail MouldError, "cannot generate: #{$!}"
         end
-      elsif
+      else
         # warn a careless user
-        if md5_system != Digest::MD5.file(to).hexdigest
-          CliUtils.errx(1, "'#{to}' already exists")
-        end
+        CliUtils.warnx "'#{to}' already exists in modified state" if md5_system != Digest::MD5.file(to).hexdigest
       end
     end
 
-    # Resolve @t from possible %%VARIABLE%% scheme.
-    def self.get_filename(t, binding)
+    # Resolve t from possible %%VARIABLE%% scheme.
+    def self.resolve_filename t, bng
       t || (return '')
       
       re = /%%([^%]+)%%/
-      t = ERB.new(t.gsub(re, '<%= \+ %>')).result(binding) if t =~ re
+      t = ERB.new(t.gsub(re, '<%= \+ %>')).result(bng) if t =~ re
       t.sub(/\.#erb$/, '')
     end
-    
 
-    # Search for all files in the template directory the line
-    #
-    # /^..? :erb:/
-    #
-    # in first n lines. If the line is found, the file is considered a
-    # candidate for an upgrade. Return a hash {target:template}
-    def upgradable_files()
-      line_max = 4
-      r = {}
-      Mould.traverse(@dir_t) {|i|
-        next if File.directory?(i)
-        next if File.symlink?(i) # hm...
-
-        File.open(i) {|fp|
-          n = 0
-          while n < line_max && line = fp.gets
-            if line =~ /^..? :erb:/
-              t = i.sub(/#{@dir_t}\//, '')
-              r[Mould.get_filename(t, binding)] = i
-              break
-            end
-            n += 1
-          end
-        }
-      }
-      
-      r
+    def getBinding
+      binding
     end
 
-    # We can upgrade only those files, which were explicitly marked by
-    # ':erb' sign a the top the file. They are collected by
-    # upgradable_files() method.
-    #
-    # The upgrade can happened only if one following conditions is met:
-    # 
-    # 1. there is no such files (all or some of them) in the project at
-    #    all;
-    #
-    # 2. the files are from the previous version of falsework.
-    #
-    # The situation may combine: you may have some missing and some old
-    # files. But if there is at least 1 file from a newer version of
-    # falsework then no upgrade is possible--it's considered a user
-    # decision to intentionally have some files from the old versions of
-    # falsework.
-    #
-    # Neithe we do check for a content of upgradable files nor try to
-    # merge old with new. (Why?)
-    def upgrade()
-      # 0. search for 'new' files in the template
-      uf = upgradable_files
-      fail "template #{@template} cannot offer you files for the upgrade" if uf.size == 0
- #     pp uf
-      
-      # 1. analyse 'old' files
-      u = {}
-      uf.each {|k, v|
-        if ! File.readable?(k)
-          u[k] = v
-        else
-          # check for its version
-          File.open(k) {|fp|
-            is_versioned = false
-            while line = fp.gets
-              if line =~ /^# Don't remove this: falsework\/(#{Gem::Version::VERSION_PATTERN})\/(.+)\/.+/
-                is_versioned = true
-                if $3 != (@template || TEMPLATE_DEFAULT)
-                  fail "file #{k} is from '#{$3}' template"
-                end
-                if Gem::Version.new(Meta::VERSION) >= Gem::Version.new($1)
-#                  puts "#{k}: #{$1}"
-                  u[k] = v
-                  break
-                else
-                  fail "file #{k} is from a newer version of #{Meta::NAME}: " + $1
-                end
-              end
-            end
-
-            CliUtils.warnx("#{k}: unversioned") if ! is_versioned
-          }
-        end
+    # Write a YAML file into a created project directory. This file is
+    # required for Upgrader.
+    def noteCreate after_upgrade = false
+      h = {
+        'project' => {
+          'classy' => @classy,
+          'upgraded' => DateTime.now.iso8601
+        },
+        'template' => {
+          'version' => @conf['version'],
+          'name' => @template
+        }
       }
-      fail "template #{@template || TEMPLATE_DEFAULT} cannot find files for an upgrade" if u.size == 0
-
-      # 2. ask user for a commitment
-      if ! @batch
-        puts "Here is a list of files in project #{@project} we can try to upgrade/add:\n\n"
-        u.each {|k,v| puts "\t#{k}"}
-        printf %{
-Does this look fine? Type y/n and press enter. If you choose 'y', those files
-will be replaced with newer versions. Your old files will be preserved with
-an '.old' extension. So? }
-        if STDIN.gets =~ /^y/i
-          puts ""
-        else
-          puts "\nNo? See you later."
-          exit 0
-        end
-      end
 
-      # 3. rename & write new
-      count = 1
-      total = u.size
-      tsl = total.to_s.size*2+1
-      u.each {|k, v|
-        printf("%#{tsl}s) mv %s %s\n",
-               "#{count}/#{total}", k, "#{k}.old") if @verbose
-        File.rename(k, "#{k}.old") rescue CliUtils.warnx('renaming failed')
-        printf("%#{tsl}s  Extracting %s ...\n", "", File.basename(v)) if @verbose
-        FileUtils.mkdir_p(File.dirname(k))
-        Mould.extract(v, binding, k)
-        count += 1
+      file = @project + '/' + NOTE
+      file = NOTE if after_upgrade # in 'upgrade' mode we are in project dir
+      File.open(file, 'w+') {|fp|
+        CliUtils.veputs 1, "N: #{File.basename(file)}"
+        fp.puts "# DO NOT DELETE THIS FILE"
+        fp.puts "# unless you don't want to upgrade scaffolds in the future."
+        fp.puts h.to_yaml
       }
     end
     
-  end # Mould
+  end
 end

data/lib/falsework/upgrader.rb

@@ -0,0 +1,120 @@
+require 'yaml'
+
+require_relative 'mould'
+require_relative 'utils'
+
+module Falsework
+  
+  class UpgradeError < StandardError
+    def initialize msg
+      super msg
+    end
+
+    alias :orig_to_s :to_s
+    def to_s
+      "upgrade: #{orig_to_s}"
+    end
+  end
+
+  class Upgrader
+    def self.noteLoad file = Mould::NOTE
+      r = YAML.load_file(file) rescue raise
+
+      ['project', 'template'].each {|idx|
+        fail "no #{idx} spec" unless r[idx]
+      }
+      
+      fail 'no project name' unless Utils.all_set?(r['project']['classy'])
+      fail "no template version" unless Utils.all_set?(r['template']['version'])
+      r['template']['version'] = Gem::Version.new r['template']['version']
+      fail "no template name" unless Utils.all_set?(r['template']['name'])
+
+      unless Mould.templates[r['template']['name']]
+        fail "unknown template '#{r['template']['name']}'"
+      end
+
+      r
+    end
+
+    def initialize dir, note = Mould::NOTE
+      fail UpgradeError, "directory #{dir} is unreadable" unless File.readable?(dir.to_s)
+      @dir = Pathname.new File.realpath(dir)
+
+      begin
+        @note = Upgrader.noteLoad(@dir + note)
+      rescue
+        raise UpgradeError, $!
+      end
+
+      @mould = Mould.new @note['project']['classy'], @note['template']['name']
+      @template_dir = Mould.templates[@note['template']['name']]
+      @project = @mould.project
+
+      @batch = false
+    end
+
+    attr_accessor :batch
+    attr_reader :project
+    attr_reader :template_dir
+
+    def getProjectBinding
+      @mould.getBinding
+    end
+
+    def able?
+      return false unless @mould.conf['upgrade']
+      return false if Gem::Version.new(@mould.conf['upgrade']['from']) > @note['template']['version']
+      return false unless @mould.conf['upgrade']['files'].is_a?(Array) && @mould.conf['upgrade']['files'].size > 0
+      true
+    end
+
+    def files
+      @mould.conf['upgrade']['files']
+    end
+
+    def obsolete
+      @mould.conf['upgrade']['obsolete'] || []
+    end
+
+    # Return true if user enter 'y' or 'a', false otherwise.
+    # Always return true for non-batch mode.
+    def userSaidYes msg, file
+      return true if @batch
+      
+      print "#{msg} '#{file}'? [y/n/a] "
+      asnwer = $stdin.gets
+      
+      if asnwer =~ /^a/i
+        @batch = true
+        return true
+      end
+      
+      yes = (asnwer =~ /^y/i)
+      return true if yes
+
+      false
+    end
+    
+    def upgrade save_old = false # yield f
+      fail UpgradeError, "this project cannot be upgraded" unless able?
+
+      at_least_one = false
+      files.each {|idx|
+        f = Mould.resolve_filename idx, @mould.getBinding
+
+        next unless userSaidYes 'update', f
+        
+        FileUtils.mv f, f + '.orig' if save_old && File.exist?(f)
+        Mould.extract @template_dir + idx, @mould.getBinding, f
+
+        # say 'opa-popa was updated'
+        yield f if block_given?
+        at_least_one = true
+      }
+
+      # update a note file
+      @mould.noteCreate true if at_least_one
+    end
+    
+  end
+end

data/lib/falsework/utils.rb

@@ -0,0 +1,23 @@
+module Falsework
+  module Utils
+    extend self
+
+    def self.all_set? t
+      return false unless t
+      
+      if t.is_a?(Array)
+        return false if t.size == 0
+        
+        t.each {|i|
+          return false unless i
+          return false if i.to_s.strip.size == 0
+        }
+      end
+      
+      return false if t.to_s.strip.size == 0
+      true
+    end
+    
+    
+  end
+end

data/templates/c-glib/#config.yaml

@@ -0,0 +1,18 @@
+---
+exe:
+- src: 'src/#exe.h'
+  dest: 'src/%s.h'
+  mode_int: null
+- src: 'src/#exe.c'
+  dest: 'src/%s.c'
+  mode_int: null
+
+doc:
+- src: 'doc/#doc.ascii'
+  dest: 'doc/%s.1.asciidoc'
+  mode_int: null
+
+test:
+- src: 'test/#test.c'
+  dest: 'test/test_%s.c'
+  mode_int: null