facets 1.7.46 → 1.8.0

data/lib/facets/more/uploadutils.rb

@@ -0,0 +1,207 @@
+# = uploadutils.rb
+#
+# TODO Incorporate password into scp and ftp.
+
+require 'openssl'
+require 'shellwords'
+require 'tmpdir'
+#require 'net/smtp'
+
+# <b>UPLOAD FILES TO A HOST</b>
+#
+# Upload files to host. These means of uploading are current 
+# supported: ftp, sftp, scp and rsync.
+#
+#     user       Username for host.
+#     host       Host server's domain name.
+#     root       Document root path on host.
+#     copy       Directory of files to publish, or
+#                Files to publish using from and to.
+#
+#     dryrun     If true only pretend to upload.
+#     quiet      Supress all output.
+#     verbose    Provide extra details.
+#
+# The copy parameter allows you to simply specify a file
+# or directory which will be published to host's document
+# root location.
+#
+# If you need more control over which files to publish
+# where, you can use the copy parameter instead. Provide
+# an array of pattern strings in the form of "{from} {to}".
+# If the desitination is the host's document root you do
+# not need to specify the {to} part. For example:
+#
+#     copy = [ 'web/*', 'doc/api/* doc/api' ]
+#
+# The first copies the files under your project's web directory
+# to the host's document root. The second copies your projects
+# doc/api files to the doc/api location on the host.
+#
+# The internal template used for the outbound destination
+# is 'username@host:root/'.
+
+module UploadUtils
+
+  module_function
+  #--
+  # SHELLS OUT! Need net/scp library to fix.
+  #++
+
+  # Use scp to upload files.
+
+  def scp( keys )
+    keys = upload_parameters(keys)
+
+    flags = []
+    flags << "-v" if keys.verbose
+    flags << "-q" if keys.quiet
+    flags = flags.join(' ').strip
+    flags = ' ' + flags unless flags.empty?
+
+    upload_stage(keys) do #|tmpdir|
+      cmd = "scp -r#{flags} * #{keys.user}@#{keys.host}:/#{keys.root}"
+      puts cmd unless keys.quiet
+      system cmd unless keys.dryrun
+    end
+  end
+
+  # Use rsync to upload files.
+
+  def rsync( keys )
+    keys = upload_parameters(keys)
+
+    flags = []
+    flags << "-n" if keys.dryrun
+    flags << "-v" if keys.verbose
+    flags << "-q" if keys.quiet
+    flags = flags.join(' ').strip
+    flags = ' ' + flags unless flags.empty?
+
+    upload_stage(keys) do #|tmpdir|
+      begin
+        ENV['RSYNC_PASSWORD'] = keys.pass if keys.pass
+        cmd = "rsync -R#{flags} -arz * #{keys.user}@#{keys.host} /#{keys.root}"
+      ensure
+        ENV.delete('RSYNC_PASSWORD') if keys.pass
+      end
+    end
+  end
+
+  # Use ftp to upload files.
+
+  def ftp( keys )
+    keys = upload_parameters(keys)
+
+    if keys.dryrun
+      puts "ftp open #{keys.user}@#{keys.host}:#{keys.root}/"
+      keys.trans.each do |f, t|
+        puts "ftp put #{f} #{t}"
+      end
+    else
+      require 'net/ftp'
+      Net::FTP.open(keys.host) do |ftp|
+        ftp.login(keys.user) #password?
+        ftp.chdir(keys.root)
+        keys.trans.each do |f, t|
+          puts "ftp #{f} #{t}" unless keys.quiet
+          ftp.putbinaryfile( f, t, 1024 )
+        end
+      end
+    end
+  end
+
+  # Use sftp to upload files.
+
+  def sftp( keys )
+    keys = upload_parameters(keys)
+
+    if keys.dryrun
+      puts "sftp open #{keys.user}@#{keys.host}:#{keys.root}/"
+      keys.trans.each do |f,t|
+        puts "sftp put #{f} #{t}"
+      end
+    else
+      require 'net/sftp'
+      Net::SFTP.start(keys.host, keys.user, keys.pass) do |sftp|
+        #sftp.login( user )
+        sftp.chdir(keys.root)
+        keys.trans.each do |f,t|
+          puts "sftp #{f} #{t}" unless keys.quiet
+          sftp.put_file(f,t) #, 1024 )
+        end
+      end
+    end
+  end
+
+  # private (can't do b/c of module_function)
+
+  # parse publishing options.
+
+  def upload_parameters( keys )
+    keys = OpenHash.new(keys)
+
+    keys.copy = keys.copy || '**/*'
+    keys.host = keys.host || keys.domain
+    keys.user = keys.user || keys.username
+    keys.pass = keys.pass || keys.password
+
+    # validate
+    raise ArgumentError, "missing publish parameter -- host" unless keys.host
+    raise ArgumentError, "missing publish parameter -- user" unless keys.user
+    raise ArgumentError, "missing publish parameter -- copy" unless keys.copy
+    raise ArgumentError, "missing publish parameter -- root" unless keys.root
+
+    keys.root = '' if keys.root.nil?
+    keys.root = keys.root[1..-1] if keys.root[0,1] == '/'
+
+    if String===keys.copy and File.directory?(keys.copy)
+      copy = File.join(keys.copy, '*')
+    end
+    keys.copy = [keys.copy].flatten.compact
+
+    trans = []
+    keys.copy.each do |from|
+      #from, to = *Shellwords.shellwords(c)
+      #to = from if to.nil?
+      #to = to[1..-1] if to[0,1] == '/'
+      from.sub('*','**/*') unless from =~ /\*\*/
+      files = Dir.glob(from)
+      files.each do |f|
+        #t = File.join(to,File.basename(f))
+        #t = t[1..-1] if t[0,1] == '/'
+        trans << [f,f]
+      end
+    end
+    keys.trans = trans
+
+    return keys
+  end
+
+  # Creates a stage from which the whole directory can be uploaded.
+  # This is needed for scp and rsync which have to shelled out,
+  # and can't conveniently copy one file at a time.
+
+  def upload_stage(keys) #:yield:
+    tmp = "scp_#{object_id.abs}_#{ Time.now.strftime("%Y%m%d%H%M%S")}"
+    tmpdir = File.join(Dir.tmpdir,tmp)
+
+    puts "mkdir -p #{tmpdir}" unless keys.quiet
+    FileUtils.mkdir_p(tmpdir)  # go ahead and do this even if dryrun
+
+    fu = keys.dryrun ? FileUtils::DryRun : FileUtils
+    keys.trans.each do |f, t|
+      to = File.join(tmpdir, t)
+      fu.mv(f,to)
+    end
+
+    puts "cd #{tmpdir}" unless keys.quiet
+    Dir.chdir(tmpdir) do
+      yield #(tmpdir)
+    end
+
+    puts "rm -r #{tmpdir}" unless keys.quiet
+    FileUtils.rm_r(tmpdir)  # now remove the temp dir
+  end
+
+end

data/lib/facets/more/version_number.rb

@@ -0,0 +1,98 @@
+##
+# VersionNumber is a simplified form of a Tuple class
+# desgined specifically for dealing with version numbers.
+#--
+# TODO Maybe add Kernel method #version ?
+#
+# TODO If Tuple were standard part of Ruby this probably would
+# not be needed or at least might be simple sublcass instead.
+#++
+
+class VersionNumber #< Tuple
+
+  #include Enumerable
+  include Comparable
+
+  def initialize( *args )
+    args = args.join('.').split(/\W+/)
+    @self = args.collect { |i| i.to_i }
+  end
+
+  def to_s ; @self.join('.') ; end
+
+  # This is here only becuase File.join calls it instead of to_s.
+
+  def to_str ; @self.join('.') ; end
+
+  def inspect
+    @self.to_s
+  end
+
+  def [](i)
+    @self.fetch(i,0)
+  end
+
+  # "Spaceship" comparsion operator.
+
+  def <=>( other )
+    #other = other.to_t
+    [@self.size, other.size].max.times do |i|
+      c = @self[i] <=> other[i]
+      return c if c != 0
+    end
+    0
+  end
+
+  # For pessimistic constraint (like '~>' in gems)
+
+  def =~( other )
+    #other = other.to_t
+    upver = other.dup
+    upver[0] += 1
+    @self >= other and @self < upver
+  end
+
+  # Major is the first number in the version series.
+
+  def major ; @self[0] ; end
+
+  # Minor is the second number in the version series.
+
+  def minor ; @self[1] || 0 ; end
+
+  # Teeny is third number in the version series.
+
+  def teeny ; @self[2] || 0 ; end
+
+  # Delegate to the array.
+
+  def method_missing( sym, *args, &blk )
+    @self.send(sym, *args, &blk ) rescue super
+  end
+
+  # Parses a string constraint returning the operation as a lambda.
+
+  def self.constraint_lambda( constraint )
+    op, val = *parse_constraint( constraint )
+    lambda { |t| t.send(op, val) }
+  end
+
+  def self.parse_constraint( constraint )
+    constraint = constraint.strip
+    re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\d+)*)$}
+    if md = re.match( constraint )
+      if op = md[1]
+        op = '=~' if op == '~>'
+        op = '==' if op == '='
+        val = new( *md[2].split(/\W+/) )
+      else
+        op = '=='
+        val = new( *constraint.split(/\W+/) )
+      end
+    else
+      raise ArgumentError, "invalid constraint"
+    end
+    return op, val
+  end
+
+end

