statsailr 0.7.1

data/example/new_mtcars.csv

@@ -0,0 +1,33 @@
+"","mpg","cyl","disp","hp","drat","wt","qsec","vs","am","gear","carb","powerful"
+"Mazda RX4",21,6,160,110,3.9,2.62,16.46,0,1,4,4,1
+"Mazda RX4 Wag",21,6,160,110,3.9,2.875,17.02,0,1,4,4,1
+"Datsun 710",22.8,4,108,93,3.85,2.32,18.61,1,1,4,1,0
+"Hornet 4 Drive",21.4,6,258,110,3.08,3.215,19.44,1,0,3,1,1
+"Hornet Sportabout",18.7,8,360,175,3.15,3.44,17.02,0,0,3,2,1
+"Valiant",18.1,6,225,105,2.76,3.46,20.22,1,0,3,1,1
+"Duster 360",14.3,8,360,245,3.21,3.57,15.84,0,0,3,4,1
+"Merc 240D",24.4,4,146.7,62,3.69,3.19,20,1,0,4,2,0
+"Merc 230",22.8,4,140.8,95,3.92,3.15,22.9,1,0,4,2,0
+"Merc 280",19.2,6,167.6,123,3.92,3.44,18.3,1,0,4,4,1
+"Merc 280C",17.8,6,167.6,123,3.92,3.44,18.9,1,0,4,4,1
+"Merc 450SE",16.4,8,275.8,180,3.07,4.07,17.4,0,0,3,3,1
+"Merc 450SL",17.3,8,275.8,180,3.07,3.73,17.6,0,0,3,3,1
+"Merc 450SLC",15.2,8,275.8,180,3.07,3.78,18,0,0,3,3,1
+"Cadillac Fleetwood",10.4,8,472,205,2.93,5.25,17.98,0,0,3,4,1
+"Lincoln Continental",10.4,8,460,215,3,5.424,17.82,0,0,3,4,1
+"Chrysler Imperial",14.7,8,440,230,3.23,5.345,17.42,0,0,3,4,1
+"Fiat 128",32.4,4,78.7,66,4.08,2.2,19.47,1,1,4,1,0
+"Honda Civic",30.4,4,75.7,52,4.93,1.615,18.52,1,1,4,2,0
+"Toyota Corolla",33.9,4,71.1,65,4.22,1.835,19.9,1,1,4,1,0
+"Toyota Corona",21.5,4,120.1,97,3.7,2.465,20.01,1,0,3,1,0
+"Dodge Challenger",15.5,8,318,150,2.76,3.52,16.87,0,0,3,2,1
+"AMC Javelin",15.2,8,304,150,3.15,3.435,17.3,0,0,3,2,1
+"Camaro Z28",13.3,8,350,245,3.73,3.84,15.41,0,0,3,4,1
+"Pontiac Firebird",19.2,8,400,175,3.08,3.845,17.05,0,0,3,2,1
+"Fiat X1-9",27.3,4,79,66,4.08,1.935,18.9,1,1,4,1,0
+"Porsche 914-2",26,4,120.3,91,4.43,2.14,16.7,0,1,5,2,0
+"Lotus Europa",30.4,4,95.1,113,3.77,1.513,16.9,1,1,5,2,0
+"Ford Pantera L",15.8,8,351,264,4.22,3.17,14.5,0,1,5,4,1
+"Ferrari Dino",19.7,6,145,175,3.62,2.77,15.5,0,1,5,6,1
+"Maserati Bora",15,8,301,335,3.54,3.57,14.6,0,1,5,8,1
+"Volvo 142E",21.4,4,121,109,4.11,2.78,18.6,1,1,4,2,0

data/example/plot_reg_example.slr

@@ -0,0 +1,55 @@
+// comment
+/*
+ multipe line comments 
+*/
+
+READ builtin = "mtcars"
+
+DATA new_mtcars set=mtcars
+if(cyl > 4){
+  powerful = 1
+}else{
+  powerful = 0
+}
+END
+
+PROC PRINT data=new_mtcars
+  head 10
+  tail
+  tail / n = 10
+END
+
+PROC PLOT data=new_mtcars
+  scatter powerful cyl
+  dev.copy png / file = "scatter.png"
+END
+
+PROC CAT data=new_mtcars
+  /* Calculate frequencies & show in list format
+  */
+  xtabs ~ cyl + powerful 
+  fisher.test
+  chisq.test
+END
+
+PROC UNI data=new_mtcars
+  var cyl carb
+END
+
+
+PROC REG data=new_mtcars
+   lm  hp ~ factor(cyl) + factor(carb)
+END
+
+GETWD
+
+SAVE new_mtcars file="./new_mtcars.csv"
+
+SAVE new_mtcars file="./new_mtcars.rda"
+
+
+// READ builtin = "CO2"
+
+// DATA:SQLDF CO2v2 
+//   SELECT Plant, conc, uptake FROM CO2 WHERE Plant IN ('Qn1','Mn1') ORDER BY uptake
+// END

