ruby_process 0.0.9 → 0.0.13

data/lib/{ruby_process_cproxy.rb → ruby_process/class_proxy.rb}

@@ -1,52 +1,52 @@
-#This class is used to seamlessly use leaky classes without working through 'Ruby_process'.
+#This class is used to seamlessly use leaky classes without working through 'RubyProcess'.
 #===Examples
-#  Ruby_process::Cproxy.run do |data|
+#  RubyProcess::ClassProxy.run do |data|
 #    data[:subproc].static(:Object, :require, "rubygems")
 #    data[:subproc].static(:Object, :require, "rexml/document")
-#    
-#    doc = Ruby_process::Cproxy::REXML::Document.new("test")
+#
+#    doc = RubyProcess::ClassProxy::REXML::Document.new("test")
 #    strio = StringIO.new
 #    doc.write(strio)
 #    puts strio.string #=> "<test/>"
 #    raise "REXML shouldnt be defined?" if Kernel.const_defined?(:REXML)
-class Ruby_process::Cproxy
+class RubyProcess::ClassProxy
   #Lock is used to to create new Ruby-process-instances and not doing double-counts.
   @@lock = Mutex.new
-  
+
   #Counts how many instances are using the Cproxy-module. This way it can be safely unset once no-body is using it again.
   @@instances = 0
-  
-  #This variable will hold the 'Ruby_process'-object where sub-objects will be created.
+
+  #This variable will hold the 'RubyProcess'-object where sub-objects will be created.
   @@subproc = nil
-  
+
   #All use should go through this method to automatically destroy sub-processes and keep track of ressources.
   def self.run
     #Increase count of instances that are using Cproxy and set the subproc-object if not already set.
     @@lock.synchronize do
       #Check if the sub-process is alive.
-      if @@subproc and (!@@subproc.alive? or @@subproc.destroyed?)
+      if @@subproc && (!@@subproc.alive? || @@subproc.destroyed?)
         raise "Cant destroy sub-process because instances are running: '#{@@instances}'." if @@instances > 0
         @@subproc.destroy
         @@subproc = nil
       end
-      
+
       #Start a new subprocess if none is defined and active.
-      if !@@subproc
-        subproc = Ruby_process.new(:title => "ruby_process_cproxy", :debug => false)
+      unless @@subproc
+        subproc = RubyProcess.new(title: "ruby_process_cproxy", debug: false)
         subproc.spawn_process
         @@subproc = subproc
       end
-      
+
       @@instances += 1
     end
-    
+
     begin
-      yield(:subproc => @@subproc)
+      yield(subproc: @@subproc)
       raise "'run'-caller destroyed sub-process. This shouldn't happen." if @@subproc.destroyed?
     ensure
       @@lock.synchronize do
         @@instances -= 1
-        
+
         if @@instances <= 0
           begin
             @@subproc.destroy
@@ -58,49 +58,49 @@ class Ruby_process::Cproxy
       end
     end
   end
-  
-  #Returns the 'Ruby_process'-object or raises an error if it has not been set.
+
+  #Returns the 'RubyProcess'-object or raises an error if it has not been set.
   def self.subproc
-    raise "CProxy process not set for some reason?" if !@@subproc
+    raise "CProxy process not set for some reason?" unless @@subproc
     return @@subproc
   end
-  
+
   #Destroy all loaded sub-process-constants.
   def self.destroy_loaded_constants
     self.constants.each do |constant|
       self.__send__(:remove_const, constant)
     end
   end
-  
-  #Creates the new constant under the 'Ruby_process::Cproxy'-namespace.
+
+  #Creates the new constant under the 'RubyProcess::ClassProxy'-namespace.
   def self.const_missing(name)
-    Ruby_process::Cproxy.load_class(self, name) if !self.const_defined?(name)
-    raise "Still not created on const: '#{name}'." if !self.const_defined?(name)
+    RubyProcess::ClassProxy.load_class(self, name) unless const_defined?(name)
+    raise "Still not created on const: '#{name}'." unless const_defined?(name)
     return self.const_get(name)
   end
-  
+
   #Loads a new class to the given constants namespace for recursive creating of missing classes.
   def self.load_class(const, name)
     const.const_set(name, Class.new{
       #Use 'const_missing' to auto-create missing sub-constants recursivly.
       def self.const_missing(name)
-        Ruby_process::Cproxy.load_class(self, name) if !self.const_defined?(name)
-        raise "Still not created on const: '#{name}'." if !self.const_defined?(name)
+        RubyProcess::ClassProxy.load_class(self, name) unless const_defined?(name)
+        raise "Still not created on const: '#{name}'." unless self.const_defined?(name)
         return self.const_get(name)
       end
-      
+
       #Manipulate 'new'-method return proxy-objects instead of real objects.
       def self.new(*args, &blk)
-        name_match = self.name.to_s.match(/^Ruby_process::Cproxy::(.+)$/)
+        name_match = self.name.to_s.match(/^RubyProcess::ClassProxy::(.+)$/)
         class_name = name_match[1]
-        return Ruby_process::Cproxy.subproc.new(class_name, *args, &blk)
+        return RubyProcess::ClassProxy.subproc.new(class_name, *args, &blk)
       end
-      
+
       def self.method_missing(method_name, *args, &blk)
-        name_match = self.name.to_s.match(/^Ruby_process::Cproxy::(.+)$/)
+        name_match = self.name.to_s.match(/^RubyProcess::ClassProxy::(.+)$/)
         class_name = name_match[1]
-        return Ruby_process::Cproxy.subproc.static(class_name, method_name, *args, &blk)
+        return RubyProcess::ClassProxy.subproc.static(class_name, method_name, *args, &blk)
       end
     })
   end
-end
+end

data/lib/{ruby_process_proxyobj.rb → ruby_process/proxy_object.rb}

@@ -1,37 +1,37 @@
 #This class handels the calling of methods on objects in the other process seamlessly.
-class Ruby_process::Proxyobj
+class RubyProcess::ProxyObject
   #Hash that contains various information about the proxyobj.
   attr_reader :__rp_rp, :__rp_id, :__rp_pid
-  
-  #Constructor. This should not be called manually but through a running 'Ruby_process'.
+
+  #Constructor. This should not be called manually but through a running 'RubyProcess'.
   #===Examples
-  # proxy_obj = rp.new(:String, "Kasper") #=> <Ruby_process::Proxyobj>
-  # proxy_obj = rp.static(:File, :open, "/tmp/somefile") #=> <Ruby_process::Proxyobj>
+  # proxy_obj = rp.new(:String, "Kasper") #=> <RubyProcess::ProxyObject>
+  # proxy_obj = rp.static(:File, :open, "/tmp/somefile") #=> <RubyProcess::ProxyObject>
   def initialize(rp, id, pid)
     @__rp_rp, @__rp_id, @__rp_pid = rp, id, pid
   end
-  
+
   #Returns the object as the real object transfered by using the marshal-lib.
   #===Examples
-  # str = rp.new(:String, "Kasper") #=> <Ruby_process::Proxyobj>
+  # str = rp.new(:String, "Kasper") #=> <RubyProcess::ProxyObject>
   # str.__rp_marshal #=> "Kasper"
   def __rp_marshal
-    return Marshal.load(@__rp_rp.send(:cmd => :obj_marshal, :id => @__rp_id))
+    return Marshal.load(@__rp_rp.send(cmd: :obj_marshal, id: @__rp_id))
   end
-  
+
   #Unsets all data on the object.
   def __rp_destroy
     @__rp_id = nil, @__rp_rp = nil, @__rp_pid = nil
   end
-  
+
   #Overwrite certain convert methods.
   RUBY_METHODS = [:to_i, :to_s, :to_str, :to_f]
   RUBY_METHODS.each do |method_name|
     define_method(method_name) do |*args, &blk|
-      return @__rp_rp.send(:cmd => :obj_method, :id => @__rp_id, :method => method_name, :args => args, &blk).__rp_marshal
+      return @__rp_rp.send(cmd: :obj_method, id: @__rp_id, method: method_name, args: args, &blk).__rp_marshal
     end
   end
-  
+
   #Overwrite certain methods.
   PROXY_METHODS = [:send]
   PROXY_METHODS.each do |method_name|
@@ -39,17 +39,17 @@ class Ruby_process::Proxyobj
       self.method_missing(method_name, *args, &blk)
     end
   end
-  
+
   #Proxies all calls to the process-object.
   #===Examples
-  # str = rp.new(:String, "Kasper") #=> <Ruby_process::Proxyobj::1>
-  # length_int = str.length #=> <Ruby_process::Proxyobj::2>
+  # str = rp.new(:String, "Kasper") #=> <RubyProcess::ProxyObject::1>
+  # length_int = str.length #=> <RubyProcess::ProxyObject::2>
   # length_int.__rp_marshal #=> 6
   def method_missing(method, *args, &block)
     debug "Method-missing-args-before: #{args} (#{@__rp_pid})\n" if @debug
     real_args = @__rp_rp.parse_args(args)
     debug "Method-missing-args-after: #{real_args}\n" if @debug
-    
-    return @__rp_rp.send(:cmd => :obj_method, :id => @__rp_id, :method => method, :args => real_args, &block)
+
+    return @__rp_rp.send(cmd: :obj_method, id: @__rp_id, method: method, args: real_args, &block)
   end
-end
+end

data/ruby_process.gemspec

@@ -2,27 +2,30 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: ruby_process 0.0.13 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "ruby_process"
-  s.version = "0.0.9"
+  s.version = "0.0.13"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Kasper Johansen"]
-  s.date = "2013-12-10"
+  s.date = "2015-04-06"
   s.description = "A framework for spawning and communicating with other Ruby-processes"
   s.email = "k@spernj.org"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
     ".rspec",
     "Gemfile",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
+    "RubyProcess.gemspec",
     "VERSION",
     "cmds/blocks.rb",
     "cmds/marshal.rb",
@@ -31,16 +34,18 @@ Gem::Specification.new do |s|
     "cmds/static.rb",
     "cmds/str_eval.rb",
     "cmds/system.rb",
+    "examples/example_csv.rb",
     "examples/example_file_write.rb",
     "examples/example_knj_db_dump.rb",
     "examples/example_strscan.rb",
     "include/args_handeling.rb",
     "lib/ruby_process.rb",
-    "lib/ruby_process_cproxy.rb",
-    "lib/ruby_process_proxyobj.rb",
+    "lib/ruby_process/class_proxy.rb",
+    "lib/ruby_process/proxy_object.rb",
     "ruby_process.gemspec",
     "scripts/ruby_process_script.rb",
-    "spec/cproxy_spec.rb",
+    "shippable.yml",
+    "spec/class_proxy_spec.rb",
     "spec/hard_load_spec.rb",
     "spec/leaks_spec.rb",
     "spec/ruby_process_spec.rb",
@@ -48,16 +53,16 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/kaspernj/ruby_process"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "2.4.0"
   s.summary = "A framework for spawning and communicating with other Ruby-processes"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<wref>, [">= 0"])
       s.add_runtime_dependency(%q<tsafe>, [">= 0"])
+      s.add_runtime_dependency(%q<string-cases>, [">= 0"])
       s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
@@ -65,6 +70,7 @@ Gem::Specification.new do |s|
     else
       s.add_dependency(%q<wref>, [">= 0"])
       s.add_dependency(%q<tsafe>, [">= 0"])