data/lib/facets/more/xmlbuilder.rb

@@ -19,7 +19,7 @@
 # Copyright:: Copyright (c) 2006 Thomas Sawyer
 # License::   Ruby License
 
-require 'facets/more/builderobject.rb'
+require 'facets/more/buildingblock.rb'
 require 'facets/more/xmlhelper.rb'
 
 # = XMLBuilder
@@ -28,33 +28,22 @@ require 'facets/more/xmlhelper.rb'
 # constructed via Ruby method calls and block structures. XMLBuilder is
 # a subclass of BuilderObject --see BuilderObject for more details.
 
-class XMLBuilder < BuilderObject
+class XMLBuilder < BuildingBlock
 
-  builder_include XMLHelper
-
-  def method_missing( op, *args, &block )
-    if block_given?
-      @stack << @buffer
-      @buffer = ''
-      body = block.call
-      @buffer = @stack.pop
-      @buffer << builder.element( op, body, *args )
-    else
-      @buffer << builder.element( op, *args )
-    end
+  def initialize
+    super(XMLHelper, :element)
   end
 
 end
 
 
-
 #  _____         _
 # |_   _|__  ___| |_
 #   | |/ _ \/ __| __|
 #   | |  __/\__ \ |_
 #   |_|\___||___/\__|
 #
-=begin test rdoc
+=begin test
 
   require 'test/unit'
 
