radar-lookup 0.1.0 → 0.2.0

data/LICENSE

@@ -1,5 +1,7 @@
 Copyright (c) 2009 Ryan Bigg
 
+Contributions by:  Josh Goebel / Dreamer3
+
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including

data/README.md

@@ -14,6 +14,7 @@
 It also takes options:
 
 * `-c or --clear` will delete the database and update the api again. This can take a minute or two.
+* `-t or --text` is useful for when you don't want lookup to spam tabs into your browser willy-nilly.
 
 ## How it finds them
 

data/bin/lookup

@@ -1,3 +1,79 @@
 #!/usr/bin/ruby
-require 'rubygems'
-require 'lookup'
+require 'optparse'
+
+# How many methods / constants to return.
+THRESHOLD = 5
+MAC = !!/darwin/.match(PLATFORM)
+WINDOWS = !!/win/.match(PLATFORM) if not MAC
+
+def clear_database
+  file = File.join(File.dirname(__FILE__), "lookup.sqlite3")
+  FileUtils.rm(file) if File.exists?(file) 
+end
+
+def display_url(result, options={})
+  # if we're not on mac or windows we default to text output
+  if OPTIONS[:text] or not (MAC || WINDOWS)
+    s = options[:number] ? options[:number].to_s + ". " : ""
+    # if we're a method then show the constant in parans
+    s += "(#{result.constant.name}) " if result.respond_to?(:constant)
+    s += "#{result.name} #{result.url}"
+    puts s
+  elsif MAC 
+    `open #{result.url}`
+  elsif WINDOWS 
+    `start #{result.url}`
+  end
+end
+
+def display_results(results, search_string)
+  if results.empty?
+    puts "There were no results matching #{search_string}."
+    # if entry
+    #   puts "There are no constants that match #{name} and contain #{entry}."
+    # else
+    #   puts "There are no constants that match #{name}"
+    # end
+  elsif results.size == 1
+    display_url(results.first)
+  elsif results.size <= THRESHOLD
+    results.each_with_index do |result, i|
+      display_url(result, :number => i+1)
+    end
+  else
+    puts "Please refine your query, we found #{results.size} results (threshold is #{THRESHOLD})."
+  end
+end
+
+OPTIONS = {}
+op=OptionParser.new do |opts|
+  opts.banner = "Usage: lookup <constant|method> [method] [OPTIONS]"
+
+  opts.on("-c", "--clear", "Clear database") do
+    OPTIONS[:clear] = true
+  end
+  opts.on("-t", "--text", "Text only") do
+    OPTIONS[:text] = true
+  end
+end
+op.parse!
+
+clear_database if OPTIONS[:clear]
+
+
+local_lib=File.join(File.dirname(__FILE__), "../lib/lookup")
+if File.exists?(local_lib + ".rb")
+  require local_lib
+else
+  require 'rubygems'
+  require 'lookup' 
+end
+
+search_string=ARGV[0..-1].join(" ")
+if search_string.strip.empty?
+  puts op.help
+  puts
+else
+  results=APILookup.search(ARGV[0..-1])
+  display_results(results, search_string)
+end

data/lib/lookup.rb

@@ -1,16 +1,7 @@
 require 'rubygems'
 require 'activerecord'
-require 'optparse'
 
-MAC = !!/darwin/.match(PLATFORM)
-WINDOWS = !!/win/.match(PLATFORM)
-
-
-# How many methods / constants to return.
-THRESHOLD = 5
-
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => File.join(File.dirname(__FILE__), "lookup.sqlite3"))
-class Lookup
+class APILookup
 
   class << self
     def update
@@ -29,11 +20,11 @@ class Lookup
     end
   
     def update_api(name, url)
-      puts "Updating API for #{name}"
+      puts "Updating API for #{name}..."
       Api.find_or_create_by_name_and_url(name, url)
       update_methods(Hpricot(Net::HTTP.get(URI.parse("#{url}/fr_method_index.html"))), url)
       update_classes(Hpricot(Net::HTTP.get(URI.parse("#{url}/fr_class_index.html"))), url)
-      puts "Updated API for #{name}!"
+      puts "DONE (with #{name})!"
     end
   
     def update_methods(doc, prefix)
@@ -63,49 +54,52 @@ class Lookup
     def find_constant(name, entry=nil)
       # Find by specific name.
       constants = Constant.find_all_by_name(name, :include => "entries")
+      # search for class methods, which is prolly what we want if we can find it
+      constants = Constant.find_all_by_name("#{name}::ClassMethods", :include => "entries") if constants.empty?
       # Find by name beginning with <blah>.
       constants = Constant.all(:conditions => ["name LIKE ?", name + "%"], :include => "entries") if constants.empty?
       # Find by fuzzy.
-      constants = Constant.find_by_sql("select * from constants where name LIKE '%#{name.split("").join("%")}%'") if constants.empty?
-      if constants.size > 1
-        # Narrow it down to the constants that only contain the entry we are looking for.
-        if !entry.nil?
-          constants = constants.select { |constant| !constant.entries.find_by_name(entry).nil? }
-          return [constants, constants.size]
-        else
-          display_constants(constants)
-        end
-        if constants.size == 1
-          if entry.nil?
-            display_constants(constants)
-          else
-            return [[constants.first], 1]
-          end
-        elsif constants.size == 0
-          if entry
-            puts "There are no constants that match #{name} and contain #{entry}."
-          else
-            puts "There are no constants that match #{name}"
-          end
-        else
-          return [constants, constants.size]
-        end
-      else
-        if entry.nil?
-         display_constants(constants)
-        else
-          return [[constants.first], 1]
-        end
+      match="%#{name.split("").join("%")}%"
+      constants = Constant.find_by_sql("select * from constants where name LIKE '#{match}'") if constants.empty?
+      regex=build_regex_from_constant(name)
+      constants = constants.select { |x| x.name =~ regex }
+      # Narrow it down to the constants that only contain the entry we are looking for.
+      if entry
+        constants = constants.select { |constant| !constant.entries.find_by_name(entry).nil? }
+      end
+      constants
+    end
+    
+    # this uses a regex to lock down our SQL finds even more
+    # so that things like AR::Base will not match
+    # ActiveRecord::ConnectionAdapters::DatabaseStatements 
+    def build_regex_from_constant(name)
+      parts=name.split("::").map do |c|
+        c.split("").join("[^:]*")+"[^:]*"
       end
-    end  
+      /#{parts.join("::")}/i
+    end
+    
+    def smart_rails_constant_substitutions(name)
+      parts=name.split("::").map { |x| x.split(":")}.flatten
+      rep = case parts.first.downcase
+        # so it falls back on fuzzy and matches AR as well as ActiveResource
+        when "ar": "ActiveRecord" 
+        when "ares": "ActiveResource" 
+        when "am": "ActionMailer"
+        when "as": "ActiveSupport"
+        when "ac": "ActionController"
+        when "av": "ActionView"
+        else 
+          parts.first
+      end
+      ([rep] + parts[1..-1]).join("::")
+    end
   
     # Find an entry.
     # If the constant argument is passed, look it up within the scope of the constant.
     def find_method(name, constant=nil)
-      if constant
-        constants, number = find_constant(constant, name)
-      end
-      methods = [] 
+      methods = []
       methods = Entry.find_all_by_name(name.to_s)
       methods = Entry.all(:conditions => ["name LIKE ?", name.to_s + "%"]) if methods.empty?
       methods = Entry.find_by_sql("select * from entries where name LIKE '%#{name.split("").join("%")}%'") if methods.empty?
@@ -114,120 +108,32 @@ class Lookup
       methods = methods.sort_by(&:weighting)
     
       if constant
+        constants = find_constant(constant, name)
         methods = methods.select { |m| constants.include?(m.constant) }
       end
-      count = 0
-      if methods.size == 1
-        method = methods.first
-        if OPTIONS[:text]
-          puts display_method(method)
-        elsif MAC
-          `open #{method.url}`
-        elsif WINDOWS
-          `start #{method.url}`
-        else
-          puts display_method(method)
-        end
-      elsif methods.size <= THRESHOLD
-        for method in methods
-          if OPTIONS[:text]
-            puts "#{count += 1}. #{display_method(method)}"
-          elsif MAC
-            `open #{method.url}`
-          elsif WINDOWS 
-            `start #{method.url}`
-          else
-            puts "#{count += 1}. #{display_method(method)}"
-          end
-        end
-        methods
-      else
-        puts "Please refine your query, we found #{methods.size} methods. Threshold is #{THRESHOLD}."
-      end
-      return nil
-    end
-    
-    def display_method(method)
-      "(#{method.constant.name}) #{method.name} #{method.url}"
-    end
-    
-  
-    def display_constants(constants)
-      count = 0
-      if constants.size == 1
-        constant = constants.first
-        if OPTIONS[:text]
-          puts "#{constant.name} #{constant.url}"
-        elsif MAC && !OPTIONS[:text]
-          `open #{constant.url}`
-        elsif WINDOWS && !OPTIONS[:text]
-          `start #{constant.url}`
-        else
-          puts "#{constant.name} #{constant.url}"
-        end
-
-      elsif constants.size <= THRESHOLD
-        for constant in constants
-          if OPTIONS[:text]
-            puts "#{count+=1}. #{constant.name} #{constant.url}"
-          elsif MAC
-            `open #{constant.url}`
-          elsif WINDOWS
-            `open #{constant.url}`
-          else
-            puts "#{count+=1}. #{constant.name} #{constant.url}"
-          end
-        end
-      else
-        puts "Please refine your query, we found #{constants.size} constants (threshold is #{THRESHOLD})."
-      end
-      return nil
+      methods      
     end
-  
-    def do(msg)
+          
+    def search(msg)
       msg = msg.split(" ")[0..-1].flatten.map { |a| a.split("#") }.flatten!
     
       # It's a constant! Oh... and there's nothing else in the string!
-      if /^[A-Z]/.match(msg.first) && msg.size == 1
-       object = find_constant(msg.first)
+      first=smart_rails_constant_substitutions(msg.first)
+      if /^[A-Z]/.match(first) && msg.size == 1
+       find_constant(first)
        # It's a method!
       else
         # Right, so they only specified one argument. Therefore, we look everywhere.
-        if msg.first == msg.last
-          object = find_method(msg)
+        if msg.size == 1
+          find_method(msg)
         # Left, so they specified two arguments. First is probably a constant, so let's find that!
         else
-          object = find_method(msg.last, msg.first)
+          find_method(msg.last, first)
         end  
       end
     end
     
-    def setup
-      file = File.join(File.dirname(__FILE__), "lookup.sqlite3")
-      FileUtils.rm(file) if File.exists?(file) && OPTIONS[:clear]
-    end
   end
 end
 
-OPTIONS = {}
-unless $TESTING
-  OptionParser.new do |opts|
-    opts.banner = "Usage: lookup <constant|method> [method] [OPTIONS]"
-
-    opts.on("-c", "--clear", "Clear database") do
-      OPTIONS[:clear] = true
-    end
-    opts.on("-t", "--text", "Text only") do
-      OPTIONS[:text] = true
-    end
-  end.parse!
-end
-# Ready!
-Lookup.setup
-
-# Set!
 require File.join(File.dirname(__FILE__), 'models')
-
-# Go!
-Lookup.do(ARGV[0..-1])
-  

data/lib/models.rb

@@ -0,0 +1,70 @@
+require 'fileutils'
+
+class APILookup
+
+  class MissingHome < StandardError
+  end
+
+  class LookupBase < ActiveRecord::Base
+  end
+  if ENV["HOME"].nil?
+    puts "The HOME environment variable should be set so lookup knows where"
+    puts "to store it's lookup database."
+    raise MissingHome, "HOME must be set to know where to store our local db."
+  end
+
+  LookupBase.establish_connection(:adapter => "sqlite3", 
+    :database => File.join(ENV["HOME"],".lookup", "lookup.sqlite3"))
+
+  class Api < LookupBase
+    set_table_name "apis"
+    has_many :constants
+  end
+
+  class Constant < LookupBase
+    set_table_name "constants"
+    belongs_to :api
+    has_many :entries
+  end
+
+  class Entry < LookupBase
+    set_table_name "entries"
+    belongs_to :constant
+  end
+
+end
+
+class SetupTables < ActiveRecord::Migration
+  def self.connection
+    APILookup::Api.connection
+  end
+
+  def self.up
+    create_table :apis do |t|
+      t.string :name, :url
+    end
+    
+    create_table :entries do |t|
+      t.string :name, :url
+      t.references :constant
+      t.integer :weighting, :default => 0
+      t.integer :count, :default => 0
+    end
+    
+    create_table :constants do |t|
+      t.string :name, :url
+      t.references :api
+      t.integer :weighting, :default => 0
+      t.integer :count, :default => 0
+    end
+  end
+end
+
+FileUtils.mkdir_p(File.join(ENV["HOME"],".lookup"))
+
+if !APILookup::Api.table_exists? && 
+   !APILookup::Constant.table_exists? && 
+   !APILookup::Entry.table_exists?
+  SetupTables.up
+  APILookup.update
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: radar-lookup
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Ryan Bigg
@@ -9,7 +9,7 @@ autorequire: lookup
 bindir: bin
 cert_chain: []
 
-date: 2009-02-07 00:00:00 -08:00
+date: 2009-03-30 00:00:00 -07:00
 default_executable: lookup
 dependencies: []
 
@@ -30,6 +30,7 @@ files:
 - TODO
 - lib/config.rb
 - lib/lookup.rb
+- lib/models.rb
 - spec/lookup_spec.rb
 - spec/spec_helper.rb
 - bin/lookup