rubyment 0.6.25524941 → 0.6.25535011

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40fae2d0cd85e64fd3eeccdd69454e73a740474d
-  data.tar.gz: d0c2832bd4d2d02685123c2c87626914d726d1fc
+  metadata.gz: 8b3bf33d8dfd18d9b8da23e205233274baf4248f
+  data.tar.gz: 14d1d282699c9976f36e26c69d10bd1c837c79b5
 SHA512:
-  metadata.gz: f4f5e9736a250ac67fd4568e6a7950fdd5b6729e8284580bb59952529fdd802685be227f7c247019c61bfa06add9a5ec3584df88c85158c9ee214306a9acec19
-  data.tar.gz: 071519a8ff3dc2b359652d496d308465c33b05cbea22fc8b7e52f4314bb5f979f29e3cf7d56a5a9ec1acd88f916d59366c68b219a330c787cdacf3436f68677e
+  metadata.gz: ddedfdd92d9e9fc379c6a06e6fd2d4f5755c61a7c9baeca65e6f6ed73fa1e2f9636e451a51a6f0b5c4ad06edc0d3825b791de4ac59b8cf6e08152d73e44c8bf6
+  data.tar.gz: 4000290e456744382005e58531029242aa21326188279cd781a4af7f6a2938d1c34386c63b7f92c6a51d17727ce26af39fb52810b4fd3a73bd1c52adc66bec4b

data/lib/rubyment.rb

@@ -52,9 +52,22 @@ class Object
   end
 
 
-  # returns +!self+
-  def negate_me
-    !self
+  # returns +!self+, unless +unless_condition+
+  # is +true+; in such case returns +self+.
+  # e.g: +false.negate_me true+ returns
+  # +false+.
+  # (by default, if no params are given,
+  # just # negates +self+)
+  def negate_me condition=true
+    #   STDERR.puts "negate_me"
+    (condition) && (
+      # STDERR.puts "condition"
+      # STDERR.puts "#{self.inspect}"
+      !self
+    ) || (!condition) && (
+      # STDERR.puts "!condition"
+      self
+    )
   end
 end
 
@@ -860,7 +873,7 @@ module RubymentModule
   end
 
 
-  # makes a rest request.
+  # makes a rest request
   # @param [Array] +args+, an +Array+ whose elements are expected to be:
   # +url+:: [String] 
   # +payload+:: [String] 
@@ -870,8 +883,13 @@ module RubymentModule
   # +auth_user+:: [String, nil] username for basic authentication method
   # +password+:: [String, nil] password for basic authentication method. Will prompt without echo if +nil+ and +auth_user+ is not +nil+
   # +timeout+:: [Fixnum] 
-  # @return [String] the response
-  def rest_request args=ARGV
+  # +debug+:: [Object] if calling the object +nne+ method returns a +false+ value, won't print debug information
+  # @return [Array] returns an +Array+ whose elements are :
+  # +response+:: [String] 
+  # +response+:: [Object] as returned by +RestClient::Request.execute+. Note that this is a dangerous object for printing, be aware.
+  # +http_response_object+:: [Net::HTTPResponse] 
+  # +http_response_object.code+:: [String] 
+  def rest_response__request_base args=ARGV
     require 'base64'
     require 'rest-client'
 
@@ -885,8 +903,13 @@ module RubymentModule
       auth_user,
       password,
       timeout,
+      debug,
       reserved = args
 
+    debug = debug.nne
+    debug.nne && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "args=#{args.inspect}")
+
     auth_user = auth_user.nne
     password  = password.nne
     method    = method.nne :get
@@ -896,8 +919,41 @@ module RubymentModule
       auth_user && (input_single_line_non_echo [password])
     ].join ":"
     auth_user && (headers["Authorization"] = "Basic #{base64_auth}")
