proutils 0.3.0

data/work/icli/icli

@@ -0,0 +1,223 @@
+#! /usr/bin/ruby
+
+require 'yaml'
+require 'facets/command'
+
+module ICli
+
+  class Command < Console::Command
+
+    class CommonOptions < Console::Command::Options
+      attr_accessor :host,
+                    :domain,
+                    :username
+    end
+
+    class ReleaseOptions < CommonOptions
+      attr_accessor :store,      # Package folder.
+                    :files,      # Files to release.
+                    :package,    # Package name.
+                    :version,    # Package version.
+                    :release,    # Release name. Defaults to +version+.
+                    :date,       # Release Date. Defaults to +Time.now+.
+                    :processor,  # Processor type. Deafults to +Any+.
+                    :changelog,  # ChangeLog file.
+                    :notelog,    # Notes file.
+                    :is_public   # Is this release public?
+    end
+
+    class PublishOptions < CommonOptions
+      attr_accessor :root        # directory with website files
+    end
+
+    class AnnounceOptions < CommonOptions
+      attr_accessor :subject,
+                    :message
+    end
+
+    #
+
+    options :publish,  PublishOptions
+    options :release,  ReleaseOptions
+    options :announce, AnnounceOptions
+    options :touch,    CommonOptions
+
+    # Publish
+    #
+    #     root        directory with website files
+
+    def publish
+      options = config_load('publish')
+
+      # merge in any commandline options
+      options.merge!(PublishOptions.parse.to_h)
+
+      name = options['host'] || options['domain']
+      host = host_class(name).new(options)
+
+      host.publish(options)
+    end
+
+    # Release options. This is a hash of options:
+    #
+    #     store        Location of packages.
+    #     version      Package version.
+    #     files        Files to release. (defaults to source/package-version.*)
+    #     package      Package name (defaults to +project+).
+    #     release      Release name (defaults to +version+).
+    #     date         Release Date (defaults to to +Time.now+).
+    #     processor    Processor type (deafults to +Any+).
+    #     changelog    ChangeLog file.
+    #     notelog      Notes file.
+    #     is_public    Is this release public?
+    #
+
+    def release
+      options = config_load('release')
+
+      # merge in any commandline options
+      options.merge!(@options.to_h) #(ReleaseOptions.parse.to_h)
+
+      #options = {}
+      #options.update info.gather('rubyforge')
+      #options.update info.gather('release')
+      #options.update info.select('version', 'changelog', 'notelog', 'processor'=>'arch')
+      #options['files'] = Dir[File.join(info.package_store,"*#{options['version']}.*")]
+
+      store = options['store']
+      name  = options['package']
+      vers  = options['version']
+
+      options['files'] ||= Dir[File.join(store,"#{name}-#{ver}.*")]
+
+      name = options['host'] || options['domain']
+      host = host_class(name).new(options)
+
+      host.release(options)
+    end
+
+    # Annouce to news.
+
+    def announce
+      options = config_load('announce')
+
+      # merge in any commandline options
+      options.merge!(AnnounceOptions.parse.to_h)
+
+      name = options['host'] || options['domain']
+      host = host_class(name).new(options)
+
+      host.announce(options)
+    end
+
+    # Test connection. Simply login and logout.
+
+    def touch
+      options = config_load
+
+      # merge in any commandline options
+      options.merge!(@options.to_h) #(CommonOptions.parse.to_h)
+
+      name = options['host'] || options['domain']
+      host = host_class(name).new(options)
+
+      host.touch
+    end
+
+    # Help
+
+    def help
+      puts DATA.read
+    end
+
+    # Default action (no subcommand)
+
+    alias_method :default, :help
+
+  private
+
+    def host_class(name)
+      Forge.factory(name)
+      #raise "unrecognized host" unless host
+      #host.send(args)
+    end
+
+    #
+
+    def config_load(section=nil)
+      if file = config_file
+        options = YAML::load(File.open(file))
+      else
+        options = {}
+      end
+      # merge in the selected section
+      if section
+        options.merge!(options[section.to_s] || {})
+      end
+      # remove subsections (should we bother?)
+      options = options.delete_if{ |k,v| Hash === v }
+      # return
+      return options
+    end
+
+    def config_file
+      Dir.glob("{meta/,.}forge{.yaml,.yml,}")[0]
+    end
+
+#     def start
+#       config = File.file?(CONFIG_FILE) ? YAML::load(f) : {}
+#       section = (@args[0] || 'all').to_s.downcase
+#
+#       if section == 'all'
+#         config.each do |name, settings|
+#           settings.update(@keys)
+#           press(settings)
+#         end
+#       else
+#         settings = config[section]
+#         settings.update(@keys)
+#         press(settings)
+#       end
+#     end
+
+  end
+end
+
+Forge::Command.start
+
+
+__END__
+
+Forge v0.2.0
+
+Usage: forge <command> <options>
+
+Commands:
+
+  touch
+    Test connection. This simply attempts to login and logout.
+
+  release
+    Release a package.
+
+  announce
+    Make an announcement via news.
+
+  publish
+    Publish website files.
+
+Common Options:
+
+  --host
+    The host name (eg. rubyforge). If LaForge supports the
+    host name then a specialized adatapter will be used.
+
+  --domain
+    The domain name of the host. If the host is not build in
+    you can supply the domain name instead of the host name.
+    The generic GForge adapter will be used.
+
+  --username
+    Your username on the host.
+
+For more information, http://proutils.rubyforge.org.