@@ -63,12 +52,12 @@ end
     def test_01
       x = XMLBuilder.new
       doc = x.html {
-        x.head {
-          x.title "Test"
+        head {
+          title "Test"
         }
-        x.body {
-          x.p "Hello"
-          x.out.text "Test"
+        body {
+          p "Hello"
+          _text "Test"
         }
       }
       r = "<html><head><title>Test</title></head><body><p>Hello</p>Test</body></html>"
@@ -76,6 +65,22 @@ end
       assert_equal( r, x.to_s )
     end
 
+    #def tes_explicit
+    #  x = XMLBuilder.new(true)
+    #  doc = x.html {
+    #    x.head {
+    #      x.title "Test"
+    #    }
+    #    x.body {
+    #      x.p "Hello"
+    #      x << text("Test")
+    #    }
+    #  }
+    #  r = "<html><head><title>Test</title></head><body><p>Hello</p>Test</body></html>"
+    #  assert_equal( r, doc )
+    #  assert_equal( r, x.to_s )
+    #end
+
   end
 
 =end

data/lib/facets/more/xmlhelper.rb

@@ -76,7 +76,7 @@ module XMLHelper
 
   # Proccessing instruction.
 
-  def instruct( name, *args )
+  def instruct( tag, *args )
     atts = Hash === args.last ? args.pop : {}
     atts = atts.collect{ |k,v| %{ #{k}="#{v}"} }.join('')
     body = ' ' + args.join(' ')

data/lib/facets/sys.rb

@@ -0,0 +1,212 @@
+#--
+# Facets System
+# Copyright (c) Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#++
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+# = Facets System
+#
+# This is a central "meta" controller for the Facets system.
+# It can be used to dynmically gleen information about Facets.
+# Or used to load a facet give the symbol of the actual method.
+#
+# == Synopsis
+#
+#  TODO
+#
+
+module Facets
+
+  extend self
+
+  OPERATORS = %w{ +@ -@ + - ** * / % ~ <=> << >> < > === == =~ <= >= | & ^ []= [] }
+  OPERATORS_REGEXP = Regexp.new( '(' << OPERATORS.collect{ |k| Regexp.escape(k) }.join('|') << ')' )
+  OPERATORS_ESCAPE = {
+     "+@"   => "op_plus_self",
+     "-@"   => "op_minus_self",
+     "+"    => "op_plus",
+     "-"    => "op_minus",
+     "**"   => "op_pow",
+     "*"    => "op_mul",
+     "/"    => "op_div",
+     "%"    => "op_mod",
+     "~"    => "op_tilde",
+     "<=>"  => "op_cmp",
+     "<<"   => "op_lshift",
+     ">>"   => "op_rshift",
+     "<"    => "op_lt",
+     ">"    => "op_gt",
+     "==="  => "op_case_eq",
+     "=="   => "op_equal",
+     "=~"   => "op_apply",
+     "<="   => "op_lt_eq",
+     ">="   => "op_gt_eq",
+     "|"    => "op_or",
+     "&"    => "op_and",
+     "^"    => "op_xor",
+     "[]="  => "op_store",
+     "[]"   => "op_fetch"
+  }
+
+  CLASS_ANCESTORS = {
+    'array'         => ['enumerable','kernel'],
+    'binding'       => ['kernel'],
+    'class'         => ['module','kernel'],
+    'comparable'    => ['kernel'],
+    'continuation'  => ['kernel'],
+    'date'          => ['comparable','kernel'],
+    'dir'           => ['enumerable','kernel'],
+    'enumerable'    => ['kernel'],
+    'file'          => ['io','enumerable','kernel'],
+    'fileutils'     => ['kernel'],
+    'float'         => ['precision','numeric','comparable','kernel'],
+    'hash'          => ['enumerable','kernel'],
+    'integer'       => ['precision','numeric','comparable','kernel'],
+    'kernel'        => ['kernel'],
+    'logger'        => ['kernel'],
+    'matchdata'     => ['kernel'],
+    'module'        => ['kernel'],
+    'nilclass'      => ['kernel'],
+    'numeric'       => ['comparable','kernel'],
+    'ostruct'       => ['kernel'],
+    'pathname'      => ['kernel'],
+    'proc'          => ['kernel'],
+    'range'         => ['enumerable','kernel'],
+    'regexp'        => ['kernel'],
+    'string'        => ['enumerable','comparable','kernel'],
+    'symbol'        => ['kernel'],
+    'time'          => ['comparable','kernel'],
+    'unboundmethod' => ['kernel'],
+  }
+
+  NOAUTO = %w{
+    array/op_fetch.rb
+    array/op_store.rb
+    binding/self/of_caller.rb
+    hash/op_fetch.rb
+    hash/op_store.rb
+    numeric/succ.rb
+    numeric/pred.rb
+    string/succ.rb
+    string/unpack.rb
+    module/attr.rb
+    hash/each.rb
+    module/methods.rb
+    object/method.rb
+    nilclass/op_fetch.rb
+    nilclass/empty.rb
+    nilclass/include.rb
+    nilclass/size.rb
+    nilclass/length.rb
+    nilclass/method_missing.rb
+    date/*
+    fileutils/*
+    ostruct/*
+    logger/*
+    gem/*
+  }
+
+  METHDIR = "facet"
+
+  def op_esc( str )
+    str = str.to_s.chomp('.rb')
+    str = str.strip.gsub(OPERATORS_REGEXP){ OPERATORS_ESCAPE[$1] }
+    str.chomp('?').chomp('!').chomp('=')
+  end
+
+  # Subs terms for Ruby's operators
+  # and removes any trailing ? ! or =.
+  def op_esc_path( name )
+    ri = name.rindex('/')
+    if ri
+      dir, file = name[0...ri], name[ri+1..-1]
+    else
+      dir, file = nil, name
+    end
+    file = op_esc(file.strip)
+    dir ? File.join( dir, file ) : file
+  end
+
+  # Returns a file list of all extensions.
+  def extensions
+    return @all_extensions if @all_extensions
+    Dir.chdir( File.join( Config::CONFIG['sitelibdir'], METHDIR ) ) do
+      all = Dir.glob( '*/*.rb' ) + Dir.glob( '*/*/*.rb' )
+    end
+    @extensions = all
+  end
+
+  # Returns file list of all extensions minus the ones that should not be autoloaded.
+  def extensions_nice
+    @safe_extensions ||= nice_only( extensions )
+  end
+
+  # Removes the NOAUTO files from the given extensions list.
+  def nice_only( exts )
+    exts = exts.dup
+    NOAUTO.each do |f|
+      if f.include?('*')
+        re = %r"#{f.gsub('*','.*')}"
+        exts.reject!{ |x| x =~ re }
+      elsif exts.include?(f)
+        exts.delete f
+      end
+    end
+    exts.sort
+  end
+
+  #--
+  # NOTE Is there any other way to handle subclasses?
+  #++
+
+  alias_method :require_facetless, :require
+
+  def require( klass, fname )
+    klass = klass.to_s.downcase
+    fname = op_esc(fname.to_s)
+    if CLASS_ANCESTORS.key?( klass )
+      ancestors = [klass, *CLASS_ANCESTORS[klass]]
+      begin
+        require_facetless( File.join( METHDIR, klass, fname ) )
+      rescue LoadError => e
+        klass = ancestors.shift
+        retry if klass
+        raise e
+      end
+    else
+      require_facetless( File.join(METHDIR, klass.name.downcase, fname) )
+    end
+  end
+
+end
+
+
+# Override Kernel require method to reroute Facet requires.
+#
+#module Kernel
+#
+#  alias_method :require_facetless, :require
+#
+#  def require( fname )
+#    if /^(facet|facets|nano)[\/\\]/ =~ fname
+#      Facets.require($')
+#    else
+#      require_facetless( fname )
+#    end
+#  end
+#
+#end
+
+