marty 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77e6182b8e9feb509b401e87c0fd8233bfa6777a
-  data.tar.gz: 78707cf573b3c33d872b0346a4751c38f26f14d3
+  metadata.gz: bebe74227eb431e5b56683fb41cdf571d65ad9ae
+  data.tar.gz: 52e50bf586ade69e69501f408ba8795d5296a108
 SHA512:
-  metadata.gz: 7ca495f675cbe04547f2d885a6661f1da7cc6793bf7c9fc9a55759e24b4877df7878a032347dd3c0d81b5c5122b8cc504d47ed0560cdd2bd73ea8e0a51ece0d4
-  data.tar.gz: 1898fd8cd7daf7d3e7d2d0f8ed8560a45c7874339b2617291f782d005910a0d6ab8c3b68d5630c32521a597bfc27883737c4b28552a08745675742f144e5367e
+  metadata.gz: 6f047a2e07c4c2808c7385e7558e9c1243710e62385f317a7ab472175f78e22fb4fd74119d3d30b5cb2117d0ee3e7b834f6077e1ab463b9df887dae4f28c6632
+  data.tar.gz: 68b1e9630134ac55a561a3e9b4df22ac4e7dc0fd6bbc43fcb032ec505c4e98c70c4a521c368d317267a5687569ab851eff8b4861ca53a273afda14f89e1d153d

data/app/components/marty/auth_app.rb

@@ -42,9 +42,11 @@ class Marty::AuthApp < Marty::SimpleApp
     if user
       Netzke::Base.controller.set_user(user)
       client.netzke_set_result(true)
+      true
     else
       client.netzke_set_result(false)
       client.netzke_notify("Wrong credentials")
+      false
     end
   end
 

data/app/components/marty/promise_view.rb

@@ -128,7 +128,7 @@ class Marty::PromiseView < Netzke::Tree::Base
 
   endpoint :clear do |params|
     Marty::Promise.cleanup(true)
-    client.on_refresh
+    client.netzke_on_refresh
   end
 
   def get_records params

data/app/components/marty/simple_app/client/simple_app.js