data/work/icli/rake.rb

@@ -0,0 +1,82 @@
+# Define rubyforge tasks.
+
+def task_rubyforge
+
+  desc "Release packages (Rubyforge)"
+  task :release do
+    project.release
+  end
+
+  desc "Publish website (Rubyforge)"
+  task :publish do
+    project.publish
+  end
+
+end
+
+#   # Publish
+#
+#   def publish
+#     options = {}
+#     options.update info.gather('rubyforge')
+#     options.update info.gather('publish')
+#
+#     rubyforge.publish(options)
+#   end
+#
+#   # Release options. This is a hash of options:
+#   #
+#   #     files        Files to release.
+#   #     version      Package version.
+#   #     package      Package name. Defaults to +project+.
+#   #     release      Release name. Defaults to +version+.
+#   #     date         Release Date. Defaults to +Time.now+.
+#   #     processor    Processor type. Deafults to +Any+.
+#   #     changelog    ChangeLog file.
+#   #     notelog      Notes file.
+#   #     is_public    Is this release public?
+#   #
+#
+#   def release
+#     options = {}
+#     options.update info.gather('rubyforge')
+#     options.update info.gather('release')
+#     options.update info.select('version', 'changelog', 'notelog', 'processor'=>'arch')
+#     options['files'] = Dir[File.join(info.package_store,"*#{options['version']}.*")]
+#
+#     rubyforge.release(options)
+#   end
+#
+#   # Rubyforge object.
+#
+#   def rubyforge
+# #     rubyforge_info = {
+# #       'domain'   => rubyforge_info['domain'],
+# #       'project'  => rubyforge_info['project'],
+# #       'username' => rubyforge_info['username'],
+# #       'group_id' => rubyforge_info['group_id'] || rubyforge_info['groupid'],
+# #       'release'  => release_info,
+# #       'publish'  => publish_info
+# #     }
+#
+#     #rubyforge_info = {}
+#     #rubyforge_info.update info.select('project')
+#     #rubyforge_info.update info.gather('rubyforge')
+#
+#     domain   = info.rubyforge_domain
+#     project  = info.rubyforge_project
+#     username = info.rubyforge_username
+#     group_id = info.rubyforge_group_id
+#
+#     #domain  ||= 'rubyforge.org'
+#     project ||= info.project
+#
+#     @rubyforge ||= RubyForge.new(
+#       :domain   => domain,
+#       :project  => project,
+#       :username => username,
+#       :group_id => group_id
+#     )
+#   end
+
+end

data/work/icli/utils/consoleutils.rb

@@ -0,0 +1,67 @@
+
+module ConsoleUtils
+
+  # Convenient method to get simple console reply.
+
+  def ask(question, answers=nil)
+    print "#{question}"
+    print " [#{answers}] " if answers
+    until inp = $stdin.gets ; sleep 1 ; end
+    inp
+  end
+
+  # Ask for a password. (FIXME: only for unix so far)
+
+  def password(prompt=nil)
+    msg ||= "Enter Password: "
+    inp = ''
+
+    print "#{prompt} "
+
+    begin
+      system "stty -echo"
+      #inp = gets.chomp
+      until inp = $stdin.gets
+        sleep 1
+      end
+    ensure
+      system "stty echo"
+    end
+
+    return inp.chomp
+  end
+
+end
+
+
+class Array
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_params
+    flags = (Hash===last ? pop : {})
+    flags = flags.collect do |f,v|
+      m = f.to_s.size == 1 ? '-' : '--'
+      case v
+      when Array
+        v.collect{ |e| "#{m}#{f} '#{e}'" }.join(' ')
+      when true
+        "#{m}#{f}"
+      when false, nil
+        ''
+      else
+        "#{m}#{f} '#{v}'"
+      end
+    end
+    return (flags + self).join(" ")
+  end
+
+  # Not empty?
+
+  def not_empty?
+    !empty?
+  end
+
+end

data/work/icli/utils/emailutils.rb

@@ -0,0 +1,85 @@
+begin
+  require 'facets/net/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+
+#module Rivets
+  module EmailUtils
+
+    module_function
+
+    # Email function to easily send out an email.
+    #
+    # Settings:
+    #
+    #     subject      Subject of email message.
+    #     from         Message FROM address [email].
+    #     to           Email address to send announcemnt.
+    #     server       Email server to route message.
+    #     port         Email server's port.
+    #     domain       Email server's domain name.
+    #     account      Email account name.
+    #     login        Login type: plain, cram_md5 or login [plain].
+    #     secure       Uses TLS security, true or false? [false]
+    #     message      Mesage to send -or-
+    #     file         File that contains message.
+    #
+    # (Square brackets indicate defaults taken from Project information.
+    # if used via Project class.)
+
+    def email(message, settings)
+      server    = settings['server']
+      account   = settings['account']
+      login     = settings['login'].to_sym
+      subject   = settings['subject']
+      mail_to   = settings['to']     || settings['mail_to']
+      mail_from = settings['from']   || settings['mail_from']
+      secure    = settings['secure']
+      domain    = settings['domain'] || server
+
+      port    ||= (secure ? 465 : 25)
+      account ||= mail_from
+      login   ||= :plain
+
+      #mail_to = nil if mail_to.empty?
+
+      raise ArgumentError, "missing email field -- server"  unless server
+      raise ArgumentError, "missing email field -- account" unless account
+      raise ArgumentError, "missing email field -- subject" unless subject
+      raise ArgumentError, "missing email field -- to"      unless mail_to
+      raise ArgumentError, "missing email field -- from"    unless mail_from
+
+      passwd = password(account)
+
+      mail_to = [mail_to].flatten.compact
+
+      msg = ""
+      msg << "From: #{mail_from}\n"
+      msg << "To: #{mail_to.join(';')}\n"
+      msg << "Subject: #{subject}\n"
+      msg << ""
+      msg << message
+
+      begin
+        Net::SMTP.enable_tls if Net::SMTP.respond_to?(:enable_tls) and secure
+        Net::SMTP.start(server, port, domain, account, passwd, login) do |s|
+          s.send_message( msg, mail_from, mail_to )
+        end
+        puts "Email sent successfully to #{mail_to.join(';')}."
+        return true
+      rescue => e
+        if trace?
+          raise e
+        else
+          abort "Email delivery failed."
+        end
+      end
+    end
+
+    #def password( account )
+    #  @password || ENV['PASSWORD'] || ask("Password for #{account}: ")
+    #end
+
+  end
+#end

data/work/icli/utils/fileutils.rb

@@ -0,0 +1,47 @@
+require 'fileutils'
+require 'digest/md5'
+
+module FileTest
+  module_function
+
+  BUF_SIZE = 1024*1024
+
+  # Are two files identical? This compares size and then checksum.
+  def identical?(file1, file2)
+    size(file1) == size(file2) && md5(file1) == md5(file2)
+  end
+
+  # Return an md5 checkum. If a directory is given, will
+  # return a nested array of md5 checksums for all entries.
+
+  def md5(path)
+    if File.directory?(path)
+      md5_list = []
+      crt_dir = Dir.new(path)
+      crt_dir.each do |file_name|
+        next if file_name == '.' || file_name == '..'
+        md5_list << md5("#{crt_dir.path}#{file_name}")
+      end
+      md5_list
+    else
+      hasher = Digest::MD5.new
+      open(path, "r") do |io|
+        counter = 0
+        while (!io.eof)
+          readBuf = io.readpartial(BUF_SIZE)
+          counter+=1
+          #putc '.' if ((counter+=1) % 3 == 0)
+          hasher.update(readBuf)
+        end
+      end
+      return hasher.hexdigest
+    end
+  end
+
+  # Show diff of two files.
+
+  def diff(file1, file2)
+    `diff #{file1} #{file2}`.strip
+  end
+
+end

data/work/mint/command-old.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'ratchets/scaffold/controller'
+
+module ProUtils
+
+  class ScaffoldCommand #< Console::Command
+
+    def self.start
+      new.start
+    end
+
+    def initialize
+      args, opts = Console::Arguments.new.parse
+
+      help if opts['help']
+
+      @type = args[0].to_s.downcase
+
+      exit -1 if @type == ''
+
+      @dryrun = opts['dryrun'] || opts['noharm'] || opts['n']
+    end
+
+    def __help
+      $stdout << File.read(File.join(File.dirname(__FILE__), 'help.txt'))
+      exit 0
+    end
+
+    def __dryrun
+      @dryrun = true
+    end
+    alias :__noharm, :__dryrun
+    alias :_n, :__dryrun
+
+    def start
+      Architect.scaffold(@type, :dryrun => @dryrun)
+    end
+
+    def help
+      $stdout << File.read(File.join(File.dirname(__FILE__), 'help.txt'))
+      exit 0
+    end
+
+  end #class Command
+
+end
+

data/work/mint/lazyfile.rb

@@ -0,0 +1,97 @@
+  # Scaffold Builder is a specialized class that acts
+  # as a restricted space with a limited command set
+  # for preforming scaffolding.
+  #
+  # The default behavior is simply to copy all the contents
+  # of the selected scaffold to the currrent directory.
+  # But if a scaffold.rb file is provided with the scaffolding
+  # this script will be run in the Builder context instead.
+
+  class Builder
+
+    def self.create( folder, options=nil )
+      i = new
+      Dir.chdir(folder) do
+        if File.exist?('scaffold.rb')
+          code = "def self.install( options=nil )\n" << File.read('scaffold.rb') << "\nend"
+          i.instance_eval code
+        end
+        i.install( options.to_openobject )
+      end
+      return *i.results
+    end
+
+    # FIXME Need to improve undefining most instance methods for this context.
+    instance_methods.each{ |m| undef_method m unless m =~ /__|send|class|object|instance/ }
+
+    def initialize( options=nil )
+      @note  = []
+      @dirs  = []
+      @copy  = {}
+    end
+
+    # Return results.
+
+    def results
+      return @note, @dirs, @copy
+    end
+
+    # Change directory in project as it is being build.
+    # This makes it easy to conditionally build tiers of
+    # structure.
+
+    def cd( dir )
+      if dir == '..'
+        @cwd = File.dirname(@cdir)
+      else
+        @cwd = [@cwd,dir].to_path
+      end
+    end
+
+    # Make a new project directory.
+
+    def mkdir(dir)
+      @dirs << [@cwd,dir].to_path
+    end
+
+    # Copy +glob+ of files from scaffolding +dir+ to project.
+    #
+    # If +to+ is omitted copies the files as named.
+    # If +to+ is given then the files are renamed or
+    # relocated accordingly. Use '*' in +to+ to substitute
+    # for the file name. For example:
+    #
+    #   copy 'standard', '**/*, 'src/*'
+    #
+    # This would copy all the files in the scaffoldings subdirectory,
+    # +standard/+, to the project directory +src/+.
+
+    def copy(dir, glob, to=nil)
+      Dir.chdir(dir) do
+        Dir.glob(glob).collect do |file|
+          if File.file?(file)
+            from = File.join(dir, file)
+            if to
+              tofile = [@cwd, to.gsub('*', file)].to_path
+            else
+              tofile = [@cwd, file].to_path
+            end
+            @copy[from] = tofile
+          else
+            @dirs << [@cwd, file].to_path
+          end
+        end
+      end
+    end
+
+    def note( str )
+      @note << str
+    end
+
+    # default installation routine
+
+    def install( options=nil )
+      copy '.', '**/*'
+    end
+
+  end