require 'rubygems' require 'net/http' gemfile = File.expand_path('../../Gemfile', __FILE__) require 'bundler' ENV['BUNDLE_GEMFILE'] = gemfile Bundler.require(:default) # Because some of you don't have ActiveSupport 3.0 # And I'm too lazy to require all the shit for 2.3.8 just for this. class Hash def stringify_keys! keys.each do |key| self[key.to_s] = delete(key) end self end end module Lookup VERSION = "1.0.0.beta9" APIS = [] class APINotFound < StandardError; end class << self def home Pathname.new(ENV["HOME"]) + ".lookup" end def config YAML.load_file(home + "config") end def apis apis = config["apis"].stringify_keys! end def update! puts "Updating API, this may take a minute or two. Please be patient!" [Constant, Entry, Api].map { |klass| klass.delete_all } puts "Updating #{apis.size} APIs." for api in apis.values update_api!(api["name"], api["url"]) end end def update_api!(name, url) puts "Updating API for #{name}..." api = Api.find_or_create_by_name_and_url(name, url) APIS << api puts "Updating methods for #{name}" api.update_methods! puts "Updating classes for #{name}" api.update_classes! puts "The #{name} API is done." end def find_constant(name, entry=nil, options={}) scope = options[:api].constants || Constant # Find by specific name. constants = scope.find_all_by_name(name, :include => "entries") # search for class methods, which is prolly what we want if we can find it constants = scope.find_all_by_name("#{name}::ClassMethods", :include => "entries") if constants.empty? # Find by name beginning with . constants = scope.all(:conditions => ["constants.name LIKE ?", name + "%"], :include => "entries") if constants.empty? # Find by fuzzy. match="%#{name.split("").join("%")}%" constants = scope.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 /#{parts.join("::")}/i end def smart_rails_constant_substitutions(name) parts = name.split("::").map { |x| x.split(":")}.flatten if parts.first rep = case parts.first.downcase # so it falls back on fuzzy and matches AR as well as ActiveResource when "ar" then "ActiveRecord" when "ares" then "ActiveResource" when "am" then "ActionMailer" when "as" then "ActiveSupport" when "ac" then "ActionController" when "av" then "ActionView" else parts.first end return ([rep] + parts[1..-1]).join("::") end name 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, options = {}) scope = options[:api].entries || Entry methods = [] # Full match methods = scope.find_all_by_name(name.to_s) # Start match methods = scope.all(:conditions => ["entries.name LIKE ?", name.to_s + "%"]) if methods.empty? # Wildcard substitution methods = scope.find_by_sql("select * from entries where name LIKE '#{name.to_s.gsub("*", "%")}'") if methods.empty? # Fuzzy match methods = scope.find_by_sql("select * from entries where name LIKE '%#{name.to_s.split("").join("%")}%'") if methods.empty? # Weight the results, last result is the first one we want shown first methods = methods.sort_by(&:weighting) if constant constants = find_constant(constant, nil, options) methods = methods.select { |m| constants.include?(m.constant) } end methods end def search(msg, options={}) options[:api] ||= msg.split.first api_check = lambda { |options| (!apis.keys.map(&:to_s).include?(options[:api]) && !options[:api].is_a?(Api)) } # to_s because yaml interprets "1.8" as a literal 1.8 # And because I'm super, super lazy if !@attempted_ruby && api_check.call(options) # Attempt a current Ruby lookup @attempted_ruby = true api = case RUBY_VERSION when /^1.8/ "1.8" when /^1.9/ "1.9" end search(msg, options.merge!(:api => api)) if api end options[:api] = Api.find_by_name!(apis[options[:api]]["name"]) unless options[:api].is_a?(Api) # We want to retain message. msg = msg.gsub(/^(.*?)\s/, "") splitter = options[:splitter] || "#" parts = msg.split(" ")[0..-1].flatten.map { |a| a.split(splitter) }.flatten! # It's a constant! Oh... and there's nothing else in the string! first = smart_rails_constant_substitutions(parts.first) output = if /^[A-Z]/.match(first) && parts.size == 1 find_constant(first, nil, options) # It's a method! else # Right, so they only specified one argument. Therefore, we look everywhere. if parts.size == 1 o = find_method(parts.last, nil, options) # Left, so they specified two arguments. First is probably a constant, so let's find that! else o = find_method(parts.last, first, options) end o end output = search(msg, options.merge(:splitter => ".")) if output.empty? && splitter != "." selected_output = output.select { |m| options[:api].name == m.api.name } selected_output = output if selected_output.empty? return selected_output end private def api_not_found raise Lookup::APINotFound, %Q{You must specify a valid API as the first keyword. Included APIs:\n} + (apis.map do |short, info| "#{short} - #{info["name"]}" end.join("\n")) end end end require File.join(File.dirname(__FILE__), 'models')