rubyment 0.6.25520645 → 0.6.25524898

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac992ef2ff77f2b3f5a7e1a392c4a0c36f40c893
-  data.tar.gz: 87ac55e2f114f278ed74dc13c6f689f265781405
+  metadata.gz: 1796154aae62fc1c6039aa65156e3a4d1673be7f
+  data.tar.gz: 0c1cc1f4952df5d65a4d0e1ed545dfebc7dcff42
 SHA512:
-  metadata.gz: 583ca6633c08eb781326c4abb175c4c56ba4e976029ff373e8bc7e4945ab94769db2add9bf872acf7e9e27bdfdf69aac1c6e48dd44fc96c2a33e97f6d7619d2c
-  data.tar.gz: 06bae45d3ba2a8c5d3d3cc2845ae2a1b1dd04079c981f04ac0437cf885f3218608bd0b25a5814fb65bc4cb00991dacaf95ed06408f4b6dde619a631eebc4041b
+  metadata.gz: b1f36db082abf40f95df2005b3d419922d52dc7ea86e7befbf6d12a639669e959e7dca3b70a4000aca7584198fd29c05714ce312d57c058b0a00b232c5ab32a7
+  data.tar.gz: 741062ad9787a496f85af8aaabf3c05d4c16e93e09459e7c8411a52ee875a211499648e94af987450c2a5dc18b2f3cfe84ea12e57126f509c9711042dc9962df

data/lib/rubyment.rb

@@ -66,7 +66,7 @@ end
 # STDOUT, just qualified output:
 # only if the function is expected
 # to output something
-class Rubyment
+module RubymentModule
 
   # this class very often needs to split
   # first argument and remaining elements.
@@ -2671,8 +2671,8 @@ require '#{gem_name}'
   end
 
 
-  # makes an OpenSSL server 
-  # @param [splat] +args+, an splat whose elements are expected to be:
+  # makes one or more OpenSSL server
+  # @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)
@@ -2681,9 +2681,11 @@ require '#{gem_name}'
   # +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/#{domain}/fullchain.pem"+ (now it's accepted to pass the file contents instead, both must work).
   # +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"]+ (now it's accepted to pass the file contents instead, both must work).
   # +output_exception+:: [Bool] output exceptions even if they are admitted?
+  # +plain_servers+:: [TCPServer, Array of TCPServer] if given, ignores +listening_port+ and +ip_addr+, does not create a +TCPServer+ and just creates an +SSLServer+ out of this one. If an +Array+ of +TCPServer+ is provided instead, it will create one +SSLServer+ to each of those +TCPServer+.
   #
-  # @return [OpenSSL::SSL::SSLServer] returns an ssl server, which can be used to accept connections.
-  def ssl_make_server *args
+  # @return [Array] returns an  #Array whose elements are:
+  # +servers+:: [Array of OpenSSL::SSL::SSLServer or of TCPServer] depending on +admit_plain+ and in the success of the creation of +SSLServers+.
+  def ssl_make_servers args=ARGV
     stderr = @memory[:stderr]
     listening_port,
       ip_addr,
@@ -2693,6 +2695,7 @@ require '#{gem_name}'
       cert_pem_file,
       extra_cert_pem_files,
       output_exception,
+      plain_servers,
       reserved = args
     debug = debug.nne
     extra_cert_pem_files = extra_cert_pem_files.nne []
@@ -2713,32 +2716,140 @@ require '#{gem_name}'
       }
     cert_pem_file = file_read [cert_pem_file, nil, nil, cert_pem_file]
     priv_pemfile  = file_read [priv_pemfile, nil, nil, priv_pemfile]
-    
     require 'socket'
