radar-lookup 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ryan Bigg
+
+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,25 @@
+# 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.
+
+## 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,3 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'lookup'

data/lib/config.rb

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

data/lib/lookup.rb

@@ -0,0 +1,233 @@
+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 << 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 "Updated API for #{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")
+      # 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
+      end
+    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 = 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
+        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
+    end
+  
+    def do(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)
+       # 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)
+        # Left, so they specified two arguments. First is probably a constant, so let's find that!
+        else
+          object = find_method(msg.last, msg.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/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,63 @@
+--- !ruby/object:Gem::Specification 
+name: radar-lookup
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Bigg
+autorequire: lookup
+bindir: bin
+cert_chain: []
+
+date: 2009-02-07 00:00:00 -08: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
+- 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: []
+