sow 0.4.0

data/lib/sow/generators/delete.rb

@@ -0,0 +1,50 @@
+require 'sow/generators/base'
+
+module Sow
+
+  module Generators
+
+    # = Delete Generator
+    #
+    #--
+    # TODO: should force option be require to do this?
+    #       And without force it just reports what would be deleted?
+    #++
+    class Delete < Base
+
+      def mark; 'delete'; end
+
+      #
+      def actionlist_check(list)
+        list
+      end
+
+      # Sort the manifest files before directory.
+      # This is opposite of Construct::Create.
+      def actionlist_sort(list)
+        list.reverse
+        #dirs, files = *list.partition{ |src, dest, opts| (source + src).directory? }
+        #files.sort{|a,b| a[1]<=>b[1]} + dirs.sort{|a,b| a[1]<=>b[1]}
+      end
+
+      # Delete template file.
+      def delete(loc, src, dest, opts)
+        if File.exist?(dest)
+          how = 'delete'
+          begin
+            rm(dest)
+          rescue Errno::ENOTEMPTY
+            how = 'skip'
+          end
+        else
+          how = 'missing'
+        end
+        return how, dest
+      end
+
+    end#class Delete
+
+  end#module Generators
+
+end#module Sow
+

data/lib/sow/generators/update.rb

@@ -0,0 +1,47 @@
+require 'sow/generators/create'
+
+#--
+# TODO: Could we use an "environment" settings file to specify environment variables to check for template variables?
+#++
+
+module Sow
+
+  module Generators
+
+    # = Update Generator
+    #
+    # Update is the same as the Create Generator with the exception
+    # that it pulls all metadata from the destination.
+    #
+    class Update < Create
+
+=begin
+      ### Copy the file, processing it with ERB if
+      ### it has an .erb extension. Unlike Create's
+      ### this will skip pre-existant non-erb files.
+      def copy_doc(src, dest)
+        tmp = File.join(source, src)
+        ext = File.extname(src)
+        case ext
+        when '.erb'
+          text = erb(tmp)
+          how = (File.exist?(dest) ? 'update' : 'create')
+          write(dest, text)
+        else
+          if File.exist?(dest)
+            how = 'skip'
+          else
+            how = 'create'
+            cp(tmp, dest)
+          end
+        end
+        return how, dest
+      end
+=end
+
+    end
+
+  end
+
+end
+

data/lib/sow/logger.rb

@@ -0,0 +1,73 @@
+module Sow
+
+  # The Logger class routes output to the console.
+  #
+  class Logger
+
+    #
+    attr :generator
+
+    #
+    def initialize(generator)
+      @generator = generator
+    end
+
+    # If there is nothing to generate this will be called
+    # to display a message to the effect.
+    def report_nothing_to_generate
+      report "Nothing to generate."
+    end
+
+    # Output to provide on startup of generation.
+    def report_startup(source, output) # FIXME: pass what info?
+      @time = Time.now
+      dir = File.basename(source) #File.basename(File.dirname(source))
+      report "Generating #{dir} in #{File.basename(output)}:\n\n"
+    end
+
+    # Output to provide when generation is complete.
+    def report_complete
+      report "\nFinished in %.3f seconds." % [Time.now - @time]
+    end
+
+    # Output to provide as generation is progressing.
+    def report_create(file, how, atime)
+      report "%10s [%.4fs] %s" % [how, (Time.now - atime), file]
+    end
+
+    # Use this to report any "templating" that needs
+    # to done by hand.
+    def report_fixes(marker='FIXME:')
+      glist = check_for_fixes(marker)
+      unless glist.empty?
+        puts "\nYou need to fix the occurances of '#{marker}' in the following files:\n\n"
+        glist.each do |file|
+          puts "      #{file}"
+        end
+        puts
+      end
+    end
+
+    # TODO: don't use grep
+    def check_for_fixes(marker)
+      g = `grep -R #{marker} .` # FIXME Use ruby code instead
+      glist = []
+      g.each_line do |line|
+        line = line.gsub('./','')
+        indx = line.index(':')
+        file, *desc = *line.split(':')
+        glist << file
+      end
+      glist.uniq
+    end
+
+  private
+
+    def report(message)
+      puts message unless generator.quiet? or generator.trial?
+    end
+
+  end
+
+end
+

data/lib/sow/manager.rb

@@ -0,0 +1,101 @@
+require 'sow/plugin'
+require 'facets/plugin_manager'
+
+module Sow
+
+  # The Manager class locates sow plugins.
+  #
+  class Manager
+
+    #
+    PLUGIN_DIRECTORY = "sow/seeds"
+
+    def initialize
+    end
+
+    # Plugins
+    #--
+    # Note that order of paths is important here.
+    #++
+    def plugin_locations
+      @plugin_locations ||= (
+        pl = {}
+        pa = []
+        pa |= plugins_from_packages
+       #pa |= plugins_core)
+       #pa |= plugins_user
+        pa.each do |d|
+          pl[File.basename(d)] = d
+        end
+        pl
+      )
+    end
+
+    def plugins
+      @plugins ||= plugin_locations.keys
+    end
+
+    def plugin(session, name, options)
+      location = plugin_locations[name]
+      raise "unknown scaffolding -- #{name}" unless location
+      Plugin.new(session, location, options)
+    end
+
+    # Convert path into plugin.
+    #def plugin(path)
+    #  path = Pathname.new(path) unless path.is_a?(Pathname)
+    #  Plugin.new(:location => path, :project => project, :command => cli)
+    #end
+
+    # This routine searches for seeds (sow plugins),
+    #
+    def plugins_from_packages
+      match = File.join(PLUGIN_DIRECTORY, '*/')
+      PluginManager.find(match).map do |path|
+        path.chomp('/')
+      end
+    end
+
+=begin
+    # Plugins installed in other packages.
+    # This routine searches through the $LOAD_PATH
+    # looking for directories with a MANIFEST.sow file.
+    #
+    def plugins_from_packages
+      plugins = []
+      # Standard $LOAD_PATH
+      $LOAD_PATH.uniq.each do |path|
+        dirs = Dir.glob(File.join(path, PLUGIN_DIRECTORY, '*/'))
+        #dirs = dirs.select{ |d| File.directory?(d) }
+        dirs = dirs.map{ |d| d.chomp('/') }
+        plugins.concat(dirs)
+      end
+      # ROLL (load latest versions only)
+      if defined?(::Roll)
+        ::Roll::Library.ledger.each do |name, lib|
+          lib = lib.sort.first if Array===lib
+          lib.load_path.each do |path|
+            path = File.join(lib.location, path)
+            dirs = Dir.glob(File.join(path, PLUGIN_DIRECTORY, '*/'))
+            #dirs = dirs.select{ |d| File.directory?(d) }
+            dirs = dirs.map{ |d| d.chomp('/') }
+            plugins.concat(dirs)
+          end
+        end
+      end
+      # RubyGems (load latest versions only)
+      if defined?(::Gem)
+        Gem.latest_load_paths do |path|
+          dirs = Dir.glob(File.join(path, PLUGIN_DIRECTORY, '*/'))
+          dirs = dirs.map{ |d| d.chomp('/') }
+          plugins.concat(dirs)
+        end
+      end
+      plugins
+    end
+=end
+
+  end
+
+end #module Sow
+

data/lib/sow/metadata.rb

@@ -0,0 +1,115 @@
+module Sow
+
+  # Metadata located in destination.
+  #
+  # This can be used to "prefill" template variables in some
+  # types of scaffolding.
+  #
+  #--
+  # TODO: Use POM::Metadata instead?
+  #
+  # TODO: Should this only be used when updating?
+  #
+  # TODO: If we copy meta/ first then it can be reused. ?
+  #++
+  class Metadata
+    alias :__id__ :object_id
+
+    instance_methods.each{ |m| private m unless m.to_s =~ /^__/ }
+
+    #
+    def initialize(destination)
+      @dir   = destination
+      @cache = {}
+    end
+
+    # Is there a metadata directory located in the destination directory?
+    def exist?
+      @exist ||= Dir.glob(File.join(@dir, '{.meta,meta}/')).first
+    end
+
+    # If method is missing, lookup metdata value by that name.
+    def method_missing(s, *a, &b)
+      s = s.to_s
+      if s =~ /=$/
+        s = s.chomp('=')
+        self[s] = a[0]
+      else
+        s = s.chomp('?')
+        self[s]
+      end
+    end
+
+    # Metadata has given +entry+?
+    def respond_to?(entry)
+      self[entry] ? true : false
+    end
+
+    # Get a metadata value directly from the metadata cache.
+    def __get__(entry)
+      @cache[entry.to_s]
+    end
+
+    # Get a metadata value. If not found in the cache,
+    # attempt to load it from the path store.
+    def [](s)
+      s = s.to_s
+      if @cache.key?(s)
+        @cache[s]
+      else
+        #@cache[s] = HOLE + " (#{s})"
+        @cache[s] = load_value(s) #|| HOLE + " (#{s})"
+      end
+    end
+
+    # Set a metadate value.
+    def []=(k,v)
+      @cache[k.to_s] = v
+    end
+
+  private
+
+    # Load metadata value.
+    #
+    # In update mode, metadata is looked for in the receiving end.
+    #
+    def load_value(name)
+      #val = read_value_from_commandline(name)
+      #return val if val
+
+      #if @plugin.update?
+      #  val = load_value_from_destination(name)
+      #  return val if val
+      #end
+
+      # See if the metadata is defined in the destination.
+
+      file = Dir[File.join(@dir, '{meta,.meta}', name)].first
+
+      if file && File.file?(file)
+        File.read(file).strip  # erb?
+      else
+        nil
+      end
+    end
+
+    #def load_template_metadata
+    #  Dir[File.join(metasrc, '*')].each do |f|
+    #    @metadata_source[File.basename(f)] = erb(f).strip
+    #  end
+    #end
+
+    # Processes with erb.
+    def erb(file)
+      erb = ERB.new(File.read(file))
+      erb.result(binding!)
+    end
+
+    def binding!
+      binding
+    end
+
+  end
+
+end
+

data/lib/sow/plugin.rb

@@ -0,0 +1,484 @@
+require 'sow/core_ext'
+require 'sow/session'
+require 'sow/logger'
+require 'sow/script'
+require 'sow/generators/create'
+require 'sow/generators/update'
+require 'sow/generators/delete'
+
+require 'facets/erb'
+require 'facets/ostruct'
+require 'facets/kernel/instance_class'
+
+module Sow
+
+  # Plugin encapsulates information about a sow plugin.
+  #
+  class Plugin
+    # Name of template directory.
+    TEMPLATE_NAME = 'template/'
+    # Name of plugin script file.
+    SCRIPT_NAME = 'SCRIPT{,.rb}'
+    # Name of usage document.
+    USAGE_NAME = 'USAGE{,.txt}'
+    # Name of metadata file.
+    DATA_NAME = 'DATA{,.yml,.yaml}'
+    # Name of copy file.
+    COPY_NAME = 'COPY{,.yml,.yaml}'
+
+    # Instanance of Session.
+    attr :session
+    # Location of plugin.
+    attr :location
+    # Argmuent
+    attr :argument
+    # Options
+    attr :options
+    # Desitnation pathname
+    attr :destination
+
+    #
+    def initialize(session, location, options)
+      @session  = session
+      @options  = options.to_ostruct
+
+      @location = Pathname.new(location)
+
+      @copy = []
+    end
+
+    # Metadata from scaffold destination.
+    def metadata
+      session.metadata
+    end
+
+    # Destination for scaffolding.
+    def destination
+      session.destination
+    end
+
+    # Argument for main command option.
+    def argument
+      options.argument
+    end
+
+    # Directory with template files.
+    def template_dir
+      @template_dir ||= grab(TEMPLATE_NAME)
+    end
+
+    # File containing usage text.
+    def usage_file
+      @usage_file ||= grab(USAGE_NAME)
+    end
+
+    # Metadata file.
+    def meta_file
+      @meta_file ||= grab(DATA_NAME)
+    end
+
+    # Transfer file.
+    def seed_file
+      @seed_file ||= grab(COPY_NAME)
+    end
+
+    # Traditional alternative to the meta & seed file.
+    def script_file
+      @script_file ||= grab(SCRIPT_NAME)
+    end
+
+    # Usage text.
+    def usage
+      @usage ||= (
+        if usage_file
+          Usage.new(usage_file)
+        else
+          "Generate #{self.class.name} scaffolding."
+        end
+      )
+    end
+
+    # Plugin's special metadata. These entries are
+    # converted to methods for rendering of the 
+    # transfer list.
+    def meta
+      @meta ||= (
+        if meta_file
+          YAML.load(File.new(meta_file))
+        else
+          {}
+        end
+      )
+    end
+
+    # Plugin's transfer list.
+    def seed
+      @seed ||= (
+        if seed_file
+          res = template.erb_result(File.read(seed_file))
+          YAML.load(res)
+        else
+          [{'from' => '**/*'}]
+        end
+      )
+    end
+
+  private
+
+    # Grab the first instance of a mathcing glob as a Pathname object.
+    def grab(glob)
+      file = Dir.glob(File.join(location, glob), File::FNM_CASEFOLD).first
+      file ? Pathname.new(file) : nil
+    end
+
+    # Erb OpenTemplate
+    def template
+      @template ||= (
+        ERB::OpenTemplate.new(options, session, :options => options, :metadata=>metadata)
+      )
+    end
+
+=begin
+    # Setup up the option parsing for the specific plugin.
+    # This method takes an instance of OptionParser.
+    def setup_options(parser)
+      txt = []
+      txt << "Usage: sow " + script[:usage] if script[:usage]
+      txt << script[:help] if script[:help]
+      parser.banner = txt.join("\n")
+      script[:options].each do |name, desc, valid|
+        if valid.arity == 0
+          parser.on("--#{name}", desc, &valid)
+        else
+          parser.on("--#{name} [VALUE]", desc, &valid)
+        end
+      end
+    end
+=end
+
+  public
+
+    # Prepare for scaffolding procedure. If a script.rb file
+    # was provided then uses the class defined within it
+    # to build the proper copylist.
+    #
+    # IMPORTANT: The class name must have the same as the
+    # plugin directory it is within.
+    #
+    # If not using a script.rb, but rather a seed.yml and/or
+    # a meta.yml file, this reads and prepares those instead.
+
+    def setup
+      if script_file
+        require(File.expand_path(script_file))
+        scriptClass = Script.registry[location.basename.to_s]
+        @script = scriptClass.new(session, options)
+        @script.setup
+        @script.manifest
+        @copy = @script.copylist
+      else
+        prepare_meta
+        prepare_seed
+        prepare_data
+      end
+    end
+
+      #setup_arguments #(arguments)
+      #setup_metadata
+      #setup_script #(session)
+      #init
+      #parse
+
+    # Any arguments defined in the script get there assigments
+    # defined as singleton methods via the script[]= call.
+    #def setup_arguments #(a)
+    #  #h = {}
+    #  a = script[:values]
+    #  script[:arguments].each_with_index do |(name, desc, valid), i|
+    #    if valid
+    #      script[name] = valid.call(a[i])
+    #    else
+    #      script[name] = a[i]
+    #    end
+    #  end
+    #  #@args = h #TODO: where?
+    #end
+
+    # Collect any metadata settings that may have been made
+    # in the initial script evaluation.
+    #def setup_metadata
+    #  script.metadata.each do |k,v|
+    #    metadata[k] = v
+    #  end
+    #end
+
+    # Setup the plugin with information about current operation.
+    #
+    # TODO: This seems wrong. Need to figure a better way!
+    #
+    #def setup_script
+    #  script.instance_variable_set("@session", session)
+    #  script.instance_variable_set("@metadata", metadata)
+    #  #script[:values].each do |v|
+    #  #end
+    #end
+
+    # Define metadata entries as singleton methods of the  Erb template.
+    def prepare_meta
+      meta.each do |m,c|
+        template.instance_class do
+          eval %{
+            def #{m}
+              #{c}
+            end
+          }
+        end
+      end
+      # validate
+      template.validate if meta['validate']
+    end
+
+    #
+    def prepare_seed
+      seed.each do |opts|
+        opts.rekey!(&:to_s)
+        from = opts.delete('from')
+        to   = opts.delete('to') || '.'
+        cond = opts.delete('if')
+        next unless template.instance_eval(cond) if cond
+        @copy << [from, to, opts]
+      end
+    end
+
+    #
+    def prepare_data
+      meta.each do |m,c|
+        metadata[m] = template.__send__(m)
+      end
+    end
+
+    # Designate a copying action.
+    #
+    #def copy(*from_to_opts)
+    #  opts = Hash===from_to_opts.last ? from_to_opts.pop : {}
+    #  from, to = *from_to_opts
+    #  to = to || '.'
+    #  @copylist << [from, to, opts]
+    #end
+
+    # Expanded copy list.
+    def copylist
+      @copylist ||= copylist_sort(copylist_glob(@copy)) #redest(list)
+    end
+
+    # Raw copylist as defined in the script.
+    #def script_copylist
+    #  @script_copylist ||= (
+    #    script[:copytemp].each{|s| s.call}
+    #    script[:copylist]
+    #  )
+    #end
+
+    # Does the script define a package name.
+    #def name
+    #  script[:name]
+    #end
+
+    # Expand copylist by globbing entries.
+
+    def copylist_glob(copylist)
+      list = []
+      dotpaths = ['.', '..']
+
+      copylist.each do |from, into, opts|
+        cdir = opts['cd'] || '.'
+        srcs = []
+
+        Dir.chdir(template_dir + cdir) do
+          less = opts['less'] ? Dir.multiglob_r(opts['less']) : []
+          srcs = Dir.glob(from, File::FNM_DOTMATCH)
+          srcs = srcs - less
+          srcs = srcs.reject{ |d| File.basename(d) =~ /^[.]{1,2}$/ }
+        end
+
+        # remove +less+ option, not needed any more
+        opts.delete('less')
+        #srcs = filter_paths(srcs)
+        srcs.each do |src|
+          case into
+          when /\/$/
+            dest = File.join(into, File.basename(src))
+          when '.'
+            dest = src
+          else
+            dest = into
+          end
+          source = (cdir == '.' ? src : File.join(cdir, src))
+          list << [template_dir, source, template_to_filename(dest), opts] #dest
+        end
+      end
+      list = uniq(list)
+      list
+    end
+
+    # Reduce copylist to uniq transfers. If transfers are the same
+    # the later transfere takes precedence. Transfire options are
+    # not considered in determining uniquness.
+
+    def uniq(list)
+      h = {}
+      list.each do |dir, src, dest, opts|
+        h[[dir,src,dest]] = opts
+      end
+      h.inject([]){ |a,x| a << x.flatten; a }
+    end
+
+=begin
+    # Filter out special paths from copylist.
+    #
+    def filter_paths(paths)
+      filter.each do |re|
+        paths = paths.reject do |pn|
+          case re
+          when Regexp
+            re =~ pn.to_s
+          else
+            re == pn.to_s
+          end
+        end
+      end
+      paths
+    end
+=end
+
+    # Convert a template pathname into a destination pathname.
+    # This allows for substitution in the pathnames themselves
+    # by using '__name__' notation.
+    #
+    def template_to_filename(path)
+      name = path.dup #chomp('.erb')
+      name = name.gsub(/__(.*?)__/) do |md|
+        metadata.__get__($1) || 'FIXME'  # TODO: raise error?
+      end
+      #if md =~ /^(.*?)[-]$/
+      #  name = metadata[md[1]] || plugin.metadata(md[1]) || name
+      #end
+      name
+    end
+
+    # Sort the list, directory before files and in alphabetical order.
+    def copylist_sort(list)
+      dirs, files = *copylist_partition(list)
+      dirs.sort{|a,b| a[2]<=>b[2]} + files.sort{|a,b| a[2]<=>b[2]}
+    end
+
+    # Partition the list between directories and files.
+    def copylist_partition(list)
+      list.partition{ |loc, src, dest, opts| (loc + src).directory? }
+    end
+
+    # Complete destination.
+    #def copylist_dest(list)
+    #  list.collect do |src, dest|
+    #    case dest
+    #    when nil
+    #      dest = src
+    #    when '/.'
+    #      dest = src
+    #    when /\/[.]$/
+    #      dest = File.join(dest.chomp('/.'), src)
+    #    when '/', '.'
+    #      dest = File.basename(src)
+    #    when /\/$/
+    #      #dest = File.join(dest, template_to_filename(File.basename(src)))
+    #      dest = File.join(dest, File.basename(src))
+    #    #else
+    #    #  dest = dest
+    #    end
+    #    dest = template_to_filename(dest)
+    #    [src, dest]
+    #  end
+    #end
+
+    ###
+    #def erb(file)
+    #  text = nil
+    #  temp = Context.new(plugin)
+    #  begin
+    #    text = temp.erb(file)
+    #  rescue => e
+    #    if trace?
+    #      raise e
+    #    else
+    #     abort "template error -- #{file}"
+    #    end
+    #  end
+    #  return text
+    #end
+
+  end
+
+end#module Sow
+
+
+
+
+
+=begin
+    #
+    def create(arguments, options={})
+      setup_for(:create, arguments, options)
+
+      #setup_arguments #(arguments)
+      #session.mode = :create
+
+      # collect metadata settings
+      #plugin.script.metadata.each do |k,v|
+      #  metadata[k] = v
+      #end
+
+      # this is kind of odd here
+      #plugin.script_setup(session)
+
+      #session   = Session.new(arguments, options)
+      generator = Generators::Create.new(session, location, copylist)
+      generator.generate
+    end
+
+    #
+    def update(arguments, options={})
+      setup_for(:update, arguments, options)
+      #setup_arguments #(arguments)
+      #session.mode = :update
+
+      #session   = Session.new(arguments, options)
+      generator = Generators::Update.new(session, location, copylist)
+      generator.generate
+    end
+
+    #
+    def delete(arguments, options={})
+      setup_for(:delete, arguments, options)
+      #setup_arguments #(arguments)
+      #session.mode = :delete
+      #session   = Session.new(arguments, options)
+      generator = Generators::Delete.new(session, location, copylist)
+      generator.generate
+    end
+
+    # No specific operation mode given, select one
+    # based on plugin and state of current location.
+    def select(arguments, options={})
+      #setup_arguments #(arguments) # FIXME
+      #session = Session.new(arguments, options)
+      if name && session.sowed?  #FIXME name?
+        setup_for(:update, arguments, options)
+        generator = Generators::Update.new(session, location, copylist)
+        generator.generate
+      else
+        setup_for(:create, arguments, options)
+        generator = Generators::Create.new(session, location, copylist)
+        generator.generate
+      end
+    end
+=end