+      s.add_dependency(%q<string-cases>, [">= 0"])
       s.add_dependency(%q<rspec>, ["~> 2.8.0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, [">= 1.0.0"])
@@ -73,6 +79,7 @@ Gem::Specification.new do |s|
   else
     s.add_dependency(%q<wref>, [">= 0"])
     s.add_dependency(%q<tsafe>, [">= 0"])
+    s.add_dependency(%q<string-cases>, [">= 0"])
     s.add_dependency(%q<rspec>, ["~> 2.8.0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
     s.add_dependency(%q<bundler>, [">= 1.0.0"])

data/scripts/ruby_process_script.rb

@@ -25,13 +25,13 @@ end
 debug = true if ARGV.index("--debug") != nil
 raise "No PID given of parent process." if !pid
 
-rps = Ruby_process.new(
-  :in => $stdin,
-  :out => $stdout,
-  :err => $stderr,
-  :debug => debug,
-  :pid => pid
+rps = RubyProcess.new(
+  in: $stdin,
+  out: $stdout,
+  err: $stderr,
+  debug: debug,
+  pid: pid
 )
 rps.listen
 $stdout.puts("ruby_process_started")
-rps.join
+rps.join

data/shippable.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.2
+script:
+  - CODECLIMATE_REPO_TOKEN=32061319cc6d2e0bd0d0eb88afdc6d7b68829b357ca76efb99f86d7a1a89539e bundle exec rspec
+notifications:
+  email: false

data/spec/class_proxy_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe "RubyProcess" do
+  it "should be able to do quick in-and-outs without leaking" do
+    ts = []
+
+    1.upto(2) do |tcount|
+      ts << Thread.new do
+        1.upto(10) do
+          RubyProcess::ClassProxy.run do |data|
+            sp = data[:subproc]
+            str = sp.new(:String, "Wee")
+            str.__rp_marshal.should eq "Wee"
+          end
+        end
+      end
+    end
+
+    ts.each do |thread|
+      thread.join
+    end
+  end
+
+  it "should be able to do basic stuff" do
+    require "stringio"
+
+    RubyProcess::ClassProxy.run do |data|
+      data[:subproc].static(:Object, :require, "rubygems")
+      data[:subproc].static(:Object, :require, "rexml/document")
+
+      doc = RubyProcess::ClassProxy::REXML::Document.new
+      doc.add_element("test")
+
+      strio = StringIO.new
+      doc.write(strio)
+
+      Kernel.const_defined?(:REXML).should eq false
+      strio.string.should eq "<test/>"
+    end
+  end
+
+  it "should be able to do multiple calls at once" do
+    ts = []
+
+    0.upto(9) do |tcount|
+      ts << Thread.new do
+        RubyProcess::ClassProxy.run do |data|
+          sp = data[:subproc]
+          sp.new(:String, "Wee")
+
+          1.upto(250) do
+            str = sp.new(:String, "Kasper Johansen")
+
+            str.__rp_marshal.should include "Kasper"
+            str << " More"
+
+            str.__rp_marshal.should include "Johansen"
+            str << " Even more"
+
+            str.__rp_marshal.should_not include "Christina"
+            str << " Much more"
+          end
+        end
+      end
+    end
+
+    count = 0
+    ts.each do |t|
+      count += 1
+      #puts "Thread #{count}"
+      t.join
+    end
+  end
+
+  it "should not leak" do
+    str = "kasper"
+    str = nil
+    sleep 0.1
+    GC.start
+    sleep 0.1
+
+    count_objs = 0
+    ObjectSpace.each_object(RubyProcess) do |obj|
+      count_objs += 1
+    end
+
+    count_proxy_objs = 0
+    ObjectSpace.each_object(RubyProcess::ProxyObject) do |obj|
+      count_proxy_objs += 1
+    end
+
+    count_objs.should be <= 1
+    RubyProcess::ClassProxy.constants.empty?.should eq true
+  end
+end

data/spec/hard_load_spec.rb

@@ -2,38 +2,34 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "RubyProcess" do
   it "should be able to do basic stuff" do
-    Ruby_process::Cproxy.run do |data|
+    RubyProcess::ClassProxy.run do |data|
       sp = data[:subproc]
       sp.new(:String, "Wee")
-      
+
       ts = []
-      
+
       1.upto(50) do |tcount|
         ts << Thread.new do
           1.upto(250) do
             str = sp.new(:String, "Kasper Johansen")
-            
-            res1 = str.include?("Kasper")
+
+            str.__rp_marshal.should eq "Kasper Johansen"
             str << " More"
-            
-            res2 = str.include?("Johansen")
+
+            str.__rp_marshal.should include "Johansen"
             str << " Even more"
-            
-            res3 = str.include?("Christina")
+
+            str.__rp_marshal.should_not include "Christina"
             str << " Much more"
-            
-            raise "Expected res1 to be true but it wasnt: '#{res1}'." if res1 != true
-            raise "Expected res2 to be true but it wasnt: '#{res2}'." if res2 != true
-            raise "Expected res3 to be false but it wasnt: '#{res3}'." if res3 != false
-            
-            #print "."
+
+            str.__rp_marshal.should eq "Kasper Johansen More Even more Much more"
           end
         end
       end
-      
+
       ts.each do |t|
         t.join
       end
     end
   end
-end
+end