-    plain_server = TCPServer.new ip_addr, listening_port
-    ssl_server = runea [admit_plain, output_exception, "nil on exception"] {
-      require 'openssl'
-      ssl_context = OpenSSL::SSL::SSLContext.new
-      ssl_context.extra_chain_cert =
-	# TODO: extra_cert_pem_files could also accept strings instead
-        extra_cert_pem_files
-          .map(&OpenSSL::X509::Certificate.method(:new))
-      ssl_context.cert = OpenSSL::X509::Certificate
-        .new cert_pem_file
-      ssl_context.key = OpenSSL::PKey::RSA
-        .new priv_pemfile
-      ssl_server = OpenSSL::SSL::SSLServer
-        .new plain_server, ssl_context
-      ssl_server
+    plain_servers ||= TCPServer.new ip_addr, listening_port
+    plain_servers = containerize plain_servers
+
+    servers = plain_servers.map { |plain_server|
+      ssl_server = runea [
+        admit_plain,
+	output_exception,
+	"nil on exception"] {
+          require 'openssl'
+          ssl_context = OpenSSL::SSL::SSLContext.new
+          ssl_context.extra_chain_cert =
+            extra_cert_pem_files
+              .map(&OpenSSL::X509::Certificate.method(:new))
+          ssl_context.cert = OpenSSL::X509::Certificate
+            .new cert_pem_file
+          ssl_context.key = OpenSSL::PKey::RSA
+            .new priv_pemfile
+          ssl_server = OpenSSL::SSL::SSLServer
+            .new plain_server, ssl_context
+          ssl_server
+      }
+      server = ssl_server || admit_plain && plain_server
     }
+    debug && (stderr.puts "will return #{[servers]}")
+    debug && (stderr.puts "#{__method__} returning")
+    [servers]
+  end
 
-    rv = ssl_server || admit_plain && plain_server
+
+  # makes an OpenSSL server 
+  # just an interface to the more powerful
+  # recommended #ssl_make_servers
+  # (kept for respecting open-closed principle)
+  # @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"+ (now it's accepted to pass the file contents instead, both must work).
+  # +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/#{domain}/fullchain.pem"+ (now it's accepted to pass the file contents instead, both must work).
+  # +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"]+ (now it's accepted to pass the file contents instead, both must work).
+  # +output_exception+:: [Bool] output exceptions even if they are admitted?
+  # +plain_server+:: [TCPServer] if given, ignores +listening_port+ and +ip_addr+, does not create a +TCPServer+ and just creates an +SSLServer+ out of this one.
+  #
+  # @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,
+      plain_server,
+      reserved = args
+    debug = debug.nne
+    debug && (stderr.puts "#{__method__} starting")
+    rv = (ssl_make_servers [
+      listening_port,
+      ip_addr,
+      debug,
+      admit_plain,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      output_exception,
+      plain_server,
+    ]).first.first
     debug && (stderr.puts "will return #{rv}")
     debug && (stderr.puts "#{__method__} returning")
     rv
   end
 
 
+  # opens one or more TCP and/or 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 [Array] returns a , an +Array+ whose elements are:
+  # +threads+:: [Array of Thread] returns an Array of Thread object looping for accepting  incoming connections (call join on those object for waiting for its completion).
+  def tcp_ssl_servers 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_servers [
+      listening_port,
+      ip_addr,
+      debug,
+      admit_plain,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      output_exception,
+    ]).first.first
+    debug.nne && (stderr.puts server)
+    Thread.start {
+      loop {
+        client = runea ["yes, rescue",
+	  "yes, output exception",
+	  "nil on exception"
+	] {
+	  server.accept
+	}
+        Thread.start(client) { |client|
+          debug.nne && (stderr.puts Thread.current)
+          debug.nne && (stderr.puts client)
+          runoe {
+            to_method([callback_method])
+              .call([client] + callback_method_args)
+          }
+        }
+      }
+    }
+  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
@@ -2765,7 +2876,7 @@ require '#{gem_name}'
       output_exception,
       reserved = args
 
-    server = ssl_make_server(
+    server = (ssl_make_servers [
       listening_port,
       ip_addr,
       debug,
@@ -2774,7 +2885,7 @@ require '#{gem_name}'
       cert_pem_file,
       extra_cert_pem_files,
       output_exception,
-    )
+    ]).first.first
     debug.nne && (stderr.puts server)
     Thread.start {
       loop {
@@ -3361,6 +3472,15 @@ n8mFEtUKobsK
   end
 
 
+  # runs a command in a shell (requires 'open3')
+  # returns stdout and stderr output mixed
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +command+:: [String] command to be executed
+  # @return [Array] returns an  #Array whose elements are:
+  # +stdoutanderr+:: [Array of Strings] mix of stdout and stderr output
+  # +stdin+:: [IO]
+  # +wait_thr+:: [Thread]
+  # +success?+:: [TrueClass, FalseClass]
   def shell_popen2e_command args=[]
     command,
       reserved = args
@@ -3370,6 +3490,16 @@ n8mFEtUKobsK
     end
 
 
+  # runs a command in a shell (requires 'open3')
+  # returns stdout and stderr output separated
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +command+:: [String] command to be executed
+  # @return [Array] returns an  #Array whose elements are:
+  # +stdout+:: [Array of Strings] stdout output
+  # +stderr+:: [Array of Strings] stderr output
+  # +stdin+:: [IO]
+  # +wait_thr+:: [Thread]
+  # +success?+:: [TrueClass, FalseClass]
   def shell_popen3_command args=[]
     command,
       reserved = args
@@ -3379,6 +3509,51 @@ n8mFEtUKobsK
     end
 
 
+  # test #rest_request
+  # for now, the parameters must still be hardcoded.
+  def test__rest_request__with_ayt args=ARGV
+    require 'json'
+    stderr = @memory[:stderr]
+
+    url = "https://owl.loftweb.nl:55031/4/3-roOomydev"
+    json =<<-ENDHEREDOC
+    {
+        "operation" : "AYT",
+        "version" : {
+            "client" : "X",
+            "protocol" : {
+                "domain_model" : "4",
+                "API" : "3"
+            }
+        }
+    }
+    ENDHEREDOC
+    payload = "#{json}"
+
+    auth_user = "web"
+    password = "vadim"
+    method = :post
+    method = :get
+    timeout = 600
+    verify_ssl = true
+    payload = "#{json}"
+    headers = ""
+    request_execution = send :rest_request, [
+      url,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      auth_user,
+      password,
+      timeout,
+    ]
+    parsed_json = JSON.parse request_execution.to_s
+    stderr.puts parsed_json
+    [parsed_json]
+  end
+
+
   # test for functions that adds syntatic sugar to
   # exceptions.
   def test__rune_functions args = ARGV
@@ -3433,51 +3608,228 @@ n8mFEtUKobsK
   end
 
 
-  # test #rest_request
-  # for now, the parameters must still be hardcoded.
-  def test__rest_request__with_ayt args=ARGV
-    require 'json'
+  # tests if  +operand_1+ is only
+  # composed by a repetition of +operand_2+
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +operand_1+:: [String]
+  # +operand_2+:: [String] 
+  # +min_repetitions+:: [FixNum] minimum of times +operand_2+ is required to appear in +operand_1+ (default: +0+). Note that in +args=["", "X", 0]+, +operand_1=""+ will be returned, because "" is a composition of +0+ times "X". 
+  # @return [String, FalseClass] returns +operand_1+ if it is only
+  # composed by a repetition of +operand_2+, otherwise +false+
+  def string_repetition  args=[]
     stderr = @memory[:stderr]
-
-    url = "https://owl.loftweb.nl:55031/4/3-roOomydev"
-    json =<<-ENDHEREDOC
-    {
-        "operation" : "AYT",
-        "version" : {
-            "client" : "X",
-            "protocol" : {
-                "domain_model" : "4",
-                "API" : "3"
-            }
-        }
+    operand_1,
+    operand_2,
+    min_repetitions,
+      reserved = args
+    debug = debug.nne
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug && (stderr.puts "args=#{args.inspect}")
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug && (stderr.puts "args=#{args.inspect}")
+    debug && (stderr.puts "will return #{is_string_repetition}")
+    debug && (stderr.puts "#{__method__} returning")
+    matches  = operand_1.to_s.scan operand_2
+    amout_of_matches = matches.size
+    min_repetitions = min_repetitions.nne 0
+    is_string_repetition = (
+      debug && (stderr.puts '(#{amout_of_matches} >= #{min_repetitions}) && (#{operand_2.size} * #{amout_of_matches} == #{operand_1.size})')
+      debug && (stderr.puts "(#{amout_of_matches} >= #{min_repetitions}) && (#{operand_2.size} * #{amout_of_matches} == #{operand_1.size})")
+      # if operand_2 was matched N times, and the sum
+      # of those N matched sizes is the same
+      (amout_of_matches >= min_repetitions) && (operand_2.size * amout_of_matches == operand_1.size) || false
+    ) && operand_1
+    debug && (stderr.puts "will return #{is_string_repetition}")
+    debug && (stderr.puts "#{__method__} returning")
+    is_string_repetition
+  end
+
+
+  # takes a flatten array and makes it deeper, starting a new array
+  # everytime it finds the string +"["+. +"]"+ stops the array (and
+  # return to the upper one). To reserve the possibility of
+  # representing "[" or "]", everytime a string contains only those
+  # chars, repeteaded any number of times, starting from 2, one of
+  # them will be removed. So +"[["+ will be left as +"["+ and
+  # +"]]]"+ will be left as +"]]"+.
+  # if the provided array is not flatten, it has an undefined
+  # behaviour (it will either a - transverse the sub-arrays
+  # or b - don't transverse it, leaving it untouched. while
+  # the a is the planned effect, initially only a may will
+  # be implemented).
+  # @param [Array] +args+, the array to be operadated
+  # @return [Array] returns the modified, deep, #Array
+  def array_unflatten_base_shallow args=[]
+    reserved_tokens = [
+      [ "[", :up], 
+      [ "]", :down.to_nil],
+    ]
+    rv = []
+    array_operand = []
+    array_operands_stack = []
+    args.each_with_index {|e, index|
+      reserved_tokens.map { |reserved_token|
+        rtoken, is_up_token = reserved_token
+
+        repetition_test = string_repetition [e, rtoken, 1]
+        (
+	  # case A: e is exactly the reserved token.
+	  # start or finish an array
+	  # note: if rtoken is false, it will succeed this
+	  # test. 
+          (repetition_test == rtoken) && (
+            is_up_token && (
+	      array_operands_stack.push array_operand
+	      array_operand = Array.new
+	    ) || (
+	      array_operand = array_operands_stack.pop
+	    )
+	  )
+        ) || (
+	  # case B: is a a repetition with at least 2
+	  # occurrences of the reserved token. remove one.
+	  # (and add it to the current array)
+          repetition_test && (
+            array_operand.push(e.sub! rtoken, "")
+          )
+        ) || (
+	  # case C: no repetition. (just add e to
+	  # the current array.)
+            array_operand.push e
+	)
+      }
     }
-    ENDHEREDOC
-    payload = "#{json}"
+    array_operand
+  end
+
+  # test for #string_repetition
+  def test__array_unflatten_base_shallow args=[]
+    test_cases ||= [
+     # [ :id, :expectation, :actual_params ],
+     # array_unflatten_base_shallow
+     [ "any test", [ :a, [ :b ], :c], [
+          :array_unflatten_base_shallow, [
+            :a, "[", :b, "]", :c
+           ]
+       ],
+     ],
 
-    auth_user = "web"
-    password = "vadim"
-    method = :post
-    method = :get
-    timeout = 600
-    verify_ssl = true
-    payload = "#{json}"
-    headers = ""
-    request_execution = send :rest_request, [
-      url,
-      payload,
-      verify_ssl,
-      headers,
-      method,
-      auth_user,
-      password,
-      timeout,
     ]
-    parsed_json = JSON.parse request_execution.to_s
-    stderr.puts parsed_json
-    [parsed_json]
+    test__tester test_cases
+  end
+
+  def test__tester args=[]
+    expectation = {}
+    actual = {}
+    test_cases = args
+    test_cases ||= [
+     # [ :id, :expectation, :actual_params ],
+    ]
+    test_cases.each_with_index{ |test_case|
+      test_case_id, test_expectation, actual_params = test_case
+      result = send actual_params[0], actual_params[1]
+      expectation[test_case_id] = test_expectation
+      actual[test_case_id] = result
+    }
+    judgement = actual.keys.map {|test_case|
+      [expectation[test_case], actual[test_case] , test_case]
+    }.map(&method("expect_equal")).all?
+  end
+
+
+  # test for #string_repetition
+  def test__string_repetition args=[]
+    expectation = {}
+    actual = {}
+    test_case = 1
+    operand_1 = "XXX"
+    operand_2 = "X"
+    # expectation and actual inverted.
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = operand_1
+
+    test_case = 2
+    operand_1 = "X"
+    operand_2 = "X"
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = operand_1
+
+    test_case = 3
+    operand_1 = "XyXy"
+    operand_2 = "XyXy"
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = operand_1
+
+    test_case = 4
+    operand_1 = "XyXy"
+    operand_2 = "XXyy"
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = false
+
+    test_case = 6
+    operand_1 = ""
+    operand_2 = ""
+    expectation[test_case] = string_repetition [operand_1, operand_2, 0]
+    actual[test_case] = operand_1
+
+    test_case = 7
+    operand_1 = ""
+    operand_2 = ""
+    expectation[test_case] = string_repetition [operand_1, operand_2, 1]
+    actual[test_case] = operand_1
+
+    test_case = 7
+    operand_1 = ""
+    operand_2 = "X"
+    expectation[test_case] = string_repetition [operand_1, operand_2, 0]
+    # "X"*0 = ""
+    actual[test_case] = operand_1
+
+    test_case = 8
+    operand_1 = ""
+    operand_2 = "X"
+    expectation[test_case] = string_repetition [operand_1, operand_2, 1]
+    # "X"*0 = "", but minimum is set to 1
+    actual[test_case] = false
+
+    test_case = 9
+    operand_1 = "XyXy"
+    operand_2 = "Xy"
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = operand_1
+
+    test_case = 10
+    operand_1 = "XyXy"
+    operand_2 = ""
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    # clearly "" appears in "XyXy" infinity times, but "XyXy" is no
+    # repetition of ""
+    actual[test_case] = false
+
+    test_case = 11
+    operand_1 = "XyXy"
+    operand_2 = "Xy"
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = operand_1
+
+    test_case = 12
+    operand_1 = "X"
+    operand_2 = "XXX"
+    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = false
+
+    judgement = actual.keys.map {|test_case|
+      [expectation[test_case], actual[test_case] , test_case]
+    }.map(&method("expect_equal")).all?
   end
 
 
+
+end
+
+
+class Rubyment
+   include RubymentModule
 end
 
 (__FILE__ == $0) && Rubyment.new({:invoke => ARGV})

metadata

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