rubyment 0.6.25581116 → 0.6.25622871

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0a1dc731e8fd7860ae00dcf476648dd311322f2
-  data.tar.gz: 75ec3ac1a176cbef2d3717f4c0aa8ec45ef05c20
+  metadata.gz: 1af01ed82dd69412c3b2bb67c4d4563a12c8866f
+  data.tar.gz: f2b77d810d636178b2e474d8e20d2df83801d80b
 SHA512:
-  metadata.gz: 798fc0253107f5b698b529776dfbd12133506b25afe02be2cd1a66ee2aad01fadf495002868f1374569d6fa281cd5c8740c0a175bd07a0c31848a28d036ccee9
-  data.tar.gz: 82bc3dccb487171a155c3af0cd0d78a379815f69338d3618ff2ce84c7e5873e5d871a250c91e5d181033327a380956b70d0b1c40ea7e7a23941ea65dadba3660
+  metadata.gz: 45908cb4f83297a21fb499e2f87bba89c87f42a1a54ec7617f75c7754b791a1736cd2e840cf0fd0ac2c2808df86f8706a0f82f259d5c67e2a66dcfed5721a1d7
+  data.tar.gz: 6b202da96a5f35e602441ed1f285896c774e3257607245fb3d8dd059cf49711443b0501a5a06b8bc7dba5fcc691a25808eb5ff99a7a43b6a2707cee2a5d7aa11

data/lib/rubyment.rb

@@ -6,7 +6,7 @@
   TrueClass will be changed just by including
   this file or requiring rubyment, which is not the
   best approach, but kept to respect the open/closed
-  principle, but new functions should be added here.
+  principle, but new functions should NOT be added here.
   # end_documentation
 =end
 class TrueClass
@@ -23,7 +23,7 @@ end
   Object will be changed just by including
   this file or requiring rubyment, which is not the
   best approach, but kept to respect the open/closed
-  principle, but new functions should be added here.
+  principle, but new functions should NOT be added here.
 
   only a bunch of methods, is, however, added:
   . negate_me
@@ -90,6 +90,82 @@ class Object
       self
     )
   end
+
+
+end
+
+
+=begin
+  # begin_documentation
+  This module offers function to interface with certain
+  internal structures. Ie, these functions are supposed
+  to be useless unless running Rubyment.
+
+  # end_documentation
+=end
+module InternalRubymentModule
+
+
+=begin
+  gets the current @memory
+=end
+  def rubyment_memory__
+    @memory
+  end
+
+
+=begin
+  updates the current @memory with a new hash m
+=end
+  def rubyment_memory__shallow_update m
+    @memory.update m
+  end
+
+
+=begin
+  updates the current @memory with a new hash m
+=end
+  def rubyment_memory__set m
+    @memory =  m
+  end
+
+
+end
+
+
+=begin
+  # begin_documentation
+  Object will be changed just by including
+  this file or requiring rubyment, which is not the
+  best approach, but kept to respect the open/closed
+  principle, the Object class is kept adding some
+  methods.
+
+  However, the best approach is to add new functions
+  to this module, which will only be used to modify
+  the Object class if the RubymentModule is included.
+
+
+  # end_documentation
+=end
+module ModifierForClassObjectModule
+
+
+  def __is object
+    object
+  end
+
+
+  def array__is *args
+    args
+  end
+
+
+  def __note arg
+    self
+  end
+
+
 end
 
 
@@ -334,29 +410,11 @@ module RubymentExperimentModule
     debug && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "caller=#{caller_label.inspect}")
     debug && (stderr.puts "args=#{args.inspect}")
