rubyment 0.6.25563758 → 0.6.25581116

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c0b41f34259313675d084aba8a00e75010aea2a
-  data.tar.gz: 340d7190aa3a71335714befea5e750069a5829b4
+  metadata.gz: f0a1dc731e8fd7860ae00dcf476648dd311322f2
+  data.tar.gz: 75ec3ac1a176cbef2d3717f4c0aa8ec45ef05c20
 SHA512:
-  metadata.gz: 28001b932b9653604fd210e35c1111b8b241e0df2731015540a116569531c0a4d6cfcb1056dda3fc49954b3b4be066e5e1ba1d930c828c5bdfc5163455b846b2
-  data.tar.gz: 8cc349d22b51b29080a1a451ea77650b2c99cc3fb48be97ef2e4a52b1eb14d2fc13cade07a6ff5405df15fdaac6f24db41a0f9f2db5e685e540b3caf784dc61c
+  metadata.gz: 798fc0253107f5b698b529776dfbd12133506b25afe02be2cd1a66ee2aad01fadf495002868f1374569d6fa281cd5c8740c0a175bd07a0c31848a28d036ccee9
+  data.tar.gz: 82bc3dccb487171a155c3af0cd0d78a379815f69338d3618ff2ce84c7e5873e5d871a250c91e5d181033327a380956b70d0b1c40ea7e7a23941ea65dadba3660

data/lib/rubyment.rb

@@ -112,11 +112,11 @@ module RubymentExperimentModule
 =begin
 
   # documentation_begin
-  # short_desc = "tests the function #call_or_itself"
+  # short_desc => "calls the method #call of an object, or return the object itself",
   @memory[:documentation].push = {
     :function   => :call_or_itself,
     :short_desc => short_desc,
-    :description => "calls the method #call of an object, or return the object itself",
+    :description => "",
     :params     => [
       {
         :name             => :args,
@@ -333,7 +333,6 @@ module RubymentExperimentModule
     debug = debug.nne
     debug && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "caller=#{caller_label.inspect}")
-    debug && (stderr.puts backtrace)
     debug && (stderr.puts "args=#{args.inspect}")
     test_cases = test_cases.nne [
      # [ :id, :expectation, :actual_params ],
@@ -351,6 +350,7 @@ module RubymentExperimentModule
       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]
@@ -364,48 +364,372 @@ module RubymentExperimentModule
 
 
 =begin
+  write the second argument of the array args into the filepath in the first argument
 =end
-  def experiment__send_array_base args=[]
-    sender,
-      object_to_send,
-      destination,
+  def file__json args=[]
+    require 'json'
+    file_path,
+      enum,
+      reserved = args
+    File.write file_path,  JSON.pretty_generate({ :root.to_s => enum })
+  end
+
+
+=begin
+  inverse of #file__json
+=end
+  def load__file_json args=[]
+    require 'json'
+    file_path,
+      reserved = args
+    file_contents = File.read file_path
+    puts "file_contents size=#{file_contents.size}"
+    loaded = JSON.parse file_contents
+    puts "loaded size=#{loaded.size}"
+    puts "loaded=#{loaded.inspect}"
+    loaded[:root.to_s]
+  end
+
+
+=begin
+c = :c
+experiment__input_select [[:a, :b, :c], c ]
+=end
+  def experiment__input_select args=[]
+    alternatives,
+      default,
+      reserved = args
+    stderr = @memory[:stderr]
+    caption = alternatives.each_with_index.map {|a, i| "#{i} - #{a.inspect}"}.join("\n")
+    stderr.puts "[alternatives: #{caption}][default: #{default.inspect}]"
+    alternative = input_single_line
+    selection = alternative.nne && alternatives[alternative.to_i] || default
+  end
+
+
+  # these shell_ functions can take only flatten arrays (intended for ARGV):
+  def shell_string_split args=[]
+    string,
+      splitter,
+      reserved = args
+    string.split Regexp.new splitter
+  end
+
+
+  def shell_array_first a
+    a.first
+  end
+
+
+  def shell_array_deepen a
+    [ a ]
+  end
+
+
+  def get_self args=[]
+    self
+  end
+
+
+=begin
+enum = (s.scan /http_[^(]*/).uniq.map
+# => #<Enumerator: ...>
+# send_enumerator [ enum, :gsub, ["http_", ""] ]
+# => ["delete", "get", "head", "post", "put"]
+
+
+=end
+  def send_enumerator args=[]
+    enum,
+      method,
+      args_to_method,
+      block_to_method,
+      replace_at_index,
+      reserved = args
+
+    args_to_method = args_to_method.nne []
+
+    calling_tuples = enum.map {|e|
+      method_name = (!method.respond_to? :call) && method || nil
+      method_to_call = (!method_name) && method || (
+        (!replace_at_index) && e.method(:send)
+      ) || method(:send)
+      c_t = args_to_method.dup
+      replace_at_index && (c_t[replace_at_index] = e)
+      method_name && (c_t.unshift method_name)
+      c_t.unshift method_to_call
+      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
+    }
+  end
+
+
+=begin
+  given a duck type table, return the entries having
+  methods that o responds to in their first entry.
+
+  by default, uses a table useful to determine
+  method_name for the call:
+  o.map.method_name {|a, b| }
+  if o is an Array, it should be each_with_entries:
+  experiment__duck_type__hash_array [ []  ]
+  => [[:product, :each_with_key, :itself]]
+
+  if o is a Hash, it should be (another) map.
+  experiment__duck_type__hash_array [ {}  ]
+  => [[:keys, :map, :reversed]]
+
+  note that "reversed" means that the order must
+  be |b,a| instead
+
+=end
+  def experiment__duck_type__hash_array args=[]
+    o,
+      duck_type_table,
+      reserved = args
+    duck_type_table = duck_type_table.nne [
+      [ :product, :each_with_index, :itself,   :to_a  ],
+      [ :keys,    :map,             :reverse,  :to_h  ],
+    ]
+    rv = duck_type_table.select { |e|
+      responding_method, *r = e
+      o.respond_to? responding_method
+    }
+    rv
+  end
+
+
+=begin
+  for each leaf of a (which normally is an Array or Hash),
+  calls block_to_send_to_leaf giving the leaf as arg,
+  (or return the leaf in the case block_to_send_to_leaf is nil).
+  modifies tuples and deep_keys so it contains the results, the
+  deep_keys and the tuples at each step.
+
+  direct_cycle_placeholder => object to place when a directed cycled
+  (ie, the object is already present in its stack) is found. defaults
+  to :direct_cycle_placeholder. undirect cycle: same thing, but searches
+  in the visited_nodes.
+
+  Don't use nil, 0, "" as cycleplace holders, use a value v which
+  returns itself if called v.nne; it means that the default
+  should be used
+
+  BFS: only problem: this uniq should work on object ID
+ x[1][:tuples].transpose[2].transpose.flatten.uniq
+ => [{:a=>{:b=>:c}, :d=>{:e=>nil}}, {:b=>:c}, {:e=>nil}]
+
+
+=end
+  def experiment__recursive_array__visitor args=[]
+    graph_object,
+      block_to_send_to_leaf,
+      deep_keys,
+      duck_type_detector,
       debug,
-      shallow,
-      args_to_bled,
-      send_to_self,
+      duck_type_table,
+      tuples,
+      stack,
+      visited_nodes,
+      direct_cycle_placeholder,
+      undirect_cycle_placeholder,
+      undirected_graph,
       reserved = args
+    recursion_args = args.dup
 
     stderr = @memory[:stderr]
     debug = debug.nne
-debug = 1
     debug && (stderr.puts "{#{__method__} starting")
-    debug && (stderr.puts "args=#{args.inspect}")
-    debug && (stderr.puts "debug=#{args[3].inspect}")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args.each_with_index=#{args.each_with_index.entries.inspect}")
+    undirect_cycle_placeholder = undirect_cycle_placeholder.nne ":undirect_cycle_placeholder"
+    direct_cycle_placeholder = direct_cycle_placeholder.nne ":direct_cycle_placeholder"
+    # structures one per node: nne
+    deep_keys  = deep_keys.nne []
+    stack = stack.nne []
+    # structures shared by all nodes: just ensure exists
+    tuples ||= []
+    visited_nodes ||= []
+
+    # old_debug = debug
+    # debug = (graph_object.keys.index :b) rescue old_debug
+    debug && (stderr.puts "=#{}")
+    debug && (stderr.puts "graph_object.object_id=#{graph_object.object_id}")
+    object_id_method_name = :object_id_method_name
+
+
+    # cycles detection section
+    undirected_cycle = undirected_graph && (
+      visited_nodes.map(&:object_id).index graph_object.object_id
+    )
+    debug && undirected_graph && (stderr.puts "visited_nodes_with_oid=#{visited_nodes.map{|y| [y, y.object_id] }}")
+    debug && (stderr.puts "undirected_cycle=#{undirected_cycle.inspect}")
 
-    method_to_send,
-      *args_to_send = sender
-    debug && (stderr.puts "general case{: #{object_to_send.inspect}.#{method_to_send.inspect}(#{args_to_send.inspect}) }")
+    directed_cycle = stack.map(&:object_id).index graph_object.object_id
+    debug && (stderr.puts "stack_with_oid=#{stack.map{|y| [y, y.object_id] }}")
+    debug && (stderr.puts "directed_cycle=#{directed_cycle.inspect}")
 
-    send_block = bled(args_to_bled) {
-      object_to_send.send method_to_send, *args_to_send
-    }.first
+    cycle_placeholder = (
+      directed_cycle   &&   direct_cycle_placeholder ||
+      undirected_cycle && undirect_cycle_placeholder
+    )
+    cycle_placeholder && (a = cycle_placeholder)
+    cycle_placeholder.negate_me && (a = graph_object)
 
-    default_block = bled(args_to_bled) {
-      args_to_send
-    }.first
+    # debug = old_debug
+    visited_nodes.push a
+    stack.push a
 
-    rv = experiment__whether [
-      method_to_send,
-      send_block,
-      default_block,
-    ]
+    # detecting the type of object. depending if Hash or Array,
+    # methods to call are different.
+    duck_type_detector = duck_type_detector.nne :map
+    duck_type_def = experiment__duck_type__hash_array(
+      [
+        a,
+        duck_type_table
+      ])
+    iterating_method = duck_type_def.transpose[1].to_a.first
+    final_method     = duck_type_def.transpose[2].to_a.first
+    revert_method    = duck_type_def.transpose[3].to_a.first
+    leaf = nil
+    result = (a.respond_to? duck_type_detector) && a.send(iterating_method).map {|a, b|
+        e, i = *([a, b].send(final_method))
+        debug && (stderr.puts "e, i=#{[e, i]}")
+        recursion_args[0] = e
+        deep_keys.push i
+        recursion_args[2] = deep_keys.dup
+        recursion_args[6] = tuples
+        recursion_args[7] = stack.dup
+        recursion_args[8] = visited_nodes
+        recursion_args[9] = directed_cycle
+        recursion_args[10] = undirected_cycle
+        debug && (stderr.puts "recursion_args.each_with_index=#{recursion_args.each_with_index.entries.inspect}")
+        child_result = send __method__, recursion_args
+        deep_keys.pop
+        [i, child_result]
+      } || (
+        block_to_send_to_leaf && (leaf = block_to_send_to_leaf. call a)
+        !block_to_send_to_leaf && (leaf = a)
+        tuples.push  [
+          deep_keys,
+          leaf,
+          stack,
+          [:cycle_to_stack_index, directed_cycle],
+          [:cycle_to_visited_nodes_index, undirected_cycle],
+        ]
+        leaf
+      )
 
+     # rebuilding the graph object after visits
+     rebuilt_object  = (nil.send revert_method) rescue result
+     (result.respond_to? duck_type_detector) && (
+        result.map {|i, e|
+          rebuilt_object[i] = e[:result]
+          # rebuilt_object[i]  = (e[:result] rescue e)
+        }
+    )
+    rv = {
+      :visited_nodes => visited_nodes,
+      :tuples => tuples,
+      :result => rebuilt_object,
+    }
+    # stack.pop
     debug && (stderr.puts "will return #{rv.inspect}")
     debug && (stderr.puts "#{__method__} returning}")
     rv
   end
 
 
+  def test__experiment__recursive_array__visitor args=[]
+    method_to_test = :experiment__recursive_array__visitor
+    direct_cycle_h = {
+      :a => {
+         :b => [ :c ],
+       },
+      :d => {
+        :e => nil,
+      },
+    }
+    direct_cycle_h[:a][:f] = direct_cycle_h[:a]
+    undirect_cycle_h = {
+      :a => {
+         :b => [ :c ],
+       },
+      :d => {
+        :e => nil,
+      },
+    }
+    undirect_cycle_h[:d][:g] = undirect_cycle_h[:a]
+    [
+      (send method_to_test, [
+        [ 1, [ 2, 3, [ 4 ] ] ],
+        lambda {|x| "a{#{x}}a" },
+        :deep_keys.to_nil,
+        :duck_type_d.to_nil,
+        :debug_please.negate_me,
+      ]),
+
+      (send method_to_test, [
+        {
+          :a => {
+             :b => :c,
+           },
+          :d => {
+            :e => nil,
+          },
+        },
+        lambda {|x| "h{#{x}}h" },
+        :deep_keys.to_nil,
+        :duck_type_d.to_nil,
+        :debug_please.negate_me,
+      ]),
+
+      (send method_to_test, [
+        direct_cycle_h,
+        lambda {|x| "dch{#{x}}dch" },
+        :deep_keys.to_nil,
+        :duck_type_d.to_nil,
+        :debug_please.negate_me,
+      ]),
+
+      (send method_to_test, [
+        undirect_cycle_h,
+        lambda {|x| "uch{#{x}}uch" },
+        :deep_keys.to_nil,
+        :duck_type_d.to_nil,
+        :debug_please.negate_me,
+        :duck_type_table.to_nil,
+        :tuples.to_nil,
+        :stack.to_nil,
+        :visited_nodes.to_nil,
+        :direct_cycle_placeholder.to_nil,
+        :undirect_cycle_placeholder.to_nil,
+        :undirect_graph,
+      ]),
+
+      (send method_to_test, [
+        undirect_cycle_h,
+        lambda {|x| "not_uch{#{x}}not_uch" },
+        :deep_keys.to_nil,
+        :duck_type_d.to_nil,
+        :debug_please.negate_me,
+        :duck_type_table.to_nil,
+        :tuples.to_nil,
+        :stack.to_nil,
+        :visited_nodes.to_nil,
+        :direct_cycle_placeholder.to_nil,
+        :undirect_cycle_placeholder.to_nil,
+        :undirect_graph.negate_me,
+      ]),
+
+    ]
+  end
+
+
 end
 
 
@@ -418,9 +742,139 @@ 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",
+          },
+        ],
+      },
+    ],
+    :return_value     => [
+      {
+        :name             => :short,
+        :duck_type        => String,
+        :default_behavior => "",
+        :description      => "a brief about the block; normally a block inspection",
+      },
+      {
+        :name             => :full,
+        :duck_type        => String,
+        :default_behavior => "",
+        :description      => "all the information about the block",
+      },
+      {
+        :name             => :inspection,
+        :duck_type        => String,
+        :default_behavior => "",
+        :description      => "the  block inspection",
+      },
+      {
+        :name             => :source_location,
+        :duck_type        => Object,
+        :duck_type        => [:_a, Array, :strings],
+        :description      => the block location",
+      },
+      {
+        :name             => :source,
+        :duck_type        => String,
+        :default_behavior => "",
+        :description      => "the block source code",
+      },
+      {
+        :name             => :class_,
+        :duck_type        => String,
+        :default_behavior => "",
+        :description      => "the  block class",
+      },
+      {
+        :name             => :comment,
+        :duck_type        => String,
+        :default_behavior => "",
+        :description      => "the  block comment",
+      },
+      {
+        :name             => :reserved,
+        :duck_type        => Object,
+        :default_behavior => nil,
+        :description      => "reserved for future use",
+      },
+    ],
+  }
+  # documentation_end
+=end
+  def block_info_base args=[]
+    block,
+      max_str_index,
+      reserved = args
+    inspection = block.inspect
+    class_ = block.class
+    comment = block.comment rescue [nil, "doesn't respond to :comment"]
+    source = block.source rescue [nil, "doesn't respond to :source"]
+    source_location = block.source_location rescue [nil, "doesn't respond to :source_location"]
+    parameters = block.parameters.inspect rescue [nil, "doesn't respond to :parameters"]
+    short = inspection
+    full = (
+      [
+        "inspection{",
+        inspection,
+        "}",
+        "class{",
+        class_,
+        "}",
+        "source_location{",
+        source_location,
+        "}",
+        "source{",
+        source,
+        "}",
+        "comment{",
+        comment,
+        "}",
+        "parameters{",
+        parameters,
+        "}",
+      ]
+    ).join "\n"
+
+    full = string_truncate [
+      full,
+      max_str_index,
+    ]
+    [short, full, inspection, source_location, source, class_, comment]
+  end
+
+
 =begin 
   # documentation_begin
-  # short_desc = "tests the function #exception_info_base"
+  # short_desc = "extracts information about an exception and return them structurally in an array."
   @memory[:documentation].push = {
     :function   => :exception_info_base,
     :short_desc => short_desc,
@@ -539,7 +993,7 @@ module RubymentMaintainedModule
 
 =begin
   # documentation_begin
-  # short_desc = "tests the function #bled"
+  # short_desc = "generates a block which may return exceptions instead of raising them."
   @memory[:documentation].push = {
     :function   => :bled,
     :short_desc => short_desc,
@@ -567,7 +1021,7 @@ module RubymentMaintainedModule
             :name             => :output_backtrace,
             :duck_type        => Object,
             :default_behavior => :nil,
-            :description      => "output when an exception happens",
+            :description      => "debug the block execution (misleading name)",
           },
           {
             :name             => :backtrace_max_str_len,
@@ -631,7 +1085,7 @@ module RubymentMaintainedModule
     stderr = @memory[:stderr]
     default_on_exception,
       dont_rescue,
-      output_backtrace,
+      output_backtrace, # better call "debug_block"
       backtrace_max_str_len,
       debug,
       reserved = args
@@ -642,16 +1096,25 @@ module RubymentMaintainedModule
     rv = Proc.new { |*block_args|
       (debug || output_backtrace) && (stderr.puts "{#{__method__} block starting")
       (debug || output_backtrace) && (stderr.puts "block_args=#{block_args.inspect}")
+      (debug || output_backtrace) && (stderr.puts "block_args.size=#{block_args.size}")
       brv = begin
-        [ (block.call *block_args), nil, nil]
+        local_rv = [ (block.call *block_args), nil, nil]
+        (debug || output_backtrace) && (stderr.puts "#{__method__} block: survived exception and returned #{local_rv.inspect}")
+        local_rv
       rescue => e
         e_info = exception_info_base [
           e,
           backtrace_max_str_len
         ]
+        b_info = block_info_base [
+          block,
+          backtrace_max_str_len
+        ]
         (debug || output_backtrace) && (stderr.puts "#{__method__} block: #{block.inspect}\nfull exception info:\n#{e_info[1]}")
-        (debug || output_backtrace) && (stderr.puts "#{__method__} block: dont_rescue=#{dont_rescue}; true means will rethrow")
+        (debug || output_backtrace) && (stderr.puts "#{__method__} block: info #{b_info[1]} ")
+        (debug || output_backtrace) && (dont_rescue) && (stderr.puts "#{__method__} block: dont_rescue=#{dont_rescue.inspect}; will rethrow")
         dont_rescue && (raise e)
+        (debug || output_backtrace) && (stderr.puts "#{__method__} block: dont_rescue=#{dont_rescue.inspect}; not rethrowing rethrow")
         [ default_on_exception, e_info, e ]
       end
       (debug || output_backtrace) && (stderr.puts "block #{block.inspect} will return #{brv.inspect}")
@@ -667,7 +1130,7 @@ module RubymentMaintainedModule
 
 =begin
   # documentation_begin
-  # short_desc = "tests the function #string_truncate"
+  # short_desc = "truncates a string"
   @memory[:documentation].push = {
     :function   => :string_truncate,
     :short_desc => short_desc,
@@ -1236,7 +1699,7 @@ module RubymentTestModule
       # test_case:
       [
          # id:
-         [ "test #{method_to_test} base :array_first_remainder" ],
+         "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:
@@ -1245,15 +1708,154 @@ module RubymentTestModule
             method_to_test,
             # args to method_to_test:
             [
-              :array_first_remainder,
-              [ :arg_to_send_1, :arg_to_send_2, :arg_to_send_3 ],
+               # 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,
             ],
-            # array_first_remainder is a function of...
-            self,
-            # 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
@@ -1283,26 +1885,23 @@ module RubymentTestModule
 =end
     stderr = @memory[:stderr]
     debug = debug.nne
-debug = 1
     debug && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "caller=#{caller_label}")
-    debug && (stderr.puts backtrace)
     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,
+      :output.negate_me,
     ] {
         experiment__tester [
-        (test_cases), 1
+        (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}")
-    # if raises exception before it will be unbalanced :
     debug && (stderr.puts "#{__method__} returning}")
     rv
   end
@@ -1526,7 +2125,7 @@ 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.
   #
   # @return [String, Object] read data (or +return_on_rescue+)
   def file_read args=ARGV
@@ -1543,17 +2142,19 @@ module RubymentModule
       method,
       timeout,
       debug,
+      request_method,
       reserved = args
     debug = debug.nne 1
     debug && (stderr.puts "{#{__method__} starting")
     debug && (stderr.puts "args=#{args.inspect}")
+    request_method = request_method.nne :rest_request_or_open_uri_open
     uri = uri.nne ""
     file_is_directory = File.directory?(uri)
     must_return_on_rescue = false
     return_on_directory_given ||= true
     contents = !(file_is_directory) && (
       begin
-        url_response = (send :rest_request_or_open_uri_open, [
+        url_response = (send request_method, [
             uri,
             payload,
             verify_ssl,
@@ -1563,15 +2164,19 @@ module RubymentModule
             password,
             timeout,
             skip_open_uri,
+            :debug_request_method.to_nil,
+            :no_rescue_i_catch_exceptions,
           ]).first
         debug && (stderr.puts "url_response=#{url_response.inspect}")
         url_response
       rescue => e1
         begin
-          debug && (stderr.puts "exception e1=#{e1.inspect}")
+          e_info = exception_info_base [e1]
+          debug && (stderr.puts "exception e1=#{e_info[1]} ")
           File.read uri
         rescue  => e2
-          debug && (stderr.puts "exception e2=#{e2.inspect}")
+          e_info = exception_info_base [e2]
+          debug && (stderr.puts "exception e2=#{e_info[2]}")
           debug && (stderr.puts "return_on_rescue=#{return_on_rescue.inspect}")
           must_return_on_rescue = true
           return_on_rescue
@@ -5046,11 +5651,13 @@ n8mFEtUKobsK
     admit_non_ssl = admit_non_ssl.nne true
     http_file_read_attempt = (
       debug && (stderr.puts "file_read \"https://#{domain}:#{http_server_port}/#{path}\"")
-      file_read ["https://#{domain}:#{http_server_port}/#{path}", nil, nil, :return_on_rescue, nil, :skip_open_uri]
+      file_read ["https://#{domain}:#{http_server_port}/#{path}", nil, nil, nil, nil, :skip_open_uri, nil, nil, nil, nil, nil, nil, :http_request_response__curl]
     )
     debug && (stderr.puts "#{admit_non_ssl.inspect} && file_read \"http://#{domain}:#{http_server_port}/#{path}\"")
     response = http_file_read_attempt ||
-      admit_non_ssl && (file_read ["http://#{domain}:#{http_server_port}/#{path}"])
+      admit_non_ssl && (
+        file_read ["http://#{domain}:#{http_server_port}/#{path}", nil, nil, nil, nil, :skip_open_uri, nil, nil, nil, nil, nil, nil, :http_request_response__curl]
+      )
     rv = [response, http_file_read_attempt]
     debug && (stderr.puts  "#{__method__} will return [response, http_file_read_attempt]=#{rv.inspect}")
     debug && (stderr.puts "#{__method__} returning}")
@@ -5196,6 +5803,10 @@ n8mFEtUKobsK
   # 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,
@@ -5857,7 +6468,8 @@ n8mFEtUKobsK
 
 
 =begin
-  # short_desc = "tests the function #string_repetion"
+  # begin_documentation
+  # short_desc = "tests the function #string_repetition"
 
   @memory[:documentation].push = {
     :function    => :test__string_repetition,
@@ -5880,6 +6492,7 @@ n8mFEtUKobsK
       },
     ],
   }
+  # end_documentation
 
 
 =end
@@ -5985,53 +6598,168 @@ n8mFEtUKobsK
 end
 
 
+module RubymentDevelopmentModule
+
+
 =begin
- includes RubymentModule
-=end
-class Rubyment
-   include RubymentModule
-end
-=begin
-c = :c
-experiment__input_select [[:a, :b, :c], c ]
+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
-class Rubyment
-  def experiment__input_select args=[]
-    alternatives,
-      default,
-      reserved = args
+  def http_request_response__curl args=[]
     stderr = @memory[:stderr]
-    caption = alternatives.each_with_index.map {|a, i| "#{i} - #{a.inspect}"}.join("\n")
-    stderr.puts "[alternatives: #{caption}][default: #{default.inspect}]"
-    alternative = input_single_line
-    selection = alternative.nne && alternatives[alternative.to_i] || default
+    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
-end
 
 
 =begin
+  returns args
 =end
-class Rubyment
-  def file__json args=[]
-    require 'json'
-    file_path,
-      enum,
+  def experiment__resolve args=[]
+    reference_or_value,
+      resolver,
+      debug,
+      dont_resolve,
       reserved = args
-    File.write file_path,  JSON.pretty_generate({ :root.to_s => enum })
+    rv
   end
-  def load__file_json args=[]
-    require 'json'
-    file_path,
+
+
+
+=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
-    file_contents = File.read file_path
-    puts "file_contents size=#{file_contents.size}"
-    loaded = JSON.parse file_contents
-    puts "loaded size=#{loaded.size}"
-    puts "loaded=#{loaded.inspect}"
-    loaded[:root.to_s]
+
+    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
+
 (__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.25563758
+  version: 0.6.25581116
 platform: ruby
 authors:
 - Ribamar Santarosa