rubyment 0.6.25484655 → 0.6.25503334

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10899b656c79527134e55de8433e25dd800660c1
-  data.tar.gz: 1ebc15afed675c406830ebca48e68ff683a1f3eb
+  metadata.gz: 1d2807035baddb1234c0afa87f542e51ba5f296d
+  data.tar.gz: 4c07bbab0d4c586d9969d7976b79fea603cc94f5
 SHA512:
-  metadata.gz: 40061cd1e9adb1331d22821109720eab4313b40af0da7605d06ebb10dd9745bebab219f8c2cba250e910d279f66a5f0711b0b496075f8869258b75b81764ed42
-  data.tar.gz: 778db1047917e439d7a75bcaec5c87bc90f9a762511b753fa9a847b83cc2666de94411b9460639def90aa73547c73fded6109f7850971b023e8b73aab6ef1f49
+  metadata.gz: fa5fa82d9a68feae96c61808c7ee43ed91ab9f5718ffd8bb11621be9f7cb14fe7a0622ee30f7df8331298c5bb3856df379e601514dce8c564e839221edae6a50
+  data.tar.gz: e9f1a8161d423e43e9238bc2c6b24d6a8439498cbf0e807724402a975cdfe665656566ec42808a7935179173c008fe271298d1c492cec63999dd1b4ee2378dfb

data/lib/rubyment.rb

@@ -1,30 +1,60 @@
 #!/usr/bin/env ruby
 
 
-class String
-  # checks if string is non neutral element.
-  #
-  # data from shell input can't be nil
-  # it will be an "" string. this
-  # function interprets "" as false
-  #
-  # @return [String, nil] self or nil
-  def nne
-    !self.empty? && self || nil
+class TrueClass
+  # returns +false+ (purpose of simplifying
+  # functional programming)
+  def false?
+    false
   end
 end
 
 
-class Fixnum
-  # checks if Fixnum is non neutral element.
+class Object
+  # returns +self+ if +self+ is not considered
+  # to be the neutral element of its class.
+  # an object is considered to the neutral
+  # element if it answers +true+ to any of
+  # a global +asserting_methods+ list.
+  # this list is by now the following:
+  # [ empty?, :zero?, :false? ]
+  # but it will grow as more classes are
+  # known to have different +asserting_methods+.
+  # it returns +nil+ when the element is
+  # considered the neutral element.
   #
-  # data from shell input can't be nil
-  # it will be an 0 string. this
-  # function interprets 0 as false
+  # data from other languagues, like most
+  # shell input, can't be +nil+ so sometimes
+  # "" has to be interpreted as +nil+. so,
+  # one example usage of the neutral element
+  # concept.
   #
-  # @return [Fixnum, nil] self or nil
-  def nne
-    !self.zero? && self || nil
+  def nne default=nil
+    asserting_methods = [
+      :empty?,
+      :zero?,
+      :false?,
+    ]
+    responds_false_to = asserting_methods.map { |am|
+      (self.respond_to? am) && (
+        self.method(am).call.negate_me
+      ) || nil
+    }
+    responds_false_to.any? && self || default
+  end
+
+
+  # returns nil out of an object.
+  # usage examples:
+  # "this_parameter_is_nil".to_nil
+  def to_nil
+    nil
+  end
+
+
+  # returns +!self+
+  def negate_me
+    !self
   end
 end
 
@@ -92,6 +122,8 @@ class Rubyment
         rv = [e.backtrace.join("\n"), e]
         stderr.puts "#{__method__} exception backtrace:"
         stderr.puts rv[0]
+        stderr.puts "#{__method__} exception inspection:"
+        stderr.puts rv[1].inspect
         stderr.puts "#{__method__} exception message:"
         stderr.puts rv[1]
         rv
@@ -100,6 +132,29 @@ class Rubyment
   end
 
 
+  # creates a +Proc+ out of a block,
+  # where exceptions may be admissible
+  # or not, and to be printed or not.
+  # it is an interface for the bl*
+  # methods above
+  # @param [splat] +args+, an splat whose elements are expected to be +blea_args+ and +blocks_args+:
+  # +blea_args+:: [Array] args to be used internally, which are expected to be:
+  # +exception_admitted+:: [Boolean]
+  # +output_exception+:: [Boolean]
+  # +blocks_args+:: [splat] args to be forwarded to the block call
+  # @return [Proc]
+  def blea *args, &block
+    blea_args, *block_args = args
+    blea_args ||= blea_args.nne []
+    exception_admitted, output_exception = blea_args
+    exception_admitted ||= exception_admitted.nne
+    output_exception ||=  output_exception.nne
+    ble_method = output_exception && :bloe || :blef
+    bl_to_call = exception_admitted && ble_method || :bl
+    send bl_to_call, *block_args, &block
+  end
+
+
   #  runs a block error free
   # (returns nil if exception happens)
   def runef *args, &block
@@ -146,6 +201,22 @@ class Rubyment
   end
 
 
+  # creates and runs a +Proc+ out of a block,
+  # where exceptions may be admissible
+  # or not, and to be printed or not.
+  # it is an interface for the run*
+  # methods above
+  # @param [splat] +args+, an splat whose elements are expected to be +blea_args+ and +blocks_args+:
+  # +blea_args+:: [Array] args to be used internally, which are expected to be:
+  # +exception_admitted+:: [Boolean]
+  # +output_exception+:: [Boolean]
+  # +blocks_args+:: [splat] args to be forwarded to the block call
+  # @return the value returned by the block
+  def runea *args, &block
+    (blea *args, &block).call
+  end
+
+
   # invoke first arg with following args
   # used by initialize
   def invoke args=ARGV
@@ -220,6 +291,19 @@ class Rubyment
   end
 
 
+  # compares the version of current rubyment with a given version.
+  # so users of rubyment can test if their code will run with
+  # the rubyment installed on the system.
+  # @param [splat] args, a list of object whose elements are expected to be:
+  # +major_version+:: [String]
+  # +minor_version+:: [String]
+  #
+  # @return [Bool] +true+ if rubyment (+self+) version is at least the version give as parameter, +false+ otherwise
+  def version_at_least *args
+    Gem::Version.new(version []) >= Gem::Version.new(version args)
+  end
+
+
   # enables the possibility to inkove a second method with
   # the results of a first one. eg, the results of a method
   #  called file_permissions_octal which returns without output
@@ -240,6 +324,21 @@ class Rubyment
   end
 
 
+  # returns an enumeration of +method_name+ for each element in
+  # the enumeration +a+. Useful for heterogeneous arrays
+  # (like arrays of Strings, of Hashes, of Arrays and so on
+  def array_map a, method_name, method_args = nil
+    a.map {|e| e.method(method_name).call  *method_args }
+  end
+
+
+  # the same as #array_map (but takes all arguments at once)
+  def array_maps args=ARGV
+    a, method_name, method_args = args
+    array_map a, method_name, method_args
+  end
+
+
   # reads a uri (if 'open-uri' available, otherwise, just do a normal File.read)
   # @param [Array] args, an +Array+ whose elements are expected to be:
   # +uri+:: [String, nil] uri or path of the file
@@ -270,6 +369,31 @@ class Rubyment
   end
 
 
+  # reads the contents of a file. if the file
+  # doesn't exist, writes to the file.
+  # note: the file may get overwritten with the
+  # same contents in some situations (not if
+  # +contents+ is +nil+).
+  # @param [splat] +args+::, an splat whose elements are expected to be:
+  # +filepath+:: [String] uri (if +'open-uri'+ installed) or local path to a file
+  # +username+:: [String] basic http authentication username
+  # +password+:: [String] basic http authentication password
+  # @return [String] file contents at the end of the process.
+  def file_read_or_write *args
+    filepath, contents, username, password = args
+    existing_file = file_read [
+      filepath,
+      username,
+      password,
+      "return on rescue".to_nil,
+      "return on dir".to_nil,
+    ]
+    file_contents ||=  existing_file || contents
+    contents && (File.write filepath, file_contents)
+    file_contents
+  end
+
+
   # if file is a nonexisting filepath, or by any reason
   # throws any exception, it will be treated as contents
   # instead, and the filename will treated as ""
@@ -315,11 +439,57 @@ class Rubyment
   end
 
 
+  def files_in_paths paths, reject_dirs=false
+    require 'find'
+    paths = paths.map {|path| Find.find(path).entries  rescue [] }.flatten 1
+    reject_dirs && paths.reject{|path| File.directory? path} || paths
+  end
+
+
+  def files_in_paths_reject_dirs paths
+     files_in_paths paths, true
+  end
+
+
+  def files_call_in_paths paths, method, reject_dirs=false
+    paths =  reject_dirs && (files_in_paths_reject_dirs paths) || paths
+    (files_in_paths paths).map {|path|  method.call path }
+  end
+
+
+  def files_dirnames_in_paths paths, reject_dirs=false
+   # (files_in_paths paths).map {|path|  File.dirname path }
+    files_call_in_paths paths, File.method(:dirname), reject_dirs
+  end
+
+
+  def files_basenames_in_paths paths, reject_dirs=false
+    files_call_in_paths paths, File.method(:basename), reject_dirs
+  end
+
+
+  def filename_replacer
+    [/[^0-9A-Za-z\-\.\/]/,  "_" ]
+  end
+
+
   # returns a string having the current backtrace, for debugging.
   def backtrace
     Thread.current.backtrace.join("\n")
   end
 
+  def caller_labels begin_range=1, range_size=1
+     caller_locations(begin_range, range_size).map(&:label)
+  end
+
+  # return the last_called function
+  def caller_label *args
+    default, reserved = *args
+    default ||= 3
+    caller_labels(default, 1)[0]
+  end
+
+
   # returns a Class object out of class_name (or itself if it is already
   # a class)
   def to_class args=ARGV
@@ -333,17 +503,18 @@ class Rubyment
 
 
   # returns a Method (object.method if object is
-  # given). give self as object to look up
-  # at the current context
-  # args:
-  # [ name (String), object (Object) ]
-  # returns:
+  # given) matching the name. Give +self+ as object
+  # to look up  at the current context
+  # @param [Array] args, whose elements are:
+  # +name+:: [String, nil]
+  # +object+:: [Object]
+  # @returns:
   #  method_object (Method)
   def to_object_method args=ARGV
     stderr = @memory[:stderr]
     name, object = containerize args
     begin
-      method =  object.method("method").call(name)
+      object.method("method").call(name.to_s)
     rescue NameError => nameError
       # every object (even nil) has :method,
       # and every Method has :call: exception
@@ -2032,8 +2203,7 @@ require '#{gem_name}'
     prepend ||= ""
     expected_new_filename = dest_dir + filename
     existing_file = (file_read [filename, nil, user, pw])
-    file_contents ||=  existing_file || "contents_of:#{filename}"
-    File.write filename, file_contents
+    file_contents = file_read_or_write filename, "contents_of:#{filename}", user, pw
     file_backup filename, dest_dir, append, prepend
     new_file_contents = File.read expected_new_filename
     original_permissions = file_permissions_octal filename
@@ -2045,6 +2215,7 @@ require '#{gem_name}'
       ].map(&method("expect_equal")).all?
     (!existing_file) && (FileUtils.rm filename)
     (!keep_new) && (FileUtils.rm expected_new_filename)
+    judgement
   end
 
 
@@ -2069,8 +2240,13 @@ require '#{gem_name}'
   #
   # @return [Method] a method
   def to_method args = ARGV
-    method_name_or_method, reserved = args
-    method_name_or_method.respond_to?(:call) && method_name_or_method || method(method_name_or_method)
+    method_name_or_method, object, reserved = args
+    (
+      to_object_method [object, method_name_or_method]
+    ) || (
+      method_name_or_method.respond_to?(:call) && method_name_or_method
+    ) ||
+      method(method_name_or_method)
   end
 
 
@@ -2088,13 +2264,16 @@ require '#{gem_name}'
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
   # +processing_arg+:: [Object]
   # +method+:: [Method, String]
-  # +method_args+:: [Method, String]
+  # +method_args+:: [Array] args to be given to the +transform_method_name+
+  # +on_object+:: [String, Boolean]
   #
   # @return [String] +processing_arg+
-  def transform_call args = ARGV
-    processing_arg, method, method_args = args
+  def test__transform_call args = ARGV
+    processing_arg, method, method_args, on_object = args
+    object_arg = on_object.nne && processing_arg || nil
+    p args
     to_method(
-      [method]).call(
+      [method, object_arg]).call(
         [processing_arg] + method_args
     )
   end
@@ -2106,23 +2285,32 @@ require '#{gem_name}'
   # +content_type+:: [String, nil] mime type of payload (default +text/plain+)
   # +version+:: [String, nil] http protocol version (+1.1+ by default)
   # +code+:: [String, nil] response code (+"200 OK"+ by default)
-  # +eol+:: [String, nil]
+  # +keep_alive+:: [Boolean] right not unsupported, always close the connection
+  # +eol+:: [String, nil] response code (+"\r\n"+ by default/on +nil+)
   #
-  # @return [String] http_response
+  # @return [Array] response with proper headers in an array where each element is a response line
   def http_OK_response args = ARGV
-    payload, content_type, code, version, eol = args
+    payload, content_type, code, version, keep_alive, debug, eol = args
+    stderr = @memory[:stderr]
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug.nne && (stderr.puts args.inspect)
     payload ||= ""
+    payload  = payload.to_s
     content_type ||= "text/plain"
     version ||= "1.1"
     code ||= "200 OK"
     eol ||= "\r\n"
-    [
+    rv = [
       "HTTP/#{version} #{code}",
       "Content-Type: #{content_type};" +
         " charset=#{payload.encoding.name.downcase}",
       "Content-Length: #{payload.bytesize}",
-      !keep_alive && "Connection: close"
-    ].join eol
+      keep_alive.negate_me && "Connection: close",
+      "",
+      "#{payload}"
+    ]
+    debug.nne && (stderr.puts "#{__method__} returning")
+    rv.join eol
   end
 
 
@@ -2153,6 +2341,40 @@ require '#{gem_name}'
   end
 
 
+  # gets an input from +io+ and writes it back to the same +io+
+  # supports an optional +replace+ and +replacement+ parameter
+  # that can be used to make simple changes to the echoing output
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +io+:: [IO] any +IO+, like a +Socket+, returned by #TCPServer::accept
+  # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +transform_method_name+:: [String]
+  # +transform_method_args+:: [Array] args to be given to the ++transform_method_name+
+  # +happy_with_request+:: [String, nil] if nil, +eol+ is used.
+  #
+  # @return [nil]
+  def io_transform args = ARGV
+    io,
+      debug,
+      happy_with_request,
+      transform_method_name,
+      transform_method_args,
+      reserved = args
+    stderr = @memory[:stderr]
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug.nne && (stderr.puts "transform_method_name: #{transform_method_name}")
+    debug.nne && (stderr.puts "transform_method_args: #{transform_method_args.inspect}")
+    io_forward [[io], io, debug, happy_with_request, reserved,
+      :test__transform_call, [
+        transform_method_name,
+	transform_method_args,
+	"on_object:true",
+      ]
+    ]
+    debug.nne && (stderr.puts "#{__method__} returning")
+    nil
+  end
+
+
   # gets and forwards the input from one IO to a list of IOs
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
   # +ios_out+:: [Array] array of +IO+, where data will be written to.
@@ -2186,9 +2408,9 @@ require '#{gem_name}'
     ios_out.map{ |shared_io_out|
       runoe_threaded(shared_io_out) {|io_out|
 	io_out = shared_io_out
-        io_out.puts processed_input
+        io_out.print processed_input
         debug.nne && (
-          stderr.puts "#{io_out}: response writen."
+          stderr.puts "#{io_out}: #{processed_input.size} bytes: response writen."
         )
         io_out.close
         debug.nne && (
@@ -2202,29 +2424,41 @@ require '#{gem_name}'
   end
 
 
-  # gets and puts
+  # gets an input from +io+ and writes it back to the same +io+
+  # supports an optional +replace+ and +replacement+ parameter
+  # that can be used to make simple changes to the echoing output
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
   # +io+:: [IO] any +IO+, like a +Socket+, returned by #TCPServer::accept
-  # +method_name_or_method+:: [String, Method] method name or method object
   # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +replace+:: [String]
+  # +replacement+:: [String]
   # +happy_with_request+:: [String, nil] if nil, +eol+ is used.
   #
   # @return [nil]
   def io_echo args = ARGV
-    io, debug, happy_with_request, reserved = args
+    io, debug, happy_with_request, replace, replacement, reserved = args
+    # this is an inefficient replacement:
+    replace ||= " "
+    replacement ||= " "
     stderr = @memory[:stderr]
     debug.nne && (stderr.puts "#{__method__} starting")
-    # io_forward [[io], io, debug, happy_with_request, reserved, :echo, []]
-    io_forward [[io], io, debug, happy_with_request, reserved,
-      :gsub!, [" ", "_"]
+    io_transform [
+      io,
+      debug,
+      happy_with_request,
+      :array_maps,
+      [
+        :gsub!, [replace, replacement]
+      ],
     ]
+
+    debug.nne && (stderr.puts "#{__method__} returning")
     nil
   end
 
 
   # writes a response to an IO (e.g.: socket)
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
-  # +method_name_or_method+:: [String, Method] method name or method object
   # +debug+:: [Object] if evals to false (or empty string), won't print debug information
   # +reserved+:: [Object] for future use
   # +args_for_http_OK_response+:: [splat] args to be forwarded to #http_OK_response (check it for specification)
@@ -2233,15 +2467,17 @@ require '#{gem_name}'
   def io_http_OK_response args = ARGV
     io, debug, reserved, *args_for_http_OK_response = args
     stderr = @memory[:stderr]
+    debug.nne && (stderr.puts "#{__method__} starting")
     debug.nne && (stderr.puts args.inspect)
     response = http_OK_response args_for_http_OK_response
     debug.nne && (
       stderr.puts response.inspect
     )
-    io.print response
+    io.puts response
     debug.nne && (stderr.puts "response writen.")
     io.close
     debug.nne && (stderr.puts "IO closed.")
+    debug.nne && (stderr.puts "#{__method__} returning")
     nil
   end
 
@@ -2266,8 +2502,108 @@ require '#{gem_name}'
       debug,
       callback_method,
       *callback_method_args = args
+
+    tcp_ssl_server [
+      listening_port,
+      ip_addr,
+      debug,
+      "admit non ssl server",
+      callback_method,
+      callback_method_args
+      ]
+  end
+
+
+  # makes an OpenSSL server 
+  # @param [splat] +args+, an splat whose elements are expected to be:
+  # +listening_port+:: [String, Integer] port to listen
+  # +ip_addr+:: [String, nil] ip (no hostname) to bind the server. 0, nil, false, empty string will bind to all addresses possible.  0.0.0.0 => binds to all ipv4 . ::0 to all ipv4 and ipv6
+  # +admit_plain+:: [Boolean] if +true+, tries to create a normal +TCPServer+, if not possible to create +SSLServer+ (default: +false+, for preventing unadvertnt non-SSL server creation)
+  # +debug+:: [Object] for future use
+  # +priv_pemfile+:: [String] argument to be given to +OpenSSL::SSL::SSLContext.key+ method, after calling +OpenSSL::PKey::RSA.new+ with it. It's the private key file. letsencrypt example: +"/etc/letsencrypt/live/#{domain}/privkey.pem"+
+  # +cert_pem_file+:: [String] argument to be given to +OpenSSL::SSL::SSLContext.cert+ method, after calling +OpenSSL::X509::Certificate+.  It's the "Context certificate" accordingly to its ruby-doc page. letsencrypt example: +"/etc/letsencrypt/live/scatologies.com/fullchain.pem"+
+  # +extra_cert_pem_files+:: [Array] array of strings. Each string will be mapped with +OpenSSL::SSL::SSLContext.new+, and the resulting array is given to +OpenSSL::SSL::SSLContext.extra_chain_cert+. "An Array of extra X509 certificates to be added to the certificate chain" accordingly to its ruby-doc. letsencryptexample: +["/etc/letsencrypt/live/#{domain}/chain.pem"]+
+  # +output_exception+:: [Bool] output exceptions even if they are admitted?
+  #
+  # @return [OpenSSL::SSL::SSLServer] returns an ssl server, which can be used to accept connections.
+  def ssl_make_server *args
+    stderr = @memory[:stderr]
+    listening_port,
+      ip_addr,
+      debug,
+      admit_plain,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      output_exception,
+      reserved = args
+    debug ||= debug.nne
+    extra_cert_pem_files ||= extra_cert_pem_files.nne []
+    admit_plain ||= admit_plain.nne
+    output_exception ||= (
+      output_exception.nne || admit_plain.negate_me
+    )
+    debug && (stderr.puts "#{__method__} starting")
+    
     require 'socket'
-    server = TCPServer.new ip_addr, listening_port
+    plain_server = TCPServer.new ip_addr, listening_port
+    ssl_server = runea [admit_plain, output_exception] {
+      require 'openssl'
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      ssl_context.extra_chain_cert =
+        extra_cert_pem_files
+          .map(&File.method(:read))
+          .map(&OpenSSL::X509::Certificate.method(:new))
+      ssl_context.cert = OpenSSL::X509::Certificate
+        .new File.read cert_pem_file
+      ssl_context.key = OpenSSL::PKey::RSA
+        .new File.read priv_pemfile
+      ssl_server = OpenSSL::SSL::SSLServer
+        .new plain_server, ssl_context
+      ssl_server
+    }
+
+    debug && (stderr.puts "#{__method__} returning")
+    ssl_server || admit_plain && plain_server
+  end
+
+
+  # opens an SSL server accepting connections.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +listening_port+:: [String, Integer] port to listen
+  # +ip_addr+:: [String, nil] ip (no hostname) to bind the server. 0, nil, false, empty string will bind to all addresses possible.  0.0.0.0 => binds to all ipv4 . ::0 to all ipv4 and ipv6
+  # +admit_plain+:: [Boolean] if +true+, tries to create a normal +TCPServer+, if not possible to create +SSLServer+ (default: +false+, for preventing unadvertnt non-SSL server creation)
+  # +debug+:: [Object] for future use
+  # +callback_method+:: [String, Method] method to call when a client connects. The method must accept a socket as parameter.
+  # +callback_method_args+:: [Array] args to be given to the call_back_method. Note that the type differs from #tcp_server_plain (which takes splat)
+  #
+  # @return [Thread] returns a Thread object looping for accepting
+  # incoming connections (call join on that object for waiting for its
+  # completion).
+  def tcp_ssl_server args = ARGV
+    stderr = @memory[:stderr]
+    listening_port,
+      ip_addr,
+      debug,
+      admit_plain,
+      callback_method,
+      callback_method_args,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      output_exception,
+      reserved = args
+
+    server = ssl_make_server(
+      listening_port,
+      ip_addr,
+      debug,
+      admit_plain,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      output_exception,
+    )
     debug.nne && (stderr.puts server)
     Thread.start {
       loop {
@@ -2284,54 +2620,296 @@ require '#{gem_name}'
   end
 
 
-  # opens a TCP client (TCPsocket) to connect to a server
-  # @param [Array] +args+, an +Array+ whose elements are expected to be:
-  #
-  # @return [nil]
-  def tcp_client_plain args = ARGV
-    listening_port,
-      ip_addr,
-      reserved,
-      debug,
-      callback_method,
-      *callback_method_args = args
-    require 'socket'
-    client = TCPSocket.new ip_addr, listening_port
-=begin
-    Thread.start {
-      to_method([callback_method])
-        .call [client]
-    }
-=end
-  Thread.start {}
-  end
-
-
   # test for tcp_server_plain
   def test__tcp_server_plain args = ARGV
-   thread = tcp_server_plain [8003, "0", "", "debug", "io_echo", "debug_io_echo"]
+   thread = tcp_server_plain [8003,
+     "0",
+     "reserved".to_nil,
+     "debug",
+     "io_echo",
+     "debug_io_echo",
+     "default happy_with_request".to_nil,
+     " ", #replace
+     "__", #replacement -- will replace empty spaces
+     ]
    thread.join
+   true
   end
 
+  # test for tcp_server_plain (call io_transform)
+  def test__tcp_server_plain__with_io_transform args = ARGV
+   thread = tcp_server_plain [
+     8003,
+     "0",
+     "",
+     "debug",
+     "io_transform",
+     "debug_io_transform",
+     "default happy_with_request".to_nil,
+     :array_maps,
+     [
+        :gsub!, [" ", "_____"]
+     ]
+   ]
+   thread.join
+   true
+  end
 
   # test for tcp_server_plain
   def test__tcp_server_plain__with_io_http_response args = ARGV
    thread = tcp_server_plain [
      8003, # listening_port
      "0",  # ip_addr: all possible
-     "",   # reserved
+     "reserved".to_nil,
      "debug_tcp_server_plain_arg",
      "io_http_OK_response",
      "debug_io_http_OK_response_arg",
-     "reserved_io_http_OK_response_arg",
-     "This is the response payload"
+     "reserved_io_http_OK_response_arg".to_nil,
+     "This is the response payload",
+     "dont_keep_alive".to_nil,
+   ]
+   thread.join
+   true
+  end
+
+
+  # test for tcp_server_plain (call #io_transform with
+  # a function that processes an http request and returns
+  # an http_response, by default #http_OK_response)
+  def test__tcp_server_plain__with_http_OK_response args = ARGV
+   http_processing_method,
+     http_processing_method_args,
+     http_server_port,
+     http_ip_addr,
+     reserved = args
+   http_processing_method ||= http_processing_method.nne :http_OK_response
+   http_processing_method_args ||= http_processing_method_args.nne []
+   http_server_port ||= http_server_port.nne  8003
+   http_ip_addr ||= http_ip_addr.nne "0"
+   thread = tcp_server_plain [
+     http_server_port,
+     http_ip_addr,
+     "reserved".to_nil,
+     "debug",
+     "io_transform",
+     "debug_io_transform",
+     "default happy_with_request".to_nil,
+     http_processing_method,
+     http_processing_method_args
    ]
    thread.join
+   true
+  end
+
+
+  # test for tcp_ssl_server (call #io_transform with
+  # a function that processes an http request and returns
+  # an http_response, by default #http_OK_response)
+  # just like #test__tcp_server_plain__with_http_OK_response
+  # but calling directly #tcp_ssl_server
+  def test__tcp_ssl_server__non_ssl args = ARGV
+   http_processing_method,
+     http_processing_method_args,
+     http_server_port,
+     http_ip_addr,
+     reserved = args
+   http_processing_method ||= http_processing_method.nne :http_OK_response
+   http_processing_method_args ||= http_processing_method_args.nne []
+   http_server_port ||= http_server_port.nne  8003
+   http_ip_addr ||= http_ip_addr.nne "0"
+   thread =  tcp_ssl_server [
+     http_server_port,
+     http_ip_addr,
+     "debug",
+     "admit non ssl server",
+     "io_transform",
+     [
+       "debug_io_transform",
+       "default happy_with_request".to_nil,
+       http_processing_method,
+       http_processing_method_args
+     ],
+   ]
+   thread.join
+   true
+  end
+
+
+  # returns a sample self signed certificate-private key pair
+  # that once was created with the command (no password, no
+  # expire date):
+  # + openssl req -x509 -nodes -newkey rsa:1024 -keyout pkey.pem -out cert.crt+
+  # @param [splat] +args+::, an splat whose elements are expected to be:
+  # +reserved+:: [splat] reserved for future use
+  # @return [Array] where the first element is a certificate (suitable to be the contents of +cert_pem_file+  in #ssl_make_server) and the second a private key (suitable to be the contents of +priv_pemfile+ in #ssl_make_server)
+  def ssl_sample_self_signed_cert *args
+    self_signed_certificate = <<-ENDHEREDOC
+-----BEGIN CERTIFICATE-----
+MIICWDCCAcGgAwIBAgIJAPa0EXsH2MwsMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQwHhcNMTgwNjI3MDkzMTEyWhcNMTgwNzI3MDkzMTEyWjBF
+MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50
+ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
+gQCplOo6dvbM1650qMYLQ8tRycYlHEZH95kUR5E5EEA8yqgimBtx6InpGQi/PejK
+tk+IXbDrxinXMXqjZxAhCjd7+frSUFwUTZ669PuRaptlkjV1KojXBW5kRERAgYId
+H7z7QRuK/gWHqTt9zl3WpW2spfWjHY+cnkYdZIWqDBOggwIDAQABo1AwTjAdBgNV
+HQ4EFgQUAIq0u116/WmTFQ8HC7/XrKl6wB8wHwYDVR0jBBgwFoAUAIq0u116/WmT
+FQ8HC7/XrKl6wB8wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOBgQBgA9ID
+JcreAgjYLxiaAd7fCfLQ1/RYM8YdP9R4Lzg2cu0dCjXoLZqzAEwUg424rPOvf0Pj
+wnZ3DFJkg1CoN2fH3yLXQ75mhfM7PJXeWoWLTS2wIG/+VIVI+nKJU0RPOM87Mdlq
++b6TI5LsGxlJhaxTmzPtkHZLIRdW6iCJTwP+5Q==
+-----END CERTIFICATE-----
+   ENDHEREDOC
+   private_key = <<-ENDHEREDOC
+-----BEGIN PRIVATE KEY-----
+MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKmU6jp29szXrnSo
+xgtDy1HJxiUcRkf3mRRHkTkQQDzKqCKYG3HoiekZCL896Mq2T4hdsOvGKdcxeqNn
+ECEKN3v5+tJQXBRNnrr0+5Fqm2WSNXUqiNcFbmRERECBgh0fvPtBG4r+BYepO33O
+Xdalbayl9aMdj5yeRh1khaoME6CDAgMBAAECgYB+Z80spU6UJFUbCk8NSIx+u6ui
+L/BHZs1Ja4tZgL6RUfKATuduQgrCoPF/NBOZPsoL+OKO7Nh1WqFyubkxF5+A6BlI
+BRe/E4K3cChBWyR5ZQyldYUNVV1HBrAhpurW/OX7FInPGo0I5TkR/CJt6xZPgK1n
+4lNXFV29gz/LPTJN4QJBANxnUn2xbtBH0xaTX4iIGEH2keLaUftg0b29Ou/MIPn3
++z7Ln9K6eknf/OGXAvBP2cnWkTGXAOBmB95s9XDrORMCQQDE+FcWTlSKFywFaxhp
+nVkDOL+k7Vpn/rKvqKB3JQOrPkovPSo/CHsUVe/r2NEsdJt1SKOs0/xzNe7wSXBa
+1tjRAkAHVbTsE+yRJ+LBfJQQUh8kitUeDI/v4q/4NYTxmAR87SDCXTprY+NP9BFR
+XJovbyjbS7W3RcQ0s5CNeWjNojZbAkA5u3SDJDhhNUOA3xALvMPfTt3VMICkJKIp
+HGrUITQ/GAXUbMAaM5knr7yfyzAcMJ10NfNLb+L5veAn686TwY9RAkArqoX6cWrd
+GflH+FhUggqgVrr9XaXkpPUxcpNqAQH/3Yl5pt9jV2VE7eD3chijMGzGJrMUsqFG
+n8mFEtUKobsK
+-----END PRIVATE KEY-----
+   ENDHEREDOC
+   [self_signed_certificate, private_key]
+  end
+
+
+  # test for tcp_ssl_server (call #io_transform with
+  # a function that processes an http request and returns
+  # an http_response, by default #http_OK_response)
+  # just like #test__tcp_ssl_server__non_ssl,
+  # calling directly #tcp_ssl_server, but making
+  # mandatory the server to be ssl one.
+  # requires, by default that the certificate and its
+  #  private key are found in the current dir, which
+  #  can be achieved with:
+  #  +openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout pkey.pem -out cert.crt+
+  # but if the files don't exist, they will be created
+  # with a sample self signed certificate.
+  def test__tcp_ssl_server__ssl_self_signed args = ARGV
+   http_processing_method,
+     http_processing_method_args,
+     http_server_port,
+     http_ip_addr,
+     priv_pemfile,
+     cert_pem_file,
+     extra_cert_pem_files,
+     reserved = args
+   http_processing_method ||= http_processing_method.nne :http_OK_response
+   http_processing_method_args ||= http_processing_method_args.nne []
+   http_server_port ||= http_server_port.nne  8003
+   http_ip_addr ||= http_ip_addr.nne "0"
+   priv_pemfile ||=  priv_pemfile.nne "pkey.pem"
+   cert_pem_file ||= cert_pem_file.nne  "cert.crt"
+   cert_contents, pkey_contents = ssl_sample_self_signed_cert
+   file_read_or_write cert_pem_file, cert_contents
+   file_read_or_write priv_pemfile, pkey_contents
+   extra_cert_pem_files ||=  extra_cert_pem_files.nne 
+   thread =  tcp_ssl_server [
+     http_server_port,
+     http_ip_addr,
+     "debug",
+     "admit non ssl server".negate_me,
+     "io_transform",
+     [
+       "debug_io_transform",
+       "default happy_with_request".to_nil,
+       http_processing_method,
+       http_processing_method_args
+     ],
+     priv_pemfile,
+     cert_pem_file,
+     extra_cert_pem_files,
+     "yes, output exceptions",
+   ]
+   thread.join
+   true
   end
 
 
-  # test for tcp_server_plain
-  def test__tcp_server_plain__with_io_http_response args = ARGV
+  # test for Object::nne
+  def test__object_nne args = ARGV
+    string_neutral = ""
+    string_non_neutral = "xxx"
+    fixnum_neutral = 0
+    fixnum_non_neutral = 1
+    array_neutral = []
+    array_non_neutral = [1, 2]
+    hash_neutral = {}
+    hash_non_neutral = { 1 => 2 }
+    judgement =
+      [
+        [string_neutral.nne, nil, "string_neutral.nne"],
+        [string_non_neutral.nne, string_non_neutral, "string_non_neutral.nne"],
+        [fixnum_neutral.nne, nil, "fixnum_neutral.nne"],
+        [fixnum_non_neutral.nne, fixnum_non_neutral, "fixnum_non_neutral.nne"],
+        [array_neutral.nne, nil, "array_neutral.nne"],
+        [array_non_neutral.nne, array_non_neutral, "array_non_neutral.nne"],
+        [hash_neutral.nne, nil, "hash_neutral.nne"],
+        [hash_non_neutral.nne, hash_non_neutral, "hash_non_neutral.nne"],
+      ].map(&method("expect_equal")).all?
+  end
+
+
+  # test for functions that adds syntatic sugar to
+  # exceptions.
+  def test__rune_functions args = ARGV
+    do_rescue = "rescue"
+    do_output = "output"
+    no_rescue = "no rescue"
+    no_output = "no output"
+    actual = {}
+    expectation = {}
+
+    #working case
+    expected_return = [1, 2, 3]
+    test_case = :rescue_and_output_work
+    actual[test_case] = runea([do_rescue, do_output], expected_return ) {|args| puts "test_case=#{test_case}";  p args  }
+    expectation[test_case] = expected_return
+    test_case = :rescue_but_no_output_work
+    actual[test_case] = runea([do_rescue, no_output.to_nil], expected_return ) {|args| puts "test_case=#{test_case}";  p args  }
+    expectation[test_case] = expected_return
+    test_case = :effectless_output_but_no_rescue_work
+    actual[test_case] = runea([no_rescue.to_nil, do_output], expected_return ) {|args| puts "test_case=#{test_case}";  p args  }
+    expectation[test_case] = expected_return
+    test_case = :no_output_and_no_rescue_work
+    actual[test_case] = runea([no_rescue.to_nil, no_output.to_nil], expected_return ) {|args| puts "test_case=#{test_case}";  p args  }
+    expectation[test_case] = expected_return
+
+    # failure cases
+    expected_return = "no_such_method"
+    test_case = :rescue_and_output_fail
+    actual[test_case] = runea([do_rescue, do_output], [1, 2, 3] ) {|args| puts "test_case=#{test_case}";  p args;  args.to_nil.no_such_method  }[1].name.to_s
+    expectation[test_case] = expected_return
+    test_case = :rescue_but_no_output_fail
+    actual[test_case] = runea([do_rescue, no_output.to_nil], [1, 2, 3] ) {|args| puts "test_case=#{test_case}"; p args ; args.to_nil.no_such_method  }.nil? && expected_return
+    expectation[test_case] = expected_return
+    test_case = :effectless_output_but_no_rescue_fail
+    actual[test_case] = begin
+      runea([no_rescue.to_nil, do_output], [1, 2, 3] ) {|args| puts "test_case=#{test_case}"; p args ; args.to_nil.no_such_method  }
+    rescue NoMethodError => noMethodError
+      noMethodError.name.to_s
+    end
+    expectation[test_case] = expected_return
+    test_case = :no_output_and_no_rescue_fail
+    actual[test_case] = begin
+      runea([no_rescue.to_nil, no_output.to_nil], [1, 2, 3] ) {|args| puts "test_case=#{test_case}"; p args ; args.to_nil.no_such_method  }
+    rescue NoMethodError => noMethodError
+      noMethodError.name.to_s
+    end
+    expectation[test_case] = expected_return
+
+    judgement = actual.keys.map {|test_case|
+      [expectation[test_case], actual[test_case] , test_case]
+    }.map(&method("expect_equal")).all?
   end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyment
 version: !ruby/object:Gem::Version
-  version: 0.6.25484655
+  version: 0.6.25503334
 platform: ruby
 authors:
 - Ribamar Santarosa