rubyment 0.7.25752540 → 0.7.25761093

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6fbbb8b232ca1a58d1440b3310dc2a87a5c6f30
-  data.tar.gz: 459ab366a552afb2fe23f31ecb2e8030842d0002
+  metadata.gz: 84fd074da46f8f1ef6ed16cac3d8585c66167edf
+  data.tar.gz: 631c77f863b75a6243f83ca966fa192d03577878
 SHA512:
-  metadata.gz: f8f6bb176e2bed86d86faa13f7c66755fef1adc4c7b64fc95a854d80b93a2697678289b9126f15b76fab6d762225cb7546b8fd3da1a55d7b57b97eba4ec7f93d
-  data.tar.gz: 8d2795d66b35b4c1f6670d1aedb69dda3ae65757c39f029f03bb7f372d0b72568a03e4040ca8ddda68eed11f55d545bd9a4edefe85383b72038c1807c8f6efda
+  metadata.gz: 4310b2d48cca557ead98af608cddcfa1d180b871040855fc19629752e2934d5fc00c4b75044dfff261447b02b24e4fb75e00bd71cb4011e009373324af68a608
+  data.tar.gz: beca4169679bf3924ed30f874519ea6d7b40f8546c627ccfbcbd7d0ff16a1f51e049f3a4a2351b0f3fa424c56a5a58f74a340f63a20ff5c58dee1a80944863d1

data/lib/rubyment.rb

@@ -92,7 +92,49 @@ class Object
   end
 
 
-end
+=begin
+  Turns any Ruby object into a composite.
+
+  Examples:
+
+  1.as_container(:components_only).entries
+  # => []
+
+  1.as_container.entries
+  # => [1]
+
+  "hello".as_container.entries
+  # => ["hello"]
+
+  [1, 2, 3].as_container().entries
+  # => [1, 2, 3]
+
+  [1, 2, 3].as_container(:components_only).entries
+  # => [1, 2, 3]
+
+  # Take the first element of the operation on the object a:
+  # a.as_container.entries - a.as_container(:only_components).entries
+  # to find what's the non composite component of a:
+
+  a = [ 1, 2, 3 ] ; a.as_container.entries - a.as_container(:only_components).entries
+  # => []
+
+  a = "str" ; a.as_container.entries - a.as_container(:only_components).entries
+  # => ["str"]
+
+=end
+  def as_container components_only=nil, method_name=:map
+    self.respond_to?(method_name) && (
+      self.send method_name
+    ) || (!components_only) && (
+      [self].send method_name
+    ) || (
+      [].send method_name
+    )
+  end
+
+
+end # of class Object
 
 
 =begin
@@ -903,9 +945,10 @@ module RubymentInternalModule
   However, it's not sequencial, and therefore not
   used for versioning.
 =end
-  def rubyment_file_sha256
+  def rubyment_file_sha256 file=nil
     require 'openssl'
-    (Digest::SHA256.hexdigest File.read __FILE__)
+    file = containerize(file).first.nne __FILE__
+    (Digest::SHA256.hexdigest File.read file)
   end
 
 
@@ -948,6 +991,89 @@ module RubymentInternalModule
 end # of  RubymentInternalModule
 
 
+=begin 
+  # begin_documentation
+
+  This module offers generic functions to help
+  achieving certain programming patterns.
+
+  # end_documentation
+=end
+module RubymentPatternsModule
+
+
+=begin
+  Turns any_object into a composite, and
+  returns it in an array with its two parts:
+  the leaf, and its children (another
+  container)
+
+  Note that if an object can be decomposed
+  by duck_type_method (:map) by default,
+  it stays in the leaf, otherwise it is
+  components are returned in the children.
+  So expect always a nil for the leaf or
+  [] for children components.
+
+  Decompose an object is useful, for example,
+  to write a recursive function in functional
+  style.  Normally a recursive function will
+  require a test to check if it is the base
+  (leaf) case, otherwise will iterate through
+  children and call recursively the function.
+  With this, no test is needed. Since the "map"
+  call is not defined for every object, it won't
+  go infinite. Also, it won't throw an exception,
+  because the children is a container (empty,
+  when the leaf is defined):
+
+  def rec leaf_or_children
+    l, c = object__decompose leaf_or_children
+    c.map { |children| rec leaf_or_children }
+    do_something_with_leaf l # must be already in
+                             # a functional/fault
+                             # tolerant style
+  end
+
+  Examples:
+
+  l, c  = object__decompose [ "a", "b", "c"]
+  # => [nil, ["a", "b", "c"]]
+
+  l, c  = object__decompose "string"
+  # => ["string", []]
+
+  l, c  = object__decompose ["a", "b", "c"], :bytes
+  # => [["a", "b", "c"], []]
+
+  l, c  = object__decompose "string", :bytes
+  # => [nil, [115, 116, 114, 105, 110, 103]]
+
+
+=end
+  def object__decompose any_object, duck_type_method=:map
+
+    children = bled {
+      any_object.as_container(:only_components, duck_type_method).entries
+    }.first.call.first || []
+
+    leaf = bled([any_object]) {
+      (
+        any_object.as_container(nil, duck_type_method).entries -
+        children
+      ).first
+    }.first.call.first
+
+    [
+      leaf,
+      children,
+    ]
+  end
+
+
+end # of RubymentPatternsModule
+
+
 =begin
   # begin_documentation
 
