statsailr 0.7.1

data/lib/statsailr/block_to_r/proc_setting_support/proc_opt_validator.rb

@@ -0,0 +1,52 @@
+class ProcOptValidator
+  attr :validator_rules
+
+  def initialize( )
+    @validator_rules = {}
+  end
+
+  def rule( option_name , is_a: nil, as: nil , required: false)
+    @validator_rules[option_name] = {"is_a" => is_a , "as" => as, "required" => required }
+  end
+
+  def check_and_modify( param_manager )
+    if ( ! @validator_rules.nil? ) && (! @validator_rules.empty?)
+      @validator_rules.each{| opt_name, validator |
+        class_name_in_param_manager = param_manager.param_hash[opt_name].class.name.split('::').last
+        if validator["required"] == true
+          if ! param_manager.param_hash.has_key?(opt_name)
+            raise "#{opt_name} is required for this PROC option"
+          end
+        end
+        if ! validator["is_a"].nil?
+          if validator["is_a"].is_a?(Array)
+            if ! validator["is_a"].include? class_name_in_param_manager
+              raise "#{opt_name} needs to be one of #{validator["is_a"].join("|")}, but #{class_name_in_param_manager} is assigned"
+            end
+          else
+            if validator["is_a"] != class_name_in_param_manager
+              raise "#{opt_name} needs to be #{validator["is_a"]}, but #{class_name_in_param_manager} is assigned"
+            end
+          end
+
+        end
+        if ! validator["as"].nil?
+          if validator["as"] != class_name_in_param_manager
+            case validator["as"]
+            when "SymbolR"
+              param_manager.param_hash[opt_name] = RBridge::SymbolR.new(param_manager.param_hash[opt_name])
+            when "String"
+              param_manager.param_hash[opt_name] = param_manager.param_hash[opt_name].to_s
+            when "Integer"
+              param_manager.param_hash[opt_name] = param_manager.param_hash[opt_name].to_i
+            when "Float"
+              param_manager.param_hash[opt_name] = param_manager.param_hash[opt_name].to_f
+            else
+              raise "We need to convert type but do not know how to do it. #{class_name_in_param_manager} => #{validator["as"]}"
+            end
+          end
+        end
+      }
+    end
+  end
+end

data/lib/statsailr/block_to_r/proc_setting_support/proc_setting_manager.rb

@@ -0,0 +1,49 @@
+require "pathname"
+
+class ProcSettingManager
+  def initialize
+    @proc_settings = {} # "command(downcase)" => { "path" => Pathname(abslute path) , "loaded" => boolean }
+  end
+  
+  def add_proc_settings_from_dir( dir )
+    raise "add_proc_settings_from_directory() requires String" unless dir.is_a? String
+    dir_pathname = Pathname.new(dir)
+    if ! dir_pathname.absolute?
+      raise "dir should be specified in absolute path."
+    end
+
+    dir_pathname.opendir{|d|
+      d.each(){|f|
+        if((dir_pathname + f).file?)
+          if( f =~ /proc_([a-zA-Z0-9]+)\.rb/ )
+            command_name = $1
+            proc_setting_path = dir_pathname + f
+            @proc_settings[command_name.downcase] = { "path" => proc_setting_path, "loaded" => false }
+          end
+        end
+      }
+    }
+  end
+
+  def is_loaded?( command )
+    command = command.downcase
+    if @proc_settings.has_key? command 
+      return @proc_settings[command]["loaded"]
+    else
+      return false
+    end
+  end
+
+  def load_setting( command )
+    command = command.downcase
+    if @proc_settings.has_key? command 
+      load( @proc_settings[command]["path"].to_s )
+      @proc_settings[command]["loaded"] = true
+    else
+      raise "specified #{command} proc command cannot be found. Loaded proc settings: #{@proc_settings.keys} "
+    end
+  end
+end
+
+
+

data/lib/statsailr/block_to_r/proc_setting_support/proc_setting_module.rb

@@ -0,0 +1,44 @@
+require "pathname"
+require_relative("./proc_opt_validator.rb")
+
+module ProcSettingModule
+  def self.included base
+    base.extend ClassMethods
+    base.instance_variable_set(:@validator, ProcOptValidator.new())
+    base.send :include, InstanceMethods
+  end
+
+  module ClassMethods
+    def extend_object( extender )
+      extender.instance_variable_set(:@validator, @validator)
+      extender.singleton_class.__send__( :attr_accessor, :validator)
+      super
+    end
+
+    def source_r_file( abs_path_dir, filename)
+      raise "directory path should be specified in absolute path for " +  __method__ unless Pathname.new(abs_path_dir).absolute?
+      r_path = abs_path_dir + "/" + filename
+      func = RBridge::create_function_call("source", { "file" => RBridge::create_strvec([r_path])} )
+      RBridge::exec_function(func)
+    end
+
+    def add_setting_from( abs_path_dir, filename)
+      raise "directory path should be specified in absolute path for " +  __method__ unless Pathname.new(abs_path_dir).absolute?
+      require( abs_path_dir + "/" + filename )
+      klass_name = File.basename( filename , ".rb").split("_").map{|elem| elem.capitalize()}.join("") + "Setting"  # e.g. dev_copy.rb => DevCopySetting
+      self.include(Object.const_get(klass_name))
+    end
+
+    def validate_option(opt_key, is_a: nil, as: nil , required: true)
+      @validator.rule( opt_key, is_a: is_a, as: as, required: required )
+    end
+
+    def validator
+      @validator
+    end
+  end
+
+  module InstanceMethods
+  end
+end
+

data/lib/statsailr/block_to_r/sts_block_to_r.rb

@@ -0,0 +1,98 @@
+require "r_bridge"
+
+module BlockToRSupport
+end
+
+require_relative "top_stmt/top_stmt_to_r_func.rb"
+module TopStmtToR
+  include BlockToRSupport
+  def self.create_function( blk )
+    r_func = nil
+    case blk.command
+    when /^(\w+)$/
+      method_to_create_r_function = "create_r_func_for_" + $1.downcase
+      if respond_to? method_to_create_r_function
+        r_func = send( method_to_create_r_function , blk.opts)
+      else
+        raise "#{method_to_create_r_function} cannot be found. Unknown top level command: #{blk.command}"
+      end
+    else
+      raise "Invalid TOPLEVEL command name: " + blk.command
+    end
+    puts "The following options are not used in " + blk.command + " : " + blk.opts.keys.join(" ") if ! blk.opts.empty?
+    return r_func
+  end
+end
+
+module DataBlockToR
+  include BlockToRSupport
+  @datasailr_library_loaded = false
+
+  def self.load_datasailr_library
+    if ! @datasailr_library_loaded
+      begin
+        lib_func1 = RBridge.create_library_function("datasailr")
+        result = RBridge.exec_function(lib_func1)
+        @datasailr_library_loaded = true
+      rescue => err
+        puts "ERROR: 'datasailr' package cannot be found in the following R library paths."
+        libpath = RBridge.create_function_call(".libPaths", {})
+        RBridge.exec_function_no_return( RBridge.create_function_call("print", {"x" => libpath}))
+        puts "Please make sure that the package is installed in one of the libraries."
+        err.set_backtrace([])
+        raise err, "DATA block evaluation failed"
+      end
+    end
+  end
+
+  def self.create_function( blk )
+    load_datasailr_library()
+
+    out_ds = blk.out
+    if set_ds = blk.opts["set"]
+    else
+      raise "DATA block requires set= option for input dataset"
+    end
+
+    puts "Processing data [input:#{set_ds.to_s} ouput:#{out_ds.to_s}]"
+
+    ds_script = blk.script
+
+    datasailr_func = RBridge.create_function_call( "sail" , {"df" => set_ds.to_r_symbol, "code" => RBridge.create_strvec([ds_script])} )
+    r_func = RBridge.create_assign_function( out_ds.to_s , datasailr_func )   
+  end
+end
+
+
+require_relative("sts_lazy_func_gen.rb")
+require_relative("proc_setting_support/proc_setting_module.rb")
+
+module ProcBlockToR
+  include BlockToRSupport
+  def self.create_lazy_funcs( blk , proc_setting_manager )
+    proc_command = blk.command
+    param_manager = RBridge::RParamManager.new( blk.opts )
+    proc_stmts = blk.stmts
+
+    if ! proc_setting_manager.is_loaded?( proc_command )
+      proc_setting_manager.load_setting( proc_command )
+      p "#{proc_command} setting is loaded"
+    end
+
+    lzf_gen = LazyFuncGenerator.new
+    lzf_gen.extend(Object.const_get("Proc"+proc_command.capitalize))
+    
+    validator = lzf_gen.validator
+    if ! validator.nil?
+      validator.check_and_modify( param_manager )
+    end
+
+    proc_lazy_funcs_with_print_result_opts = proc_stmts.map(){|proc_stmt|
+      lzf_gen.gen_lazy_func( proc_command, proc_stmt, param_manager )
+    }
+    return proc_lazy_funcs_with_print_result_opts
+  end
+end
+
+
+

data/lib/statsailr/block_to_r/sts_lazy_func_gen.rb

@@ -0,0 +1,236 @@
+require "r_bridge"
+
+module LazyFuncGeneratorSettingUtility
+  def read_as_formula(ary)
+    return RBridge.create_formula_from_syms( ary )
+  end
+
+  def read_as_strvec(ary)
+    return RBridge.create_strvec( ary.map(){|elem| elem.to_s } )
+  end
+
+  def read_as_one_str(ary)
+    return RBridge.create_strvec( [ ary.map(){|elem| elem.to_s }.join(" ") ] )
+  end
+
+  def read_as_numvec(ary)
+    if ary.any?(){|elem| elem.is_a?(Float) }
+      read_as_realvec(ary)
+    else
+      read_as_intvec(ary)
+    end
+  end
+
+  def read_as_intvec(ary)
+    return RBridge.create_intvec( ary )
+  end
+
+  def read_as_realvec(ary)
+    return RBridge.create_realvec( ary )
+  end
+
+  def read_as_symbol(ary)
+    raise "main argument is expected to be length of 1" unless ary.length == 1
+    raise "symbol is expected" unless ary[0].is_a?( RBridge::SymbolR )
+    return ary[0].to_r_symbol
+  end
+
+  def read_symbols_as_strvec(ary)
+    raise "symbol is expected as an element" unless ary.all?{|elem| elem.is_a?( RBridge::SymbolR )}
+    return RBridge.create_strvec( ary.map(){|elem| elem.to_s } )
+  end
+
+  def result( name , *addl )
+    if addl.empty?
+      return RBridge::RResultName.new(name)
+    else
+      ary = ([name] + addl).map(){|elem|
+        RBridge::RResultName.new(elem)
+      }
+      return RBridge::RResultNameArray.new(ary)
+    end
+  end
+
+  def param( name )
+    return RBridge::RParamName.new(name)
+  end
+
+  def previous_or( default_obj )
+    return RBridge::RResultPrevious.new( default_obj )
+  end
+
+  def r_obj( val )
+    return RBridge.convert_to_r_object( val )
+  end
+
+  def is_result_name?( val )
+    val.is_a? RBridge::RResultName
+  end
+
+  def is_result_name_array?( val )
+    val.is_a? RBridge::RResultNameArray
+  end
+
+  def is_param_name?( val )
+    val.is_a? RBridge::RParamName
+  end
+
+  def is_r_obj?(val)
+    RBridge.is_pointer?(val)
+  end
+
+  def one_from( name, *addl )
+    if addl.empty?
+      if ! ( is_result_name?(name) || is_result_name_array?(name) || is_param_name?(name) ||  is_pointer?(name) )
+          raise "one_from() create RBridge::RNameContainer, which only stores RResultName, RParamName or R object(pointer)."
+      end
+      return name
+    else
+      ary = ([name] + addl).map(){|elem|
+        elem
+      }
+      return RBridge::RNameContainer.new(ary)
+    end
+  end
+
+end
+
+class LazyFuncGeneratorSetting
+  include LazyFuncGeneratorSettingUtility
+
+  attr_accessor :libname, :envname, :func_name, :main_arg_and_how_to_treat, :runtime_args, :store_result, :print_opt, :plot_opt
+  def initialize
+    @libname = nil
+    @envname = nil
+    @func_name = nil
+
+    @main_arg_and_how_to_treat = nil
+    @runtime_args = nil
+
+    @store_result = true
+    @print_opt = nil
+    @plot_opt = nil
+  end
+
+  def create_func_arg_hash( main_arg, opt_args )
+    if ! @main_arg_and_how_to_treat.nil?
+      main_arg_name, how_to_treat, allow_nil = @main_arg_and_how_to_treat
+    else
+      main_arg_name, how_to_treat, allow_nil = [nil, nil, nil]
+    end
+    runtime_args = @runtime_args
+
+    if( ! main_arg_name.nil? )
+      if( ! main_arg.empty? )
+        if( how_to_treat.to_s =~ /^read/ )
+          r_main_arg_hash = {main_arg_name => self.send( how_to_treat, main_arg)  }
+        else
+          raise "String element that specifies how_to_treat should start from 'read_'"
+        end
+      elsif allow_nil.to_s == "allow_nil"
+        r_main_arg_hash = {}
+      else
+        raise "main_arg needs needs to be specified or setting.main_arg_and_how_to_treat needs to allow nil"
+      end
+    else
+      r_main_arg_hash = {}
+    end
+
+    if( ! opt_args.nil? )
+      r_opt_arg_hash = convert_args_to_r_args( opt_args )
+    else
+      r_opt_arg_hash = {}
+    end
+
+    if( !runtime_args.nil?)
+      raise "rumtime_args needs to be Hash" if ! runtime_args.is_a?( Hash )
+    else
+      runtime_args = {}
+    end
+
+    r_args = {}
+    r_args.merge!( runtime_args )
+    r_args.merge!( r_opt_arg_hash )
+    r_args.merge!( r_main_arg_hash )
+    # The latter hashes have higher priority
+
+    return r_args
+  end
+
+  private
+  def convert_args_to_r_args( hash )
+    r_hash = {}
+    hash.each(){|key, value|
+      if value.is_a?(Hash) && value["type"] == :func
+        case value["fname"]
+        when "param"
+          raise "function for " + value["fname"] + " should have one argument." if value["fargs"].size > 1
+          r_hash[key] = param(value["fargs"][0].to_s)
+        when "result"
+          raise "function for " + value["fname"] + " should have one argument." if value["fargs"].size > 1
+          r_hash[key] = result(value["fargs"][0].to_s)
+        else
+          raise "unknown function name in optional argument: " + value.fname
+        end
+      elsif value.is_a?(Array)
+        r_hash[key] = RBridge::convert_to_r_object(value)
+      else
+        r_hash[key] = RBridge::convert_to_r_object(value)
+      end
+    }
+    return r_hash
+  end
+end
+
+
+class LazyFuncGenerator
+  include LazyFuncGeneratorSettingUtility
+  SETTING_FOR_PREFIX = "setting_for_"
+
+  def gen_lazy_func( command, proc_stmt , param_manager)
+
+    inst = proc_stmt[0]
+    main_arg = proc_stmt[1]
+    opt_args = proc_stmt[2]
+
+    underscored_inst = inst.gsub(/\./, "_")
+
+    setting = LazyFuncGeneratorSetting.new()
+    if respond_to?( SETTING_FOR_PREFIX + underscored_inst )
+      send( SETTING_FOR_PREFIX + underscored_inst , setting )
+    else
+      raise "method for this instruction(#{inst})" "is not defined: " + SETTING_FOR_PREFIX + underscored_inst
+    end
+    libname = setting.libname 
+    envname = setting.envname
+    func_name = setting.func_name
+    func_hash = setting.create_func_arg_hash( main_arg, opt_args )
+    result_name = inst
+
+    store_result = setting.store_result
+    print_opt = setting.print_opt
+    plot_opt = setting.plot_opt
+
+    if libname.nil? || libname == ""
+      libname = nil
+    end
+    if envname.nil? || libname == ""
+      envname = nil
+    end
+
+    if ! libname.nil?
+      lazy_func = RBridge::create_ns_lazy_function( libname, func_name, func_hash, param_manager)
+    else
+      if ! envname.nil?
+        lazy_func = RBridge::create_env_lazy_function( envname, func_name, func_hash, param_manager)
+      else
+        lazy_func = RBridge::create_lazy_function( func_name, func_hash, param_manager)
+      end
+    end
+
+    return [ lazy_func, print_opt, plot_opt, store_result, result_name  ]
+  end
+
+end
+
+