@@ -41,7 +41,7 @@
   },
 
   netzkeLoadComponentByAction: function(action){
-    this.router.add(action.name);
+    this.router.add(action.name.underscore());
   },
 
   onToggleConfigMode: function(params){

data/app/models/marty/data_grid.rb

@@ -147,13 +147,11 @@ class Marty::DataGrid < Marty::Base
     data_type.constantize rescue nil
   end
 
-  def lookup_grid_distinct(pt, h, return_grid_data=false, distinct=true)
-    isets = {}
-
-    (dir_infos("v") + dir_infos("h")).each do
-      |inf|
+  def query_grid_dir(h, infos)
+    return [0] if infos.empty?
 
-      dir, type, attr = inf["dir"], inf["type"], inf["attr"]
+    sqla = infos.map do |inf|
+      type, attr = inf["type"], inf["attr"]
 
       next unless h.has_key?(attr)
 
@@ -161,6 +159,8 @@ class Marty::DataGrid < Marty::Base
 
       ix_class = INDEX_MAP[type] || INDEX_MAP["string"]
 
+      q = "key IS NULL"
+
       unless v.nil?
         q = case type
             when "boolean"
@@ -169,7 +169,7 @@ class Marty::DataGrid < Marty::Base
               "key @> ?"
             else # "string", "integer", AR klass
               "key @> ARRAY[?]"
-            end
+            end + " OR #{q}"
 
         # FIXME: very hacky -- need to cast numrange/intrange values or
         # we get errors from PG.
@@ -185,34 +185,35 @@ class Marty::DataGrid < Marty::Base
             else # AR class
               v.to_s
             end
-
-        ixa = ix_class.
-              where(data_grid_id: group_id,
-                    created_dt:   created_dt,
-                    attr:         inf["attr"],
-                   ).
-              where(q, v).uniq.pluck(:index)
       end
 
-      if v.nil? || ixa.empty?
-        ixa = ix_class.
-          where(data_grid_id: group_id,
-                created_dt:   created_dt,
-                attr:         inf["attr"],
-                key:          nil,
-                ).uniq.pluck(:index)
-      end
+      # FIXME: could potentially order results by key NULLS LAST.
+      # This would prefer more specific rather than wild card
+      # solutions.  However, would need to figure out how to preserve
+      # ordering on subsequent INTERSECT operations.
+      ixq = ix_class.
+            select(:index).
+            distinct.
+            where(data_grid_id: group_id,
+                  created_dt:   created_dt,
+                  attr:         inf["attr"],
+                 ).
+            where(q, v).to_sql
+    end.compact
 
-      # FIXME: optimization: bail out if one of the sets is empty.
-      # Or, even better, we should submit all the queris together.
-      isets[dir] = isets[dir] ? isets[dir] & ixa : Set.new(ixa)
-    end
+    sql = sqla.join(" INTERSECT ")
+
+    self.class.connection.execute(sql).to_a.map { |h| h["index"].to_i }
+  end
+
+  def lookup_grid_distinct(pt, h, return_grid_data=false, distinct=true)
+    isets = ["h", "v"].each_with_object({}) do |dir, isets|
+      infos = dir_infos(dir)
 
-    ["h", "v"].each do |dir|
-      isets[dir] = Set[0] if !isets[dir] && dir_infos(dir).empty?
+      isets[dir] = query_grid_dir(h, infos)
 
       unless isets[dir] or return_grid_data
-        attrs = dir_infos(dir).map { |inf| inf["attr"] }
+        attrs = infos.map { |inf| inf["attr"] }
 
         raise "#{dir} attrs not provided: %s" % attrs.join(',')
       end
@@ -221,7 +222,8 @@ class Marty::DataGrid < Marty::Base
         distinct && isets[dir] && isets[dir].count > 1
     end
 
-    vi, hi = isets["v"].first, isets["h"].first if isets["v"] && isets["h"]
+    # deterministic result: pick min index when there's a choice
+    vi, hi = isets["v"].min, isets["h"].min if isets["v"] && isets["h"]
 
     raise "DataGrid lookup failed #{name}" unless (vi && hi) or lenient or
       return_grid_data
@@ -343,29 +345,22 @@ class Marty::DataGrid < Marty::Base
     meta_rows = dt_row.empty? ? [] : [dt_row]
 
     meta_rows += metadata.map { |inf|
-      [
-       inf["attr"],
-       inf["type"],
-       inf["dir"],
-       inf["rs_keep"] || "",
-      ]
+      [inf["attr"], inf["type"], inf["dir"], inf["rs_keep"] || ""]
     }
 
     v_infos, h_infos = dir_infos("v"), dir_infos("h")
 
-    h_key_rows = h_infos.map do
-      |inf|
-
+    h_key_rows = h_infos.map { |inf|
       [nil]*v_infos.count + self.class.export_keys(inf)
-    end
+    }
 
     transposed_v_keys = v_infos.empty? ? [[]] :
       v_infos.map {|inf| self.class.export_keys(inf)}.transpose
 
-    data_rows = transposed_v_keys.each_with_index.map do
-      |keys, i|
+    data_rows = transposed_v_keys.each_with_index.map { |keys, i|
       keys + (self.data[i] || [])
-    end
+    }
+
     [meta_rows, h_key_rows, data_rows]
   end
 
@@ -460,8 +455,12 @@ class Marty::DataGrid < Marty::Base
     raise "must have a blank row separating metadata" unless
       blank_index
 
-    data_type = nil
-    lenient   = false
+    raise "can't import grid with trailing blank column" if
+      rows.map { |r| r.last.nil? }.all?
+
+    raise "last row can't be blank" if rows[-1].all?(&:nil?)
+
+    data_type, lenient = nil, false
 
     # check if there's a data_type definition
     dt, *x = rows[0]
@@ -661,10 +660,10 @@ class Marty::DataGrid < Marty::Base
 
   def opposite_sign(op)  # toggle sign and inclusivity
     {
-      lt: :ge,
-      le: :gt,
-      gt: :le,
-      ge: :lt,
+      :<  => :>=,
+      :<= => :>,
+      :>  => :<=,
+      :>= => :<,
     }[op]
   end
 
@@ -682,35 +681,35 @@ class Marty::DataGrid < Marty::Base
       lhv, rhv = orig_lhv || -Float::INFINITY, orig_rhv || Float::INFINITY
 
       case op
-      when :ge, :gt
+      when :>=, :>
         next if value > rhv
 
         if value == rhv
-          if rhop == :le && op == :ge
+          if rhop == :<= && op == :>=
             rewrite_a.push(
-              [index, rewrite_range(lhop, orig_lhv, orig_rhv, :lt)])
+              [index, rewrite_range(lhop, orig_lhv, orig_rhv, :<)])
           end
         elsif value > lhv
           rewrite_a.push(
             [index, rewrite_range(lhop, orig_lhv, value, opposite_sign(op))])
