rubyment 0.7.25733511 → 0.7.25752196

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b710e93d0b0389965a9b49b720148c6e365463a
-  data.tar.gz: b212104266d18535aaf66e800ea3360017876310
+  metadata.gz: 0ff1f7d16c03cf284f9c40a12b9f9fb4a9461703
+  data.tar.gz: 716243cf167c62a24a6b27d637a82d54459b1cc6
 SHA512:
-  metadata.gz: 6509d00070397420335d4e9e36e99b8a90dc66d9db658e658d8ad947991a47df6843759114fe122ec17f33e7cc20639942640d76475f75a0cfba9f1705aba9a4
-  data.tar.gz: 9c7ebeeb1255a241d461c200b51227f9d158cc777a6eede7595d3f0e03b1047374381a4cda9f44f3b4591da611ad3d05e1218ec6ca97feabc69f56ebd0b3a177
+  metadata.gz: 5220772a0d31f7acffe2ec685f3538baef96dd56f0dfad3282e29133dbeb5ef157a993e26c6e6313b21cbd4ae94ba5f275bd058c35f43c535245eb576323bf20
+  data.tar.gz: 789476d027b047058543b76143e71f149f3544b487a14f6ecc54f3d3c6f6903d8e9296aaaca75aea37cf1126f19554900d343fa2020041b1d65578c59a867deb

data/lib/rubyment.rb

@@ -142,7 +142,20 @@ end # of NewModule
   end
 
 
-end
+=begin
+if you use vim or a similar  editor, you can use such a function as:
+:read !./rubyment.rb invoke_double puts code_rubyment_debug_puts
+=end
+  def code_rubyment_debug_puts
+    code =<<-ENDHEREDOC
+    debug && (stderr.puts "=\#{}")
+    ENDHEREDOC
+    [code]
+
+  end
+
+
+end # of RubymentRubyCodeGenerationModule
 
 
 =begin 
@@ -262,7 +275,50 @@ module RubymentStringsModule
   end
 
 
-end
+=begin
+  Function that can generate distribution or combinations of
+  an array of strings.
+
+  Closed for extension
+
+  examples:
+  strings__product [ "model 1", "model 2"], [":"], ["variant with sound system", "variant no sound system"], [" "],  ["and stabilizer", "and without stabilizer"]
+  # => ["model 1:variant with sound system and stabilizer",
+  #  "model 1:variant with sound system and without stabilizer",
+  # ...
+  #  "model 2:variant no sound system and stabilizer",
+  #  "model 2:variant no sound system and without stabilizer"]
+
+
+=end
+  def strings__product *strings
+    arrays = arrays__product *strings
+    invoke__basic_sender_array [ arrays, :map  ], &:join
+  end
+
+
+=begin
+  Function that can generate a match of
+  an array of strings.
+
+  Closed for extension
+
+  examples:
+
+  # compare the results below, with calling strings__product [ "model 1", "model 2"], [":"], ["variant with sound system", "variant no sound system"], [" "],  ["and stabilizer", "and without stabilizer"]
+
+  strings__zip [ "model 1", "model 2"], [":"], ["variant with sound system", "variant no sound system"], [" "],  ["and stabilizer", "and without stabilizer"]
+  # => ["model 1:variant with sound system and stabilizer",
+  #  "model 2variant no sound systemand without stabilizer"]
+
+=end
+  def strings__zip *strings
+    arrays = arrays__zip *strings
+    invoke__basic_sender_array [ arrays, :map  ], &:join
+  end
+
+
+end # of RubymentStringsModule
 
 
 =begin 
@@ -333,6 +389,88 @@ module RubymentArraysModule
   end
 
 
