marty 8.5.0 → 9.3.0

data/delorean/enum_report.dl

@@ -1,4 +1,4 @@
-import MartyFields
+import Fields
 import Styles
 
 EnumValuesReport:
@@ -7,5 +7,4 @@ EnumValuesReport:
     raw     = Marty::Enums::Report.call()
     result  = Marty::Helper.to_csv(raw)
     form    = []
-    format  = "csv"
-
+    format  = "csv"

data/delorean/{marty_fields.dl → fields.dl}

@@ -60,3 +60,19 @@ TextField:
     xtype        = ":textfield"
     field_label  = "Text"
     name         = "text_field"
+
+######################################################################
+
+DateField:
+    field_label = "Date"
+    xtype       = ":datefield"
+    name        = "date"
+    value       = nil
+    format      = 'Y-m-d'
+
+DatetimeField:
+    field_label = "Datetime"
+    xtype       = ":datetimefield"
+    name        = "datetime"
+    value       = nil
+    format      = 'Y-m-d H:i:s'

data/delorean/styles.dl

@@ -0,0 +1,216 @@
+Style:
+    digit_0       = {"format_code" : "0"}
+    digit_1       = {"format_code" : "0.0"}
+    digit_2       = {"format_code" : "0.00"}
+    digit_3       = {"format_code" : "0.000"}
+    digit_4       = {"format_code" : "0.0000"}
+    digit_5       = {"format_code" : "0.00000"}
+    digit_6       = {"format_code" : "0.000000"}
+    date          = {"format_code" : "mm/dd/yy"}
+    timestamp     = {"format_code" : "m/d/yy h:mm AM/PM"}
+    datetime      = {"format_code" : "yyyy-mm-dd h:mm:ss"}
+    date_w_time   = {"format_code" : "mm/dd/yy h:mm:ss"}
+    dollars       = {"format_code" : "$#,###"}
+    dollars_cent  = {"format_code" : "$#,###.##"}
+    text          = {"format_code" : "@"}
+
+    bg_gray       = {"bg_color": "C5D9F1"}
+    bg_lightgreen = {"bg_color": "99CC00"}
+    bg_tan        = {"bg_color": "FFCC66"}
+    bg_redish     = {"bg_color": "EF5959"}
+    bg_lightgray  = {"bg_color": "F1F5F5"}
+
+    quoted        = {"quote_prefix": true}
+
+    gray_digit_3  = bg_gray + digit_3
+
+    bg_penny      = {
+        "bg_color":     "0D056F",
+        "fg_color":     "FFFFFF",
+        }
+
+    bg_highlight  = {
+        "bg_color":     "FFFF00",
+        "fg_color":     "0D056F",
+        }
+
+    bold = {"b": true}
+
+    penny_bold = bold + bg_penny
+
+    align_center = {
+        "alignment": {
+            "horizontal": ":center",
+            }
+        }
+
+    align_left = {
+        "alignment": {
+            "horizontal": ":left",
+            }
+        }
+
+    align_right = {
+        "alignment": {
+            "horizontal": ":right",
+            }
+        }
+
+    calibri     = {"font_name": "Calibri"}
+    sz_14       = {"sz": 14}
+    sz_12       = {"sz": 12}
+    sz_10       = {"sz": 10}
+
+    h_hdr       = bold + bg_highlight + align_center + calibri + sz_14
+    m_hdr       = penny_bold + align_center + calibri + sz_14
+    s_hdr       = penny_bold + align_left + calibri + sz_12
+    s_hdr_dt    = s_hdr + datetime
+    s_hdr_date  = s_hdr + date
+    s_hdr_dwt   = s_hdr + date_w_time
+    g_bold      = bg_gray + bold
+
+    border_thin = {
+        "style" : ":thin",
+        "color" : "000000",
+        }
+
+  ######################################################################
+
+    m_hdr_style0 = {"style": m_hdr}
+    m_hdr_style1 = {"style": [m_hdr]}
+
+    s_hdr_style2 = {"style": [s_hdr]*2}
+    s_hdr_style3 = {"style": [s_hdr]*3}
+
+HeatMapFmt:
+    color_scale = [
+        {"type":":min",     "val":0,    "color":"FF63BE7B"},
+        {"type":":percent", "val":"50", "color":"FFFFEB84"},
+        {"type":":max",     "val":0,    "color":"FFF8696B"}
+        ]
+
+    cfmt = {
+        "type":         ":colorScale",
+        "priority":     1,
+        "color_scale":  color_scale,
+        }
+
+ThresholdFmt:
+    winner =? 0
+    thresh_cell =? '$B$1'
+
+    cfmt = {
+        "type":         ":expression",
+        "priority":     1,
+        "dxfId" : {
+            "fg_color": "FFF8696B",
+            "type":     ":dxf",
+            "b":        true,
+            },
+        "formula":      'ABS(INDIRECT("RC", FALSE))>'+thresh_cell,
+        }
+
+    cfmtnot0 = {
+         "type"     : ":cellIs",
+         "operator" : ":notEqual",
+         "formula"  : "0",
+         "dxfId"    : {
+            "fg_color": "FFF8696B",
+            "type":     ":dxf",
+            "b":        true,
+            },
+         "priority" : 1,
+         }
+
+    cfmtequal = {
+         "type"     : ":cellIs",
+         "operator" : ":equal",
+         "formula"  : winner.to_s,
+         "dxfId"    :
+            {
+            "fg_color": "FFF8696B",
+            "type":     ":dxf",
+            "b":        true,
+            },
+         "priority" : 1,
+         }
+
+    cfmtticks = {
+        "type":         ":expression",
+        "priority":     1,
+        "dxfId" : {
+            "fg_color": "FFF8696B",
+            "type":     ":dxf",
+            "b":        true,
+            },
+        "formula":      'ABS(LEFT(INDIRECT("RC", FALSE),FIND("-",INDIRECT("RC", FALSE), 2)-1))+MID(SUBSTITUTE(INDIRECT("RC", FALSE),"+",""),FIND("-",INDIRECT("RC", FALSE), 2)+1,9)/32+(RIGHT(INDIRECT("RC", FALSE))="+")/64>'+thresh_cell,
+        }
+
+Row:
+    blank_cells =? 0
+    values      =? []
+    styles      =? []
+
+    blank_styles = [{}]*blank_cells
+    blank  = ["row", [nil]*blank_cells,
+              {"style": blank_styles}]
+
+    result = ["row", values + blank[1],
+              {"style": styles + blank_styles}]
+
+Fill:
+    rows   =?
+    fill   =? nil
+    length =?
+
+    filled_rows = [
+        [r[0],
+         (if r[1].length >= length
+          then r[1]
+          else r[1] + [fill]*(length - r[1].length)
+         ),
+         {'style': (r[2]['style'] || []) + [{}]*(length - r[1].length)}]
+        for r in rows]
+
+Merge:
+    init         =? 0
+    rows_a       =?
+    rows_b       =?
+    blank_length =?
+
+    add_options =? {}
+
+    ra_len = rows_a.length
+    rb_len = rows_b.length
+
+    len = if ra_len >= rb_len then ra_len else rb_len
+
+    result = [
+        ["row",
+         ((rows_a[i] || Row(blank_cells=blank_length).blank)[1] +
+          (rows_b[i] || Row.blank)[1]),
+         {"style": (if rows_a[i][2]
+                    then rows_a[i][2]['style']
+                    else Row(blank_cells=blank_length).blank_styles) +
+                   (if rows_b[i][2]
+                    then rows_b[i][2]['style']
+                    else [])
+         } + (add_options[i] || {})
+        ] for i in Marty::Helper.range_step(init, len-1, 1)]
+
+Alternate:
+    bg_color_a =? 'F3F3F3'
+    bg_color_b =? 'FFFFFF'
+
+    color = {
+        0: {'bg_color': bg_color_a},
+        1: {'bg_color': bg_color_b},
+        }
+
+    rows  =?
+
+    result = [
+        ['row',
+         rows[i][1],
+         {'style': [(color[i%2] + s) for s in rows[i][2]['style']]}
+        ] for i in Marty::Helper.range_step(0, rows.length - 1, 1)]

data/delorean/table_report.dl

@@ -1,7 +1,7 @@
-import MartyFields
+import Fields
 import Styles
 
-ReadableField: MartyFields::CheckboxField
+ReadableField: Fields::CheckboxField
     name        = "readable"
     field_label = "Disable Encoding"
 
@@ -26,8 +26,8 @@ TableReport:
     row_count   = result_raw.length
     result      = Marty::Helper.to_csv(result_raw, {'readable' : readable})
     form        = [
-        MartyFields::PostingField,
-        MartyFields::ClassField,
+        Fields::PostingField,
+        Fields::ClassField,
         ReadableField,
         ]
     format      = "csv"

data/lib/marty/monkey.rb

@@ -376,6 +376,23 @@ module Netzke
   end
 end
 
+module Netzke
+  module Core
+    class ClientClassConfig
+      # FIXME: move to Netzke
+      # This fix removes ; in the end of JS code that is required by JS linters
+      # And adds new line before closing bracket, so that if there is a comment
+      # in the end of file, it won't break the code.
+      def override_from_file(path)
+        str = File.read(path)
+        str.chomp!("\n").chomp!(';')
+        %{#{class_name}.override(#{str}
+);}
+      end
+    end
+  end
+end
+
 require 'delayed_cron_job'
 require_relative './delayed_job/scheduled_job_plugin.rb'
 

data/lib/marty/promise_job.rb

@@ -8,6 +8,7 @@ class Marty::PromiseJob < Struct.new(:promise,
                                      :params,
                                      :attrs,
                                      :hook,
+                                     :max_run_time
                                     )
   # def log(msg)
   #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
@@ -41,10 +42,18 @@ class Marty::PromiseJob < Struct.new(:promise,
       end
 
       # log "DONE #{Process.pid} #{promise.id} #{Time.now.to_f} #{res}"
+    rescue ::Delayed::WorkerTimeout => e
+      timeout_error = StandardError.new(
+        ::Marty::Promise.timeout_message(promise)
+      )
+      timeout_error.set_backtrace(e.backtrace)
+
+      res = Delorean::Engine.grok_runtime_exception(timeout_error)
     rescue StandardError => e
       res = Delorean::Engine.grok_runtime_exception(e)
       # log "ERR- #{Process.pid} #{promise.id} #{Time.now.to_f} #{e}"
     end
+
     promise.set_result(res)
     process_hook(res)
   end

data/lib/marty/promise_ruby_job.rb

@@ -4,6 +4,7 @@ class Marty::PromiseRubyJob < Struct.new(:promise,
                                          :method_name,
                                          :method_args,
                                          :hook,
+                                         :max_run_time
                                         )
 
   def enqueue(job)
@@ -26,6 +27,13 @@ class Marty::PromiseRubyJob < Struct.new(:promise,
       ENV['__promise_id'] = promise.id.to_s
       mod = module_name.constantize
       res = { 'result' => mod.send(method_name, *method_args) }
+    rescue ::Delayed::WorkerTimeout => e
+      timeout_error = StandardError.new(
+        ::Marty::Promise.timeout_message(promise)
+      )
+      timeout_error.set_backtrace(e.backtrace)
+
+      res = Delorean::Engine.grok_runtime_exception(timeout_error)
     rescue StandardError => e
       res = ::Marty::Promise.exception_to_result(promise: promise, exception: e)
     end

data/lib/marty/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Marty
-  VERSION = '8.5.0'
+  VERSION = '9.3.0'
 end

data/make-lint.mk

@@ -0,0 +1,19 @@
+lint:
+	make lint-ruby
+	make lint-js
+
+lint-fix:
+	make lint-ruby-fix
+	make lint-js-fix
+
+lint-ruby:
+	bundle exec rubocop
+
+lint-ruby-fix:
+	bundle exec rubocop -a
+
+lint-js:
+	yarn lint
+
+lint-js-fix:
+	yarn lintfix

data/package.json

@@ -0,0 +1,16 @@
+{
+  "private": true,
+  "scripts": {
+    "lint": "eslint 'app/**/*.{js,jsx}' && prettier --check \"app/**/*.{js,jsx,css,scss}\"",
+    "lintfix": "eslint --fix 'app/**/*.{js,jsx}' && prettier --write \"app/**/*.{js,jsx,css,scss}\""
+  },
+  "dependencies": {
+  },
+  "devDependencies": {
+    "babel-eslint": "^10.0.1",
+    "eslint": "^6.0.0",
+    "eslint-config-prettier": "^6.0.0",
+    "eslint-plugin-prettier": "^3.1.0",
+    "prettier": "^1.17.1"
+  }
+}

data/prettier.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  arrowParens: "always",
+  printWidth: 80,
+  quoteProps: "consistent",
+  semi: true
+};

data/spec/controllers/diagnostic/controller_spec.rb

@@ -8,7 +8,6 @@ end
 module Marty::Diagnostic
   RSpec.describe Controller, type: :controller do
     before(:each) { @routes = Marty::Engine.routes }
-    let(:json_response) { JSON.parse(response.body) }
 
     def my_ip
       Node.my_ip

data/spec/controllers/rpc_controller_spec.rb

@@ -488,6 +488,8 @@ describe Marty::RpcController do
   let(:p1) { @p1 }
   let(:p2) { @p2 }
 
+  let(:json_response) { JSON.parse(response.body) }
+
   it 'should be able to post' do
     post 'evaluate', params: {
            format: :json,
@@ -511,7 +513,7 @@ describe Marty::RpcController do
            params: { a: 333, d: 5 }.to_json,
            background: true,
          }
-    res = ActiveSupport::JSON.decode response.body
+    res = json_response
     expect(res).to include('job_id')
     job_id = res['job_id']
 
@@ -787,10 +789,10 @@ describe Marty::RpcController do
           params: params
         }
     expect = 'Schema error for M1/A attrs=b: Schema not defined'
-    res = JSON.parse(response.body)
-    expect(res.keys.size).to eq(1)
-    expect(res.keys[0]).to eq('error')
-    expect(res.values[0]).to eq(expect)
+    expect(json_response['backtrace']).to be nil
+    expect(json_response.size).to eq(1)
+    expect(json_response.keys[0]).to eq('error')
+    expect(json_response.values[0]).to eq(expect)
   end
 
   it 'returns an error message on missing attributes in schema script' do
@@ -849,6 +851,7 @@ describe Marty::RpcController do
         }
     expect = '[""The property \'#/p\' of type string did not '\
              'match the following type: integer'
+
     expect(response.body).to include(expect)
   end
 
@@ -870,9 +873,10 @@ describe Marty::RpcController do
             attrs: attr,
             params: params
           }
-      res = JSON.parse(response.body)
       errpart = 'of type string did not match the following type: integer'
-      expect(res['error']).to include(errpart)
+      expect(json_response['error']).to include(errpart)
+      expect(json_response['backtrace']).to be nil
+
       logs = Marty::Log.all
       expect(logs.count).to eq(1)
       expect(logs[0].details['error'][0]).to include(errpart)
@@ -1386,41 +1390,51 @@ describe Marty::RpcController do
     it 'returns bad attrs if attr is not a string' do
       get :evaluate, params: { format: :json, attrs: 0 }
       expect(response.body).to match(/"error":"Malformed attrs"/)
+      expect(json_response['backtrace']).to be nil
     end
 
     it 'returns malformed attrs for improperly formatted json' do
       get :evaluate, params: { format: :json, attrs: '{' }
       expect(response.body).to match(/"error":"Malformed attrs"/)
+      expect(json_response['backtrace']).to be nil
     end
 
     it 'returns malformed attrs if attr is not an array of strings' do
       get :evaluate, params: { format: :json, attrs: '{}' }
       expect(response.body).to match(/"error":"Malformed attrs"/)
+      expect(json_response['backtrace']).to be nil
 
       get :evaluate, params: { format: :json, attrs: '[0]' }
       expect(response.body).to match(/"error":"Malformed attrs"/)
+      expect(json_response['backtrace']).to be nil
     end
 
     it 'returns malformed params for improperly formatted json' do
       get :evaluate, params: { format: :json, attrs: 'e', params:  '{' }
       expect(response.body).to match(/"error":"Malformed params"/)
+      expect(json_response['backtrace']).to be nil
     end
 
     it 'returns malformed params if params is not a hash' do
       get :evaluate, params: { format: :json, attrs: 'e', params: '[0]' }
       expect(response.body).to match(/"error":"Malformed params"/)
+      expect(json_response['backtrace']).to be nil
     end
 
     it 'returns engine/tag lookup error if script not found' do
       get :evaluate, params: { format: :json, script: 'M1', attrs: 'e', tag: 'invalid' }
       expect(response.body).to match(/bad tag identifier.*invalid/)
+      expect(json_response['backtrace']).to be nil
+
       get :evaluate, params: { format: :json, script: 'Invalid', attrs: 'e', tag: t1.name }
       expect(response.body).to match(/"error":"Can't get engine:/)
+      expect(json_response['backtrace']).to be nil
     end
 
     it 'returns the script runtime error (no node specified)' do
       get :evaluate, params: { format: :json, script: 'M1', attrs: 'e', tag: t1.name }
       expect(response.body).to match(/"error":"bad node/)
+      expect(json_response['backtrace']).to be nil
     end
   end
 end