-        elsif value == lhv && lhop == :ge && op == :gt
-          rewrite_a.push([index, rewrite_range(:ge, value, value, :le)])
+        elsif value == lhv && lhop == :>= && op == :>
+          rewrite_a.push([index, rewrite_range(:>=, value, value, :<=)])
         elsif value <= lhv
           prune_a.push(index)
         end
-      when :le, :lt
+      when :<=, :<
         next if value < lhv
 
         if value == lhv
-          if lhop == :ge && op == :le
+          if lhop == :>= && op == :<=
             rewrite_a.push(
-              [index, rewrite_range(:gt, orig_lhv, orig_rhv, rhop)])
+              [index, rewrite_range(:>, orig_lhv, orig_rhv, rhop)])
           end
         elsif value < rhv
           rewrite_a.push(
             [index, rewrite_range(opposite_sign(op), value, orig_rhv, rhop)])
-        elsif value == rhv && rhop == :le && op == :lt
-          rewrite_a.push([index, rewrite_range(:ge, value, value, :le)])
+        elsif value == rhv && rhop == :<= && op == :<
+          rewrite_a.push([index, rewrite_range(:>=, value, value, :<=)])
         elsif value >= rhv
           prune_a.push(index)
         end
@@ -753,18 +752,18 @@ class Marty::DataGrid < Marty::Base
     lhv = lhs.blank? ? nil : lhs.to_f
     rhv = rhs.blank? ? nil : rhs.to_f
 
-    [lboundary == '(' ? :gt : :ge, lhv, rhv, rboundary == ')' ? :lt : :le]
+    [lboundary == '(' ? :> : :>=, lhv, rhv, rboundary == ')' ? :< : :<=]
   end
 
   def rewrite_range(lb, lhv, rhv, rb)
-    lboundary = lb == :gt ? '(' : '['
+    lboundary = lb == :> ? '(' : '['
 
     # even though numranges are float type, we don't want to output ".0"
     # for integer values.  So for values like that we convert to int
     # first before conversion to string
     lvalue = (lhv.to_i == lhv ? lhv.to_i : lhv).to_s
     rvalue = (rhv.to_i == rhv ? rhv.to_i : rhv).to_s
-    rboundary = rb == :lt ? ')' : ']'
+    rboundary = rb == :< ? ')' : ']'
     lboundary + lvalue + ',' + rvalue + rboundary
   end
 
@@ -774,16 +773,8 @@ class Marty::DataGrid < Marty::Base
 
     opstr, ident = match[1..2]
 
-    orig_op = {
-      '<'  => :lt,
-      '>'  => :gt,
-      '<=' => :le,
-      '>=' => :ge,
-      ''   => :inc,
-    }[opstr]
-
     # data grid value is expressed as what to keep
     # we convert to the opposite (what to prune)
-    [opposite_sign(orig_op), ident]
+    [opposite_sign(opstr.to_sym), ident]
   end
 end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.0.1"
+  VERSION = "1.0.3"
 end

data/spec/models/data_grid_spec.rb

@@ -127,6 +127,25 @@ n\tnumrange\tv
 true\t1\t<10\t<10.0\tY
 \t2\t\t\tM
 false\t\t>10\t\tN
+EOS
+
+Gg = <<EOS
+lenient
+i1\tinteger\tv
+i2\tinteger\tv
+
+\t1\t1
+2\t1\t21
+2\t\t20
+EOS
+
+Gh = <<EOS
+lenient
+property_state\tstring\tv
+county_name\tstring\tv
+
+NY\t\t10
+\tR\t8
 EOS
 
     before(:each) do
@@ -140,6 +159,20 @@ EOS
       [res["result"], res["name"]]
     end
 
+    describe "imports" do
+      it "should not allow imports with trailing blank columns" do
+        expect {
+          dg_from_import("G1", G1.gsub("\n", "\t\n"))
+        }.to raise_error(RuntimeError)
+      end
+
+      it "should not allow imports with last blank row" do
+        expect {
+          dg_from_import("Gh", Gh+"\t\t\n")
+        }.to raise_error(RuntimeError)
+      end
+    end
+
     describe "validations" do
       it "a basic data grid should load ok" do
         dg_from_import("G1", G1)
@@ -223,7 +256,7 @@ EOS
 
       before(:each) do
         ["G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "Ga", "Gb",
-         "Gc", "Gd", "Ge", "Gf"].each { |g|
+         "Gc", "Gd", "Ge", "Gf", "Gg", "Gh"].each { |g|
           dg_from_import(g, "Marty::DataGridSpec::#{g}".constantize)
         }
       end
@@ -232,32 +265,27 @@ EOS
         let(:dg) { Marty::DataGrid.lookup(pt, "Gf") }
 
         it 'true returns Y' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"b"=>true}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"b"=>true}, false)
           expect(res).to eq('Y')
         end
 
         it '13 returns N' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13}, true)
           expect(res).to eq('N')
         end
 
         it '13 & numrange 0 returns nil' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "n"=>0}, true)
-          expect(res).to be_nil
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "n"=>0}, true)
+          expect(res).to eq('N')
         end
 
         it '13 & int4range 15 returns N' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "i4"=>15}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "i4"=>15}, true)
           expect(res).to eq('N')
         end
 
         it '13 & int4range 1 returns nil' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "i4"=>1}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "i4"=>1}, true)
           expect(res).to be_nil
         end
 
@@ -268,12 +296,38 @@ EOS
         end
 
         it '13, numrange 15 returns N' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "n"=>15}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "n"=>15}, true)
           expect(res).to eq('N')
         end
       end
 
+      it "should handle ambiguous lookups" do
+        dg = Marty::DataGrid.lookup(pt, "Gh")
+
+        h1 = {
+          "property_state" => "NY",
+          "county_name"    => "R",
+        }
+
+        res = Marty::DataGrid.lookup_grid(pt, dg, h1, false)
+        expect(res).to eq(10)
+      end
+
+      it "should handle ambiguous lookups (2)" do
+        dg = Marty::DataGrid.lookup(pt, "Gg")
+        res = Marty::DataGrid.
+              lookup_grid(pt, dg, {"i1"=>2, "i2"=>1}, false)
+        expect(res).to eq(1)
+
+        res = Marty::DataGrid.
+              lookup_grid(pt, dg, {"i1"=>3, "i2"=>1}, false)
+        expect(res).to eq(1)
+
+        res = Marty::DataGrid.
+              lookup_grid(pt, dg, {"i1"=>2, "i2"=>3}, false)
+        expect(res).to eq(20)
+      end
+
       it "should handle non-distinct lookups" do
         dg = Marty::DataGrid.lookup(pt, "Ge")
         res = Marty::DataGrid.lookup_grid(pt, dg, {"ltv"=>500}, false)
@@ -372,11 +426,12 @@ EOS
       it "should handle matches which also have a wildcard match" do
         dg_from_import("G9", G9)
 
-        res = lookup_grid_helper('infinity',
-                                 "G9",
-                                 {"state" => "CA", "ltv" => 81},
-                                )
-        expect(res).to eq [123,"G9"]
+        expect {
+          res = lookup_grid_helper('infinity',
+                                   "G9",
+                                   {"state" => "CA", "ltv" => 81},
+                                  )
+        }.to raise_error(RuntimeError)
 
         res = lookup_grid_helper('infinity',
                                  "G9",
@@ -449,7 +504,8 @@ EOS
       end
 
       it "should handle DataGrid typed data grids" do
-        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).to eq "Marty::DataGrid"
+        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).
+          to eq "Marty::DataGrid"
         g1 = Marty::DataGrid.lookup('infinity', "G1")
 
         res = lookup_grid_helper('infinity',
@@ -461,7 +517,8 @@ EOS
       end
 
       it "should handle multi DataGrid lookups" do
-        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).to eq "Marty::DataGrid"
+        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).
+          to eq "Marty::DataGrid"
         g1 = Marty::DataGrid.lookup('infinity', "G1")
 
         h = {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-20 00:00:00.000000000 Z
+date: 2016-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg