marty 1.2.0 → 1.2.1

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/lib/tasks/marty_tasks.rake

@@ -23,6 +23,48 @@ namespace :marty do
     Marty::Script.load_scripts(load_dir)
   end
 
+  # currently this is for delorean style rules only.  if other types were ever
+  # added (eg some sort of SQL rule like apollo has), that would probably be
+  # a new rake task
+  desc 'generate rule table migration'
+  task :generate_rule_table_migration, [:table] => :environment do |t, args|
+    (puts "Usage: rake marty:generate_rule_table_migration[<table name>]"
+     next) unless args[:table]
+    table = args[:table]
+    filename = Rails.root.join("db/migrate",Time.zone.now.strftime(
+                                 "%Y%m%d%H%M%S_create_#{table}.rb"))
+    puts "creating #{filename}"
+    File.open(filename, "w") do |f|
+      f.puts <<~EOF
+        class Create#{table.camelize} < McflyMigration
+          include Marty::Migrations
+          def change()
+            create_table :#{table} do |t|
+              t.string :name, null: false
+              # set type enum
+              t.column :rule_type, :enum_name, null: false
+              t.datetime :start_dt, null: false
+              t.datetime :end_dt, null: true
+              t.string :engine, null: true  # add engine default if used
+              # add any additional attrs here
+              t.jsonb :simple_guards,    null: false, default: {}
+              t.json  :computed_guards,  null: false, default: {}
+              t.jsonb :grids,            null: false, default: {}
+              t.json  :results,          null: false, default: {}
+              # only needed for delorean type rules
+              t.jsonb :fixed_results,    null: false, default: {}
+            end
+            execute("CREATE OR REPLACE FUNCTION to_numrange(val text) "\\
+                    "RETURNS numrange AS "\\
+                    "$BODY$ select numrange(val); $BODY$ "\\
+                    "LANGUAGE SQL IMMUTABLE;")
+           end
+        end
+      EOF
+    end
+    puts "please edit the migration file to customize the rule"
+  end
+
   desc 'Print out all models and their fields'
   task print_schema: :environment do
     Rails.application.eager_load!

data/spec/dummy/app/components/gemini/cm_auth_app.rb

@@ -11,6 +11,8 @@ class Gemini::CmAuthApp < Marty::MainAuthApp
         icon: icon_hack(:database_key),
         menu: [
           :loan_program_view,
+          :my_rule_view,
+          :xyz_rule_view,
         ],
       }
     ]
@@ -21,7 +23,23 @@ class Gemini::CmAuthApp < Marty::MainAuthApp
     a.handler = :netzke_load_component_by_action
   end
 
+  action :my_rule_view do |a|
+    a.text    = a.tooltip = 'My Rules'
+    a.handler = :netzke_load_component_by_action
+  end
+
+  action :xyz_rule_view do |a|
+    a.text    = a.tooltip = 'Xyz Rules'
+    a.handler = :netzke_load_component_by_action
+  end
+
   component :loan_program_view do |c|
     c.klass = Gemini::LoanProgramView
   end
+  component :my_rule_view do |c|
+    c.klass = Gemini::MyRuleView
+  end
+  component :xyz_rule_view do |c|
+    c.klass = Gemini::XyzRuleView
+  end
 end

data/spec/dummy/app/components/gemini/my_rule_view.rb

@@ -0,0 +1,63 @@
+class Gemini::MyRuleView < Marty::DeloreanRuleView
+  has_marty_permissions create: :admin,
+                        read: :admin,
+                        update: :admin,
+                        delete: :admin
+
+  def self.base_fields
+    super + [:other_flag]
+  end
+  def configure(c)
+    super
+    c.title = 'My Rules'
+  end
+
+  def self.klass
+    Gemini::MyRule
+  end
+
+  attribute :other_flag do |c|
+    c.width = 75
+  end
+
+  def form_items_grids
+    [
+      self.class.grid_column(:grid1),
+      self.class.grid_column(:grid2),
+    ]
+  end
+  def default_form_items
+    [
+      hbox(
+        vbox(*form_items_attrs +
+             form_items_guards +
+             form_items_grids,
+             border: false,
+             width: "40%",
+        ),
+        vbox(width: '2%', border: false),
+        vbox(
+             width: '55%', border: false),
+        height: '56%',
+        border: false,
+      ),
+      hbox(
+        vbox(*form_items_computed_guards +
+             form_items_results,
+             width: '99%',
+             border: false
+        ),
+        height: '35%',
+        border: false
+      )
+    ]
+  end
+
+  self.init_fields
+
+  attribute :rule_type do |c|
+    c.width = 200
+    enum_column(c, Gemini::MyRuleType)
+  end
+
+end

data/spec/dummy/app/components/gemini/xyz_rule_view.rb

@@ -0,0 +1,25 @@
+class Gemini::XyzRuleView < Marty::DeloreanRuleView
+  has_marty_permissions create: :admin,
+                        read: :admin,
+                        update: :admin,
+                        delete: :admin
+  def self.klass
+    Gemini::XyzRule
+  end
+
+  def configure(c)
+    super
+    c.title = 'Xyz Rules'
+  end
+
+  def default_form_items
+    super
+  end
+  self.init_fields
+
+  attribute :rule_type do |c|
+    c.width = 200
+    enum_column(c, Gemini::XyzRuleType)
+  end
+
+end

data/spec/dummy/app/models/gemini/guard_one.rb

@@ -0,0 +1,5 @@
+class Gemini::GuardOne < ActiveRecord::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['G1V1', 'G1V2', 'G1V3']
+end

data/spec/dummy/app/models/gemini/guard_two.rb

@@ -0,0 +1,5 @@
+class Gemini::GuardTwo < ActiveRecord::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['G2V1', 'G2V2', 'G2V3']
+end

data/spec/dummy/app/models/gemini/my_rule.rb

@@ -0,0 +1,46 @@
+class Gemini::MyRule < Marty::DeloreanRule
+  self.table_name = 'gemini_my_rules'
+
+  gen_mcfly_lookup :lookup, {
+    name: false,
+  }
+
+  cached_mcfly_lookup :lookup_id, sig: 2 do
+    |pt, group_id|
+    find_by_group_id group_id
+  end
+
+  mcfly_validates_uniqueness_of :name, scope: [:start_dt, :end_dt]
+
+  def self.guard_info
+    super + {"g_array" => { multi: true, type: :string,
+                            enum: Gemini::GuardOne,},
+             "g_single" => { type: :string,
+                             enum: Gemini::GuardTwo,
+                             width: 100},
+             "g_string" => { type: :string,
+                             values: ["Hi Mom", "abc", "def", "zzz"],
+                             width: 100},
+             "g_bool" => { type: :boolean,
+                           width: 100},
+             "g_range" => { type: :range,
+                            width: 100},
+             "g_integer" => { type: :integer,
+                              width: 100},
+             "g_has_default" => { type:  :string,
+                                  default: "string default"}}
+  end
+  def self.results_cfg_var
+    'RULEOPTS_MYRULE'
+  end
+
+  mcfly_lookup :get_matches, sig: 3 do
+    |pt, attrs, params|
+    get_matches_(pt, attrs, params)
+  end
+
+  def compute(*args)
+    base_compute(*args)
+  end
+
+end

data/spec/dummy/app/models/gemini/my_rule_type.rb

@@ -0,0 +1,5 @@
+class Gemini::MyRuleType < ActiveRecord::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['SimpleRule','ComplexRule']
+end

data/spec/dummy/app/models/gemini/xyz_enum.rb

@@ -0,0 +1,5 @@
+class Gemini::XyzEnum < ActiveRecord::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['Vanilla', 'Chocolate', 'Strawberry']
+end

data/spec/dummy/app/models/gemini/xyz_rule.rb

@@ -0,0 +1,63 @@
+class Gemini::XyzRule < Marty::DeloreanRule
+  self.table_name = 'gemini_xyz_rules'
+
+  gen_mcfly_lookup :lookup, {
+    name: false,
+  }
+
+  cached_mcfly_lookup :lookup_id, sig: 2 do
+    |pt, group_id|
+    find_by_group_id group_id
+  end
+
+  mcfly_validates_uniqueness_of :name, scope: [:start_dt, :end_dt]
+
+  def self.results_cfg_var
+    'RULEOPTS_XYZ'
+  end
+  def self.guard_info
+    super + {"flavors" => { multi: true, type: :string,
+                            enum: Gemini::XyzEnum,
+                            width: 150},
+             "guard_two" => { type: :string,
+                              enum: Gemini::GuardTwo,
+                              width: 100},
+             "g_date" => { type: :date },
+             "g_datetime" => { type: :datetime },
+             "g_string" => { type: :string,
+                              width: 100},
+             "g_bool" => { type: :boolean,
+                              width: 100},
+             "g_range1" => { type: :range,
+                              width: 100},
+             "g_range2" => { type: :range,
+                              width: 100},
+             "g_integer" => { type: :integer,
+                              width: 100}
+    }
+  end
+
+  mcfly_lookup :get_matches, sig: 3 do
+    |pt, attrs, params|
+    get_matches_(pt, attrs, params)
+  end
+
+  def compute(*args)
+    base_compute(*args)
+  end
+  def compute_xyz(pt, xyz_param)
+    # Given a set of parameters, compute the RULE adjustment.  Returns
+    # {} if precondition is not met.
+
+    xyz_keys =  computed_guards.select{|k,_|k.starts_with?("xyz_")}.keys
+    return {} unless xyz_keys.present?
+
+    eclass = engine && engine.constantize || Marty::RuleScriptSet
+    engine = eclass.new(pt).get_engine(self)
+    res = engine.evaluate("XyzNode", xyz_keys, {"xyz_param"=>xyz_param})
+
+    res.all?
+  end
+
+
+end

data/spec/dummy/app/models/gemini/xyz_rule_type.rb

@@ -0,0 +1,5 @@
+class Gemini::XyzRuleType < ActiveRecord::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['XRule','YRule', 'ZRule']
+end

data/spec/dummy/config/locales/en.yml

@@ -3,3 +3,13 @@
 
 en:
   hello: "Hello world"
+  rule: "Rules"
+  
+  attributes:
+    g_array: "Array Guard"
+    g_single: "Single Guard"
+    g_bool: "Bool Guard"
+    g_range: "Range Guard"
+    g_range1: "Range Guard 1"
+    g_range2: "Range Guard 2"
+    other_flag: "Other"

data/spec/dummy/db/migrate/20171220150101_add_rule_type_enums.rb

@@ -0,0 +1,14 @@
+class AddRuleTypeEnums < ActiveRecord::Migration
+  def change
+    [Gemini::XyzRuleType, Gemini::MyRuleType, Gemini::GuardOne,
+     Gemini::GuardTwo, Gemini::XyzEnum].each do |cl|
+      values = cl::VALUES
+      str_values = values.map {|v| ActiveRecord::Base.connection.quote v}.
+                   join(',')
+      clstr = cl.to_s.sub('Gemini::','').underscore
+      execute <<-SQL
+         CREATE TYPE #{clstr} AS ENUM (#{str_values})
+      SQL
+    end
+  end
+end

data/spec/dummy/db/migrate/20171221095312_create_gemini_my_rules.rb

@@ -0,0 +1,22 @@
+class CreateGeminiMyRules < McflyMigration
+  include Marty::Migrations
+  def change()
+    create_table :gemini_my_rules do |t|
+      t.string :name, null: false
+      t.column :rule_type, :my_rule_type, null: false
+      t.datetime :start_dt, null: false
+      t.datetime :end_dt, null: true
+      t.string :engine, null: false, default: 'Gemini::MyRuleScriptSet'
+      t.boolean :other_flag
+      t.jsonb :simple_guards,    null: false, default: {}
+      t.json  :computed_guards,  null: false, default: {}
+      t.jsonb :grids,            null: false, default: {}
+      t.json  :results,          null: false, default: {}
+      t.jsonb :fixed_results,    null: false, default: {}
+    end
+    execute("CREATE OR REPLACE FUNCTION to_numrange(val text) "\
+            "RETURNS numrange AS "\
+            "$BODY$ select numrange(val); $BODY$ "\
+            "LANGUAGE SQL IMMUTABLE;")
+   end
+end

data/spec/dummy/db/migrate/20171221095359_create_gemini_xyz_rules.rb

@@ -0,0 +1,21 @@
+class CreateGeminiXyzRules < McflyMigration
+  include Marty::Migrations
+  def change()
+    create_table :gemini_xyz_rules do |t|
+      t.string :name, null: false
+      t.column :rule_type, :xyz_rule_type, null: false
+      t.datetime :start_dt, null: false
+      t.datetime :end_dt, null: true
+      t.string :engine, null: false, default: 'Gemini::XyzRuleScriptSet'
+      t.jsonb :simple_guards,    null: false, default: {}
+      t.json  :computed_guards,  null: false, default: {}
+      t.jsonb :grids,            null: false, default: {}
+      t.json  :results,          null: false, default: {}
+      t.jsonb :fixed_results,    null: false, default: {}
+    end
+    execute("CREATE OR REPLACE FUNCTION to_numrange(val text) "\
+            "RETURNS numrange AS "\
+            "$BODY$ select numrange(val); $BODY$ "\
+            "LANGUAGE SQL IMMUTABLE;")
+   end
+end

data/spec/dummy/db/migrate/20171222150100_add_rule_indices.rb

@@ -0,0 +1,34 @@
+class AddRuleIndices < ActiveRecord::Migration
+  def change
+    ['gemini_my_rules',  'g_array',    :array,
+     'gemini_my_rules',  'g_single',   :scalar,
+     'gemini_my_rules',  'g_string',   :scalar,
+     'gemini_my_rules',  'g_bool',     :scalar,
+     'gemini_my_rules',  'g_integer',  :scalar,
+     'gemini_my_rules',  'g_range',    :range,
+     'gemini_xyz_rules', 'flavors',    :array,
+     'gemini_xyz_rules', 'guard_two',  :scalar,
+     'gemini_xyz_rules', 'g_date',     :scalar,
+     'gemini_xyz_rules', 'g_datetime', :scalar,
+     'gemini_xyz_rules', 'g_bool',     :scalar,
+     'gemini_xyz_rules', 'g_integer',  :scalar,
+     'gemini_xyz_rules', 'g_range1',   :range,
+     'gemini_xyz_rules', 'g_range2',   :range,
+    ].in_groups_of(3).each do |table, field, type|
+      index = { array: "GIN",
+                scalar: "BTREE",
+                range: "GIST" }[type]
+      case type
+      when :array, :scalar
+        col="(simple_guards->'#{field}')"
+      when :range
+        col="(to_numrange(simple_guards->>'#{field}'))"
+      end
+      sql =<<-SQL
+        CREATE INDEX idx_#{table}_#{field} ON #{table} USING #{index}
+        (#{col});
+      SQL
+      execute sql
+    end
+  end
+end

data/spec/dummy/db/seeds.rb

@@ -74,4 +74,4 @@ STATES ||=
 
 STATES.each { |s| Gemini::State.create(full_name: s[0], name: s[1]) }
 
-######################################################################
+######################################################################

data/spec/dummy/delorean/base_code.dl

@@ -0,0 +1,6 @@
+BaseCode:
+    p1 =?
+    p2 =?
+    flavor =?
+
+    base_value = "%s --> %d" % [flavor, p1*p2]