-    request_execution = RestClient::Request.execute(:method => method, :url => url, :payload => payload, :headers => headers, :verify_ssl => verify_ssl, :timeout => timeout)
-    request_execution.to_s
+    response,
+      request,
+      http_response_object = RestClient::Request.execute(
+      :method => method,
+      :url => url,
+      :payload => payload,
+      :headers => headers,
+      :verify_ssl => verify_ssl,
+      :timeout => timeout
+    ) {|*args| args}
+    rv = [
+      response.to_s,
+      request,
+      http_response_object,
+      http_response_object.code,
+    ]
+    debug && (stderr.puts "will return #{rv.map(&:to_s)}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+  # makes a rest request.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +url+:: [String] 
+  # +payload+:: [String] 
+  # +verify_ssl+:: [Boolean] 
+  # +headers+:: [Hash] +"Authorization"+ key will be added to it if +auth_user+ is given.
+  # +method+:: [HTTP method] one of +:get+, +:method+, +:post+ or +:delete+
+  # +auth_user+:: [String, nil] username for basic authentication method
+  # +password+:: [String, nil] password for basic authentication method. Will prompt without echo if +nil+ and +auth_user+ is not +nil+
+  # +timeout+:: [Fixnum] 
+  # @return [String] the response
+  def rest_request args=ARGV
+    (rest_response__request_base args).first
   end
 
 
@@ -1968,6 +2024,7 @@ require '#{gem_name}'
     gem_is_current_file && (
       FileUtils.mkdir_p 'lib'
       file_backup "lib/#{gem_name}.rb", "lib/"
+      # FIX ME: accept true
       save_file gem_is_current_file, "lib/#{gem_name}.rb"
     )
 
@@ -3509,51 +3566,6 @@ n8mFEtUKobsK
     end
 
 
-  # test #rest_request
-  # for now, the parameters must still be hardcoded.
-  def test__rest_request__with_ayt args=ARGV
-    require 'json'
-    stderr = @memory[:stderr]
-
-    url = "https://owl.loftweb.nl:55031/4/3-roOomydev"
-    json =<<-ENDHEREDOC
-    {
-        "operation" : "AYT",
-        "version" : {
-            "client" : "X",
-            "protocol" : {
-                "domain_model" : "4",
-                "API" : "3"
-            }
-        }
-    }
-    ENDHEREDOC
-    payload = "#{json}"
-
-    auth_user = "web"
-    password = "vadim"
-    method = :post
-    method = :get
-    timeout = 600
-    verify_ssl = true
-    payload = "#{json}"
-    headers = ""
-    request_execution = send :rest_request, [
-      url,
-      payload,
-      verify_ssl,
-      headers,
-      method,
-      auth_user,
-      password,
-      timeout,
-    ]
-    parsed_json = JSON.parse request_execution.to_s
-    stderr.puts parsed_json
-    [parsed_json]
-  end
-
-
   # test for functions that adds syntatic sugar to
   # exceptions.
   def test__rune_functions args = ARGV
@@ -3625,11 +3637,7 @@ n8mFEtUKobsK
     debug = debug.nne
     debug.nne && (stderr.puts "#{__method__} starting")
     debug && (stderr.puts "args=#{args.inspect}")
-    debug.nne && (stderr.puts "#{__method__} starting")
-    debug && (stderr.puts "args=#{args.inspect}")
-    debug && (stderr.puts "will return #{is_string_repetition}")
-    debug && (stderr.puts "#{__method__} returning")
-    matches  = operand_1.to_s.scan operand_2
+    matches  = (operand_1.scan operand_2) rescue []
     amout_of_matches = matches.size
     min_repetitions = min_repetitions.nne 0
     is_string_repetition = (
@@ -3645,7 +3653,95 @@ n8mFEtUKobsK
   end
 
 
-  # takes a flatten array and makes it deeper, starting a new array
+  # operates and/or returns a structure similar to an pushdown automaton.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +pd+:: [Array] an +Array+ whose elements are :
+  # +pd.operand+:: [Array] current state
+  # +pd.stack+:: [Array] state stack
+  # +operation_plan+:: [Array, Object] +false+ object is interpreted as no operation (only creates a pd). Otherwise, it is an +Array+ whose elements are :
+  #     reserved_token, reservation_type, token = operation_plan.to_a
+  # +operation_plan.reserved_token+:: [Object] operates stack if +true+, otherwise, operate +state+
+  # +operation_plan.reservation_type+:: [Object] pushes stack if +true+ into state, otherwise, pops.
+  # +operation_plan.token+:: [Object] state operand (element that will be pushed into the current state, when operating +state+)
+  # +operation_plan.bulk+:: [Object] if calling the object +nne+ method returns a +true+ value, will operate as +operation_plan.token+ is a container of tokens instead. If the object is an +Array+, it will prepend the first element and append to +pd.operand+ after the bulk insertion is done.
+  # +debug+:: [Object] +debug.nne+ will be used to determine whether to output or not debug information.
+  # +pd+:: [Array] 
+  # @return [Array] returns the operated (or a new, when no operation) +pd+
+  def pushdown_operate args=[]
+    stderr = @memory[:stderr]
+    pd,
+      operation_plan,
+      debug,
+      reserved = args
+
+    pd = pd.nne []
+    array_operand,
+      array_operands_stack,
+      reserved = pd
+
+    operation_plan = operation_plan.nne
+
+    debug = debug.nne
+    debug.nne && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "args=#{args.inspect}")
+    debug && (stderr.puts "operation_plan=#{operation_plan.inspect}")
+
+    array_operands_stack = array_operands_stack.nne []
+    array_operand = array_operand.nne []
+
+    reserved_token,
+      reservation_type,
+      token,
+      reserved_token_symbol,
+      bulk = operation_plan.to_a
+    bulk = bulk.nne
+    debug && (stderr.puts "reserved_token=#{reserved_token.inspect}")
+    debug && (stderr.puts "reservation_type=#{reservation_type.inspect}")
+    debug && (stderr.puts "token=#{token.inspect}")
+    debug && (stderr.puts "bulk=#{bulk.inspect}")
+    operation_plan && reserved_token && (
+      reservation_type && (
+        debug && (stderr.puts "case is_up_token: #{token.inspect}")
+        array_operands_stack.push array_operand
+        array_operand = Array.new
+        true
+      ) || (
+        debug && (stderr.puts "case is_down_token: #{token.inspect}")
+        # this approach:
+        #  array_operand = array_operands_stack.pop.push array_operand
+        # won't accept pops when the stack is empty.
+        # this approach:
+        #  array_operand = array_operands_stack.pop.to_a.push array_operand
+        # will work as a "push" was added to the beginning
+        # another approach (not coded here) would be stop accept
+        # pushes to *array_operand* (at least when a new
+        # stack push/token up is done). To keep simplicity,
+        # the reset approach is done (past is forgotten),
+        # but the other options are left for the case of a
+        # future option implementation
+        array_operand = (array_operands_stack.pop.push array_operand) rescue []
+        true
+      )
+    ) || operation_plan && (
+        debug && (stderr.puts "case is_no_token: #{token.inspect}")
+
+        bulk_token_duck_type_method = :map
+        bulk_token_push = bulk && token.respond_to?(bulk_token_duck_type_method)
+        debug && (stderr.puts "[bulk, bulk_token_duck_type_method, bulk_token_push]=#{[bulk, bulk_token_duck_type_method, bulk_token_push].inspect}")
+        bulk_token_push.negate_me && (array_operand.push token)
+        prepend, append, reserved = bulk.to_a
+        bulk_token_push && (token = [prepend, token, append].flatten(1))
+        bulk_token_push && (token.map &array_operand.method(:push))
+        true
+    )
+    pd = [array_operand, array_operands_stack]
+    debug && (stderr.puts "will return #{pd.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    pd
+  end
+
+
+  # will take a flatten array and makes it deeper, starting a new array
   # everytime it finds the string +"["+. +"]"+ stops the array (and
   # return to the upper one). To reserve the possibility of
   # representing "[" or "]", everytime a string contains only those
@@ -3656,19 +3752,58 @@ n8mFEtUKobsK
   # behaviour (it will either a - transverse the sub-arrays
   # or b - don't transverse it, leaving it untouched. while
   # the a is the planned effect, initially only a may will
-  # be implemented).
-  # @param [Array] +args+, the array to be operadated
+  # be implemented) (currently this behaviour is easily configurable
+  # by the value +deep+, hardcoded in the function. soon, new
+  # functions will come to clarify and specify the proper behaviours)
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +flatten_array+:: [Array] the array to be operated.
+  # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +shallow+:: [Object] if evals to false (or empty string), will traverse recursively +flatten_array+ and apply the rules, in the case it is not flatten.
+  # +reserved_tokens+:: [Array of Arrays]
+  # +inverse+:: [Object] if calling the object +nne+ method returns a +false+ value, will operate this function inversely: will take a unflatten array and flatten it, applying the inverse escaping rules (note that any object responding to +:map+ will be considered an array in +flatten_array+).
+  # +debug_pushdown+:: [Object] if evals to false (or empty string), won't print debug information about the call #pushdown_operated
+# +inversion_envelope+::  [Array, nil], if +nil+, the first colum of +reserved_tokens+ will be used. if an +Array+ whose elements are expected to be:
+  # +inversion_envelope.prepend+::  [Object] when an inversion occurrs, this element will be prepended when a new object responding to +:map+, like +Array+ is found.
+  # +inversion_envelope.append+::  [Object] when an inversion occurrs, this element will be prepended when a new object responding to +:map+, like +Array+ is found.
   # @return [Array] returns the modified, deep, #Array
-  def array_unflatten_base_shallow args=[]
-    reserved_tokens = [
-      [ "[", :up], 
-      [ "]", :down.to_nil],
+  def array_unflatten_base args=[]
+    stderr = @memory[:stderr]
+    flatten_array,
+      shallow,
+      debug,
+      reserved_tokens,
+      inverse,
+      debug_pushdown,
+      inversion_envelope,
+      reserved = args
+    reserved_tokens = reserved_tokens.nne [
+      [ "[", :up],
+      [ "]", :up.negate_me],
     ]
-    rv = []
-    array_operand = []
-    array_operands_stack = []
-    args.each_with_index {|e, index|
-      reserved_tokens.map { |reserved_token|
+    inversion_envelope = inversion_envelope.nne(
+      reserved_tokens.transpose.first
+    )
+    inverse = inverse.nne
+    shallow = shallow.nne
+    debug_pushdown = debug_pushdown.nne
+    debug = debug.nne
+    debug.nne && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "args=#{args.inspect}")
+    pd = pushdown_operate
+    flatten_array.each_with_index {|e, index|
+      debug && (stderr.puts "-------------------")
+      debug && (stderr.puts "[e, index]=#{[e, index].inspect}")
+      shallow.negate_me && (
+        debug && (stderr.puts "e.hash=#{e.hash}")
+        args_recursion = args.clone
+        args_recursion[0] = e
+        e = (send __method__, args_recursion) rescue ( debug && (stderr.puts "#{__method__} finished with exception }" ) ; e)
+        debug && (stderr.puts "e.hash=#{e.hash}")
+      )
+      operations = reserved_tokens.map { |reserved_token|
+        debug && (stderr.puts "reserved_token=#{reserved_token.inspect}")
+        debug && (stderr.puts "array_operands_stack=#{pd[1].inspect}")
+        debug && (stderr.puts "array_operand=#{pd.first.inspect}")
         rtoken, is_up_token = reserved_token
 
         repetition_test = string_repetition [e, rtoken, 1]
@@ -3676,13 +3811,15 @@ n8mFEtUKobsK
 	  # case A: e is exactly the reserved token.
 	  # start or finish an array
 	  # note: if rtoken is false, it will succeed this
-	  # test. 
+	  # test.
           (repetition_test == rtoken) && (
+	    inverse  && (e = (e.sub! "", rtoken) rescue e)
             is_up_token && (
-	      array_operands_stack.push array_operand
-	      array_operand = Array.new
+              debug && (stderr.puts "case is_up_token")
+	      [:reserved_token.negate_me(inverse), :up, e, rtoken, false ]
 	    ) || (
-	      array_operand = array_operands_stack.pop
+              debug && (stderr.puts "case is_down_token")
+	      [:reserved_token.negate_me(inverse), :up.negate_me, e, rtoken, false ]
 	    )
 	  )
         ) || (
@@ -3690,34 +3827,70 @@ n8mFEtUKobsK
 	  # occurrences of the reserved token. remove one.
 	  # (and add it to the current array)
           repetition_test && (
-            array_operand.push(e.sub! rtoken, "")
+            debug && (stderr.puts "case escape")
+	    # room for improvement: and if array had sub! ?
+	    !inverse && (escaped_e = (e.sub! rtoken, "") rescue e)
+	    [:reserved_token.negate_me, nil, escaped_e, rtoken, false ]
           )
         ) || (
 	  # case C: no repetition. (just add e to
 	  # the current array.)
-            array_operand.push e
+            debug && (stderr.puts "case just add")
+	    [:reserved_token.negate_me, nil, e, rtoken, inverse && inversion_envelope ]
 	)
       }
+      # now operations has |reserved_tokens| operations.
+      # but only one will be applied: either the first
+      # one which is a reserved token (:first), or the
+      # last operation, in case of no reserved tokens.
+      operation = operations.lazy.find(&:first) || (
+        operations[-1].to_a
+      )
+      reserved_token, reservation_type, token = operation
+      pd = pushdown_operate [pd, operation, debug_pushdown]
     }
-    array_operand
+    debug && (stderr.puts "will return #{pd.first}")
+    debug && (stderr.puts "#{__method__} returning}")
+    pd.first
   end
 
-  # test for #string_repetition
-  def test__array_unflatten_base_shallow args=[]
-    test_cases ||= [
-     # [ :id, :expectation, :actual_params ],
-     # array_unflatten_base_shallow
-     [ "any test", [ :a, [ :b ], :c], [
-          :array_unflatten_base_shallow, [
-            :a, "[", :b, "]", :c
-           ]
-       ],
-     ],
 
+  # takes a flatten array and makes it deeper, starting a new array
+  # everytime it finds the string +"["+. +"]"+ stops the array (and
+  # return to the upper one). To reserve the possibility of
+  # representing "[" or "]", everytime a string contains only those
+  # chars, repeteaded any number of times, starting from 2, one of
+  # them will be removed. So +"[["+ will be left as +"["+ and
+  # +"]]]"+ will be left as +"]]"+.
+  # if the provided array is not flatten, it won't be transversed.
+  # @param [Array] +args+, the array to be operadated
+  # @return [Array] returns the modified, deep, #Array
+  def array_unflatten_base_shallow args=[]
+    stderr = @memory[:stderr]
+    deep = false
+    reserved_tokens = [
+      [ "[", :up],
+      [ "]", :up.negate_me],
     ]
-    test__tester test_cases
+    # debug = 1
+    debug = debug.nne
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug && (stderr.puts "args=#{args.inspect}")
+
+    rv = array_unflatten_base [
+      args,
+      deep.negate_me,
+      debug,
+      reserved_tokens,
+    ]
+
+    debug && (stderr.puts "will return #{rv}")
+    debug && (stderr.puts "#{__method__} returning")
+    rv
   end
 
+
+  # generic function for test__ functions
   def test__tester args=[]
     expectation = {}
     actual = {}
@@ -3737,6 +3910,215 @@ n8mFEtUKobsK
   end
 
 
+  # test for #array_unflatten_base_shallow
+  def test__array_unflatten_base_shallow args=[]
+    test_cases ||= [
+      # [ :id, :expectation, :actual_params ],
+      [
+        "base_case", [ :a, [ :b ], :c], [
+           :array_unflatten_base_shallow, [
+             :a, "[", :b, "]", :c
+           ]
+        ],
+      ],
+
+      [
+        "base_escape_case", [ :a, "[", :b, "]", :c], [
+           :array_unflatten_base_shallow, [
+             :a, "[[", :b, "]]", :c
+           ]
+        ],
+      ],
+
+      [
+        "base_open_right_case", [ :c], [
+           :array_unflatten_base_shallow, [
+             :a, :b, "[", :c
+           ]
+        ],
+      ],
+
+      [
+        "base_open_left_case", [ :b, :c], [
+           :array_unflatten_base_shallow, [
+             :a, "]", :b, :c
+           ]
+        ],
+      ],
+
+      [
+        "base_case_double", [ :a, [ [ :b ] ], :c], [
+           :array_unflatten_base_shallow, [
+             :a, "[", "[",  :b, "]", "]", :c
+           ]
+        ],
+      ],
+
+      [
+        "base_case_inverted", [ :c], [
+           :array_unflatten_base_shallow, [
+             :a, "]",  :b, "[", :c
+           ]
+        ],
+      ],
+
+
+      [
+        "base_nested_case", [ :a, [ [ :b ] ], :c], [
+           :array_unflatten_base_shallow, [
+             :a, "[", [ :b ], "]", :c
+           ]
+        ],
+      ],
+
+
+      [
+        "base_mixed_nested_case", [ :a, [ [ "[", :b, "]",  ] ], :c], [
+           :array_unflatten_base_shallow, [
+             :a, "[", [ "[", :b, "]", ], "]", :c
+           ]
+        ],
+      ],
+
+
+    ]
+    test__tester test_cases
+  end
+
+
+  # test for #array_unflatten_base
+  def test__array_unflatten_base args=[]
+    test_cases ||= [
+      # [ :id, :expectation, :actual_params ],
+      [
+        "base_case", [ :a, [ :b ], :c], [
+           :array_unflatten_base, [
+             [:a, "[", :b, "]", :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+      [
+        "base_escape_case", [ :a, "[", :b, "]", :c], [
+           :array_unflatten_base, [
+             [:a, "[[", :b, "]]", :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+      [
+        "base_open_right_case", [ :c], [
+           :array_unflatten_base, [
+             [:a, :b, "[", :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+      [
+        "base_open_left_case", [ :b, :c], [
+           :array_unflatten_base, [
+             [:a, "]", :b, :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+      [
+        "base_case_double", [ :a, [ [ :b ] ], :c], [
+           :array_unflatten_base, [
+             [:a, "[", "[",  :b, "]", "]", :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+      [
+        "base_case_inverted", [ :c], [
+           :array_unflatten_base, [
+             [:a, "]",  :b, "[", :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+
+      [
+        "base_nested_case", [ :a, [ [ :b ] ], :c], [
+           :array_unflatten_base, [
+             [:a, "[", [ :b ], "]", :c],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+
+      [
+        "base_mixed_nested_case_deep", [ :a, [ [ [ :b, ] ] ], :c], [
+           :array_unflatten_base, [
+             [:a, "[", [ "[", :b, "]", ], "]", :c],
+             :shallow.negate_me,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+
+      [
+        "base_mixed_nested_case_shallow", [ :a, [ [ "[", :b, "]",  ] ], :c], [
+           :array_unflatten_base, [
+             [ :a, "[", [ "[", :b, "]", ], "]", :c ],
+             :shallow,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse.negate_me,
+           ]
+        ],
+      ],
+
+      [
+        "base_case_inverse", [ :a, "[", :b, "]", :c], [
+           :array_unflatten_base, [
+             [:a, [ :b, ], :c],
+             :shallow.negate_me,
+             :debug.negate_me,
+             :reserved_tokens.to_nil,
+             :inverse,
+           ]
+        ],
+      ],
+
+
+    ]
+    test__tester test_cases
+  end
+
+
   # test for #string_repetition
   def test__string_repetition args=[]
     expectation = {}
@@ -3745,84 +4127,140 @@ n8mFEtUKobsK
     operand_1 = "XXX"
     operand_2 = "X"
     # expectation and actual inverted.
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = operand_1
 
     test_case = 2
     operand_1 = "X"
     operand_2 = "X"
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = operand_1
 
     test_case = 3
     operand_1 = "XyXy"
     operand_2 = "XyXy"
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = operand_1
 
     test_case = 4
     operand_1 = "XyXy"
     operand_2 = "XXyy"
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = false
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = false
 
     test_case = 6
     operand_1 = ""
     operand_2 = ""
-    expectation[test_case] = string_repetition [operand_1, operand_2, 0]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2, 0]
+    expectation[test_case] = operand_1
 
     test_case = 7
     operand_1 = ""
     operand_2 = ""
-    expectation[test_case] = string_repetition [operand_1, operand_2, 1]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2, 1]
+    expectation[test_case] = operand_1
 
     test_case = 7
     operand_1 = ""
     operand_2 = "X"
-    expectation[test_case] = string_repetition [operand_1, operand_2, 0]
+    actual[test_case] = string_repetition [operand_1, operand_2, 0]
     # "X"*0 = ""
-    actual[test_case] = operand_1
+    expectation[test_case] = operand_1
 
     test_case = 8
     operand_1 = ""
     operand_2 = "X"
-    expectation[test_case] = string_repetition [operand_1, operand_2, 1]
+    actual[test_case] = string_repetition [operand_1, operand_2, 1]
     # "X"*0 = "", but minimum is set to 1
-    actual[test_case] = false
+    expectation[test_case] = false
 
     test_case = 9
     operand_1 = "XyXy"
     operand_2 = "Xy"
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = operand_1
 
     test_case = 10
     operand_1 = "XyXy"
     operand_2 = ""
-    expectation[test_case] = string_repetition [operand_1, operand_2]
+    actual[test_case] = string_repetition [operand_1, operand_2]
     # clearly "" appears in "XyXy" infinity times, but "XyXy" is no
     # repetition of ""
-    actual[test_case] = false
+    expectation[test_case] = false
 
     test_case = 11
     operand_1 = "XyXy"
     operand_2 = "Xy"
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = operand_1
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = operand_1
 
     test_case = 12
     operand_1 = "X"
     operand_2 = "XXX"
-    expectation[test_case] = string_repetition [operand_1, operand_2]
-    actual[test_case] = false
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = false
+
+    test_case = 13
+    operand_1 = [:b]
+    operand_2 = "]"
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = false
+
+    test_case = 14
+    operand_1 = "[:b]"
+    operand_2 = "]"
+    actual[test_case] = string_repetition [operand_1, operand_2]
+    expectation[test_case] = false
 
     judgement = actual.keys.map {|test_case|
       [expectation[test_case], actual[test_case] , test_case]
     }.map(&method("expect_equal")).all?
   end
 
+  # test #rest_request
+  # for now, the parameters must still be hardcoded.
+  def test__rest_request__with_ayt args=ARGV
+    require 'json'
+    stderr = @memory[:stderr]
+
+    url = "https://owl.loftweb.nl:55031/4/3-roOomydev"
+    json =<<-ENDHEREDOC
+    {
+        "operation" : "AYT",
+        "version" : {
+            "client" : "X",
+            "protocol" : {
+                "domain_model" : "4",
+                "API" : "3"
+            }
+        }
+    }
+    ENDHEREDOC
+    payload = "#{json}"
+
+    auth_user = "web"
+    password = "vadim"
+    method = :post
+    method = :get
+    timeout = 600
+    verify_ssl = true
+    payload = "#{json}"
+    headers = ""
+    request_execution = send :rest_response__request_base, [
+      url,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      auth_user,
+      password,
+      timeout,
+    ]
+    parsed_json = JSON.parse request_execution.first.to_s
+    [parsed_json]
+  end
+
+
 
 
 end

metadata

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