ruby_codex 0.0.8 → 0.0.9

data/lib/ruby_codex.rb

@@ -95,6 +95,11 @@ class Codex
       key.merge({ 
         :func => Proc.new { |x| func_name.call(x) },
         :sig => Proc.new { |x| x.children.drop(2).map { |y| type.call(y) } },
+        :norm_code => Proc.new do |x| 
+          name = func_name.call(x)
+          sig = x.children.drop(2).map { |y| type.call(y) }.join(",")
+          "#{name}(#{sig})"
+        end
       }),
       data_core.merge({
         :info => Proc.new { |x| info.call(without_caller(x)) },
@@ -102,6 +107,8 @@ class Codex
       }),
       combine,
       Proc.new do |db,keys,values| 
+        primatives = ["str","int","float","array","hash"]
+        all_prim = keys[:sig].all? { |x| primatives.include?(x) }
         query = db.where( :type => keys[:type], :func => keys[:func], :sig => keys[:sig]).first
         query_count = query.nil? ? 0 : query.count
         func = db.where(:type => keys[:type], :func => keys[:func], :sig => {:$ne => keys[:sig]}).sort(:count => -1).limit(1).first
@@ -118,7 +125,7 @@ class Codex
             "Function call #{keys[:func]}:#{keys[:sig].join(",")} has appeared #{query_count.to_s} times, " +
             alt_text,
           :unlikely => Proc.new do |ac=5,t=1024| 
-            query_count == 0 && alt_count >= ac || alt_count >= t * (query_count + 1)
+            all_prim && query_count == 0 && alt_count >= ac || alt_count >= t * (query_count + 1)
           end
         }
       end
@@ -131,13 +138,18 @@ class Codex
         :type => Proc.new { "func_chain" },
         :f1 => Proc.new { |x| func_name.call(x) },
         :f2 => Proc.new { |x| func_name.call(x.children.first) },
+        :norm_code => Proc.new do |x|
+          f1 = func_name.call(x)
+          f2 = func_name.call(x.children.first)
+          "#{f1}.#{f2}"
+        end
       }),
       data_core,
       combine,
       Proc.new do |db,keys,data|
         query = db.where(keys).first
         query_count = query.nil? ? 0 : query.count
-        fs = [:f1,:f2].map { |f| db.where(:type => "send", :func => keys[f]).size }
+        fs = [:f1,:f2].map { |f| db.where(:type => "send", :func => keys[f]).sum(:count) }
         { :keys => keys, 
           :message => 
             "Function #{keys[:f1]} has appeared #{fs[0].to_s} times " +
@@ -169,6 +181,7 @@ class Codex
       key.merge({
         :type => Proc.new { "ident" },
         :ident => Proc.new { |x| x.children.first.to_s },
+        :norm_code => Proc.new { |x| x.children.first.to_s + " ="}
       }),
       data_core.merge({
         :ident_type => Proc.new { |x| type.call(x.children[1]) rescue nil }
@@ -177,9 +190,10 @@ class Codex
         :ident_types => Proc.new { |v| v.group_by { |y| y[:ident_type] }.map_hash { |x| x.size } }
       }),
       Proc.new { |db, keys, data|
+        #pp keys
         primatives = ["str","int","float","array","hash"]
         query = db.where(keys).first
-        if query && primatives.include?(keys[:ident_type])
+        if query && primatives.include?(data[:ident_type])
           types = query.ident_types.select { |k,v| primatives.include? k }
           types.default = 0
           best = types.select { |k,v| k != data[:ident_type] }.sort_by{ |k,v| v*-1 }.first
@@ -190,7 +204,7 @@ class Codex
               "times as #{data[:ident_type].to_s} and #{best_str}", 
               :unlikely => Proc.new do |ac=5,t=8| 
                 if best
-                  types[keys[:ident_type]] == 0 && best[1] >= ac || best[1] >= t * (types[keys[:ident_type]] + 1)
+                  (types[keys[:ident_type]] == 0 && best[1] >= ac) || (best[1] >= t * (types[keys[:ident_type]] + 1))
                 else
                   false
                 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_codex
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors: