rubyment 0.5.25471659 → 0.6.25484655

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 048e8eae5ac557122a9a5e74a3019c29768cf1c5
-  data.tar.gz: 7ad419465aab2718f75be44c706f435a326313ab
+  metadata.gz: 10899b656c79527134e55de8433e25dd800660c1
+  data.tar.gz: 1ebc15afed675c406830ebca48e68ff683a1f3eb
 SHA512:
-  metadata.gz: 218c7e8b2b10503986b12b7a0d0b0411f4dfb9c910614b8535e9608241884bbe57efbd0cb558347c057d4bf3580a6dd6e1fcc719ed0d8288bd84f86eda17deba
-  data.tar.gz: 398b1b171d911c3f79e9040e05e10429f34265690b3749acd44ec32aaa757ce380dfd6ff768c872599d6a8bff2af1804a7ed6ad5ee600b0382bdbc138a994aa8
+  metadata.gz: 40061cd1e9adb1331d22821109720eab4313b40af0da7605d06ebb10dd9745bebab219f8c2cba250e910d279f66a5f0711b0b496075f8869258b75b81764ed42
+  data.tar.gz: 778db1047917e439d7a75bcaec5c87bc90f9a762511b753fa9a847b83cc2666de94411b9460639def90aa73547c73fded6109f7850971b023e8b73aab6ef1f49

data/lib/rubyment.rb

@@ -1,5 +1,34 @@
 #!/usr/bin/env ruby
 
+
+class String
+  # checks if string is non neutral element.
+  #
+  # data from shell input can't be nil
+  # it will be an "" string. this
+  # function interprets "" as false
+  #
+  # @return [String, nil] self or nil
+  def nne
+    !self.empty? && self || nil
+  end
+end
+
+
+class Fixnum
+  # checks if Fixnum is non neutral element.
+  #
+  # data from shell input can't be nil
+  # it will be an 0 string. this
+  # function interprets 0 as false
+  #
+  # @return [Fixnum, nil] self or nil
+  def nne
+    !self.zero? && self || nil
+  end
+end
+
+
 # Collection of Ruby functions
 # * output
 # normally outputs to STDERR, with
@@ -22,6 +51,101 @@ class Rubyment
   end
 
 
+  # creates a Proc out of a block
+  def bl *args, &block
+    block ||= lambda {}
+    # Proc.new &block
+    Proc.new { block.call  *args }
+  end
+
+
+  # creates a Proc out of a block,
+  # will capture all exceptions
+  # inside that block and ignore it
+  # returns nil
+  def blef *args, &block
+    # bl exception free
+    block ||= lambda {}
+    bl {
+      begin
+        block.call *args
+      rescue => e
+      end
+    }
+  end
+
+
+  # creates a Proc out of a block,
+  # will capture all exceptions
+  # inside that block and ignore it
+  # will return an array having
+  # the backtrace (as String) as
+  # the first member and the
+  # the exception as the second.
+  def bloe *args, &block
+    block ||= lambda {}
+    bl {
+      begin
+        block.call *args
+      rescue => e
+        stderr = @memory[:stderr]
+        rv = [e.backtrace.join("\n"), e]
+        stderr.puts "#{__method__} exception backtrace:"
+        stderr.puts rv[0]
+        stderr.puts "#{__method__} exception message:"
+        stderr.puts rv[1]
+        rv
+      end
+    }
+  end
+
+
+  #  runs a block error free
+  # (returns nil if exception happens)
+  def runef *args, &block
+    (blef &block).call *args
+  end
+
+
+  #  runs a block error free, in
+  # a different Thread. the Thread object
+  #  is returned (call .join on it to
+  # wait for its completion)
+  # (the Thread itself returns nil if exception happens)
+  def runef_threaded *args, &block
+    Thread.start(*args) {|*args|
+      runef *args, &block
+    }
+  end
+
+
+  # runs a block error free
+  # (if exception happens,
+  # will return an array having
+  # the backtrace (as String) as
+  # the first member and the
+  # the Exception object as the second).
+  def runoe *args, &block
+    (bloe &block).call *args
+  end
+
+
+  # runs a block error free, in
+  # a different Thread. the Thread object
+  # is returned (call .join on it to
+  # wait for its completion)
+  # (if exception happens, the thread
+  # itself will return an array having
+  # the backtrace (as String) as
+  # the first member and the
+  # the Exception object as the second).
+  def runoe_threaded *args, &block
+    Thread.start(*args) {|*args|
+      runoe *args, &block
+    }
+  end
+
+
   # invoke first arg with following args
   # used by initialize
   def invoke args=ARGV
