ruby_codex 0.0.6 → 0.0.7

data/lib/ruby_codex.rb

@@ -28,15 +28,15 @@ class Codex
     end
 
     key = {
-      :type => type
+      :type => type,
+      :info => info,
+      :func_info => func_info
     }
 
     data_core = {
       :file => Proc.new { |node, f, p| f },
       :project => Proc.new { |node, f, p| p },
       :line => Proc.new { |node, f, p| node.loc ? node.loc.line : nil },
-      :info => info,
-      :func_info => func_info,
       :orig_code => Proc.new { |node, f, p| Unparser.unparse(node) rescue nil },
     }
 
@@ -49,8 +49,6 @@ class Codex
           {:code => x[:orig_code], :file => x[:file], :line => x[:line]} 
         end.uniq },
       :count => Proc.new { |v| v.map { |x| x[:orig_code] }.count },
-      :info => Proc.new { |v| v.first[:info] }, # some process may overwrite
-      :func_info => Proc.new { |v| v.first[:func_info] }
     }
 
     @nodes[:block] = DataNode.new(
@@ -60,18 +58,17 @@ class Codex
         :func => Proc.new { |x| func_name.call(x.children.first) },
         :body => Proc.new { |x| normalize_nodes(x.children.last) },
         :arg_size => Proc.new { |x| x.children[1].children.size },
+        :info => Proc.new { |x| info.call(block_without_caller(x)) },
+        :func_info => Proc.new { |x| func_info.call(block_without_caller(x)) },
         :ret_val => Proc.new do |x| 
             body = x.children.last
             ret = type.call(body) == "begin" ? body.children.last : body
             typ = type.call(ret)
             typ == "send" ? func_name.call(ret) : typ
           end,
-        :norm_code => Proc.new { |x| 
-          normal_node(x) do |x|
-            Unparser.unparse(x.updated(nil, x.children.map.with_index do |y,i|
-              i == 0 ? without_caller(y) : y
-            end)) rescue nil
-          end } 
+        :norm_code => Proc.new do |x| 
+          normal_node(x) { |x| Unparser.unparse(block_without_caller(x)) rescue nil } 
+        end
       }),
       data_core.merge({
         :args => Proc.new { |x| x.children[1].children.map{ |y| y.children[0].to_s }} 
@@ -89,7 +86,7 @@ class Codex
             "We've seen #{keys[:func]} blocks returning the #{keys[:ret_val]} type #{query_count.to_s} " +
             "times, and we've seen #{keys[:func]} blocks #{blocks.to_s} times and #{keys[:ret_val]} " +
             "returned #{rets.to_s} times.",
-          :unlikely => Proc.new { |gt=1,bt = 0,rt = 0| query_count < gt && blocks > bt && rets > rt}
+          :unlikely => Proc.new { |gt=1,bt = 5,rt = 5| query_count < gt && blocks > bt && rets > rt}
         }
       }
     )
@@ -100,28 +97,34 @@ class Codex
       key.merge({ 
         :func => Proc.new { |x| func_name.call(x) },
         :norm_code => Proc.new { |x| normal_node(x) { |x| Unparser.unparse(without_caller(x)) rescue nil } },
-        :sig => Proc.new { |x| x.children.drop(2).map { |y| type.call(y) } }
+        :sig => Proc.new { |x| x.children.drop(2).map { |y| type.call(y) } },
+        :info => Proc.new { |x| info.call(without_caller(x)) },
+        :func_info => Proc.new { |x| func_info.call(without_caller(x)) }
       }),
       data_core,
       combine,
       Proc.new { |db,keys,values| 
-        query = db.where(keys).first
-        query_count = query.nil? ? 0 : query.count
-        func = db.where(:type => keys[:type], :func => keys[:func]).sort(:count => -1).limit(1).first
-        alt_text = 
-          if func
-            alt_count = func.count 
-            "and the most common alternative #{func.norm_code} has appeared #{alt_count.to_s} times."
-          else
-            alt_count = 0
-            "and we've seen no known alternative."
-          end
-        { :keys => keys,
-          :message =>
-            "Function call #{keys[:norm_code]} has appeared #{query_count.to_s} times, " +
-            alt_text,
-          :unlikely => Proc.new { |t=10| alt_count > t * (query_count + 1)}
-        }
+        if keys[:norm_code] != nil # Hack for binary operators that disappear
+          query = db.where(keys).first
+          query_count = query.nil? ? 0 : query.count
+          func = db.where(:type => keys[:type], :func => keys[:func]).sort(:count => -1).limit(1).first
+          alt_text = 
+            if func
+              alt_count = func.count 
+              "and the most common alternative #{func.norm_code} has appeared #{alt_count.to_s} times."
+            else
+              alt_count = 0
+              "and we've seen no known alternative."
+            end
+          { :keys => keys,
+            :message =>
+              "Function call #{keys[:norm_code]} has appeared #{query_count.to_s} times, " +
+              alt_text,
+            :unlikely => Proc.new { |t=10| alt_count > t * (query_count + 1)}
+          }
+        else
+          { :message => "Never Seen", :unlikely => Proc.new { false } }
+        end
       }
     )
 
@@ -131,12 +134,11 @@ class Codex
       key.merge({ 
         :type => Proc.new { "func_chain" },
         :f1 => Proc.new { |x| func_name.call(x) },
-        :f2 => Proc.new { |x| func_name.call(x.children.first) }
-      }),
-      data_core.merge({
+        :f2 => Proc.new { |x| func_name.call(x.children.first) },
         :info => Proc.new { 0 },
         :func_info => Proc.new { 0 }
       }),
+      data_core,
       combine,
       Proc.new do |db,keys,data|
         query = db.where(keys).first
@@ -171,19 +173,20 @@ class Codex
       key.merge({
         :type => Proc.new { "ident" },
         :ident => Proc.new { |x| x.children.first.to_s },
-      }),
-      data_core.merge({
-        :ident_type => Proc.new { |x| type.call(x.children[1]) rescue nil },
         :info => Proc.new { 0 },
         :func_info => Proc.new { 0 }
       }),
+      data_core.merge({
+        :ident_type => Proc.new { |x| type.call(x.children[1]) rescue nil }
+      }),
       combine.merge({
         :ident_types => Proc.new { |v| v.group_by { |y| y[:ident_type] }.map_hash { |x| x.size } }
       }),
       Proc.new { |db, keys, data|
+        primatives = ["str","int","float","array","hash"]
         query = db.where(keys).first
-        if query
-          types = query.ident_types.select { |k,v| ["str","int","float","array","hash"].include? k }
+        if query && primatives.include?(keys[: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
           best_str = best ? "#{best[1].to_s} times as #{best[0].to_s}" : "never as anything else."
@@ -228,11 +231,24 @@ class Codex
     unlikely
   end   
   
+  def tree_walk(ast, &block)
+    if ast.is_a?(AST::Node)
+      yield ast if block
+      ast.children.each { |node| tree_walk(node, &block) }
+    end
+  end
+  
   def without_caller(node) 
     node.updated(nil, node.children.map.with_index do |x,i|
       i == 0 ? nil : x
     end)
   end
+  
+  def block_without_caller(node)
+    node.updated(nil, node.children.map.with_index do |y,i| 
+      i == 0 ? without_caller(y) : y
+    end)
+  end
 
   def normal_node(node)
     norm = ASTNormalizer.new

metadata

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