+=begin
+  returns an array with the indexes of ocurrences
+  of element in each array of arrays.
+
+  examples:
+  array__index [ [ :a, :b, :c], [ nil, :b ], [:a] ], :a
+  # => [0, nil, 0]
+
+  r.array__index [ [ :a, :b, :c], [ nil, :b ], [:a] ], :b
+  # => [1, 1, nil]
+
+
+=end
+  def array__index arrays, element
+
+    pattern_exec__mapping_an_object [
+      arrays,
+      "map",
+      "index",
+      element,
+    ]
+
+  end
+
+
+=begin
+
+  returns an array with the elements at the given
+  position in each array of arrays.
+
+  it's equivalent of calling arrays.transpose[position],
+  however, it saves the transposed memory.
+
+  examples:
+  array__at [ [ :a, :b, :c], [ nil, :b ], [:a] ], 0
+  # => [:a, nil, :a]
+
+  array__at [ [ :a, :b, :c], [ nil, :b ], [:a] ], 2
+  # => [:c, nil, nil]
+
+  # slices can be given in an array:
+  array__at [ [ :a, :b, :c], [ nil, :b ], [:a] ], [1..2]
+  # => [[:b, :c], [:b], []]
+
+=end
+  def array__at arrays, position
+
+    pattern_exec__mapping_an_object [
+      arrays,
+      "map",
+      "slice",
+      position,
+    ]
+
+  end
+
+
+=begin
+  Just a convenience function for achieving the
+  same as first_array.product other_arrays
+
+  Closed for extension
+
+  examples:
+
+  arrays__product [ "model 1", "model 2"], [":"], ["variant with sound system", "variant no system"], ["and stabilizer", "and without stabilizer"]
+  #  => [["model 1", ":", "variant with sound system", "and stabilizer"],
+  #  ["model 1", ":", "variant with sound system", "and without stabilizer"],
+  # ...
+  #  ["model 2", ":", "variant no system", "and stabilizer"],
+  #  ["model 2", ":", "variant no system", "and without stabilizer"]]
+
+
+
+
+=end
+  def arrays__product *args
+    first, *others = args
+    first.product *others
+  end
+
+
 end # of RubymentArraysModule
 
 
@@ -435,7 +573,188 @@ module RubymentInternalModule
   include InternalRubymentModule
 
 
-end # of InternalRubymentModule
+=begin
+  merges the current @memory with m
+  (so @memory will contain the resulting merged
+  hash).
+  The merge is shallow, ie, only top-level
+  keys are merged.
+  If the same key is present in both objects,
+  the one in m will prevail.
+=end
+  def rubyment_memory__merge_shallow m
+    @memory.merge!  m
+  end
+
+
+=begin
+  merges the m with the current @memory
+  (so @memory will contain the resulting merged
+  hash).
+  The merge is shallow, ie, only top-level
+  keys are merged.
+  If the same key is present in both objects,
+  the one in @memory will prevail. Note that this
+  is the inverted behaviour as of
+  #rubyment_memory__merge_shallow
+=end
+  def rubyment_memory__merge_shallow_on m
+    rubyment_memory__set m.merge @memory
+  end
+
+
+=begin
+  returns a m, or copy of @memory if not given,
+  without the keys listed in closure_keys, or m[:closure_keys],
+  if not given (still, m["closure_keys"] if m[:closure_keys]
+  is empty).
+=end
+  def rubyment_memory__without_closure_keys m=nil, closure_keys=nil
+    m = m.nne @memory.dup
+    closure_keys = closure_keys.nne(
+      m[:closure_keys]
+    ).nne(
+      m["closure_keys"]
+    )
+    closure_keys.each {|closure_key|
+      m.delete closure_key
+    }
+    m
+  end
+
+
+=begin
+  dumps the contents of m, or @memory if not given,
+  into filepath, or m[:memory_json_file_default]
+  if not given (still m["memory_json_file_default"]
+  if nil).
+=end
+  def rubyment_memory__to_json_file filepath=nil, m=nil
+    m = m.nne @memory
+    filepath = filepath.nne(
+      m[:memory_json_file_default]
+    ).nne(
+      m["memory_json_file_default"]
+    )
+    file__json [
+      filepath,
+      m,
+    ]
+  end
+
+
+=begin
+  ensure the top level keys of m, @memory if not given,
+  are all symbols
+  returns a copy of m, @memory if not given, where
+  all the keys are ensured to be symbols.
+
+  When a ruby hash is stored as a JSON file, the symbol
+  keys will be restored as strings. When that JSON file
+  is reloaded, those strings will be loaded as strings.
+  Therefore the resulting hash is not the same as the
+  original. There may be other issues with keys having
+  other types than strings and symbols, and deep keys
+  can also be lost with that transformation. This function
+  just takes cares of the issues created by the Rubyment
+  memory implementation itself.
+
+  other special cases:
+  m[:closure_keys] contents will be converted into symbols
+
+=end
+  def rubyment_memory__symbol_keys_shallow m = nil
+    update_memory = m.nne.negate_me
+    m = m.nne @memory
+    m = m.map { |k, v|  [k.to_sym, v] }.to_h
+    m[:closure_keys].map!(&:to_sym)
+    update_memory && (@memory = m) || m
+  end
+
+
+=begin
+  merge
+  @memory with the hash loaded from filepath, or
+  @memory[:memory_json_file_default] if not given
+  (still @memory["memory_json_file_default"] if nil).
+
+  The merge is shallow, ie, only top-level
+  keys are merged.
+  If the same key is present in both objects,
+  the one in m will prevail.
+=end
+  def rubyment_memory__merge_shallow_with_json_file filepath=nil, debug=nil
+    filepath = filepath.nne(
+      @memory[:memory_json_file_default]
+    ).nne(
+      @memory["memory_json_file_default"]
+    )
+    m = load__file_json_quiet [
+      filepath,
+      debug,
+    ]
+    rubyment_memory__merge_shallow(
+      rubyment_memory__without_closure_keys(
+        rubyment_memory__symbol_keys_shallow m
+      )
+    )
+  end
+
+
+=begin
+  merge
+  @memory with the hash loaded from filepath, or
+  @memory[:memory_json_file_default] if not given
+  (still @memory["memory_json_file_default"] if nil).
+
+  The merge is shallow, ie, only top-level
+  keys are merged.
+  If the same key is present in both objects,
+  the one in @memory will prevail. Note that
+  this is the inverse behaviour compared to
+  #rubyment_memory__merge_shallow_with_json_file
+=end
+  def rubyment_memory__merge_shallow_on_load_json_file filepath=nil, debug=nil
+    filepath = filepath.nne(
+      @memory[:memory_json_file_default]
+    ).nne(
+      @memory["memory_json_file_default"]
+    )
+    m = load__file_json_quiet [
+      filepath,
+      debug,
+    ]
+    rubyment_memory__merge_shallow_on(
+      rubyment_memory__without_closure_keys(
+        rubyment_memory__symbol_keys_shallow m
+      )
+    )
+  end
+
+
+=begin
+  returns a string having help for the idea of persistence
+  achieved with many of the functions of this module:
+=end
+  def help__concept__rubyment_memory_persistence
+    string = [
+      "# saves the current memory to the default memory_json_file_default ('memory.rubyment.json' by default, in the current dir): ",
+      "rubyment_memory__to_json_file",
+      "",
+      "# if you add a new key to that file, you can load it to memory with",
+      "rubyment_memory__merge_shallow_on_load_json_file",
+      "# in the above case, keys in the current memory will prevail, when they equal.",
+      "",
+      "# this function will try to restore the memory, as much as possible (not everything is serializable), to the state of when it was saved: ",
+      "rubyment_memory__merge_shallow_with_json_file",
+      "# in the above case, keys in the json file will prevail, when they equal.",
+      "",
+    ]
+    [ string.join("\n") ]
+  end
+
+
+end # of  RubymentInternalModule
 
 
 =begin
@@ -521,6 +840,48 @@ module RubymentModifierForClassObjectModule
 end
 
 
+=begin 
+  # begin_documentation
+
+  This module offers functions for invocation of Rubyment
+  (and Ruby) code in general.
+
+  # end_documentation
+=end
+module RubymentInvocationModule
+
+
+=begin
+  Takes an array as parameter and invokes a
+  method (second element of that array) of an object
+  (first element of that array) giving the remaining
+  array as argument list, and optionally giving
+  a block as extra parameter.
+
+  Closed for extensions
+
+  examples:
+
+  invoke__basic_sender_array [ 9, "next" ]
+  # => 10
+
+  invoke__basic_sender_array [ self, "p", "args", "to", "p" ]
+  # => ["args", "to", "p"]
+
+  invoke__basic_sender_array [ [["S", "2"], ["<", "3" ]], :map  ], &:join
+  # => ["S2", "<3"]
+
+
+=end
+  def invoke__basic_sender_array args, &block
+    object, method_name, *args_to_method = args
+    object.send method_name, *args_to_method, &block
+  end
+
+
+end # of RubymentInvocationModule
+
+
 =begin
   # begin_documentation
   This module receives functions that are being worked on.
@@ -775,32 +1136,18 @@ module RubymentExperimentModule
 
 =begin
   write the second argument of the array args into the filepath in the first argument
+  read it back with #load__file_json_quiet
 =end
   def file__json args=[]
     require 'json'
     file_path,
       enum,
       reserved = args
+    FileUtils.mkdir_p File.dirname file_path
     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 ]
@@ -2317,7 +2664,66 @@ trying to get the interface compatible with
   end
 
 
-end
+=begin
+  inverse of #file__json
+=end
+  def load__file_json_quiet args=[]
+    require 'json'
+    file_path,
+    debug,
+      reserved = args
+    debug = debug.nne
+    stderr = @memory[:stderr]
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args=#{args.inspect}")
+    file_contents = File.read file_path
+    debug && (stderr.puts "file_contents size=#{file_contents.size}")
+    loaded = JSON.parse file_contents
+    debug && (stderr.puts "loaded size=#{loaded.size}")
+    debug && (stderr.puts "loaded=#{loaded.inspect}")
+    rv = loaded[:root.to_s]
+    # if raises exception before it will be unbalanced :
+    debug && (stderr.puts "#{__method__} will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+=begin
+
+  To generate and execute a code like this:
+
+    arrays.map { |a|
+      a.index element
+    }
+
+    just give as a code_pattern:
+
+    [
+      arrays,
+      "map",
+      "index",
+      element,
+    ]
+
+=end
+  def pattern_exec__mapping_an_object code_pattern
+
+    iterating_object,         # arrays
+      yielding_method_name,   # "map"
+      mapping_method_name,    # "index"
+      args_to_mapping_method, # element
+      reserved = code_pattern
+
+    iterating_object.send(yielding_method_name) { |a|
+      a.send mapping_method_name, *args_to_mapping_method
+    }
+
+  end
+
+
+end # of RubymentExperimentModule
 
 
 =begin
@@ -2982,7 +3388,36 @@ module RubymentDeprecatedModule
   end
 
 
-end
+=begin
+  inverse of #file__json
+  note that, contrary to the common convention,
+  the debug output is on for this function
+  (due to a mistake, and to respect API-backwards-compatibility)
+=end
+  def load__file_json args=[]
+    require 'json'
+    file_path,
+    quiet,
+      reserved = args
+    debug = quiet.nne.negate_me
+    stderr = @memory[:stderr]
+    debug && (stderr.puts "{#{__method__} starting")
+    debug && (stderr.puts "caller=#{caller_label}")
+    debug && (stderr.puts "args=#{args.inspect}")
+    file_contents = File.read file_path
+    debug && (stderr.puts "file_contents size=#{file_contents.size}")
+    loaded = JSON.parse file_contents
+    debug && (stderr.puts "loaded size=#{loaded.size}")
+    debug && (stderr.puts "loaded=#{loaded.inspect}")
+    rv = loaded[:root.to_s]
+    # if raises exception before it will be unbalanced :
+    debug && (stderr.puts "#{__method__} will return #{rv.inspect}")
+    debug && (stderr.puts "#{__method__} returning}")
+    rv
+  end
+
+
+end # of RubymentDeprecatedModule
 
 
 =begin
@@ -3477,6 +3912,7 @@ module RubymentModule
   include RubymentStringsModule
   include RubymentArraysModule
   include RubymentInternalModule
+  include RubymentInvocationModule
   include RubymentExperimentModule
   include RubymentMaintainedModule
   include RubymentDeprecatedModule
@@ -3541,11 +3977,18 @@ module RubymentModule
       :running_dir => Dir.pwd,
       :home_dir => Dir.home,
       :system_user => ENV['USER'] || ENV['USERNAME'],
-      :system_user_is_super => ENV['USER']  == "root", # changed plan: platform indenpend.
+      :system_user_is_super => ENV['USER']  == "root",
       :static_separator_key => "strings_having_this"  +  "_string_not_guaranteed_to_work",
       :static_end_key => "strings_havinng_this_string" + "_also_not_guaranteed_to_work",
       :static_separator_key_per_execution => "strings_having_this"  +  "_string_not_guaranteed_to_work" + (Proc.new {}).to_s + Time.now.to_s,
-      :threads => [Thread.current]
+      :threads => [Thread.current],
+      :memory_json_file_default => "memory.rubyment.json",
+      :closure_keys => [
+        :stdin,
+        :stderr,
+        :stdout,
+        :threads,
+      ],
     }
     @memory.update memory.to_h
     invoke @memory[:invoke].to_a

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyment
 version: !ruby/object:Gem::Version
-  version: 0.7.25733511
+  version: 0.7.25752196
 platform: ruby
 authors:
 - Ribamar Santarosa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-05 00:00:00.000000000 Z
+date: 2018-12-18 00:00:00.000000000 Z
 dependencies: []
 description: a gem for keeping Rubyment, a set of ruby helpers
 email: ribamar@gmail.com