@@ -1070,9 +1196,271 @@ module RubymentInvocationModule
   end
 
 
+=begin
+  Just a convenience for typing less. Calls
+  the block inside a bled, which is a function
+  which captures and returns exceptions and
+  runtime errors in a functional way, instead
+  of Ruby's way.
+
+  Examples:
+
+   bled_call {:return_value }
+   # => [:return_value, nil, nil]
+
+   bled_call { UndefinedStuff }
+   # => [nil,
+   # ...
+   #    nil],
+   #  NameError],
+   #   #<NameError: uninitialized constant #<Class:#<Rubyment:0x000000035adcc0>>::UndefinedStuff>]
+
+
+   bled_call [:return_value_on_error] { UndefinedStuff }
+   # => [:return_value_on_error,
+   #  [nil,
+   #   "message{\nuninitialized constant #<Class:#<Rubyment:0x0000000308e078>>::UndefinedStuff\
+
+=end
+  def bled_call *args, &block
+    b = bled *args, &block
+    b.first.call
+  end
+
+
+=begin
+  Generates a string that can be given to system (or any other
+  command line executor) to execute a binary in memory (Ie,
+  a file is generated having as contents a given string).
+  If not file path is given a default one in /tmp will be
+  generated (using the digest sha256 of the file (truncated
+  at 96 chars, by now).
+  Arguments can be given in an array (they will be escaped
+  with Shellwords.join) or String (no escape apply)
+
+  Examples:
+
+  # write the contents of /bin/ls to a temporary file and offers
+  # a command to execute it:
+  system_command__exec_via_file [ [nil, File.read("/bin/ls") ] , ["-l", "-h"] ]
+  # => "/tmp/rubyment.file.a90ba058c747458330ba26b5e2a744f4fc57f92f9d0c9112b1cb2f76c66c4ba0 -l -h"
+
+  system_command__exec_via_file [ ["/tmp/my_ls", File.read("/bin/ls") ] , ["-l", "-h"] ]
+  # => "/tmp/my_ls -l -h"
+
+  system_command__exec_via_file [ ["/tmp/my_ls", File.read("/bin/ls") ] , "-l -h" ]
+  # => "/tmp/my_ls -l -h"
+
+
+=end
+  def system_command__exec_via_file exec_via_file
+   args = exec_via_file
+
+    binary_or_script_blob,
+    args_to_binary_or_blob,
+      reserved = containerize(args)
+
+    file_path_src,
+      string_src,
+      reserved = containerize(binary_or_script_blob)
+
+    require 'openssl'
+    string_src_sha256 = string_truncate [
+      Digest::SHA256.hexdigest(string_src.to_s),
+      96,
+    ]
+    default_path_for_string_src = "/tmp/rubyment.file.#{string_src_sha256}"
+
+    actual_file_path,
+      old_contents,
+      reserved = file_string__experimental [
+        file_path_src.nne(default_path_for_string_src),
+        string_src,
+      ]
+
+    bled_call {
+      require 'fileutils'
+      FileUtils.chmod "+x", actual_file_path
+    }
+    require "shellwords"
+    escaped_args_as_str = (
+      bled_call [ args_to_binary_or_blob ] {
+        Shellwords.join args_to_binary_or_blob
+      }
+    ).first.to_s
+    string__recursive_join [
+      " ",
+      actual_file_path,
+      escaped_args_as_str,
+    ]
+  end # of system_command__exec_via_file
+
+
+=begin
+  "Rubyfy" a system's executable binary string/blob/memory chunk.
+  Ruby gems won't distribute binaries other than Ruby executables
+  (no whims, it is just their mechanisms of handling binaries with
+  multiple versions in the system, they solved only for Ruby case).
+
+  With this function, a binary string can be given (in a file_string
+  definition/structure; ie as second element), and a ruby code
+  (which normally relies on Rubyment) will be generated to wrap
+  that binary in a ruby code. A temporary file (not for the ruby
+  code, but for storing the binary memory chunk/string is by
+  default generated at /tmp/ dir; however it can set if given
+  as the first element of that file_string.
+
+  Examples:
+
+  ruby_code__from_binary [nil, File.read("/bin/ls") ] # long output
+  # => "#!/usr/bin/env ruby\n# Autogenerated on 2018.12.21_16:45:11\nrequire 'base64'\nblob_base64 = \"f0VMRgIBAQAAAAAAAAAAAAIAPgABAAAAoElAAAAAAABAAAAAAAAAADjnAQAA\\nAAAAAAAAAEAAOAAJAEAAHQAcAAYAAAA
+
+  # this version is good for self development: include this current .rb file, which contains function not yet in the gem package:
+  ruby_code__from_binary [nil, File.read("/bin/ls") ], [ nil, :include_this_file ] # long output
+  # => "#!/usr/bin/env ruby\n# Autogenerated on 2018.12.21_16:45:11\nrequire 'base64'\nblob_base64 = \"f0VMRgIBAQAAAAAAAAAAAAIAPgABAAAAoElAAAAAAABAAAAAAAAAADjnAQAA\\nAAAAAAAAAEAAOAAJAEAAHQAcAAYAAAA
+
+  ruby_code__from_binary ["/tmp/temporary_ls", File.read("/bin/ls") ] # long output
+  # => "#!/usr/bin/env ruby\n# Autogenerated on 2018.12.21_16:50:37\nrequire \"rubyment\"\nrequire 'base64'\nblob_base64 =
+
+  system_command__exec_via_file   [ [ nil, (ruby_code__from_binary [nil, File.read("/bin/ls") ]) ] ]
+  # => "/tmp/rubyment.file.1e7f29e90deb6ba33b3e2e21540c77c56fca5995bb88141b572481f322290cad"
+
+  # this version is good for self development: include this current .rb file, which contains function not yet in the gem package:
+  system_command__exec_via_file [ [ nil, (ruby_code__from_binary [nil, File.read("/bin/ls") ], [ nil, :include_this_file ])  ] ]
+
+  # or even:
+  # this version is good for self development: include this current .rb file
+  system_command__exec_via_file [ [ nil, (ruby_code__from_binary [nil, File.read("/bin/ls") ], [ nil, :include_this_file ])  ] , "-l" ]
+
+
+=end
+  def ruby_code__from_binary binary_or_script_blob, requirements=nil
+    require 'base64'
+    temporary_file_path,
+      blob_string = containerize(binary_or_script_blob)
+    blob_base64 = Base64.encode64 blob_string
+
+    required_gems,
+      load_current,
+      object_creator,
+      memory_exec_function,
+      reserved = containerize(requirements)
+
+    memory_exec_function = memory_exec_function.nne(
+      "system_command__exec_via_file"
+    )
+
+    object_creator = object_creator.nne(
+      "#{self.class}.new"
+    )
+
+    memory_exec_function_call = string__recursive_join [
+      ".",
+      object_creator,
+      memory_exec_function,
+    ]
+
+
+    required_gem,
+      *only_one_currently_supported,
+      reserved = containerize(required_gem)
+
+    required_gem = required_gem.nne "rubyment"
+    load_current &&= "load #{__FILE__.inspect}"
+
+    code =<<-ENDHEREDOC
+#!/usr/bin/env ruby
+# Autogenerated on #{time__now_strftime_default}
+require #{required_gem.inspect}
+#{load_current}
+require 'base64'
+blob_base64 = #{blob_base64.inspect}
+system #{memory_exec_function_call} [
+  [
+    #{temporary_file_path.inspect},
+    Base64.decode64(blob_base64),
+  ],
+  ARGV,
+]
+    ENDHEREDOC
+  end # of ruby_code__from_binary
+
+
 end # of RubymentInvocationModule
 
 
+=begin 
+  # begin_documentation
+
+  This module offers functions to generate or
+  deploy gem packages.
+
+  As of now, there are many similar functions
+  directly coded in RubymentModule; they will
+  be moved here upon proper maintenance/cleanup
+
+  # end_documentation
+=end
+module RubymentGemGenerationModule
+
+
+=begin
+  Gem files by default can distribute only Ruby files.
+  This function implements the work needed to convert
+  and automatize the generation of ruby executables out
+  of  non ruby binaries
+=end
+  def gem_deploy__non_ruby_binaries args
+    gem_name,
+      gem_non_ruby_executables,
+      gem_executables, # same as gem_bin_executables
+      reserved = args
+
+    new_executables = gem_non_ruby_executables.map { |gem_non_ruby_executable|
+
+      new_gem_executable = string__recursive_join [
+        "/",
+        "bin",
+        File.basename(gem_non_ruby_executable),
+      ]
+
+      new_gem_executable_contents = ruby_code__from_binary(
+        [
+          nil,
+          File.read(gem_non_ruby_executable),
+        ],
+        [
+          gem_name,
+        ],
+      )
+
+      # write file
+      file_string__experimental [
+        new_gem_executable,
+        new_gem_executable_contents,
+      ]
+
+      bled_call {
+        require 'fileutils'
+        FileUtils.chmod "+x", new_gem_executable
+      }
+
+      File.basename(new_gem_executable)
+
+    } # of gem_non_ruby_executables.map
+
+    gem_executables = gem_executables.nne([]).concat new_executables
+
+    [
+      gem_executables,
+    ]
+
+  end # of gem_deploy_non_ruby_binaries
+
+
+end # of RubymentGemGenerationModule
+
+
 =begin
   # begin_documentation
   This module receives functions that are being worked on.
@@ -2915,6 +3303,166 @@ trying to get the interface compatible with
   end
 
 
+=begin
+  Takes a file_string definition as input and output
+  a new one.
+
+  A file_string definition is an image of a file on
+  a string. Each time this function is called, the
+  image is written to the disk (if set), and the previous
+  file_contents is loaded into the string.
+
+  The first element of file_string is a file_path, existing
+  or not.
+
+  the returned file_string has the same first element, and
+  the second is either:
+  . unexisting file_path
+  . a string having the file path contents, in the case it is a file_path
+  . a list of file_strings, one per each file inside a directory, in
+  the case file_path is a directory.
+
+  This function, after generating the file_string to be returned,
+  will write file_path accordingly to the second parameter. If :
+  . a string: will write the string to the file_path (if file_path
+  is not a directory, otherwise does nothing).
+  . a list of file_strings / nil: will call recursively this function
+  for each of the file_string inside, and will create file_path as
+  directory (if still does not exist).
+
+  There is yet a third element in a file_string,  mode (as in "rw+",
+  and not as in permissions), used as parameter for file write.
+  Check https://ruby-doc.org/core-2.3.1/IO.html#method-c-new
+
+
+  This function does not have semantics to be called from
+  the command line in its full interface, because
+  it differentiates nil from ""
+
+  Planned improvements: permissions, shallow cat of a dir.
+
+  Examples:
+
+  # -- case: touch (non existing path and empty string)
+  file_string__experimental ["non_existing_path", ""]
+
+  # -- case: echo >  (existing or not path (can't be a dir) and non empty string)
+  file_string__experimental ["existing_or_not_path__file", "contents of file"]
+
+  # -- case: echo >>  (existing path (no dir) and non empty string, "a" mode)
+  file_string__experimental ["existing_or_not_path__file", "contents of file", "a"]
+
+  # -- case: cat (path exists, (dir or file) otherwise becomes mkdir, nil string  -- it is a recursive cat in the case of directories )
+  file_string__experimental ["existing_path"]
+
+   # --- case: mkdir (or mkdir -p with only one argument): (non existing filepath, no string)
+  file_string__experimental ["non_existing_path"]
+
+   # -- case: mkdir -p  (non existing filepath, no string)
+  file_string__experimental ["a/b/c/d"]
+
+
+=end
+  def file_string__experimental file_string
+    args = file_string
+
+    file_path,
+      string_or_file_strings,
+      mode,
+      reserved = containerize(args)
+
+
+    # if file_path is a directory, calls recursively this
+    # function, retrieving the file_string representation
+    # for each entry in a subdirectory:
+    file_strings_entries = File.directory?(file_path) && (
+      Dir.new(file_path).entries
+    ).nne([]).map { |file_path_entry|
+      next_file_path = [file_path, file_path_entry].join("/")
+      # To avoid infinite recursion, we need to check if
+      # the next file path is not something like the
+      # parent with "/./" at the end.
+      # It is not simple to normalize file paths:
+      # https://stackoverflow.com/a/53884097/533510
+      # It makes more difficult the fact that the next
+      # may not yet exist (although the parent must exist).
+      # But the parent has to exist. And, if the next
+      # and the parent are the same, then both exist. In
+      # that case, we case compare if both have the
+      # same inode.
+
+      inodes = [
+        [
+          File.stat(file_path).ino,
+          File.stat(File.dirname file_path).ino,
+        ],
+        :index,
+        (
+          bled_call { File.stat(next_file_path).ino }
+        ).first,
+      ]
+
+      skip = invoke__basic_sender_array(inodes)
+      skip.negate_me &&
+        # recursive call
+        send(__method__, [next_file_path]) ||
+        nil
+    }.compact
+
+    # what is considered to be a file_path's contents?
+    # this value will be the string_or_file_strings of
+    # the returned value
+    file_contents =
+      # first case: it's a directory, thus its contents.
+      file_strings_entries || (
+      # second case: plain file, thus its contents as string
+        bled_call {
+          File.read(file_path)
+        }
+      # third case: non existing file (nil returned)
+      ).first
+
+    string,
+     file_strings = object__decompose string_or_file_strings
+
+    # let's just write file_path accordingly
+    # to string_or_file_strings, regardless of file_contents
+
+    require 'fileutils'
+    bled_call {
+      string && (
+        # for write matters:
+        # if string, then file_path is a file...
+        FileUtils.mkdir_p File.dirname file_path
+        File.write file_path,  string, mode: mode
+      ) || (
+        # otherwise file_path is a directory...
+        FileUtils.mkdir_p file_path
+      )
+    }
+
+
+    # if string_or_file_strings is a a list of file_strings
+    # so file_path is interpreted to be written as a
+    # directory
+    file_strings = file_strings.map { |next_file_string|
+      next_file_string = next_file_string.as_container
+      # prepend file_path:
+      next_file_string[0] = [
+        file_path,
+        next_file_string[0].to_s,
+      ].join("/")
+
+      send __method__, next_file_string # recursive call
+    }
+
+    [
+      file_path,
+      file_contents,
+    ]
+  end # of file_string__experimental
+
+
 end # of RubymentExperimentModule
 
 
@@ -3179,6 +3727,33 @@ module RubymentMaintainedModule
 =begin
   # documentation_begin
   # short_desc = "generates a block which may return exceptions instead of raising them."
+  examples = [
+    "
+    (bled [] { :bled_returns }).first.call
+    # => [:bled_returns, nil, nil]
+    ",
+    "
+    (bled { :bled_returns }).first.call
+    # => [:bled_returns, nil, nil]
+    ",
+    '
+    (bled  { X }).first.call
+    => [nil,
+     [nil,
+     # ...
+     #   ["uninitialized constant #<Class:#<Rubyment:0x000000035adcc0>>::X", nil],
+     # NameError],
+     #    #<NameError: uninitialized constant #<Class:#<Rubyment:0x000000035adcc0>>::X>]
+     ',
+     '
+     (bled ["X is not undefined" ]  { X }).first.call
+     # => ["X is not undefined",
+     #  [nil,
+     #   "message{\
+     ',
+
+  ]
+
   @memory[:documentation].push = {
     :function   => :bled,
     :short_desc => short_desc,
@@ -4066,6 +4641,17 @@ end
   this module from a file without stopping the process (#autoreload).
   - some function to redesign part of Ruby API arguably misdesigned,
   like #arrays__zip
+  - functional exception handling (#bled_call and #bled)
+  - certain programming patterns, like turning any ruby object in
+  an effective composite pattern (#as_container, #object__decompose)
+  - ... or a imaging of two system resources, like a file and a
+  memory chunk (string), in a simplified interface that can
+  abstract away many functions (file_string__experimental).
+  - some functions to run a binary directly from a binary blob/memory
+  chunk, or to convert that memory chunk in to an executable ruby
+  script (#system_command__exec_via_file, #ruby_code__from_binary), so
+  it can be deployed as a binary in a gem package
+  (#gem_deploy__non_ruby_binaries).
 
 
   Rubyment functions must respect the open/closed principle
@@ -4104,7 +4690,9 @@ module RubymentModule
   include RubymentStringsModule
   include RubymentArraysModule
   include RubymentInternalModule
+  include RubymentPatternsModule
   include RubymentInvocationModule
+  include RubymentGemGenerationModule
   include RubymentExperimentModule
   include RubymentMaintainedModule
   include RubymentDeprecatedModule
@@ -5816,6 +6404,7 @@ module RubymentModule
     gem_bin_contents,
     gem_bin_executables,
     gem_dependencies,
+      gem_non_ruby_executables,
     reserved = args
 
     debug = @memory[:debug]
@@ -5833,6 +6422,14 @@ module RubymentModule
     debug && (stderr.puts "gem_dependencies=#{gem_dependencies}")
     debug && (stderr.puts "gem_dependencies_str=#{gem_dependencies_str.inspect}")
 
+    gem_bin_executables,
+      reserved = gem_deploy__non_ruby_binaries [
+        gem_name,
+        gem_non_ruby_executables,
+        gem_bin_executables,
+      ]
+    #
+
     contents =<<-ENDHEREDOC
 Gem::Specification.new do |s|
   s.name        = '#{gem_name}'
@@ -5893,22 +6490,28 @@ end
     major_version = memory[:major_version]
 
     gem_name,
-    gem_version,
-    gem_dir,
-    gem_ext,
-    gem_hifen,
-    gem_date,
-    gem_summary,
-    gem_description,
-    gem_authors,
-    gem_email,
-    gem_files,
-    gem_homepage,
-    gem_license,
-    gem_validate_class,
-    gem_validate_class_args,
-    gem_validate_class_method,
-    gem_is_current_file = args
+      gem_version,
+      gem_dir,
+      gem_ext,
+      gem_hifen,
+      gem_date,
+      gem_summary,
+      gem_description,
+      gem_authors,
+      gem_email,
+      gem_files,
+      gem_homepage,
+      gem_license,
+      gem_validate_class,
+      gem_validate_class_args,
+      gem_validate_class_method,
+      gem_is_current_file,
+      gem_bin_generate,
+      gem_bin_contents,
+      gem_executables,
+      gem_dependencies,
+      gem_non_ruby_executables,
+      reserved = args
 
     gem_name ||= "rubyment"
     gem_version ||= (version [])
@@ -5928,20 +6531,28 @@ end
     gem_validate_class ||= self.class.to_s
     gem_validate_class_args ||= {:invoke => ["p", "installed and validated"] }
     gem_validate_class_method ||= "new"
-    gem_is_current_file = __FILE__ # this enables the possibility of building
+    gem_is_current_file ||= __FILE__ # this enables the possibility of building
     #  a gem for the calling file itself, but be aware that lib/gem_file.rb
     # is supposed to be overriden later.
-    gem_bin_generate = "bin/#{gem_name}" # generate a bin file
-    gem_bin_contents =<<-ENDHEREDOC
+    gem_bin_generate ||= "bin/#{gem_name}" # generate a bin file
+    gem_bin_contents ||=<<-ENDHEREDOC
 #!/usr/bin/env ruby
 require '#{gem_name}'
 #{gem_validate_class}.new({:invoke => ARGV})
     ENDHEREDOC
-    gem_executables = [ gem_bin_generate && "#{gem_name}" ]
-    gem_dependencies = [
+    gem_executables ||= [ gem_bin_generate && "#{gem_name}" ]
+    gem_dependencies ||= [
       #  use the format, for gems with semantic versioning
       # ["gems", "~> 0"],
     ]
+    gem_non_ruby_executables ||= [
+      # gem normally can only deploy non_ruby execs.
+      # each file in this array will be escapsulated
+      # as a ruby script that calls that file instead.
+      # that ruby script will be placed in the
+      # bin/ dir, and added to gem_executables
+
+    ]
 
     [
        gem_name,
@@ -5965,6 +6576,7 @@ require '#{gem_name}'
        gem_bin_contents,
        gem_executables,
        gem_dependencies,
+       gem_non_ruby_executables,
    ]
   end
 
@@ -6531,6 +7143,7 @@ require '#{gem_name}'
 
   # test file_backup (just like a copy)
   def test__file_backup args=ARGV
+    require 'fileutils'
     dest_dir, filename, append, prepend, file_contents, user, pw, keep_new  = args
     filename ||= "testing-" + Time.now.hash.abs.to_s + ""
     dest_dir ||= "/tmp/"

metadata

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