@@ -60,7 +184,7 @@ class Rubyment
       :stdout => STDOUT,
       :stdin  => STDIN,
       :time   => Time.now,
-      :major_version => "0.5",
+      :major_version => "0.6",
       :basic_version => (Time.now.to_i  / 60), # new one every minute
       :filepath => __FILE__,
       :running_dir => Dir.pwd,
@@ -70,6 +194,7 @@ class Rubyment
       :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]
     }
     @memory.update memory.to_h
     invoke @memory[:invoke].to_a
@@ -115,30 +240,81 @@ class Rubyment
   end
 
 
+  # reads a uri (if 'open-uri' available, otherwise, just do a normal File.read)
+  # @param [Array] args, an +Array+ whose elements are expected to be:
+  # +uri+:: [String, nil] uri or path of the file
+  # +username+:: [String] basic http authentication username
+  # +password+:: [String] basic http authentication password
+  # +return_on_rescue+:: [Object] a default to return in the case of exceptions raised
+  # +return_on_directory_given+:: [Object] a default to return in the case uri is a directory. Defaults to true
+  #
+  # @return [String, Object] read data (or +return_on_rescue+)
+  def file_read args=ARGV
+    uri, username, password, return_on_rescue, return_on_directory_given = args
+    (require 'open-uri') && open_uri = true
+    file_is_directory = File.directory?(uri)
+    return_on_directory_given ||= true
+    contents = !(file_is_directory) && open_uri &&  (
+      begin
+        open(uri, :http_basic_authentication => [username, password]).read
+      rescue  => e
+        return_on_rescue
+      end
+    ) || (!open_uri) && (
+      begin
+        File.read uri
+      rescue  => e
+        return_on_rescue
+      end
+    ) || (file_is_directory) && (return_on_directory_given)
+  end
+
+
   # if file is a nonexisting filepath, or by any reason
   # throws any exception, it will be treated as contents
   # instead, and the filename will treated as ""
   # file can be a url, if 'open-uri' is available.
-  def file_backup file = __FILE__ , dir = '/tmp/', append = ('-' + Time.now.hash.abs.to_s), prepend='/'
+  # extension: before file couldn't be a directory. now it can.
+  # planned improvement: use file_read instead
+  # @param [Array] args, an +Array+ whose elements are expected to be:
+  # +file+:: [String] uri or path of the file
+  # +dir+:: [String] dir where to backup file
+  # +append+:: [String] append this string to the end of file
+  # +prepend+:: [String] append this string to the beginning of file
+  # +permissions+:: [Integer, nil] writes the file with this mode  (preserves if nil)
+  # @return [String] file contents
+  def file_backup file = __FILE__ , dir = '/tmp/', append = ('-' + Time.now.hash.abs.to_s), prepend='/', permissions = nil
+  default_permissions = 0755
     stderr = @memory[:stderr]
     debug  = @memory[:debug]
     (require 'open-uri') && open_uri = true
     require 'fileutils'
     file_is_filename = true
-    open_uri && (
+    file_is_directory = File.directory?(file)
+    open_uri && (!file_is_directory) && (
       contents = open(file).read rescue  (file_is_filename = false) || file
-    ) || (
+    ) || (!file_is_directory) && (
       contents = File.read file rescue  (file_is_filename = false) || file
     )
     debug && (stderr.puts "location = dir:#{dir} + prepend:#{prepend} + (#{file_is_filename} && #{file} || '' ) + #{append}")
     location = dir + prepend + (file_is_filename && file || '' ) + append
     debug && (stderr.puts "FileUtils.mkdir_p File.dirname #{location}")
     FileUtils.mkdir_p File.dirname location # note "~" doesn't work
-    File.write location, contents
+    file_is_directory && FileUtils.mkdir_p(location) || (
+      File.write location, contents
+    )
+    permissions ||= file_permissions_octal file
+    File.chmod permissions, location
     contents
   end
 
 
+  # same interface as file_backup, but append and prepend defaults are empty.
+  def  file_copy file = __FILE__, dir = '/tmp/', append = '', prepend='', permissions = nil
+    file_backup file, dir, append, prepend, default_permissions
+  end
+
+
   # returns a string having the current backtrace, for debugging.
   def backtrace
     Thread.current.backtrace.join("\n")
@@ -163,7 +339,7 @@ class Rubyment
   # [ name (String), object (Object) ]
   # returns:
   #  method_object (Method)
-  def to_method args=ARGV
+  def to_object_method args=ARGV
     stderr = @memory[:stderr]
     name, object = containerize args
     begin
@@ -189,7 +365,7 @@ class Rubyment
     stderr = @memory[:stderr]
     method, object, *call_args = containerize args
     object ||= self
-    method = to_method [method, object]
+    method = to_object_method [method, object]
     call_args = call_args && (containerize call_args)
     begin
       call_args && (method.call *call_args) || method.call
@@ -404,8 +580,6 @@ class Rubyment
     stdin  = @memory[:stdin]
     static_separator_key_per_execution = @memory[:static_separator_key_per_execution]
     require "io/console"
-    # puts backtrace
-    # p args.map {|e| e.to_s[0..15] }
     stderr.print "multiline[enter + control-D to stop]:"
     args.shift.to_s.b.split(static_separator_key_per_execution).first || stdin.noecho{ stdin.readlines}.join.chomp
   end
@@ -1822,6 +1996,345 @@ require '#{gem_name}'
   end
 
 
+  # test file_backup when file is a dir
+  def test__file_backup__when_file_is_dir args=ARGV
+    require 'fileutils'
+    dest_dir, filename, append, prepend, keep_new = args
+    filename ||= "testing-" + Time.now.hash.abs.to_s + ""
+    dest_dir ||= "/tmp/"
+    append ||= ""
+    prepend ||= ""
+    filename  += "/"
+    expected_new_dir = dest_dir + filename
+    existing_dir = (file_read [filename, nil, nil, nil])
+    FileUtils.mkdir_p filename
+    file_backup filename, dest_dir, append, prepend
+    filename_test = File.directory? filename
+    expected_new_dir_test = File.directory? expected_new_dir
+    original_permissions = file_permissions_octal filename
+    new_permissions = file_permissions_octal expected_new_dir
+    judgement =
+      [
+        [filename_test, expected_new_dir_test, "File.directory?"],
+        [original_permissions, new_permissions, "file_permissions"],
+      ].map(&method("expect_equal")).all?
+    (!existing_dir) && (FileUtils.rmdir filename)
+    (!keep_new) && (FileUtils.rmdir expected_new_dir)
+  end
+
+
+  # test file_backup (just like a copy)
+  def test__file_backup args=ARGV
+    dest_dir, filename, append, prepend, file_contents, user, pw, keep_new  = args
+    filename ||= "testing-" + Time.now.hash.abs.to_s + ""
+    dest_dir ||= "/tmp/"
+    append ||= ""
+    prepend ||= ""
+    expected_new_filename = dest_dir + filename
+    existing_file = (file_read [filename, nil, user, pw])
+    file_contents ||=  existing_file || "contents_of:#{filename}"
+    File.write filename, file_contents
+    file_backup filename, dest_dir, append, prepend
+    new_file_contents = File.read expected_new_filename
+    original_permissions = file_permissions_octal filename
+    new_permissions = file_permissions_octal expected_new_filename
+    judgement =
+      [
+        [file_contents, new_file_contents, "file_contents"],
+        [original_permissions, new_permissions, "file_permissions"],
+      ].map(&method("expect_equal")).all?
+    (!existing_file) && (FileUtils.rm filename)
+    (!keep_new) && (FileUtils.rm expected_new_filename)
+  end
+
+
+  # same as test__file_backup__when_file_is_dir, but backup is not removed.
+  def test__file_backup__when_file_is_dir__but_keep args=ARGV
+    dest_dir, filename, append, prepend, dont_keep_new = args
+    test__file_backup__when_file_is_dir [dest_dir, filename, append, prepend, !dont_keep_new]
+  end
+
+
+  # same as test__file_backup, but backup is not removed.
+  def test__file_backup__but_keep args=ARGV
+    dest_dir, filename, append, prepend, file_contents, user, pw, dont_keep_new  = args
+    test__file_backup [dest_dir, filename, append, prepend, file_contents, user, pw, !dont_keep_new]
+  end
+
+
+  # returns a method object out of a string or a method object,
+  # in a polymorphic style.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +method_name_or_method+:: [String, Method] method name or method object
+  #
+  # @return [Method] a method
+  def to_method args = ARGV
+    method_name_or_method, reserved = args
+    method_name_or_method.respond_to?(:call) && method_name_or_method || method(method_name_or_method)
+  end
+
+
+  # echoes the processing arg
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +processing_arg+:: [String]
+  #
+  # @return [String] +processing_arg+
+  def echo args = ARGV
+    args.first
+  end
+
+
+  # calls a function with the processing arg
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +processing_arg+:: [Object]
+  # +method+:: [Method, String]
+  # +method_args+:: [Method, String]
+  #
+  # @return [String] +processing_arg+
+  def transform_call args = ARGV
+    processing_arg, method, method_args = args
+    to_method(
+      [method]).call(
+        [processing_arg] + method_args
+    )
+  end
+
+
+  # returns an HTTP response (1.1 200 OK by default)
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +response+:: [String, nil] response payload (default empty)
+  # +content_type+:: [String, nil] mime type of payload (default +text/plain+)
+  # +version+:: [String, nil] http protocol version (+1.1+ by default)
+  # +code+:: [String, nil] response code (+"200 OK"+ by default)
+  # +eol+:: [String, nil]
+  #
+  # @return [String] http_response
+  def http_OK_response args = ARGV
+    payload, content_type, code, version, eol = args
+    payload ||= ""
+    content_type ||= "text/plain"
+    version ||= "1.1"
+    code ||= "200 OK"
+    eol ||= "\r\n"
+    [
+      "HTTP/#{version} #{code}",
+      "Content-Type: #{content_type};" +
+        " charset=#{payload.encoding.name.downcase}",
+      "Content-Length: #{payload.bytesize}",
+      !keep_alive && "Connection: close"
+    ].join eol
+  end
+
+
+  # will call #gets on  +io+ until line starts with +happy_with_request+
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +io+:: [IO] any +IO+, like a +Socket+, returned by #TCPServer::accept
+  # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +happy_with_request+:: [String, nil] if nil, +eol+ is used.
+  # +eol+:: [String] end of line
+  #
+  # @return [Array] array of strings having the lines read from the IO.
+  def io_gets args = ARGV
+    io, debug, happy_with_request = args
+    happy_with_request ||= "\r\n"
+    stderr = @memory[:stderr]
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug.nne && (stderr.puts args.inspect)
+    lines = []
+    (1..Float::INFINITY).
+      lazy.map {|i|
+        r = lines.push(io.gets).last
+        debug.nne && (stderr.puts r)
+	r.index(happy_with_request.to_s).to_i.nne && r
+      }.find {|x| !x }
+    debug.nne && (stderr.puts lines.inspect)
+    debug.nne && (stderr.puts "#{__method__} returning")
+    lines
+  end
+
+
+  # gets and forwards the input from one IO to a list of IOs
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +ios_out+:: [Array] array of +IO+, where data will be written to.
+  # +io_in+:: [IO] any +IO+, like a +Socket+, returned by #TCPServer::accept, where data will be read from.
+  # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +happy_with_request+:: [String, nil] if nil, +eol+ is used.
+  #
+  # @return [nil]
+  def io_forward args = ARGV
+
+    ios_out,
+      io_in,
+      debug,
+      happy_with_request,
+      reserved,
+      processing_method,
+      processing_method_args = args
+    io_gets_args = [io_in, debug, happy_with_request]
+    stderr = @memory[:stderr]
+    debug.nne && (stderr.puts "#{__method__} starting")
+    debug.nne && (stderr.puts args.inspect)
+    input = io_gets io_gets_args
+    debug.nne && (stderr.puts input.inspect)
+    debug.nne && (stderr.puts ios_out.class.inspect)
+    processing_method ||= :echo
+    processing_method_args ||= []
+    processed_input = to_method(
+      [processing_method]).call(
+        [input] + processing_method_args
+    )
+    ios_out.map{ |shared_io_out|
+      runoe_threaded(shared_io_out) {|io_out|
+	io_out = shared_io_out
+        io_out.puts processed_input
+        debug.nne && (
+          stderr.puts "#{io_out}: response writen."
+        )
+        io_out.close
+        debug.nne && (
+          stderr.puts "#{io_out}: IO closed."
+        )
+
+      }
+    }
+    debug.nne && (stderr.puts "#{__method__} returning")
+    nil
+  end
+
+
+  # gets and puts
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +io+:: [IO] any +IO+, like a +Socket+, returned by #TCPServer::accept
+  # +method_name_or_method+:: [String, Method] method name or method object
+  # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +happy_with_request+:: [String, nil] if nil, +eol+ is used.
+  #
+  # @return [nil]
+  def io_echo args = ARGV
+    io, debug, happy_with_request, reserved = args
+    stderr = @memory[:stderr]
+    debug.nne && (stderr.puts "#{__method__} starting")
+    # io_forward [[io], io, debug, happy_with_request, reserved, :echo, []]
+    io_forward [[io], io, debug, happy_with_request, reserved,
+      :gsub!, [" ", "_"]
+    ]
+    nil
+  end
+
+
+  # writes a response to an IO (e.g.: socket)
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +method_name_or_method+:: [String, Method] method name or method object
+  # +debug+:: [Object] if evals to false (or empty string), won't print debug information
+  # +reserved+:: [Object] for future use
+  # +args_for_http_OK_response+:: [splat] args to be forwarded to #http_OK_response (check it for specification)
+  #
+  # @return [nil]
+  def io_http_OK_response args = ARGV
+    io, debug, reserved, *args_for_http_OK_response = args
+    stderr = @memory[:stderr]
+    debug.nne && (stderr.puts args.inspect)
+    response = http_OK_response args_for_http_OK_response
+    debug.nne && (
+      stderr.puts response.inspect
+    )
+    io.print response
+    debug.nne && (stderr.puts "response writen.")
+    io.close
+    debug.nne && (stderr.puts "IO closed.")
+    nil
+  end
+
+
+  # opens a TCP server accepting connections.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +listening_port+:: [String, Integer] port to listen
+  # +ip_addr+:: [String, nil] ip (no hostname) to bind the server. 0, nil, false, empty string will bind to all addresses possible.  0.0.0.0 => binds to all ipv4 . ::0 to all ipv4 and ipv6
+  # +reserved+:: [Object] for future use
+  # +debug+:: [Object] for future use
+  # +callback_method+:: [String, Method] method to call when a client connects. The method must accept a socket as parameter.
+  # +callback_method_args+:: [splat] args to be given to the call_back_method
+  #
+  # @return [Thread] returns a Thread object looping for accepting
+  # incoming connections (call join on that object for waiting for its
+  # completion).
+  def tcp_server_plain args = ARGV
+    stderr = @memory[:stderr]
+    listening_port,
+      ip_addr,
+      reserved,
+      debug,
+      callback_method,
+      *callback_method_args = args
+    require 'socket'
+    server = TCPServer.new ip_addr, listening_port
+    debug.nne && (stderr.puts server)
+    Thread.start {
+      loop {
+        Thread.start(server.accept) { |client|
+          debug.nne && (stderr.puts Thread.current)
+          debug.nne && (stderr.puts client)
+          runoe {
+            to_method([callback_method])
+              .call([client] + callback_method_args)
+          }
+        }
+      }
+    }
+  end
+
+
+  # opens a TCP client (TCPsocket) to connect to a server
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  #
+  # @return [nil]
+  def tcp_client_plain args = ARGV
+    listening_port,
+      ip_addr,
+      reserved,
+      debug,
+      callback_method,
+      *callback_method_args = args
+    require 'socket'
+    client = TCPSocket.new ip_addr, listening_port
+=begin
+    Thread.start {
+      to_method([callback_method])
+        .call [client]
+    }
+=end
+  Thread.start {}
+  end
+
+
+  # test for tcp_server_plain
+  def test__tcp_server_plain args = ARGV
+   thread = tcp_server_plain [8003, "0", "", "debug", "io_echo", "debug_io_echo"]
+   thread.join
+  end
+
+
+  # test for tcp_server_plain
+  def test__tcp_server_plain__with_io_http_response args = ARGV
+   thread = tcp_server_plain [
+     8003, # listening_port
+     "0",  # ip_addr: all possible
+     "",   # reserved
+     "debug_tcp_server_plain_arg",
+     "io_http_OK_response",
+     "debug_io_http_OK_response_arg",
+     "reserved_io_http_OK_response_arg",
+     "This is the response payload"
+   ]
+   thread.join
+  end
+
+
+  # test for tcp_server_plain
+  def test__tcp_server_plain__with_io_http_response args = ARGV
+  end
+
+
 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.5.25471659
+  version: 0.6.25484655
 platform: ruby
 authors:
 - Ribamar Santarosa