data/exe/sailr

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+## Parse argumnet and initialize setting
+
+require('optparse')
+opt = OptionParser.new
+params = {}
+new_params = {}
+
+opt.on('--procs-gem VAL')
+opt.parse!(ARGV, into: params)
+
+if params[:"procs-gem"]
+  if params[:"procs-gem"] =~ /[a-zA-Z,_-]+/ 
+    if params[:"procs-gem"].include?( "," )
+      new_params[:"procs_gem"] = params[:"procs-gem"].split(",")
+    else
+      new_params[:"procs_gem"] = params[:"procs-gem"]
+    end
+  else
+    raise "--procs-gem option takes gem name or gem names separated with comma(,)."
+  end
+else
+  # nothing to be specified.
+end
+
+specified_script_path = ARGV[0]
+
+raise "Please spcify StatSailr script path" if( specified_script_path.nil? )
+
+
+## Set path
+
+require('pathname')
+
+if Pathname.new(specified_script_path).relative?
+  $script_file_path = Dir.pwd + "/" + specified_script_path
+else
+  $script_file_path = specified_script_path
+end
+
+raise "StatSailr script file specified does not exist" if ! File.exist?( $script_file_path )
+
+$script_dir_path = File.dirname( $script_file_path )
+
+
+## Run
+
+require("statsailr")
+
+StatSailr.run( **new_params )
+
+
+

data/exe/sailrREPL

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+## Parse argumnet and initialize setting
+
+require 'optparse'
+opt = OptionParser.new
+params = {}
+new_params = {}
+
+opt.on('--thread')
+opt.on('--procs-gem VAL')
+opt.parse!(ARGV, into: params)
+
+fork_or_thread = params[:thread]
+if fork_or_thread
+  new_params[:fork_or_thread] = "thread"
+else
+  new_params[:fork_or_thread] = "fork"
+end
+
+if new_params[:fork_or_thread] == "fork"
+  if Process.respond_to?(:fork)
+    # "fork" is used and system has "fork" implementation.
+  else
+    raise 'fork is not implemented on this system. Please try to run sailrREPL with "--thread" option'
+  end
+end
+
+if params[:"procs-gem"]
+  if params[:"procs-gem"] =~ /[a-zA-Z,_-]+/ 
+    if params[:"procs-gem"].include?( "," )
+      new_params[:"procs_gem"] = params[:"procs-gem"].split(",")
+    else
+      new_params[:"procs_gem"] = params[:"procs-gem"]
+    end
+  else
+    raise "--procs-gem option takes gem name or gem names separated with comma(,)."
+  end
+else
+  # nothing to be specified.
+end
+
+## Main
+
+require("statsailr")
+
+reader, writer = IO.pipe
+
+child_service = StatSailr::Service.start( reader , writer, **new_params )
+
+prompt = "(^^)v: "
+line = ""
+print prompt
+while true
+  line = STDIN.gets()
+  if line.nil? # When C-d
+    puts "C-d : Parent process finishes. Close pipe."
+    writer.close
+    break
+  elsif line =~ /^!exit/
+    puts "!exit : Parent process finishes. Close pipe."
+    writer.close
+    break
+  else
+    writer.write line
+    print prompt
+  end
+end
+
+case fork_or_thread
+when "fork"
+  Process.waitpid(child_service)
+when "thread"
+  child_service.join()
+end

data/lib/statsailr.rb

@@ -0,0 +1,7 @@
+require "statsailr/version"
+require "statsailr/sts_runner.rb"
+require "statsailr/sts_server.rb"
+
+module StatSailr
+  class Error < StandardError; end
+end

data/lib/statsailr/block_builder/sts_block.rb

@@ -0,0 +1,167 @@
+require "r_bridge"
+require_relative "./sts_block_parse_proc_opts.rb"
+
+module BlockSupport
+  def type_adjust(obj , type)
+    case type
+    when :ident
+      if obj.is_a?(String)
+        result = RBridge::SymbolR.new( obj )
+      else
+        raise "GramNode should have string value for type(#{type.to_s})"
+      end
+    when :num
+      if obj.is_a?(Integer) || obj.is_a?(Float)
+        result = obj 
+      else
+        raise "GramNode with inconsistent type(#{type.to_s}) and object(#{obj.class})"
+      end
+    when :string
+      if obj.is_a?(String)
+        result = obj
+      else
+        raise "GramNode with inconsistent type(#{type.to_s}) and object(#{obj.class})"
+      end
+    when :sign
+      if obj.is_a?(String)
+        result = RBridge::SignR.new(obj)
+      else
+        raise "GramNode with inconsistent type(#{type.to_s}) and object(#{obj.class})"
+      end
+    end
+    return result
+  end
+end
+
+class TopStmt
+  extend BlockSupport
+  attr :command, :opts
+
+  def initialize( str, hash )
+    @command = str
+    @opts = hash
+  end
+
+  def self.new_from_gram_node( node )
+    command_name = node.e1
+    top_opts = node.e2
+    if (! top_opts.nil? ) && (top_opts.size != 0 )
+      hash = {}
+      top_opts.each(){|nd|
+        top_opt_key = nd.e1
+        if(!nd.e2.nil?)
+          top_opt_val = type_adjust( nd.e2.e1 , nd.e2.type )
+        else
+          top_opt_val = nil
+        end
+        hash[top_opt_key] = top_opt_val
+      }
+    else
+      hash = {}
+    end
+    return TopStmt.new( command_name, hash)
+  end
+end
+
+class DataBlock
+  extend BlockSupport
+  attr :out, :opts, :script
+
+  def initialize( str, hash, script)
+    @out = str
+    @opts = hash
+    @script = script
+  end
+
+  def self.new_from_gram_node( node )
+    out_df = type_adjust( node.e1.e1, node.e1.type )
+    data_hash = {}
+    data_opts = node.e2
+
+    if ! data_opts.nil?
+      data_opts.each(){|nd|
+        data_opt_key = nd.e1
+        if(!nd.e2.nil?)
+          data_opt_val = type_adjust( nd.e2.e1 , nd.e2.type )
+        else
+          data_opt_val = nil
+        end
+        data_hash[data_opt_key] = data_opt_val
+      }
+    else
+      data_opts = {}
+    end
+
+    data_script = type_adjust( node.e3.e1, node.e3.type )
+
+    return DataBlock.new( out_df , data_hash , data_script)
+  end
+end
+
+class ProcBlock
+  extend BlockSupport
+  attr :command, :opts, :stmts
+
+  def initialize( command, opts, stmts )
+    @command = command
+    @opts = opts
+    @stmts = stmts
+  end
+
+  def self.new_from_gram_node( node )
+    proc_command = type_adjust( node.e1.e1, :string )
+
+    proc_opt_hash = {}
+    proc_opts = node.e2
+    if(! proc_opts.nil?)
+      proc_opts.each(){|nd|
+        proc_opt_key = nd.e1
+        proc_opt_val = type_adjust( nd.e2.e1 , nd.e2.type )
+        proc_opt_hash[proc_opt_key] = proc_opt_val
+      }
+    else
+      proc_opt_hash = {}
+    end
+
+    proc_stmts = []
+
+    proc_stmts_ori = node.e3
+    proc_stmts_ori.each(){|proc_stmt_ori|
+        proc_stmt_inst = ""
+        proc_stmt_arg = []
+        proc_stmt_opt_hash = {}
+
+        proc_stmt_inst = type_adjust( proc_stmt_ori.e1.e1, :string) # String
+        proc_stmt_arg_ori = proc_stmt_ori.e2
+        if ! proc_stmt_arg_ori.nil? then
+          idx = 0
+          while idx < proc_stmt_arg_ori.size() do
+            elem = proc_stmt_arg_ori[idx]
+            if( elem.type == :sign && elem.e1 == "/" )
+              break
+            else
+              x = type_adjust( elem.e1, elem.type )
+              proc_stmt_arg << x
+              idx = idx + 1
+            end
+          end
+          idx = idx + 1
+          if idx < proc_stmt_arg_ori.size()
+
+            proc_stmt_opt_hash = STSBlockParseProcOpts.include(BlockSupport).new(proc_stmt_arg_ori, idx).parse()
+          else
+            proc_stmt_opt_hash = {}
+          end
+        else  # When no arguments (even )
+          prc_stmt_arg = []
+        end
+
+        proc_stmts.push( [proc_stmt_inst, proc_stmt_arg, proc_stmt_opt_hash ] )
+    }
+
+    return ProcBlock.new( proc_command , proc_opt_hash, proc_stmts)
+  end
+
+end
+
+

data/lib/statsailr/block_builder/sts_block_parse_proc_opts.rb

@@ -0,0 +1,168 @@
+class STSBlockParseProcOpts
+
+  def initialize(elems, idx)
+    @size = elems.size
+    @elems = elems
+    @idx = idx
+    @result_hash = Hash.new()
+  end
+
+  def has_next?()
+    if @idx + 1 < @size
+      return true
+    else
+      return false
+    end
+  end
+
+  def next_token()
+    if has_next?
+      @idx = @idx + 1
+      @elems[@idx]
+    else
+      nil
+    end
+  end
+
+  def peek()
+    if has_next?
+      @elems[@idx + 1]
+    else
+      nil
+    end
+  end
+
+  def current_token()
+    @elems[@idx]
+  end
+
+# Entry point
+  def parse()
+    arg_opts()
+    return @result_hash
+  end
+
+# The following grammar is parsed using recursive descent algorithm
+
+# arg_opts : arg_opt
+#          | arg_opts arg_opt
+#
+# arg_opt  : IDENT = primary
+#          | IDENT = array
+#          | IDENT = func 
+#          | IDENT
+#
+# parimary : STRING
+#          | NUM
+#          | IDENT
+#
+# array    : [ elems ]
+#
+# func     : IDENT ( elems )
+#
+# elems    : primary
+#          | elems , primary
+#
+#
+
+  def arg_opts()
+    arg_opt()
+    if has_next?
+      next_token()
+      arg_opts()
+    end
+  end
+
+  def arg_opt()
+    opt_key = ident()
+    if (!peek.nil?) && peek.type == :sign && peek.e1 == "="
+      next_token()  # At = 
+      if peek.type == :sign && peek.e1 == "[" # RHS of = is array
+        next_token() # Now at [
+        opt_value = array()
+      elsif peek.type == :ident # RHS of = is ident, meaning just ident or function 
+        next_token()
+        if (! peek.nil?) && peek.type == :sign && peek.e1 == "("
+          opt_value = func()
+        else
+          opt_value = ident() # According to BNF, this should be parimary(). However, ident() is more direct and makes sense here.
+        end
+      elsif [:string, :num].include? peek.type
+         next_token()
+         opt_value = primary()
+      else
+        p current_token()
+        raise "the token should be :ident or primaries such as :ident, :num and :string after = . Current token: " + current_token().type.to_s
+      end
+    else
+      opt_value = true
+    end
+    @result_hash[opt_key.to_s] = opt_value
+  end
+
+  def array()
+    raise "array should start with [ " if ! (current_token.type == :sign && current_token.e1 == "[")
+
+    next_token()
+    ary = Array.new()
+    elems( ary )
+
+    raise "array should end with ] " if ! (current_token.type == :sign && current_token.e1 == "]")
+
+    return ary
+  end
+
+  def elems( ary )
+    ary.push primary()
+    next_token
+    if current_token.type == :sign && current_token.e1 == ","
+      next_token
+      elems( ary )
+    else
+      return ary
+    end
+  end
+
+  def primary()
+    case current_token.type
+    when :ident
+      return ident()
+    when :string
+      return string()
+    when :num
+      return num()
+    else
+      raise "the current token should be :ident, :string or :num."
+    end
+  end
+
+  def func()
+    func_name = ident()
+    parenthesis = next_token()
+    raise "func arg should start with ( " if ! (parenthesis.type == :sign && parenthesis.e1 == "(")
+
+    next_token()
+    func_args = elems( Array.new() )
+    raise "func should end with ) " if ! (current_token.type == :sign && current_token.e1 == ")")
+
+    func_hash = {"type" => :func , "fname" => func_name.to_s , "fargs" => func_args}
+    return func_hash
+  end
+
+  def ident()
+    raise "the current token should be ident" if current_token.type != :ident 
+    return type_adjust( current_token.e1, :ident)
+  end
+
+  def string()
+    raise "the current token should be string" if current_token.type != :string 
+    return type_adjust( current_token.e1, :string)
+  end
+
+  def num()
+    raise "the current token should be num" if current_token.type != :num
+    return type_adjust( current_token.e1, :num)
+  end
+end
+
+