yyyc514-lookup 0.2.0

data/LICENSE

@@ -0,0 +1,22 @@
+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
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+# Lazy Man's ri (lookup)
+
+## Example usage:
+
+ * `lookup ActiveRecord::Base#new` (returns a single method, since the method name is right)
+ * `lookup ActiveRecord::Base#destroy` (returns two methods, since there's two methods with that name)
+ * `lookup ActiveRecord::Base#destro` (returns three methods, uses methods beginning with "destroy")
+ * `lookup ActiveRecord::Base#d` (tells you to be more specific, because it can't open 35 tabs at once)
+ * `lookup ActiveRecord::Base` (returns a single consant)
+ * `lookup Acv::Base` (returns six constants, because it does a fuzzy match)
+ 
+## Options
+
+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
+
+1. Checks if there's constants/methods with that exact name.
+2. Checks if there's constants/methods with names beginning with that name.
+3. Does a "fuzzy match" splitting the name and getting anything containing those letters in that order.
+4. Opens your browser if you're running a DECENT_OPERATING_SYSTEM (may add support for things other than Mac later on)
+5. ???
+6. Profit

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = "lookup"
+GEM_VERSION = "0.1.0"
+AUTHOR = "Ryan Bigg"
+EMAIL = "radarlistener@gmail.com"
+HOMEPAGE = "http://gitpilot.com"
+SUMMARY = "A gem that provides a lazy man's ri"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.md", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.executables << "lookup"
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  (Dir.entries("doc") - ['..', '.']).each do |file|
+    FileUtils.rm("doc/#{file}")
+  end
+  Dir.delete("doc")
+  Dir.mkdir("doc")
+  s.files = %w(LICENSE README.md Rakefile TODO) + Dir.glob("{lib,spec,bin,doc}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1,2 @@
+TODO:
+Test the bloody thing.

data/bin/lookup

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby
+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/config.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'hpricot'
+require 'net/http'
+
+DEBUG = true

data/lib/lookup.rb

@@ -0,0 +1,139 @@
+require 'rubygems'
+require 'activerecord'
+
+class APILookup
+
+  class << self
+    def update
+      require 'hpricot'
+      require 'net/http'
+      puts "Updating API, this may take a minute or two. Please be patient!"
+      Constant.delete_all
+      Entry.delete_all
+      # Ruby on Rails Classes & Methods
+      update_api("Rails", "http://api.rubyonrails.org")
+      # Ruby Classes & Methods
+      update_api("Ruby", "http://www.ruby-doc.org/core")
+      
+      weight_results
+      puts "Updated API index! Use the lookup <method> or lookup <class> <method> to find what you're after"
+    end
+  
+    def update_api(name, url)
+      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 "DONE (with #{name})!"
+    end
+  
+    def update_methods(doc, prefix)
+      doc.search("a").each do |a|
+        names = a.inner_html.split(" ")
+        method = names[0]
+        name = names[1].gsub(/[\(|\)]/, "")
+        # The same constant can be defined twice in different APIs, be wary!
+        url = prefix + "/classes/" + name.gsub("::", "/") + ".html"
+        constant = Constant.find_or_create_by_name_and_url(name, url)
+        constant.entries.create!(:name => method, :url => prefix + "/" + a["href"])
+      end
+    end
+  
+    def update_classes(doc, prefix)
+      doc.search("a").each do |a|
+        constant = Constant.find_or_create_by_name_and_url(a.inner_html, prefix + "/" + a["href"])
+      end
+    end
+    
+    # Weights the results so the ones more likely to be used by people come up first.
+    def weight_results
+      e = Constant.find_by_name("ActiveRecord::Associations::ClassMethods").entries.find_by_name("belongs_to")
+      e.increment!(:weighting)
+    end
+  
+    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.
+      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
+      /#{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)
+      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?
+      
+      # Weight the results, last result is the first one we want shown first
+      methods = methods.sort_by(&:weighting)
+    
+      if constant
+        constants = find_constant(constant, name)
+        methods = methods.select { |m| constants.include?(m.constant) }
+      end
+      methods      
+    end
+          
+    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!
+      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.size == 1
+          find_method(msg)
+        # Left, so they specified two arguments. First is probably a constant, so let's find that!
+        else
+          find_method(msg.last, first)
+        end  
+      end
+    end
+    
+  end
+end
+
+require File.join(File.dirname(__FILE__), 'models')

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

data/spec/lookup_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Lookup" do
+  before do
+    # So it outputs text for us.
+    OPTIONS.merge!({ :text => true })
+  end
+  
+  it "should be able to find a constant" do
+    Lookup.do("ActiveRecord::Base")
+  end
+  
+  it "should be able to find a constant and a method (using hash symbol)" do
+    Lookup.do("ActiveRecord::Base#new")
+  end
+  
+  it "should be able to find a constant and a method (using space)" do
+    Lookup.do("ActiveRecord::Base new")
+  end
+  
+  it "should be able to do a fuzzy match on the method" do
+    Lookup.do("ActiveRecord::Base#destry")
+  end
+  
+  it "should prompt the user to be more specific" do
+    Lookup.do("be")
+  end
+  
+  it "should be able to do a fuzzy match on the constant and method" do
+    Lookup.do("AR::B#destroy")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require 'lookup'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: yyyc514-lookup
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Ryan Bigg
+autorequire: lookup
+bindir: bin
+cert_chain: []
+
+date: 2009-03-30 00:00:00 -07:00
+default_executable: lookup
+dependencies: []
+
+description: A gem that provides a lazy man's ri
+email: radarlistener@gmail.com
+executables: 
+- lookup
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- lib/config.rb
+- lib/lookup.rb
+- lib/models.rb
+- spec/lookup_spec.rb
+- spec/spec_helper.rb
+- bin/lookup
+has_rdoc: true
+homepage: http://gitpilot.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A gem that provides a lazy man's ri
+test_files: []
+