-    test_cases = test_cases.nne [
-     # [ :id, :expectation, :actual_params ],
-     # :actual_params: array with :method_name + :method_args
+    rv = tester_with_bled [
+      test_cases,
+      debug,
+      :use_first_of_bled_return.__is(true),
     ]
-    expectation = {}
-    actual = {}
-    debug && (stderr.puts "test_cases.size=#{test_cases.size}")
-    test_cases.each_with_index{ |test_case|
-      debug && (stderr.puts "test_case=[test_case_id, test_expectation, actual_params]=#{test_case.inspect}")
-      test_case_id, test_expectation, actual_params = test_case
-      actual_params_method_name,
-        *actual_params_method_args = actual_params
-      debug && (stderr.puts "will send: #{actual_params_method_name.to_s}(*#{actual_params_method_args.inspect})")
-      result = send actual_params_method_name, *actual_params_method_args
-      expectation[test_case_id] = test_expectation
-      actual[test_case_id] = result
-      debug && (stderr.puts "[test_expectation.hash, result.hash]=#{[test_expectation.hash, result.hash].inspect}")
-    }
-    judgement = actual.keys.map {|test_case|
-      [expectation[test_case], actual[test_case] , test_case]
-    }.map(&method("expect_equal")).all?
-
-    rv = judgement
     debug && (stderr.puts "will return #{rv.inspect}")
     debug && (stderr.puts "#{__method__} returning}")
     rv
@@ -437,6 +495,24 @@ enum = (s.scan /http_[^(]*/).uniq.map
 # send_enumerator [ enum, :gsub, ["http_", ""] ]
 # => ["delete", "get", "head", "post", "put"]
 
+send_enumerator [ ["tinga_http_tinga", "http_catepa"], :gsub, ["http_", ""] ]
+#  => ["tinga_tinga", "catepa"]
+
+send_enumerator [ [ [1, 2, 3] ], :map, [], Proc.new {|x| x + 1 } ]  
+#  => [[2, 3, 4]]
+
+send_enumerator [ [ {}, {} ], :containerize, [], nil, 0]
+# => [[{}], [{}]]
+
+
+#bug:
+send_enumerator [ [ {}, {} ], :method.to_nil, :args.to_nil, Proc.new {}  ]
+# ArgumentError: no method name given
+
+# no bug, just not intuitive usage: 
+
+send_enumerator [ [ {}, {} ], Proc.new {|x| x.size }, [].to_nil, :whatever, 0]
+# => [0, 0]
 
 =end
   def send_enumerator args=[]
@@ -445,9 +521,21 @@ enum = (s.scan /http_[^(]*/).uniq.map
       args_to_method,
       block_to_method,
       replace_at_index,
+      debug,
+      no_output_exceptions,
+      rescuing_exceptions,
+      return_not_only_first,
       reserved = args
 
+    stderr = @memory[:stderr]
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args=#{args.inspect}")
     args_to_method = args_to_method.nne []
+    no_output_exceptions = no_output_exceptions.nne
+    rescuing_exceptions = rescuing_exceptions.nne
+    return_not_only_first = return_not_only_first.nne
 
     calling_tuples = enum.map {|e|
       method_name = (!method.respond_to? :call) && method || nil
@@ -458,13 +546,28 @@ enum = (s.scan /http_[^(]*/).uniq.map
       replace_at_index && (c_t[replace_at_index] = e)
       method_name && (c_t.unshift method_name)
       c_t.unshift method_to_call
+      debug && (stderr.puts "[e, method_to_call, method_name, replace_at_index]=#{[e, method_name, method_to_call, replace_at_index]}")
+
       c_t
     }
-
-    calling_tuples.map {|c_t|
-      method_to_call, *args_to_call = c_t
-      method_to_call.call *args_to_call, &block_to_method
+    debug && (stderr.puts "calling_tuples=#{calling_tuples}")
+
+    rv = calling_tuples.map {|c_t|
+      block = bled [
+        :nil,
+        rescuing_exceptions,
+        no_output_exceptions,
+      ] {
+        method_to_call, *args_to_call = c_t
+        method_to_call.call *args_to_call, &block_to_method
+      }
+      return_not_only_first.negate_me && (lrv = block.first.call.first)
+      return_not_only_first && (lrv = block.first.call)
+      lrv
     }
+    debug && (stderr.puts "will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
   end
 
 
@@ -730,23 +833,193 @@ enum = (s.scan /http_[^(]*/).uniq.map
   end
 
 
-end
+=begin
+trying to get the interface compatible with
+# rest_request_or_open_uri_open
+# ideally, i would need an equivalent for
+# rest_response__request_base
+
+=end
+  def http_request_response__curl args=[]
+    stderr = @memory[:stderr]
+    url,
+      payload,
+      verify_ssl,
+      unimplemented__headers,
+      method,
+      auth_user,
+      password,
+      unimplemented__timeout,
+      unused__skip_open_uri,
+      debug,
+      no_rescuing,
+      output_exception,
+      reserved = args
+
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    no_rescuing = no_rescuing.nne
+    output_exception = output_exception.nne
+    method = method.nne "get"
+    verify_ssl = verify_ssl.nne
+    curl_method = "http_#{method.downcase}"
+    curl_post_data = payload.nne
+    curl_args = [url, curl_post_data].compact
+    block = bled [
+      :no_answer.to_nil,
+      no_rescuing,
+      output_exception,
+    ] {
+        require 'curb'
+        c = Curl::Easy.send(curl_method, *curl_args){|c|
+          c.http_auth_types = :basic
+          c.username = auth_user
+          c.password = password
+          c.ssl_verify_host = verify_ssl
+          c.ssl_verify_peer = verify_ssl
+          c.follow_location = true
+          debug && (stderr.puts "c.ssl_verify_peer=#{c.ssl_verify_peer?}")
+          debug && (stderr.puts "c.ssl_verify_host=#{c.ssl_verify_host?}")
+        }
+        c.perform
+        [ c.body_str, nil, c.http_connect_code]
+    }
+    rv = block.first.call
+
+    debug && (stderr.puts "#{__method__}  will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
 
 
 =begin
-  # begin_documentation
-  This module receives only functions that are maintained.
-  Ie, the non-deprecated or not under deprecation functions.
-  # end_documentation
+   tests #experiment__web_http_https_server, creating two
+   servers, one ssl and another plain, redirecting to
+   the ssl one. then, opens a client thread with a client
+   connecting to the root document of the plain server
+   (and in the end being served by the root document of
+   the ssl server).
+   note that this function, with default values will run
+   forever. client_loop_times must be set (to at least 1)
 =end
-module RubymentMaintainedModule
+  def test__experiment__web_http_https_server args = ARGV
+    stderr = @memory[:stderr]
+    tcp_ssl_server_method,
+      http_processing_method,
+      http_processing_method_args,
+      http_server_port,
+      http_ip_addr,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      ssl_cert_pkey_chain_method,
+      debug_tcp_ssl_server_method,
+      happy_with_request,
+      io_method,
+      io_method_debug,
+      domain,
+      admit_non_ssl,
+      plain_http_processing_method,
+      plain_http_processing_method_args,
+      plain_http_server_port,
+      plain_http_ip_addr,
+      no_debug_client,
+      client_loop_times,
+      reserved = args
+    tcp_ssl_server_method = tcp_ssl_server_method.nne :experiment__web_http_https_server
+    domain = domain.nne "localhost"
+    http_server_port = http_server_port.nne 8003
+    plain_http_server_port = plain_http_server_port.nne 8004
+    no_debug_client = no_debug_client.nne
+    client_loop_times = client_loop_times.nne Float::INFINITY
+    servers = send tcp_ssl_server_method,
+      [
+        http_processing_method,
+        http_processing_method_args,
+        http_server_port,
+        http_ip_addr,
+        priv_pemfile,
+        cert_pem_file,
+        extra_cert_pem_files,
+        ssl_cert_pkey_chain_method,
+        debug_tcp_ssl_server_method,
+        happy_with_request,
+        io_method,
+        io_method_debug,
+        admit_non_ssl,
+        plain_http_processing_method,
+        plain_http_processing_method_args,
+        plain_http_server_port,
+        plain_http_ip_addr,
+      ]
+
+    thread_client = Thread.new {
+      (1..client_loop_times).map { |i|
+        response = test__file_read__uri_root [
+          domain,
+          plain_http_server_port,
+          admit_non_ssl,
+          no_debug_client.negate_me,
+        ]
+        sleep 2
+      }
+    }
+    thread_client.join
+
+    true
+  end
+
+
+=begin
+  calls a function with the processing arg
+  @param [Array] +args+, an +Array+ whose elements are expected to be:
+  +processing_arg+:: [Object]
+  +method+:: [Method, String]
+  +method_args+:: [Array] args to be given to the +transform_method_name+
+  +on_object+:: [String, Boolean]
+  +debug+:: [Boolean]
+  +output_exceptions+:: [Boolean]
+  
+  @return [String] +processing_arg+
+=end
+  def transform_call args = ARGV
+    processing_arg,
+      method,
+      method_args,
+      on_object,
+      debug,
+      output_exceptions,
+      reserved = args
+    stderr = @memory[:stderr]
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    object_arg = on_object.nne && processing_arg || nil
+    to_method_block = bled [
+      nil,
+      :no_rescue.negate_me,
+      output_exceptions,
+    ] {
+      to_method(
+        [method, object_arg]).call(
+          [processing_arg] + method_args
+      )
+    }
+    rv =  to_method_block.first.call
+    debug && (stderr.puts "will return first of: #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv.first
+  end
 
 
 =begin
   # documentation_begin
-  # short_desc = "extracts information about a block and return them structurally in an array."
+  # short_desc = "natural improvement of experiment__tester: but protect each case from exception throwing",
   @memory[:documentation].push = {
-    :function   => :block_info_base,
+    :function   => :tester_with_bled,
     :short_desc => short_desc,
     :description => "",
     :params     => [
@@ -757,22 +1030,790 @@ module RubymentMaintainedModule
         :default_behavior => [],
         :params           => [
           {
-            :name             => :block,
-            :duck_type        => Exception,
-            :default_behavior => nil,
-            :description      => "block to extract info from",
+            :name             => :test_cases,
+            :duck_type        => Array,
+            :default_behavior => :[],
+            :description      => "Array having the fields: __test_id__, __test_expected_value__ and __actual_params__. __actual_params__ is an __Array__ having  as first member __method_name__ to be called, and all its remaining args __method_args__ (a __splat__) will be given to __method_name__",
           },
           {
-            :name             => :max_str_index,
-            :duck_type        => FixNum,
-            :default_behavior => -1,
-            :description      => "limit the full string output to this last index",
+            :name             => :debug,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "prints debug information to the __IO__ specified by __@memory[:stderr]__ (STDERR by default)",
           },
           {
-            :name             => :reserved,
+            :name             => :use_first_of_bled_return,
             :duck_type        => Object,
-            :default_behavior => nil,
-            :description      => "reserved for future use",
+            :default_behavior => :nil,
+            :description      => "will ignore the exception report information returned by bled, and use only the first value.",
+          },
+          {
+            :name             => :output_exceptions,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "exceptions are normally properly handled by inner functions, but setting this to true can be helpful to debug some cases",
+            :forwarded        => [
+              { :to => :bled, :as => :output_exceptions }
+            ],
+          },
+          {
+            :name             => :no_rescue,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "don't protect against exceptions happening",
+            :forwarded        => [
+              { :to => :bled, :as => :dont_rescue }
+            ],
+          },
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+        ],
+      },
+    ],
+    :return_value     => [
+      {
+        :name             => :args,
+        :description      => "__true__ if tests were successful, __false__ otherwise",
+        :duck_type        => :boolean,
+      },
+    ],
+  }
+  # documentation_end
+=end
+  def tester_with_bled args=[]
+    stderr = @memory[:stderr]
+    test_cases,
+      debug,
+      use_first_of_bled_return,
+      output_exceptions,
+      no_rescue,
+      reserved = args
+
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label.inspect}")
+    debug && (stderr.puts "args=#{args.inspect}")
+    use_first_of_bled_return = use_first_of_bled_return.nne
+    test_cases = test_cases.nne [
+     # [ :id, :expectation, :actual_params ],
+     # :actual_params: array with :method_name + :method_args
+    ]
+    expectation = {}
+    actual = {}
+    debug && (stderr.puts "test_cases.size=#{test_cases.size}")
+    test_cases.each_with_index{ |test_case|
+      debug && (stderr.puts "test_case=[test_case_id, test_expectation, actual_params]=#{test_case.inspect}")
+      test_case_id, test_expectation, actual_params = test_case
+      actual_params_method_name,
+        *actual_params_method_args = actual_params
+      debug && (stderr.puts "will send: #{actual_params_method_name.to_s}(*#{actual_params_method_args.inspect})")
+
+      block = bled [
+        nil,
+        no_rescue,
+        output_exceptions,
+      ] {
+          send actual_params_method_name, *actual_params_method_args
+      }
+      result = block.first.call
+
+      expectation[test_case_id] = test_expectation
+      use_first_of_bled_return && (actual[test_case_id] = result.first)
+      use_first_of_bled_return.negate_me && (actual[test_case_id] = result)
+      debug && (stderr.puts "[test_expectation.hash, result.hash]=#{[test_expectation.hash, result.hash].inspect}")
+    }
+    judgement = actual.keys.map {|test_case|
+      [expectation[test_case], actual[test_case] , test_case]
+    }.map(&method("expect_equal")).all?
+
+    rv = judgement
+    debug && (stderr.puts "will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+=begin
+  returns a timestamp in the format "%Y.%m.%d_%H:%M:%S"
+=end
+  def time__now_strftime_default
+    Time.now.strftime("%Y.%m.%d_%H:%M:%S")
+  end
+
+
+=begin
+  # documentation_begin
+  # short_desc = "this improves experiment__tester by encapsulating the bled block building, calls experiment__tester too "
+  @memory[:documentation].push = {
+    :function   => :experiment__tester_with_bled,
+    :short_desc => short_desc,
+    :description => "",
+    :params     => [
+      {
+        :name             => :args,
+        :description      => "list of parameters",
+        :duck_type        => Array,
+        :default_behavior => [],
+        :params           => [
+          {
+            :name             => :test_cases_method_args,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+          {
+            :name             => :test_cases_array,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+          {
+            :name             => :debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "prints debug information to the __IO__ specified by __@memory[:stderr]__ (STDERR by default)",
+          },
+          {
+            :name             => :debug_experiment__tester,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :forwarded        => [
+              { :to => :experiment__tester, :as => :debug }
+            ],
+          },
+          {
+            :name             => :output_exceptions,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "exceptions are normally properly handled by inner functions, but setting this to true can be helpful to debug some cases",
+          },
+          {
+            :name             => :to_method_debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :forwarded        => [
+              { :to => :to_method , :as => :to_method_debug }
+            ],
+          },
+          {
+            :name             => :to_object_method_debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :forwarded        => [
+              { :to => :to_method , :as => :to_object_method_debug }
+            ],
+          },
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+        ],
+      },
+    ],
+    :return_value     => [
+      {
+        :name             => :args,
+        :description      => "list of parameters",
+        :duck_type        => Array,
+        :default_behavior => [],
+        :params           => [
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+        ],
+      },
+    ],
+  }
+  # documentation_end
+=end
+  def experiment__tester_with_bled args=[]
+    stderr = @memory[:stderr]
+    test_cases_method,
+      test_cases_method_args,
+      test_cases_array,
+      debug,
+      debug_experiment__tester,
+      output_exceptions,
+      to_method_debug,
+      to_object_method_debug,
+      no_rescue,
+      reserved = args
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args=#{args.inspect}")
+    test_cases_array = test_cases_array.nne []
+    test_cases_method_args = test_cases_method_args.nne []
+    test_cases_from_method = (to_method [
+      test_cases_method,
+      to_method_debug,
+      to_object_method_debug,
+      no_rescue,
+    ]).call *test_cases_method_args
+    debug && (stderr.puts "test_cases_array.size=#{test_cases_array.size}")
+    debug && (stderr.puts "test_cases_from_method.size=#{test_cases_from_method.size}")
+    test_cases = test_cases_from_method.to_a + test_cases_array.to_a
+    debug && (stderr.puts "test_cases.size=#{test_cases.size}")
+    experiment__tester_block = bled [
+      nil,
+      no_rescue,
+      output_exceptions,
+    ] {
+        experiment__tester [
+        test_cases,
+        debug_experiment__tester,
+      ]
+    }
+    debug && (stderr.puts "experiment__tester_block=#{experiment__tester_block.inspect}")
+    rv = experiment__tester_block.first.call
+    debug && (stderr.puts "will return first of #{rv.inspect}")
+    !rv.first && (stderr.puts "{#{__method__}: failed with arguments=#{args.inspect}}")
+    rv[1] && (stderr.puts "{#{__method__} exception caught:")
+    rv[1] && (stderr.puts :exception_output.__is(rv[1][1]))
+    rv[1] && (stderr.puts "#{__method__} exception caught}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv.first
+  end
+
+
+=begin
+  give as first element in args to experiment__tester_with_bled
+=end
+  def test_cases__send_enumerator args=[]
+    testing_method = :send_enumerator
+    test_cases ||= [
+      [
+        :test_case_id.__is("array_base"),
+        :expectation.array__is("post", "get"),
+        :get_actual_results_with.array__is(
+          testing_method,
+          :testing_method_args.array__is(
+            :enum.array__is("http_post", "http_get"),
+            :method_to_each_in_enum.__is(:gsub),
+            :args_to_method.array__is("http_", ""),
+            :block_to_method.__is(:whatever),
+            :insert_iterating_element_at.__is(:ensure.__is(nil)),
+            :debug.__is(false),
+            :no_output_exceptions.__is(nil),
+            :rescuing_exceptions.__is(nil),
+            :return_not_only_first.__is(nil),
+          ),
+        ),
+      ].__note("end of array_base"),
+
+      [
+        :test_case_id.__is("two_hashes_base"),
+        :expectation.array__is(
+          [{}], [{}],
+        ),
+        :get_actual_results_with.array__is(
+          testing_method,
+          :testing_method_args.array__is(
+            [ {}, {} ],
+            :containerize,
+            [],
+            :block_to_method.__is(:whatever),
+            :insert_iterating_element_at.__is(0),
+            :debug.__is(nil),
+            :no_output_exceptions.__is(nil),
+            :rescuing_exceptions.__is(nil),
+            :return_not_only_first.__is(nil),
+          ),
+        ),
+      ].__note("end of two_hashes_base"),
+
+      [
+        :test_case_id.__is("two_hashes_size"),
+        :expectation.array__is(0, 0),
+        :get_actual_results_with.array__is(
+          testing_method,
+          :testing_method_args.array__is(
+            [ {}, {} ],
+            Proc.new {|x| x.size },
+            [].to_nil,
+            :block_to_method.__is(:whatever),
+            :insert_iterating_element_at.__is(0),
+            :debug.__is(nil),
+            :no_output_exceptions.__is(nil),
+            :rescuing_exceptions.__is(nil),
+            :return_not_only_first.__is(nil),
+          ),
+        ),
+      ].__note("end of two_hashes_size"),
+
+      [
+        :test_case_id.__is("distribute_methods_over_object_v1"),
+        :expectation.array__is(
+          "Test", "TEST",
+        ),
+        :get_actual_results_with.array__is(
+          testing_method,
+          :testing_method_args.array__is(
+            ["capitalize", "upcase" ],
+            Proc.new {|method| "test".send method },
+            nil,
+            :block_to_method.__is(:whatever),
+            :insert_iterating_element_at.__is(0),
+            :debug.__is(nil),
+            :no_output_exceptions.__is(nil),
+            :rescuing_exceptions.__is(nil),
+            :return_not_only_first.__is(nil),
+          ),
+        ),
+      ].__note("end of distribute_methods_over_object_v1"),
+
+      [
+        :test_case_id.__is("distribute_methods_over_object_v2"),
+        :expectation.array__is(
+          "Test", "TEST",
+        ),
+        :get_actual_results_with.array__is(
+          testing_method,
+          :testing_method_args.array__is(
+            ["capitalize", "upcase" ],
+            "test".method(:send),
+            :args_to_method.__is(nil),
+            :block_to_method.__is(:whatever),
+            :insert_iterating_element_at.__is(0),
+            :debug.__is(nil),
+            :no_output_exceptions.__is(nil),
+            :rescuing_exceptions.__is(nil),
+            :return_not_only_first.__is(nil),
+          ),
+        ),
+      ].__note("end of distribute_methods_over_object_v2"),
+
+      [
+        :test_case_id.__is("array_map"),
+        :expectation.array__is(
+          [2, 3, 4],
+        ),
+        :get_actual_results_with.array__is(
+          testing_method,
+          :testing_method_args.array__is(
+            :enum.array__is([1, 2, 3]),
+            :method_to_each_in_enum.__is(:map),
+            :args_to_method.__is(nil),
+            :block_to_method.__is(Proc.new {|x| x + 1 }),
+            :insert_iterating_element_at.__is(:ensure.__is(nil)),
+            :debug.__is(nil),
+            :no_output_exceptions.__is(nil),
+            :rescuing_exceptions.__is(nil),
+            :return_not_only_first.__is(nil),
+          ),
+        ),
+      ].__note("end of array_map"),
+
+    ]
+
+  end
+
+
+=begin
+  Just alias to
+  experiment__tester_with_bled containerize test_cases__send_enumerator
+=end
+  def test__send_enumerator args=[]
+    debug,
+      reserved = args
+    stderr = @memory[:stderr]
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args=#{args.inspect}")
+    rv = experiment__tester_with_bled [:test_cases__send_enumerator]
+    debug && (stderr.puts "will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+=begin
+  # documentation_begin
+  # short_desc = "parses an http request"
+  @memory[:documentation].push = {
+    :function   => :experiment__http_request_parse,
+    :short_desc => short_desc,
+    :description => "",
+    :params     => [
+      {
+        :name             => :args,
+        :description      => "list of parameters",
+        :duck_type        => Array,
+        :default_behavior => [],
+        :params           => [
+          {
+            :name             => :request,
+            :duck_type        => [String, :array_of_strings],
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+            :name             => :debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "prints debug information to the __IO__ specified by __@memory[:stderr]__ (STDERR by default)",
+          },
+          {
+            :name             => :methods_to_call,
+            :duck_type        => Array,
+            :default_behavior => [
+              :path_info,
+              :request_uri,
+              :body,
+              :request_method,
+              :ssl?,
+            ]
+            :description      => "methods/properties to extract from a WEBrick::HTTPRequest object -- it must be a valid method callable without parameters.",
+          },
+          {
+            :name             => :output_exceptions,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "exceptions are normally properly handled by inner functions, but setting this to true can be helpful to debug some cases",
+          },
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+        ],
+      },
+    ],
+    :return_value     => [
+      {
+        :name             => :args,
+        :description      => "list of parameters",
+        :duck_type        => Array,
+        :default_behavior => [],
+        :params           => [
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "for future use",
+          },
+        ],
+      },
+    ],
+  }
+  # documentation_end
+=end
+  def experiment__http_request_parse args=[]
+    request,
+      debug,
+      methods_to_call,
+      output_exceptions,
+      reserved = args
+    stderr = @memory[:stderr]
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    # debug && (stderr.puts "backtrace=#{backtrace}")
+    output_exceptions = output_exceptions.nne
+    methods_to_call = methods_to_call.nne [
+      :path_info,
+      :request_uri,
+      :body,
+      :request_method,
+      :ssl?,
+    ]
+    request = (containerize request.nne "").join
+    debug && (stderr.puts "=#{}")
+    require 'webrick'
+    require 'stringio'
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    block = bled [
+      :no_answer.to_nil,
+      :no_rescue.negate_me,
+      output_exceptions,
+    ] {
+      req.parse(StringIO.new(request))
+      req
+    }
+    parse_return = block.first.call
+    methods_result_return = send_enumerator [
+      methods_to_call,
+      req.method(:send),
+      :args_to_method.array__is(nil),
+      :block_to_method.__is(:whatever),
+      :insert_iterating_element_at.__is(0),
+      :debug.__is(nil),
+      :no_output_exceptions.__is(output_exceptions.negate_me),
+      :rescuing_exceptions.__is(nil),
+      :return_not_only_first.__is(true),
+    ]
+    methods_result = methods_result_return.transpose[0]
+    rv = [
+      req,
+      methods_to_call,
+      methods_result,
+      parse_return,
+      methods_result_return,
+    ]
+    debug && (stderr.puts "#{__method__}  will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+=begin
+  returns an array having all the valid values for elements
+  of methods_to_call parameter of #experiment__http_request_parse
+=end
+  def callable_methods__http_request_parse args=[]
+    methods_to_call = methods_to_call.nne [
+      :path_info,
+      :request_uri,
+      :content_length,
+      :body,
+      :request_method,
+      :ssl?,
+      :path,
+      :host,
+      :attributes,
+      :accept,
+      :port,
+      :query,
+      :user,
+      :addr,
+      :header,
+      :body,
+      :request_method,
+      :content_type,
+      :keep_alive,
+      :cookies,
+      :http_version,
+      :accept_charset,
+      :query_string,
+      :script_name,
+      :server_name,
+      :accept_encoding,
+      :accept_language,
+      :peeraddr,
+      :raw_header,
+      :continue,
+      :remote_ip,
+      :keep_alive?,
+      :fixup,
+    ]
+  end
+
+
+=begin
+  # short_desc = "creates an http response, after executing the GET "
+
+  @memory[:documentation].push = {
+    :function   => :experiment__http_response_invoke,
+    :short_desc => short_desc,
+    :description => "",
+    :params     => [
+      {
+        :name             => :args,
+        :description      => "list of parameters",
+        :duck_type        => Array,
+        :default_behavior => "interpreted as empty array",
+        :params           => [
+          {
+            :name             => :request,
+            :duck_type        => String,
+            :default_behavior => :nil
+            :description      => "ignored, will redirect whatever request is made. nil is used.",
+          },
+          {
+            :name             => :location,
+            :duck_type        => String,
+            :default_behavior => "",
+            :description      => "Location: field value (the url to redirect to)",
+          },
+          {
+            :name             => :code,
+            :duck_type        => String,
+            :default_behavior => "200 OK",
+            :description      => "Request code",
+          },
+          {
+            :name             => :version,
+            :duck_type        => String,
+            :default_behavior => "1.1",
+            :description      => "HTTP protocol version",
+          },
+          {
+            :name             => :debug,
+            :duck_type        => Object,
+            :default_behavior => :nil,
+            :description      => "prints debug information to the __IO__ specified by __@memory[:stderr]__ (STDERR by default)",
+          },
+          {
+            :name             => :eol,
+            :duck_type        => Object,
+            :default_behavior => "\r\n",
+            :description      => "separator to join each line of the response",
+          },
+          {
+            :name             => :debug_request_parse,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :forwarded        => [
+              { :to => experiment__http_request_parse , :as => :debug }
+            ],
+          },
+          {
+            :name             => :output_exceptions,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "exceptions are normally properly handled by inner functions, but setting this to true can be helpful to debug some cases",
+          },
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => "interpreted as nil",
+            :description      => "for future use",
+          },
+        ],
+      },
+    ],
+  }
+
+=end
+  def experiment__http_response_invoke args = []
+    request,
+      location,
+      code,
+      version,
+      debug,
+      eol,
+      debug_request_parse,
+      output_exceptions,
+      reserved = args
+    stderr = @memory[:stderr]
+    stdout = @memory[:stdout]
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    request_parse = experiment__http_request_parse [
+      request,
+      debug_request_parse,
+      :methods_to_call.to_nil,
+      output_exceptions,
+    ]
+    debug && (stderr.puts "request_parse[2]=#{request_parse[2]}")
+    require "shellwords"
+    # request_parse[2][0] is the  the request_uri
+    # remove any starting slashes before sending to invoke:
+    args_for_rubyment = Shellwords.split(request_parse[2][0].to_s.gsub /\/*/, "")
+    debug && (stderr.puts "args_for_rubyment=#{args_for_rubyment}")
+    request_stdout = StringIO.new
+    request_stderr = StringIO.new
+    # not thread-safe:
+    @memory[:stdout] = request_stdout
+    @memory[:stderr] = request_stderr
+    block = bled [
+      :no_answer.to_nil,
+      :no_rescue.negate_me,
+      :output.negate_me,
+    ] {
+      invoke args_for_rubyment
+    }
+    invoke_result = block.first.call
+    @memory[:stdout] = stdout
+    @memory[:stderr] = stderr
+    require 'json'
+    payload = ({
+     "invoke_result"  => invoke_result,
+     "request_stdout" => request_stdout.string,
+     "request_stderr" => request_stderr.string,
+    }).to_json
+    debug && (stderr.puts "payload=#{payload}")
+    location = location.nne ""
+    version = version.nne "1.1"
+    code = code.nne "200 OK"
+    eol = eol.nne "\r\n"
+    rv = http_response_base [
+      payload,
+      :content_type.to_nil,
+      code,
+      version,
+      :keep_alive.to_nil,
+      debug,
+      eol,
+      location,
+    ]
+    debug && (stderr.puts "#{__method__} will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+=begin
+  returns an array having all the paths which are ancestors of
+  path, and path at the end of that array
+=end
+  def parent_dirs__from path
+    path_parent = File.dirname(path)
+    base_case   = (path == path_parent)
+    rv = []
+    base_case.negate_me && (
+      rv =  parent_dirs__from path_parent
+    )
+    rv.push path
+  end
+
+
+end
+
+
+=begin
+  # begin_documentation
+  This module receives only functions that are maintained.
+  Ie, the non-deprecated or not under deprecation functions.
+  # end_documentation
+=end
+module RubymentMaintainedModule
+
+
+=begin
+  # documentation_begin
+  # short_desc = "extracts information about a block and return them structurally in an array."
+  @memory[:documentation].push = {
+    :function   => :block_info_base,
+    :short_desc => short_desc,
+    :description => "",
+    :params     => [
+      {
+        :name             => :args,
+        :description      => "list of parameters",
+        :duck_type        => Array,
+        :default_behavior => [],
+        :params           => [
+          {
+            :name             => :block,
+            :duck_type        => Exception,
+            :default_behavior => nil,
+            :description      => "block to extract info from",
+          },
+          {
+            :name             => :max_str_index,
+            :duck_type        => FixNum,
+            :default_behavior => -1,
+            :description      => "limit the full string output to this last index",
+          },
+          {
+            :name             => :reserved,
+            :duck_type        => Object,
+            :default_behavior => nil,
+            :description      => "reserved for future use",
           },
         ],
       },
@@ -1085,7 +2126,7 @@ module RubymentMaintainedModule
     stderr = @memory[:stderr]
     default_on_exception,
       dont_rescue,
-      output_backtrace, # better call "debug_block"
+      output_backtrace,
       backtrace_max_str_len,
       debug,
       reserved = args
@@ -1289,11 +2330,109 @@ module RubymentDeprecatedModule
       backtrace.to_a
     ).join "\n"
 
-    full = string_truncate [
-      full,
-      max_str_index,
+    full = string_truncate [
+      full,
+      max_str_index,
+    ]
+    [short, full, inspection, backtrace]
+  end
+
+
+  # calls a function with the processing arg
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +processing_arg+:: [Object]
+  # +method+:: [Method, String]
+  # +method_args+:: [Array] args to be given to the +transform_method_name+
+  # +on_object+:: [String, Boolean]
+  #
+  # @return [String] +processing_arg+
+  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, object_arg]).call(
+        [processing_arg] + method_args
+    )
+  end
+
+
+  # use #tcp_ssl_server
+  # 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
+
+
+  def test_cases_template args=[]
+    # testing_method = :send_enumerator
+    test_cases ||= [
+      # [ :id, :expectation, :actual_params ],
+      # actual_params can be an array with method_name + args to that method.
     ]
-    [short, full, inspection, backtrace]
+  end
+
+
+  def test__file_read___http_request_response__curl args=[]
+    # these tests depend on internet connection, so it may be difficult
+    # to automate them.
+    url_1 = "https://www.google.com/"
+    url_1 = "http://www.google.com/"
+    url_1 = "https://localhost:8003/"
+    url_1 = "https://localhost:8003/"
+    url_1 = "http://localhost:8004/tinga"
+    p file_read [url_1, nil, nil, nil, nil, :skip_open_uri, :payload.to_nil, false, nil, nil, nil, nil, :http_request_response__curl]
   end
 
 
@@ -1522,6 +2661,29 @@ module RubymentUnderDeprecationModule
   include RubymentUnderDeprecationRuneFunctionsModule
 
 
+  # experimental stuff coming. usage example:
+  # ./rubyment.rb  invoke_double p test__shell_send_array__main  "tinga" "" sub in EN 
+  # ["tENga"]
+  #  will be deprecated by send_array_base
+  # ./rubyment.rb  invoke_double p experiment__send_array_base 300 "bytes"
+  # [[51, 48, 48], nil, nil]
+  # only works with strings by now
+  def test__shell_send_array__main args=[]
+    p args
+    object_to_send,
+      reserved,
+      method_to_send,
+      *args_to_send = args
+    object_to_send = object_to_send.nne
+    method_to_send = method_to_send.nne :main
+    object_to_send && (
+      object_to_send.send method_to_send, *args_to_send
+    ) || (!object_to_send) && (
+      send method_to_send, args_to_send
+    )
+  end
+
+
 end
 
 
@@ -1538,14 +2700,6 @@ end
 module RubymentTestModule
 
 
-  def test_cases_template args=[]
-    test_cases ||= [
-      # [ :id, :expectation, :actual_params ],
-      # actual_params can be an array with method_name + args to that method.
-    ]
-  end
-
-
 =begin
   test for #bled
 =end
@@ -1689,228 +2843,20 @@ module RubymentTestModule
   end
 
 
-=begin
-=end
-  def test_cases__experiment__send_array_base args=[]
-    method_to_test,
-      reserved = args
-    method_to_test = method_to_test.nne :experiment__send_array_base
+  def test_cases__template args=[]
+    # current best example: test_cases__send_enumerator
+    # testing_method = :send_enumerator
     test_cases ||= [
-      # test_case:
-      [
-         # id:
-         "test #{method_to_test} base :array_first_remainder",
-         # expectation:
-         [ [ :arg_to_send_1, [:arg_to_send_2, :arg_to_send_3]], nil, nil],
-         # method_name + args:
-         [
-            # method_name:
-            method_to_test,
-            # args to method_to_test:
-            [
-               # array_first_remainder is a method of...
-               self,
-               # method to call
-               :array_first_remainder,
-               # args to array_first_remainder
-               [ :arg_to_send_1, :arg_to_send_2, :arg_to_send_3 ],
-               # block to array_first_remainder
-               nil,
-               # args_to_bled:
-               [nil, :dont_rescue.negate_me, :debug_block.negate_me],
-               # nil method takes Array (and not splat)
-               :is_array_method,
-               # destination:
-               nil,
-               # debug:
-               0,
-            ],
-         ],
-      ],
-      # test_case:
-      [
-         # id:
-         "test #{method_to_test} base nil method ",
-         # expectation:
-         [[ :arg_to_send_1, :arg_to_send_2, :arg_to_send_3 ], nil, nil],
-         # method_name + args:
-         [
-            # method_name:
-            method_to_test,
-            # args to method_to_test:
-            [
-               # object responding to method to call:
-               self,
-               # method to call: nil method (no method):
-               :method_to_call.to_nil,
-               # args to nil method:
-               [ :arg_to_send_1, :arg_to_send_2, :arg_to_send_3 ],
-               # block to nil method:
-               nil,
-               # args_to_bled:
-               [nil, :no_rescue.negate_me, :debug_block.to_nil],
-               # nil method takes splat (and not Array)
-               :is_array_method.to_nil,
-               # destination:
-               nil,
-               # debug:
-               0,
-            ],
-         ],
-      ],
-      # test_case:
-      [
-         # id:
-         "test #{method_to_test} nil.inspect ",
-         # expectation:
-         ["nil", nil, nil],
-         # method_name + args:
-         [
-            # method_name:
-            method_to_test,
-            # args to method_to_test:
-            [
-               # object responding to method to call:
-               nil,
-               # method to call on nil
-               :inspect,
-               # args to inspect:
-               nil,
-               # block to inspect:
-               nil,
-               # args_to_bled:
-               [nil, :no_rescue.negate_me, :debug_block.to_nil ],
-               # inspect takes splat (and not Array)
-               :is_array_method.to_nil,
-               # destination:
-               nil,
-               # debug:
-               0,
-            ],
-         ],
-      ],
-      # test_case:
-      [
-         # id:
-         "test #{method_to_test} array.map(&:to_s) ",
-         # expectation:
-         [["1", "2", "3"], nil, nil],
-         # method_name + args:
-         [
-            # method_name:
-            method_to_test,
-            # args to method_to_test:
-            [
-               # object responding to method to call:
-               [1, 2, 3],
-               # method to call on [1, 2, 3]:
-               :map,
-               # args to :map
-               [],
-               # block to map:
-               lambda {|x| x.to_s },
-               # args_to_bled:
-               [nil, :no_rescue.negate_me, :debug_block.to_nil ],
-               # map takes splat (and not Array)
-               :is_array_method.to_nil,
-               # destination:
-               nil,
-               # debug:
-               0,
-            ],
-         ],
-      ],
-      # test_case:
-      [
-         # id:
-         "test #{method_to_test} array_unflatten_base",
-         # expectation:
-         [[ :a, [ :b ], :c], nil, nil],
-         # method_name + args:
-         [
-            # method_name:
-            method_to_test,
-            # args to method_to_test:
-            [
-               # object responding to method call:
-               self,
-               # method to call on self
-               :array_unflatten_base, [
-                 [:a, "[", :b, "]", :c],
-                 :shallow,
-                 :debug.negate_me,
-                 :reserved_tokens.to_nil,
-                 :inverse.negate_me,
-               ],
-               # block to array_unflatten_base
-               nil,
-               # args_to_bled:
-               [nil, :dont_rescue.negate_me, :debug_block.to_nil],
-               # array_unflatten_base takes array (and not splat)
-               :is_array_method,
-               # destination:
-               nil,
-               # debug:
-               0,
-            ],
-         ],
-      ],
-      # test_case end
-
-    ]
-  end
-
-
-=begin
-  test for #experiment__send_array_base
-=end
-  def test__experiment__send_array_base args=[]
-=begin
-    method_to_test,
-      reserved = args
-    method_to_test = method_to_test.nne :experiment__send_array_base
-    e1 = [ [ :arg_to_send_1, [:arg_to_send_2, :arg_to_send_3]], nil, nil]
-    a1 = send method_to_test, [
-      [
-        :array_first_remainder,
-        [ :arg_to_send_1, :arg_to_send_2, :arg_to_send_3 ],
-      ],
-      self,
+      # [ :id, :expectation, :actual_params ],
+      # actual_params can be an array with method_name + [args] to that method.
     ]
-
-    judgement =
-      [
-        [e1, a1, "test #{method_to_test} base :array_first_remainder"],
-      ].map(&method("expect_equal")).all?
-=end
-    stderr = @memory[:stderr]
-    debug = debug.nne
-    debug && (stderr.puts "{#{__method__} starting")
-    debug && (stderr.puts "caller=#{caller_label}")
-    debug && (stderr.puts "args=#{args.inspect}")
-    test_cases = (test_cases__experiment__send_array_base args)
-    debug && (stderr.puts "test_cases.size=#{test_cases.size}")
-    experiment__tester_block = bled [
-      nil,
-      :no_rescue.negate_me,
-      :output.negate_me,
-    ] {
-        experiment__tester [
-        (test_cases), 0
-      ]
-    }
-    debug && (stderr.puts "experiment__tester_block=#{experiment__tester_block.inspect}")
-    rv = experiment__tester_block.first.call
-    debug && (stderr.puts "will return #{rv.inspect}")
-    debug && (stderr.puts "#{__method__} returning}")
-    rv
   end
 
 
 end
 
 
-=begin
+=begin 
   # begin_documentation
   This module receives functions that change other
   Ruby classes, by adding or changing their classes.
@@ -1941,6 +2887,7 @@ end
   - HTTP/HTTPS server ready-to-go
   - gem package generation and submission.
   - tree parsing.
+  - graph visitor.
 
 
   Rubyment functions must respect the open/closed principle
@@ -1969,7 +2916,8 @@ end
 =end
 module RubymentModule
 
-  include RubymentClassInjectorModule
+  Object.class_eval { include ModifierForClassObjectModule }
+  include InternalRubymentModule
   include RubymentExperimentModule
   include RubymentMaintainedModule
   include RubymentDeprecatedModule
@@ -2125,7 +3073,9 @@ module RubymentModule
   # +headers+:: [Hash] +"Authorization"+ key will be added to it if +auth_user+ is given. Defaults to +{}+
   # +method+:: [HTTP method] one of +:get+, +:method+, +:post+ or +:delete+. defaults to +:get+
   # +timeout+:: [Fixnum, nil] defaults to +nil+
+  # +debug+:: [Object] if calling the object +nne+ method returns a +false+ value, won't print debug information
   # +request_method+:: [Method name] if given, won't call open-uri's or 'rest-client' , and will use this method instead. It has to have the same signature as #rest_request_or_open_uri_open. By default is +false+ to respect open-closed principle, but it is advised to be set to http_request_response__curl (which depends on 'curb') -- since, for some kind of responses, as redirects, a full featured http client is needed.
+  # +output_exceptions+:: [bool] output exceptions, for the methods supporting it.
   #
   # @return [String, Object] read data (or +return_on_rescue+)
   def file_read args=ARGV
@@ -2143,8 +3093,10 @@ module RubymentModule
       timeout,
       debug,
       request_method,
+      output_exceptions,
       reserved = args
-    debug = debug.nne 1
+    debug = debug.nne
+    output_request_method_exceptions = output_request_method_exceptions.nne
     debug && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "args=#{args.inspect}")
     request_method = request_method.nne :rest_request_or_open_uri_open
@@ -2166,6 +3118,7 @@ module RubymentModule
             skip_open_uri,
             :debug_request_method.to_nil,
             :no_rescue_i_catch_exceptions,
+            output_exceptions,
           ]).first
         debug && (stderr.puts "url_response=#{url_response.inspect}")
         url_response
@@ -2335,16 +3288,28 @@ module RubymentModule
   #  method_object (Method)
   def to_object_method args=ARGV
     stderr = @memory[:stderr]
-    name, object = containerize args
-    begin
+    name,
+      object,
+      debug,
+      reserved = containerize args
+
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args=#{args.inspect}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    rv = begin
       object.method("method").call(name.to_s)
     rescue NameError => nameError
       # every object (even nil) has :method,
       # and every Method has :call: exception
       # is thrown in call
-      stderr.puts nameError
+      debug && (stderr.puts nameError)
       nil
     end
+    debug && (stderr.puts "will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
   end
 
   # calls object.method call_args
@@ -2744,11 +3709,9 @@ module RubymentModule
       reserved = args
 
     debug = debug.nne
-    debug = 1
     debug && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "args=#{args.inspect}")
     skip_open_uri = skip_open_uri.nne
-    debug && (stderr.puts "skip_open_uri=#{skip_open_uri.inspect}")
 
     response = runea ["yes, rescue".negate_me,
       "already not rescuing, forget about output".to_nil,
@@ -3947,8 +4910,6 @@ require '#{gem_name}'
     command="gem uninstall #{all} -x #{user_install}  #{gem_spec}"
     debug && (stderr.puts "command=#{command}")
     `#{command}`
-    #stdin, stdout, stderr, wait_thr = Open3.popen3(":;" + command)
-    #stdout
   end
 
   # gem_list
@@ -4315,16 +5276,44 @@ require '#{gem_name}'
   # in a polymorphic style.
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
   # +method_name_or_method+:: [String, Method] method name or method object
+  # +debug+::
+  # +to_object_method_debug+:: debug to_object_method call
+  # +output_exceptions+::
+  # +no_rescue+::
+  # +default_method+:: in the case no method can be derived from the args, this one is returned. Suggested Proc.new {|*args| } (not done for API respect)
   #
   # @return [Method] a method
   def to_method args = ARGV
-    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)
+    method_name_or_method,
+      object,
+      debug,
+      to_object_method_debug,
+      output_exceptions,
+      no_rescue,
+      default_method,
+      reserved = args
+
+    stderr = @memory[:stderr]
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    default_method = default_method.nne # ideally Proc.new {|*args| }, but we can't change the API
+    to_method_block = bled [
+      nil,
+      no_rescue,
+      output_exceptions,
+    ] {
+      (
+        to_object_method [object, method_name_or_method, to_object_method_debug ]
+      ) || (
+        method_name_or_method.respond_to?(:call) && method_name_or_method
+      ) ||
+        method(method_name_or_method) || default_method
+    }
+    rv = to_method_block.first.call
+    debug && (stderr.puts "will return first of: #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv.first
   end
 
 
@@ -4338,25 +5327,6 @@ require '#{gem_name}'
   end
 
 
-  # calls a function with the processing arg
-  # @param [Array] +args+, an +Array+ whose elements are expected to be:
-  # +processing_arg+:: [Object]
-  # +method+:: [Method, String]
-  # +method_args+:: [Array] args to be given to the +transform_method_name+
-  # +on_object+:: [String, Boolean]
-  #
-  # @return [String] +processing_arg+
-  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, object_arg]).call(
-        [processing_arg] + method_args
-    )
-  end
-
-
   # returns an HTTP response
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
   # +response+:: [String, nil] response payload
@@ -4547,7 +5517,7 @@ require '#{gem_name}'
       lazy.map {|i|
         r = lines.push(io.gets).last
         debug.nne && (stderr.puts r)
-	r.index(happy_with_request.to_s).to_i.nne && r
+        r.index(happy_with_request.to_s).to_i.nne && r
       }.find {|x| !x }
     debug.nne && (stderr.puts lines.inspect)
     debug.nne && (stderr.puts "#{__method__} returning")
@@ -4564,6 +5534,11 @@ require '#{gem_name}'
   # +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.
+  # +io_forward_debug+:: [boolean] will forward this argument to io_forward
+  # +transform_call_debug+:: [boolean] will forward this argument to  transform_call
+  # +to_method_debug+:: [boolean] will forward this argument to  to_method
+  # +to_object_method_debug+:: [boolean] will forward this argument to to_object_method
+  # +output_exceptions+:: [boolean]
   #
   # @return [nil]
   def io_transform args = ARGV
@@ -4572,19 +5547,30 @@ require '#{gem_name}'
       happy_with_request,
       transform_method_name,
       transform_method_args,
+      io_forward_debug,
+      transform_call_debug,
+      to_method_debug,
+      to_object_method_debug,
+      output_exceptions,
       reserved = args
     stderr = @memory[:stderr]
-    debug.nne && (stderr.puts "#{__method__} starting")
+    debug.nne && (stderr.puts "#{__method__} starting{")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
     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, [
+    io_forward [[io], io, io_forward_debug, happy_with_request, reserved,
+      :transform_call, [
         transform_method_name,
-	transform_method_args,
-	"on_object:true",
-      ]
+        transform_method_args,
+        "on_object:true",
+        transform_call_debug,
+        output_exceptions,
+      ],
+      to_method_debug,
+      to_object_method_debug,
     ]
-    debug.nne && (stderr.puts "#{__method__} returning")
+    debug.nne && (stderr.puts "#{__method__} returning}")
     nil
   end
 
@@ -4595,6 +5581,9 @@ require '#{gem_name}'
   # +io_in+:: [IO] any +IO+, like a +Socket+, returned by #TCPServer::accept, where data will be read from.
   # +debug+:: [Object] if evals to false (or empty string), won't print debug information
   # +happy_with_request+:: [String, nil] if nil, +eol+ is used.
+  # +to_method_debug+:: [boolean] will forward this argument to  to_method
+  # +to_object_method_debug+:: [boolean] will forward this argument to to_object_method
+  # +output_exceptions+:: [boolean]
   #
   # @return [nil]
   def io_forward args = ARGV
@@ -4605,25 +5594,40 @@ require '#{gem_name}'
       happy_with_request,
       reserved,
       processing_method,
-      processing_method_args = args
-    io_gets_args = [io_in, debug, happy_with_request]
+      processing_method_args,
+      to_method_debug,
+      to_object_method_debug,
+      output_exceptions,
+      reserved = args
     stderr = @memory[:stderr]
-    debug.nne && (stderr.puts "#{__method__} starting")
+    debug.nne && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
     debug.nne && (stderr.puts args.inspect)
+    io_gets_args = [io_in, debug, happy_with_request]
     input = io_gets io_gets_args
     debug.nne && (stderr.puts input.inspect)
     debug.nne && (stderr.puts ios_out.class.inspect)
     processing_method ||= :echo
+    debug && (stderr.puts "processing_method=#{processing_method}")
     processing_method_args ||= []
     processed_input = to_method(
-      [processing_method]).call(
+      [
+        processing_method,
+        :object.to_nil,
+        to_method_debug,
+        to_object_method_debug,
+      ]
+    ).call(
         [input] + processing_method_args
     )
-    ios_out.map{ |shared_io_out|
+    threads = ios_out.map{ |shared_io_out|
       runoe_threaded(shared_io_out) {|io_out|
-	io_out = shared_io_out
+        io_out = shared_io_out
         io_out.print processed_input
-        debug.nne && (
+        debug && (
+          stderr.puts "#{io_out}: processed_input.class=#{processed_input.class}"
+        )
+        debug && processed_input && (
           stderr.puts "#{io_out}: #{processed_input.size} bytes: response writen."
         )
         io_out.close
@@ -4633,7 +5637,12 @@ require '#{gem_name}'
 
       }
     }
-    debug.nne && (stderr.puts "#{__method__} returning")
+    threads.map { |thread|
+      runoe_threaded() {
+        thread.join
+      }
+    }
+    debug.nne && (stderr.puts "#{__method__} returning}")
     nil
   end
 
@@ -4760,16 +5769,17 @@ require '#{gem_name}'
     output_exception = (
       output_exception.nne || admit_plain.negate_me
     )
-    debug && (stderr.puts "#{__method__} starting")
+    debug && (stderr.puts "#{__method__} starting{")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
     # openssl functions want contents, not filenames:
     extra_cert_pem_files =  extra_cert_pem_files
       .map! { |extra_cert_pem_file|
         file_read [
-	  extra_cert_pem_file,
-	  nil,
-	  nil,
-	  extra_cert_pem_file
-	]
+          extra_cert_pem_file,
+          nil,
+          nil,
+          extra_cert_pem_file
+        ]
       }
     cert_pem_file = file_read [cert_pem_file, nil, nil, cert_pem_file]
     priv_pemfile  = file_read [priv_pemfile, nil, nil, priv_pemfile]
@@ -4780,8 +5790,8 @@ require '#{gem_name}'
     servers = plain_servers.map { |plain_server|
       ssl_server = runea [
         admit_plain,
-	output_exception,
-	"nil on exception"] {
+        output_exception,
+        "nil on exception"] {
           require 'openssl'
           ssl_context = OpenSSL::SSL::SSLContext.new
           ssl_context.extra_chain_cert =
@@ -4798,7 +5808,7 @@ require '#{gem_name}'
       server = ssl_server || admit_plain && plain_server
     }
     debug && (stderr.puts "will return #{[servers]}")
-    debug && (stderr.puts "#{__method__} returning")
+    debug && (stderr.puts "#{__method__} returning}")
     [servers]
   end
 
@@ -4833,77 +5843,20 @@ require '#{gem_name}'
       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)
-          }
-        }
-      }
-    }
+    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
 
 
@@ -4931,8 +5884,13 @@ require '#{gem_name}'
       cert_pem_file,
       extra_cert_pem_files,
       output_exception,
+      debug_client,
       reserved = args
 
+    debug = debug.nne
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
     server = (ssl_make_servers [
       listening_port,
       ip_addr,
@@ -4943,25 +5901,38 @@ require '#{gem_name}'
       extra_cert_pem_files,
       output_exception,
     ]).first.first
-    debug.nne && (stderr.puts server)
-    Thread.start {
+    debug_client = debug_client.nne || debug
+    debug && (stderr.puts "server=#{server}")
+    rv = Thread.start {
       loop {
-        client = runea ["yes, rescue",
-	  "yes, output exception",
-	  "nil on exception"
-	] {
-	  server.accept
-	}
+        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 {
+          debug_client && (stderr.puts "{client #{client} starting")
+          debug_client && (stderr.puts Thread.current)
+          block = bled [
+            nil,
+            :no_rescue.negate_me,
+            output_exception,
+          ] {
             to_method([callback_method])
               .call([client] + callback_method_args)
           }
+          rv  = block.first.call
+          debug_client && (stderr.puts "client will return #{rv}")
+          debug_client && (stderr.puts "client #{client} finishing}")
+          rv
         }
       }
     }
+    debug && (stderr.puts "will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
   end
 
 
@@ -5362,7 +6333,8 @@ n8mFEtUKobsK
             :name             => :http_processing_method_args,
             :duck_type        => Array,
             :default_behavior => [],
-            :description      => "arguments for the method that returns an http request string (used by the first server)",
+            :description      => "arguments for the method that returns an http request string (used by the first server). http_processing_method is fully controlled throught these arguments -- internally, io_forward will only prepend an argument having the request this list.
+            ",
           },
           {
             :name             => :http_server_port,
@@ -5455,6 +6427,42 @@ n8mFEtUKobsK
             :default_behavior => "0",
             :description      => "ip address (used by the redirect server)",
           },
+          {
+            :name             => :output_exceptions,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "exceptions are normally properly handled by inner functions, but setting this to true can be helpful to debug some cases",
+          },
+          {
+            :name             => :io_forward_debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "will be forwarded as debug argument to io_forward, somehow",
+          },
+          {
+            :name             => :transform_call_debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "will be forwarded as debug argument to transform_call, somehow",
+          },
+          {
+            :name             => :to_method_debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "will be forwarded as debug argument to to_method, somehow",
+          },
+          {
+            :name             => :to_object_method_debug,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "will be forwarded as debug argument to to_method_method, somehow",
+          },
+          {
+            :name             => :debug_accept,
+            :duck_type        => :boolean,
+            :default_behavior => :nil,
+            :description      => "will be forwarded as __debug_client__ argument to tcp_ssl_server, somehow",
+          },
           {
             :name             => :reserved,
             :duck_type        => Object,
@@ -5486,11 +6494,20 @@ n8mFEtUKobsK
       plain_http_processing_method_args,
       plain_http_server_port,
       plain_http_ip_addr,
+      output_exceptions,
+      io_forward_debug,
+      transform_call_debug,
+      to_method_debug,
+      to_object_method_debug,
+      debug_accept,
       reserved = args
 
     debug = debug.nne
+    output_exceptions = output_exceptions.nne
     debug.nne && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "args=#{args.inspect}")
+    # http_OK_response is completely controlled by here -- io_forward
+    # will only prepend an argument having the request to it.
     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
@@ -5502,9 +6519,8 @@ n8mFEtUKobsK
     priv_pemfile  =   priv_pemfile.nne ssl_cert_pkey_chain[1]
     cert_pem_file =  cert_pem_file.nne ssl_cert_pkey_chain[0]
     extra_cert_pemiles =  extra_cert_pem_files.nne ssl_cert_pkey_chain[2]
-    debug =  debug.nne "yes, debug"
     io_method =  io_method.nne "io_transform"
-    io_method_debug =  io_method_debug.nne debug
+    io_method_debug = io_method_debug.nne
     happy_with_request = happy_with_request.nne
     admit_non_ssl = admit_non_ssl.nne
     plain_http_processing_method =  plain_http_processing_method.nne :test__http_response__redirect
@@ -5524,12 +6540,18 @@ n8mFEtUKobsK
         io_method_debug,
         happy_with_request,
         http_processing_method,
-        http_processing_method_args
+        http_processing_method_args,
+        io_forward_debug,
+        transform_call_debug,
+        to_method_debug,
+        to_object_method_debug,
+        output_exceptions,
       ],
       priv_pemfile,
       cert_pem_file,
       extra_cert_pem_files,
-      "yes, output exceptions",
+      output_exceptions,
+      debug_accept,
     ]
     tcp_ssl_server_thread   =  send :tcp_ssl_server, tcp_ssl_server_args
     tcp_plain_server_args = [
@@ -5543,11 +6565,15 @@ n8mFEtUKobsK
         happy_with_request,
         plain_http_processing_method,
         plain_http_processing_method_args,
+        io_forward_debug,
+        transform_call_debug,
+        to_method_debug,
+        to_object_method_debug,
       ],
       :priv_pemfile.to_nil,
       :cert_pem_file.to_nil,
       :extra_cert_pem_files.to_nil,
-      "yes, output exceptions",
+      output_exceptions,
     ]
     tcp_plain_server_thread =  send :tcp_ssl_server, tcp_plain_server_args
 
@@ -5674,73 +6700,6 @@ n8mFEtUKobsK
   end
 
 
-=begin
-   tests #experiment__web_http_https_server, creating two
-   servers, one ssl and another plain, redirecting to
-   the ssl one. then, opens a client thread with a client
-   connecting to the root document of the plain server
-   (and in the end being served by the root document of
-   the ssl server).
-=end
-  def test__experiment__web_http_https_server args = ARGV
-    stderr = @memory[:stderr]
-    tcp_ssl_server_method,
-      http_processing_method,
-      http_processing_method_args,
-      http_server_port,
-      http_ip_addr,
-      priv_pemfile,
-      cert_pem_file,
-      extra_cert_pem_files,
-      ssl_cert_pkey_chain_method,
-      debug_tcp_ssl_server_method,
-      happy_with_request,
-      io_method,
-      io_method_debug,
-      domain,
-      admit_non_ssl,
-      no_debug_client,
-      reserved = args
-    tcp_ssl_server_method = tcp_ssl_server_method.nne :experiment__web_http_https_server
-    domain = domain.nne "localhost"
-    http_server_port = http_server_port.nne 8003
-    no_debug_client = no_debug_client.nne
-    servers = send tcp_ssl_server_method,
-      [
-        http_processing_method,
-        http_processing_method_args,
-        http_server_port,
-        http_ip_addr,
-        priv_pemfile,
-        cert_pem_file,
-        extra_cert_pem_files,
-        ssl_cert_pkey_chain_method,
-        debug_tcp_ssl_server_method,
-        happy_with_request,
-        io_method,
-        io_method_debug,
-        admit_non_ssl,
-      ]
-
-    # TODO: not hardcoded this way
-    plain_http_server_port = 8004
-    thread_client = Thread.new {
-      loop {
-        response = test__file_read__uri_root [
-          domain,
-          plain_http_server_port,
-          admit_non_ssl,
-          :no_debug_client,
-        ]
-        sleep 2
-      }
-    }
-    servers.first.join
-
-    true
-  end
-
-
   # tests test__tcp_ssl_server__io_method and opens
   # another thread for the client
   def test__tcp_ssl_server__get_root args = ARGV
@@ -5800,29 +6759,6 @@ n8mFEtUKobsK
   end
 
 
-  # experimental stuff coming. usage example:
-  # ./rubyment.rb  invoke_double p test__shell_send_array__main  "tinga" "" sub in EN 
-  # ["tENga"]
-  #  will be deprecated by send_array_base
-  # ./rubyment.rb  invoke_double p experiment__send_array_base 300 "bytes"
-  # [[51, 48, 48], nil, nil]
-  # only works with strings by now
-  def test__shell_send_array__main args=[]
-    p args
-    object_to_send,
-      reserved,
-      method_to_send,
-      *args_to_send = args
-    object_to_send = object_to_send.nne
-    method_to_send = method_to_send.nne :main
-    object_to_send && (
-      object_to_send.send method_to_send, *args_to_send
-    ) || (!object_to_send) && (
-      send method_to_send, args_to_send
-    )
-  end
-
-
   # test for Object::nne
   def test__object_nne args = ARGV
     string_neutral = ""
@@ -6278,9 +7214,9 @@ n8mFEtUKobsK
         ],
       ],
 
-    # test__array_unflatten_base_shallow
 
     ]
+    # test__array_unflatten_base_shallow is finishing:
     experiment__tester [ test_cases ]
   end
 
@@ -6460,9 +7396,9 @@ n8mFEtUKobsK
            ]
         ],
       ],
-# test__array_unflatten_base
 
     ]
+    # test__array_unflatten_base is finishing
     experiment__tester [ test_cases ]
   end
 
@@ -6598,166 +7534,7 @@ n8mFEtUKobsK
 end
 
 
-module RubymentDevelopmentModule
-
-
-=begin
-trying to get the interface compatible with
-# rest_request_or_open_uri_open
-# ideally, i would need an equivalent for
-# rest_response__request_base
-
-=end
-  def http_request_response__curl args=[]
-    stderr = @memory[:stderr]
-    url,
-      payload,
-      verify_ssl,
-      unimplemented__headers,
-      method,
-      auth_user,
-      password,
-      unimplemented__timeout,
-      unused__skip_open_uri,
-      debug,
-      no_rescuing,
-      reserved = args
-
-    debug = debug.nne
-    debug && (stderr.puts "{#{__method__} starting")
-    debug && (stderr.puts "caller=#{caller_label}")
-    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
-    no_rescuing = no_rescuing.nne
-    method = method.nne "get"
-    verify_ssl = verify_ssl.nne
-    curl_method = "http_#{method.downcase}"
-    curl_post_data = payload.nne
-    curl_args = [url, curl_post_data].compact
-    block = bled [
-      :no_answer.to_nil,
-      no_rescuing,
-      no_rescuing,
-    ] {
-        require 'curb'
-        c = Curl::Easy.send curl_method, *curl_args
-        c.http_auth_types = :basic
-        c.username = auth_user
-        c.password = password
-        # follow_location?
-        c.ssl_verify_host = verify_ssl
-        c.ssl_verify_peer = verify_ssl
-        c.perform
-        [ c.body_str, nil, c.http_connect_code]
-    }
-    rv = block.first.call
-    # rv = block_rv.first
-
-    debug && (stderr.puts "#{__method__}  will return #{rv.inspect}")
-    debug && (stderr.puts "#{__method__} returning}")
-    rv
-  end
-
-
-  def runtime_tmp_dir # for initialize
-  end
-
-
-=begin
-  returns args
-=end
-  def experiment__resolve args=[]
-    reference_or_value,
-      resolver,
-      debug,
-      dont_resolve,
-      reserved = args
-    rv
-  end
-
-
-
-=begin
-      # note: some functions may misbehave if they have different
-      # behaviours depending if they get a block or not
-      # to be tested.
-=end
-  def experiment__send_array_base args=[]
-    object_to_send,
-      method_to_send,
-      args_to_send,
-      block_to_send,
-      args_to_bled,
-      is_array_method,
-      reference,
-      derref_args,
-      debug,
-      shallow,
-      send_to_self,
-      reserved = args
-
-    stderr = @memory[:stderr]
-    debug = debug.nne
-    debug && (stderr.puts "{#{__method__} starting")
-    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
-
-    reference = reference.nne
-    args_to_send = args_to_send.nne []
-    is_array_method = is_array_method.nne
-    args_to_send = is_array_method && [args_to_send] || args_to_send
-    block_to_send = block_to_send.nne
-
-    args_to_bled = args_to_bled.nne []
-    default_on_exception,
-      dont_rescue,
-      output_backtrace,
-      unsed = args_to_bled
-
-    default_on_exception = default_on_exception.nne
-    dont_rescue =  dont_rescue.nne
-    output_backtrace = output_backtrace.nne
-
-    debug && (stderr.puts "general case{: #{object_to_send.inspect}.#{method_to_send.inspect}(#{args_to_send.inspect})&#{block_to_send}  }")
-
-    send_block = bled(args_to_bled) {
-      (debug || output_backtrace) && (stderr.puts "{#{__method__} block starting")
-      (debug || output_backtrace) && (stderr.puts "#{__method__}  block: args.each_with_index=#{args.each_with_index.entries.inspect}")
-
-      brv = object_to_send.send method_to_send, *args_to_send, &block_to_send
-
-      (debug || output_backtrace) && (stderr.puts "#{__method__} block will return #{brv.inspect}")
-      (debug || output_backtrace)  && (stderr.puts "#{__method__} block returning}")
-      brv
-    }.first
-
-    default_block = bled(args_to_bled) {
-      (debug || output_backtrace) && (stderr.puts "#{__method__} block: nil method makes  return #{args_to_send.inspect}")
-      args_to_send
-    }.first
-
-    block_return, e_info, exception = experiment__whether [
-      method_to_send,
-      send_block,
-      default_block,
-    ]
-
-    rv = [block_return, e_info, exception]
-
-    debug && (stderr.puts "will return #{rv.inspect}")
-    debug && (stderr.puts "#{__method__} returning}")
-    rv
-  end
-
-
-end
-
-
-=begin
-  the purpose of this class is just to be able
-  to have all the functions of RubymentModule
-  available in a single object.
-=end
 class Rubyment
-    include RubymentDevelopmentModule # must NOT be in master TODO
    include RubymentModule
 end