raka 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a3391bad82ef017d820e266d897d570d32f6a62c3b09382b4b6ad8d1f8ead6fe
+  data.tar.gz: 39aa088fc9e87bda8a7ad14f60678b934ca006de0d78c893da5678f0a1082740
+SHA512:
+  metadata.gz: b0b426ad5076914630e192345d0796dfa1c30c580f3709d6c88773170ee8e18148c9795f6f7c2619bc5fa22983f0f50f4ed34e09880fc3a8004cbd773b138a5e
+  data.tar.gz: db00045e711049a23735dc9358b7faca10528a07b893307becd8eb4d73a90002430a19f6a4e5bb228366455b5066ee1e27b0b609b9b2192768fb8ea33131986a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 yarray
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,261 @@
+**Raka** is a **DSL**(Domain Specific Language) on top of **Rak**e for defining and running d**a**t**a** processing workflows. Raka is specifically designed for data processing with improved pattern matching, scopes, language extensions and lots of conventions to prevent verbosity.
+
+## Why Raka
+
+Data processing tasks can involve plenty of steps, each with its dependencies. Compared to bare Rake or the more classical Make, Raka offers the following advantages:
+
+1. Advanced pattern matching and template resolving to define general rules and maximize code reuse.
+2. Extensible and context-aware protocol architecture
+3. Multilingual. Other programming languages can be easily embedded
+4. Auto dependency and naming by conventions
+5. Support scopes to ease comparative studies
+6. Terser syntax
+
+... and more.
+
+## Usage
+
+Raka is a drop-in library for rake. Though rake is cross platform, raka may not work on Windows since it relies some shell facilities. To use raka, one has to install ruby and rake first. Ruby is available for most \*nix systems including Mac OSX so the only task is to install rake like:
+
+```bash
+gem install rake
+```
+
+The next step is to clone this project to local machine, cd to the directory, and install the gem:
+
+```bash
+gem install pkg/raka-0.1.0.gem
+```
+
+## For the Impatient
+
+First create a file named `main.raka` and import & initialize the DSL
+
+```ruby
+require 'raka'
+
+dsl = DSL.new(self,
+  output_types: [:txt, :table, :pdf, :idx],
+  input_types: [:txt, :table]
+)
+```
+
+Then the code below will define two simple rules:
+
+```ruby
+txt.sort.first50 = shell* "cat sort.txt | head -n 50 > $@"
+txt.sort = [txt.input] | shell* "cat $< | sort -rn > $@"
+```
+
+For testing let's prepare an input file named `input.txt`:
+
+```bash
+seq 1000 > input.txt
+```
+
+We can then invoke `rake first50.txt`, the script will read data from _input.txt_, sort the numbers descendingly and get the first 50 lines.
+
+The workflow here is as follows:
+
+1. Try to find _first50\_\_sort.txt_: not exists
+2. Rule `txt.sort.first50` matched
+3. For rule `txt.sort.first50`, find input file _sort.txt_ or _sort.table_. Neither exists
+4. Rule `txt.sort` matched
+5. Rule `txt.sort` has no input but a depended target `txt.input`
+6. Find file _input.txt_ or _input.table_. Use the former
+7. Run rule `txt.sort` and create _sort.txt_
+8. Run rule `txt.sort.first50` and create _first50\_\_sort.txt_
+
+This illustrates some basic ideas but may not be particularly interesting. Following is a much more sophisticated example from real world research which covers more features.
+
+```ruby
+SRC_DIR = File.absolute_path 'src'
+USER = 'postgres'
+DB = 'osm'
+HOST = 'localhost'
+PORT = 5432
+
+def idx_this() [idx._('$(output_stem)')] end
+
+dsl.scope :de
+
+idx._ = psqlf(script_name: '$stem_idx.sql')
+pdf.buildings.func['(\S+)_graph'] = r(:graph)* %[
+  table_input("$(input_stem)") | draw_%{func0} | ggplot_output('$@') ]
+table.buildings = [csv.admin] | psqlf(admin: '$<') | idx_this
+```
+
+Assume that we have a schema named _de_ in database _osm_, have a input file _admin.csv_, and have _graph.R_ and _buildings.sql_ under _src/_. Now further assume that _graph.R_ contains two functions:
+
+```r
+draw_stat_snapshot <- function(d) { ... }
+draw_user_trend <- function(d) { ... }
+```
+
+...and _buildings.sql_ contains table creation code like:
+
+```sql
+DROP TABLE IF EXISTS buildings;
+CREATE TABLE buildings AS ( ... );
+```
+
+We may also have a _buildings_idx.sql_ to create index for the table.
+
+Then we can run either `rake de/stat_snapshot_graph__buildings.pdf` or `rake de/user_trend_graph__buildings.pdf`, which will do a bunch of things at first run (take the former as example):
+
+1. Target file not found.
+2. Rule `pdf.buildings.func['(\S+)_graph']` matched. "stat_snapshot_graph" is bound to `func` and "stat_snapshot" is bound to `func0`.
+3. None of the four possible input files: _de/buildings.table_, _de/buildings.txt_, _buildings.table_, _buildings.txt_ can be found. Rule `table.buildings` is matched and the only dependecy file _admin.csv_ is found.
+4. The protocol `psqlf` finds the source file _src/buildings.sql_, intepolate the options with automatic variables (`$<` as "admin.csv"), run the sql, and create a placeholder file _de/buildings.table_ afterwards.
+5. Run the post-job `idx_this`, according to the rule `idx._` it will find and run _buildings_idx.sql_, then create a placeholder file _de/buildings.idx_.
+6. For rule `pdf.buildings.func['(\S+)_graph']`, the R code in `%[]` is interpolated with several automatic variables (`$(input_stem)` as "buildings", `$@` as "de/stat_snapshot_graph\_\_buildings.pdf") and the variables (`func`, `func0`) bound before.
+7. Run the R code. The _buildings_ table is piped into the function `draw_snapshot_graph` and then output to `ggplot_output`, which writes the graph to the specified pdf file.
+
+## Syntax of Rules
+
+It is possible to use Raka with little knowledge of ruby / rake, though minimal understandings are highly recommended. The formal syntax of rule can be defined as follows (EBNF form):
+
+```ebnf
+rule = lexpr "=" {target_list "|"} protocol {"|" target_list};
+
+target = rexpr | template;
+
+target_list = "[]" | "[" target {"," target} "]";
+
+lexpr = ext "." {ltoken "."} ltoken;
+rexpr = ext "." rtoken {"." rtoken};
+
+ltoken = word | word "[" pattern "]";
+rtoken = word | word "(" template ")";
+
+word = ("_" | letter) { letter | digit | "_" };
+
+protocol = ("shell" | "r" | "psql") ("*" template | BLOCK )
+         | "psqlf" | "psqlf" "(" HASH ")";
+```
+
+The corresponding railroad diagrams are:
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/rule.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/target.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/target_list.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/lexpr.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/rexpr.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/ltoken.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/rtoken.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/word.svg)
+
+![](https://cdn.rawgit.com/yarray/raka/master/doc/figures/protocol.svg)
+
+The definition is concise but several details are omitted for simplicity:
+
+1. **BLOCK** and **HASH** is ruby's block and hash object.
+2. A **template** is just a ruby string, but with some placeholders (see the next section for details)
+3. A **pattern** is just a ruby string which represents regex (see the next section for details)
+4. The listed protocols are merely what we offered now. It can be greatly extended.
+5. Nearly any concept in the syntax can be replaced by a suitable ruby variable.
+
+## Pattern matching and template resolving
+
+When defined a rule like `lexpr = rexpr`, the left side represents a pattern and the right side contains specifications for extra dependecies, actions and some targets to create thereafter. When raking a target file, the left sides of the rules will be examined one by one until a rule is matched. The matching process based on Regex also support named captures so that some varibales can be bound for use in the right side.
+
+The specifications on the right side of a rule can be incomplete from various aspects, that is, they can contains some templates. The "holes" in the templates will be fulfilled by automatic variables and variables bounded when matching the left side.
+
+### Pattern matching
+
+To match a given _file_ with a `lexpr`, asides the extension, the substrings of the file name between "\_\_" are mapped to tokens separated by `.`, in reverse order. After that, each substring is matched to the corresponding token or the regex in `[]`. For example, the rule
+
+```ruby
+pdf.buildings.indicator['\S+'].top['top_(\d+)']
+```
+
+can match "top_50\_\_node_num\_\_buildings.pdf". The logical process is:
+
+1. The extension `pdf` matches.
+2. The substrings and the tokens are paired and they all match:
+   - `buildings ~ buildings`
+   - `'\S+' ~ node_num`
+   - `top_(\d+) ~ top_50`
+3. Two levels of captures are made. First, 'node_num' is captured as `indicator`, 'top_50' is captured as `top`; Second, '50' is captured as `top0` since `\d+` is wrapped in parenthesis and is the first.
+
+One can write special token `_` or `something[]` if the captured value is useful later, as the syntax sugar of `something['\S+']`.
+
+### Template resolving
+
+In some places of `rexpr`, templates can be written instead of strings, so that it can represent different values at runtime. There are two types of variables that can be used in templates. The first is automatic variables, which is just like `$@` in Make or `task.name` in Rake. We even preserve some Make conventions for easier migrations. All automatic varibales begin with `$`. The possible automatic variables are:
+
+| symbol         | meaning                | symbol        | meaning                         |
+| -------------- | ---------------------- | ------------- | ------------------------------- |
+| \$@            | output file            | \$^           | all dependecies (sep by spaces) |
+| \$<            | first dependency       | $0, $1, … \$i | ith depdency                    |
+| \$(scope)      | scope for current task | \$(output_stem)      | stem of the output file         |
+| \$(input_stem) | stem of the input file |               |                                 |
+
+The other type of variables are those bounded during pattern matching,which can be referred to using `%{var}`. In the example of the [pattern matching](###pattern-matching) section, `%{indicator}` will be replaced by `node_num`, `%{top}` will be replaced by `top_50` and `%{top0}` will be replaced by `50`. In such case, a template as `'calculate top %{top0} of %{indicator} for $@'` will be resolved as `'calculate top 50 of node_num for top_50__node_num__buildings.pdf'`
+
+The replacement of variables happen before any process to the template string. So do not include the symbols for automatic variables or `%{<anything>}` in templates.
+
+Templates can happen in various places. For depdencies and post jobs, tokens with parenthesis can wrap in templates, like `csv._('%{indicator}')`. The symbol of a token with parenthesis is of no use and is generally omitted. It is also possible to write template literal directly, i.e. `'%{indicator}.csv'`. Where templates can be applied in actions depends on the protocols and will be explained later in the [Protocols](###protocols) section
+
+## APIs
+
+### Initialization and options
+
+These APIs are bounded to an instance of DSL, you can create the object at the top:
+
+```ruby
+dsl = DSL.new(<env>, <options>)
+```
+
+The argument `<env>` should be the _self_ of a running Rakefile. In most case you can directly write:
+
+```ruby
+dsl = DSL.new(self, <options>)
+```
+
+The argument `options` currently support `output_types` and `input_types`. For each item in `output_types`, you will get an extra function to bootstrap a rule. For example, with
+
+```ruby
+dsl = DSL.new(self, { output_types: [:csv, :pdf] })
+```
+
+you can write these rules like:
+
+```ruby
+csv.data = ...
+pdf.graph = ...
+```
+
+which will generate data.csv and graph.pdf
+
+The `input_types` involves the strategy to find inputs. For example, raka will try to find both _numbers.csv_ and _numbers.table_ for a rule like `table.numbers.mean = …` if `input_type = [:csv, :table]`.
+
+### Scope
+
+### Protocols
+
+Currently Raka support 4 lang: shell, psql, r and psqlf.
+
+```ruby
+shell(base_dir='./')* code::templ_str { |task| ... }
+psql(options={})* code::templ_str { |task| ... }
+r(src:str, libs=[])* code::templ_str { |task| ... }
+
+# options = { script_name: , script_file: , params: }
+psqlf(options={})
+```
+
+## Rakefile Template
+
+## Write your own protocols
+
+## Compare to other tools
+
+Raka borrows some ideas from Drake but not much (currently mainly the name "protocol"). Briefly we have different visions and maybe different suitable senarios.

data/VERSION

@@ -0,0 +1 @@
+0.2.3

data/lib/compile.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require_relative './token'
+
+def array_to_hash(array)
+  array.nil? ? {} : Hash[((0...array.size).map { |i| i.to_s.to_sym }).zip array]
+end
+
+def protect_percent_symbol(text)
+  anchor = '-_-_-'
+  safe_text = text.gsub(/%(?=[^\s{]+)/, anchor) # replace % not in shape of %{ to special sign
+  safe_text = yield safe_text
+  safe_text.gsub(anchor, '%') # replace % not in shape of %{ to special sign
+end
+
+# compiles rule (lhs = rhs) to rake task
+class DSLCompiler
+  attr_reader :env
+
+  # keep env as running environment of rake since we want to inject rules
+  def initialize(env, options)
+    @env = env
+    @options = options
+  end
+
+  # Raka task structure, input task is rake's task pushed into blocks
+  def dsl_task(token, task)
+    name = task.name
+    deps = task.prerequisites
+
+    output_info = token._parse_output_ name
+    task_info = {
+      name: name,
+      deps: deps,
+      deps_str: deps.join(','),
+      input: deps.first || '',
+      task: task
+    }
+    OpenStruct.new(output_info.to_h.merge(task_info))
+  end
+
+  # resolve auto variables with only output info,
+  # useful when resolve extra deps (task is not available yet)
+  def resolve_by_output(target, output_info)
+    info = output_info
+    text = target.respond_to?(:_template_) ? target._template_(info.scope).to_s : target.to_s
+    text = text
+      .gsub('$(scope)', info.scope.nil? ? '' : info.scope)
+      .gsub('$(target_scope)', info.target_scope.nil? ? '' : info.target_scope)
+      .gsub('$(output)', info.output)
+      .gsub('$(output_stem)', info.stem)
+      .gsub('$(input_stem)', info.input_stem.nil? ? '' : info.input_stem)
+      .gsub('$@', info.name)
+
+    protect_percent_symbol text do |safe_text|
+      safe_text = safe_text % (info.to_h.merge info.captures.to_h)
+      safe_text = safe_text.gsub(/\$\(rule_scope(\d+)\)/, '%{\1}') % array_to_hash(info.rule_scopes)
+      safe_text.gsub(/\$\(target_scope(\d+)\)/, '%{\1}') % array_to_hash(info.target_scope_captures)
+    end
+  end
+
+  # resolve auto variables with dsl task
+  def resolve(target, task)
+    # convert target to text whether it is expression or already text
+    text = resolve_by_output target, task
+
+    # convert $0, $1 to the universal shape of %{dep} as captures
+    text = text
+      .gsub('$^', task.deps_str)
+      .gsub('$<', task.input || '')
+      .gsub('$(deps)', task.deps_str)
+      .gsub('$(input)', task.input || '')
+
+    protect_percent_symbol text do |safe_text|
+      # add numbered auto variables like $0, $2 referring to the first and third deps
+      safe_text.gsub(/\$\(dep(\d+)\)/, '%{\1}') % array_to_hash(task.deps)
+    end
+  end
+
+  def rule_action(lhs, actions, extra_tasks, task)
+    return if actions.empty?
+
+    task = dsl_task(lhs, task)
+    @env.logger.info "raking #{task.name}"
+    unless task.scope.nil?
+      folder = task.scope
+      folder = File.join(task.scope, task.target_scope) unless task.target_scope.nil?
+      FileUtils.makedirs(folder)
+    end
+    actions.each do |action|
+      action.call @env, task do |code|
+        resolve(code, task)
+      end
+    end
+
+    extra_tasks.each do |templ|
+      Rake::Task[resolve(templ, task)].invoke
+    end
+  end
+
+  # build one rule
+  def create_rule(lhs, input_ext, actions, extra_deps, extra_tasks)
+    # the "rule" method is private, maybe here are better choices
+    @env.send(:rule, lhs._pattern_ => [proc do |target|
+      inputs = lhs._inputs_(target, input_ext)
+      output = lhs._parse_output_(target)
+      plain_extra_deps = extra_deps.map do |templ|
+        resolve_by_output(templ, output)
+      end
+      # main data source and extra dependencies
+      inputs + plain_extra_deps
+    end]) do |task|
+      # rake continue task even if dependencies not met, we handle ourselves
+      absence = task.prerequisites.find_index { |f| !File.exist? f }
+      unless absence.nil?
+        @env.logger.warn\
+          "Dependent #{task.prerequisites[absence]} does not exist, skip task #{task.name}"
+        next
+      end
+      rule_action(lhs, actions, extra_tasks, task)
+    end
+  end
+
+  # compile token = rhs to rake rule
+  # rubocop:disable Style/MethodLength
+  def compile(lhs, rhs)
+    unless @env.instance_of?(Object)
+      raise "DSL compile error: seems not a valid @env of rake with class #{@env.class}"
+    end
+
+    # the format is [dep, ...] | [action, ...] | [post, ...], where the posts
+    # are those will be raked after the actions
+    actions_start = rhs.find_index { |item| item.respond_to?(:call) }
+
+    # case 1: has action
+    if actions_start
+      extra_deps = rhs[0, actions_start]
+      actions_end = rhs[actions_start, rhs.length].find_index do |item|
+        !item.respond_to?(:call)
+      end
+
+      # case 1.1: has post
+      if actions_end
+        actions_end += actions_start
+        actions = rhs[actions_start, actions_end]
+        extra_tasks = rhs[actions_end, rhs.length]
+      # case 1.2: no post
+      else
+        actions = rhs[actions_start, rhs.length]
+        extra_tasks = []
+      end
+    # case 2: no action
+    else
+      extra_deps = rhs
+      actions = []
+      extra_tasks = []
+    end
+
+    unless lhs._input_?
+      create_rule lhs, proc { [] }, actions, extra_deps, extra_tasks
+      return
+    end
+
+    # We generate a rule for each possible input type
+    @options.input_types.each do |ext|
+      # We find auto source from both THE scope and the root
+      create_rule lhs, ext, actions, extra_deps, extra_tasks
+    end
+  end
+end
+# rubocop:enable Style/MethodLength

data/lib/interface.rbs

@@ -0,0 +1,23 @@
+class RakaTask
+  attr_reader name: String
+  attr_reader stem: String
+  attr_reader func: String?
+  attr_reader input_stem: String?
+  attr_reader scope: String?
+  attr_reader target_scope: String?
+  attr_reader scopes: Array[String]
+  attr_reader target_scope_captures: Array[String]
+  attr_reader captures: Hash[String, String]
+  attr_reader deps: Array[String]
+  attr_reader deps_str: String
+  attr_reader input: String
+  attr_reader task: Object # RakeTask
+end
+
+class RakaEnv
+end
+
+class LanguageImpl
+  def build: (String code, RakaTask task) -> String
+  def run_script: (RakaEnv env, String fname, RakaTask task) -> nil
+end

data/lib/lang/psql/impl.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../protocol'
+
+def bash(env, cmd)
+  code = remove_common_indent(
+    %(set -e
+      set -o pipefail
+
+      #{cmd}
+    )
+  )
+  # puts code
+  env.send :sh, 'bash ' + create_tmp(code)
+end
+
+# postgresql protocol using psql, requires HOST, PORT, USER, DB
+class Psql
+  # Sometimes we want to use the psql command with bash directly
+  def sh_cmd(scope)
+    c = @conn
+    env_vars = "PGOPTIONS='-c search_path=#{scope ? scope + ',' : ''}public' "
+    "PGPASSWORD=#{c.password} #{env_vars} psql -h #{c.host} -p #{c.port} -U #{c.user} -d #{c.db} -v ON_ERROR_STOP=1"
+  end
+
+  # 1. do not add required argument here, so psql.config will work or we can only use psql(conn: xxx).config
+  def initialize(conn: nil, create: 'mview', params: {})
+    @create = create
+    @params = params
+    @conn = conn
+  end
+
+  def build(code, _)
+    # 2. lazily check the argument only when used
+    raise 'argument conn required' if @conn.nil?
+
+    if @create.to_s == 'table'
+      'DROP TABLE IF EXISTS :_name_;' \
+        'CREATE TABLE :_name_ AS (' + code + ');'
+    elsif @create.to_s == 'mview'
+      'DROP MATERIALIZED VIEW IF EXISTS :_name_;' \
+        'CREATE MATERIALIZED VIEW :_name_ AS (' + code + ');'
+    else
+      code
+    end
+  end
+
+  def run_script(env, fname, task)
+    param_str = (@params || {}).map { |k, v| "-v #{k}=\"#{v}\"" }.join(' ')
+
+    bash env, %(
+    #{sh_cmd(task.scope)} #{param_str} -v _name_=#{task.stem} \
+      -f #{fname} | tee #{fname}.log
+    mv #{fname}.log #{task.name}
+    )
+  end
+end
+
+creator :psql, Psql

data/lib/lang/python/impl.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../protocol'
+
+# Binding for python language, allow specifying imports and paths
+class Python
+  # @implements LanguageImpl
+  def initialize(libs: [], paths: [], runner: 'python')
+    common_aliases = {
+      pandas: :pd,
+      numpy: :np
+    }.freeze
+
+    libs = libs.map(&:to_s) # convert all to strings
+    @imports = libs.map { |lib| "import #{lib}" }
+    common_aliases.each do |name, short|
+      @imports.push("import #{name} as #{short}") if libs.include? name.to_s
+    end
+    @paths = ['import sys'] + paths.map { |path| "sys.path.append('#{path}')" }
+    @runner = runner
+  end
+
+  def build(code, _task)
+    (@paths + @imports + [code]).join "\n"
+  end
+
+  def run_script(env, fname, _task)
+    run_cmd(env, "#{@runner} #{fname}")
+  end
+end
+
+creator :py, Python

data/lib/lang/r/impl.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../protocol'
+
+# r language protocol
+class R
+  def initialize(src, libs = [], **kwargs)
+    @src = src
+    @libs = libs
+    super(**kwargs)
+  end
+
+  def build(code, _)
+    libraries = ([
+      :pipeR
+    ] + @libs).map { |name| "suppressPackageStartupMessages(library(#{name}))" }
+
+    sources = ["source('#{File.dirname(__FILE__)}/io.R')"] +
+              (@src ? [@src] : []).map { |name| "source('#{SRC_DIR}/#{name}.R')" }
+
+    extra = [
+      '`|` <- `%>>%`',
+      "conn_args <- list(host='#{HOST}', user='#{USER}', dbname='#{DB}', port='#{PORT}')",
+      'args <- commandArgs(trailingOnly = T)',
+      'sql_input    <- init_sql_input(conn_args, args[1])',
+      'table_input  <- init_table_input(conn_args, args[1])',
+      'table_output <- init_table_output(conn_args, args[1])'
+    ]
+
+    [libraries, sources, extra, code].join "\n"
+  end
+
+  def run_script(env, fname, task)
+    env.send :sh, "Rscript #{fname} '#{task.scope || 'public'}'"
+  end
+end
+
+creator :r, R