allgems 0.0.1

data/lib/allgems/IndexBuilder.rb

@@ -0,0 +1,17 @@
+module AllGems
+    class IndexBuilder
+        def initialize(args={})
+            raise ArgumentError.new('Expecting a Sequel::Database to be passed') unless args[:database] && args[:database].is_a?(Sequel::Database)
+            @db = args[:database]
+        end
+        def build_array(filter=[])
+            b = []
+            Gem::SpecFetcher.fetcher.list(AllGems.allgems).each_pair{|uri, x| b = b | x.reject{|a|filter.include?(a)}.map{|c|{:name => c[0], :version => c[1]}}}
+            b
+        end
+        def local_array
+            la = @db[:versions].join(:gems, :id => :gem_id).join(:platforms, :id => :versions__platform_id).select(:name, :version, :platform).all.collect{|x|x.values}
+            la.map{|a| [a[0], Gem::Version.new(a[1]), a[2]]}
+        end
+    end
+end

data/lib/allgems/Indexer.rb

@@ -0,0 +1,23 @@
+module AllGems
+    class Indexer
+        class << self
+            def index_gem(spec, format)
+                case format
+                    when :hanna
+                        self.index_hanna(spec)
+                    when :rdoc
+                        self.index_rdoc(spec)
+                    when :sdoc
+                        self.index_sdoc(spec)
+                end
+                AllGems.logger.info "Gem index is complete for #{spec.full_name}"
+            end
+            def index_hanna(spec)
+            end
+            def index_rdoc(spec)
+            end
+            def index_sdoc(spec)
+            end
+        end
+    end
+end

data/lib/allgems/Runner.rb

@@ -0,0 +1,59 @@
+require 'actionpool'
+require 'actiontimer'
+require 'allgems/IndexBuilder'
+require 'allgems/GemWorker'
+
+module AllGems
+    class Runner
+        # :db_path:: path to sqlite database
+        # :runners:: maximum number of threads to use
+        # :interval:: how often to update documents (useless if using cron)
+        def initialize(args={})
+            raise ArgumentError.new('Expecting path to database') unless args[:db_path]
+            @db = Sequel.connect("sqlite://#{args[:db_path]}")
+            AllGems.initialize_db(@db)
+            @pool = ActionPool::Pool.new(:max_threads => args[:runners] ? args[:runners] : 10)
+            GemWorker.setup
+            @index = IndexBuilder.new(:database => @db)
+            @interval = args[:interval] ? args[:interval] : nil
+            @timer = nil
+            @lock = Mutex.new
+            @guard = ConditionVariable.new
+            @stop = false
+        end
+        
+        def do_sync
+            if(@interval)
+                @timer = ActionTimer::Timer.new(:pool => @pool)
+                sync
+                @timer.add(@interval){ sync }
+            else
+                sync
+            end
+        end
+        # Get the list of gems we need and load up the pool. Then take a nap
+        # until the pool gets bored and wakes us up
+        def sync
+            Gem.refresh
+            Thread.new do
+                @pool.add_jobs(@index.build_array(@index.local_array).collect{|x| lambda{GemWorker.process({:database => @db}.merge(x))}})
+            end
+            begin
+                @pool << lambda{@lock.synchronize{@guard.signal}}
+                @lock.synchronize{@guard.wait(@lock)}
+            rescue StandardError => boom
+                AllGems.logger.error boom.to_s
+                retry unless @stop
+            end
+        end
+        # Stop the runner
+        def stop(now=false)
+            @timer.clear if @timer
+            @stop = true
+            @lock.synchronize{@guard.broadcast}
+            @pool.shutdown(now)
+            GemWorker.pool.shutdown(now)
+        end
+
+    end
+end

data/lib/allgems/Specer.rb

@@ -0,0 +1,12 @@
+module AllGems
+    class Specer
+        class << self
+            def get_spec(gem, version=nil)
+                spec = AllGems.db[:specs].join(:versions, :id => :version_id).join(:gems, :id => :gem_id).filter(:name => gem)
+                spec = spec.filter(:version => version) if version
+                spec = spec.order(:version.desc).limit(1).first
+                return spec ? Marshal.load(spec[:spec].unpack('m')[0]) : nil
+            end            
+        end
+    end
+end

data/lib/allgems/ViewHelpers.rb

@@ -0,0 +1,48 @@
+require 'rdoc/markup/to_html'
+
+module AllGems
+    module ViewHelpers
+    
+        def tag_options(options, escape = true)
+            option_string = options.collect {|k,v| %{#{k}="#{v}"}}.join(' ')
+            option_string = " " + option_string unless option_string.blank?
+        end
+
+        def content_tag(name, content, options, escape = true)
+            tag_options = tag_options(options, escape) if options
+            "<#{name}#{tag_options}>#{content}</#{name}>"
+        end
+
+        def link_to(text, link = nil, options = {})         
+            link ||= text
+            link = url_for(link)
+            "<a href=\"#{link}\">#{text}</a>"
+        end
+
+        def link_to_gem(gem, options = {})
+            version = options[:version] ? options[:version] : ''
+            text = options[:text] ? options[:text] : gem
+            link_to(text, "/gems/#{gem}/#{version}")
+        end
+
+        def url_for(link_options)
+            case link_options
+            when Hash
+                path = link_options.delete(:path) || request.path_info
+                params.delete('captures')
+                path + '?' + build_query(params.merge(link_options))
+            else
+                link_options
+            end
+        end
+
+        def ts(time)
+            time.strftime('%b %d, %Y') if time
+        end
+
+        def rdocify(text)
+            @_rdoc ||= RDoc::Markup::ToHtml.new
+            @_rdoc.convert(text)
+        end
+    end
+end

data/lib/allgems/hanna_hack.rb

@@ -0,0 +1,82 @@
+# This file is a simple hack to force hanna to use
+# the 2.3.0 version of rdoc
+
+if ARGV.size == 1 and ARGV.first == '-h'
+  puts <<-HELP
+Hanna -- a better RDoc template
+Synopsis:
+  hanna [options]  [file names...]
+  [sudo] hanna --gems  [gem names...]
+
+Example usage:
+
+  hanna lib/**/*.rb
+
+Hanna passes all arguments to RDoc. To find more about RDoc options, see
+"rdoc -h". Default options are:
+
+  -o doc --inline-source --charset=UTF-8
+
+The second form, with the "--gems" argument, serves the same purpose as
+the "gem rdoc" command: it generates documentation for installed gems.
+When no gem names are given, "hanna --gems" will install docs for EACH of
+the gems, which can, uh, take a little while.
+
+HELP
+  exit 0
+end
+
+unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
+  require 'pathname'
+  hanna_dir = Pathname.new(__FILE__).realpath.dirname + '../lib'
+else
+  # windows
+  hanna_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+end
+
+$:.unshift(hanna_dir) unless $:.include?(hanna_dir)
+
+require 'rubygems'
+gem 'rdoc', '2.3.0'
+require 'rdoc/rdoc'
+
+options = []
+
+options << '-f' << 'html' << '-T' << 'hanna'
+options << '--inline-source' << '--charset=UTF-8'
+
+if ARGV.first == '--gems'
+  require 'rubygems/doc_manager'
+  Gem::DocManager.configured_args = options
+
+  gem_names = ARGV.dup
+  gem_names.shift
+
+  unless gem_names.empty?
+    specs = gem_names.inject([]) do |arr, name|
+      found = Gem::SourceIndex.from_installed_gems.find_name(name)
+      spec = found.sort_by {|s| s.version }.last
+      arr << spec if spec
+      arr
+    end
+  else
+    specs = Gem::SourceIndex.from_installed_gems.inject({}) do |all, pair|
+      full_name, spec = pair
+      if spec.has_rdoc? and (!all[spec.name] or spec.version > all[spec.name].version)
+        all[spec.name] = spec
+      end
+      all
+    end
+    specs = specs.values
+    puts "Hanna is installing documentation for #{specs.size} gem#{specs.size > 1 ? 's' : ''} ..."
+  end
+
+  specs.each do |spec|
+    Gem::DocManager.new(spec).generate_rdoc
+  end
+else
+  options << '-o' << 'doc' unless ARGV.include?('-o') or ARGV.include?('--op')
+  options.concat ARGV
+
+  RDoc::RDoc.new.document(options)
+end

data/lib/allgems/migrations/001_initialize.rb

@@ -0,0 +1,39 @@
+Class.new(Sequel::Migration) do
+    def up
+        AllGems.db << "CREATE TABLE gems (
+                        name VARCHAR NOT NULL UNIQUE COLLATE NOCASE,
+                        summary TEXT,
+                        description TEXT,
+                        id INTEGER NOT NULL PRIMARY KEY)"
+#         create_table(:gems) do
+#             String :name, :null => false, :unique => true
+#             String :summary
+#             String :description
+#             primary_key :id, :null => false
+#         end
+        AllGems.db.create_table(:platforms) do
+            String :platform, :null => false, :unique => true
+            primary_key :id, :null => false
+        end
+        AllGems.db.create_table(:versions) do
+            String :version, :null => false
+            Time :release, :null => false
+            foreign_key :gem_id, :table => :gems, :null => false
+            foreign_key :platform_id, :table => :platforms, :null => false
+            index [:gem_id, :version, :platform_id], :unique => true
+            primary_key :id, :null => false
+        end
+        AllGems.db.create_table(:specs) do
+            String :spec, :null => false
+            foreign_key :version_id, :table => :versions, :null => false
+            index [:spec, :version_id], :unique => true
+            primary_key :id, :null => false
+        end
+    end
+    def down
+        AllGems.db.drop_table(:specs)
+        AllGems.db.drop_table(:versions)
+        AllGems.db.drop_table(:platforms)
+        AllGems.db.drop_table(:gems)
+    end
+end

data/public/javascripts/base.js

@@ -0,0 +1,212 @@
+(function(){
+  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
+
+  // The base Class implementation (does nothing)
+  this.Class = function(){};
+ 
+  // Create a new Class that inherits from this class
+  Class.extend = function(prop) {
+    var _super = this.prototype;
+   
+    // Instantiate a base class (but only create the instance,
+    // don't run the init constructor)
+    initializing = true;
+    var prototype = new this();
+    initializing = false;
+   
+    // Copy the properties over onto the new prototype
+    for (var name in prop) {
+      // Check if we're overwriting an existing function
+      prototype[name] = typeof prop[name] == "function" &&
+        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
+        (function(name, fn){
+          return function() {
+            var tmp = this._super;
+           
+            // Add a new ._super() method that is the same method
+            // but on the super-class
+            this._super = _super[name];
+           
+            // The method only need to be bound temporarily, so we
+            // remove it when we're done executing
+            var ret = fn.apply(this, arguments);       
+            this._super = tmp;
+           
+            return ret;
+          };
+        })(name, prop[name]) :
+        prop[name];
+    }
+   
+    // The dummy class constructor
+    function Class() {
+      // All construction is actually done in the init method
+      if ( !initializing && this.init )
+        this.init.apply(this, arguments);
+    }
+   
+    // Populate our constructed prototype object
+    Class.prototype = prototype;
+   
+    // Enforce the constructor to be what we expect
+    Class.constructor = Class;
+
+    // And make this class extendable
+    Class.extend = arguments.callee;
+   
+    return Class;
+  };
+})();
+
+
+$.fn.extend({
+	getId: function() {
+		var match = $(this).attr("id").match(/\d+/)
+		return match ? parseInt(match[0]) : null;
+	},
+	setInputHint: function() {
+		el = $(this);
+		el.data('default', el.val());
+
+		el.focus(function() {
+			if(el.data('default') != el.val()) return;
+			el.removeClass('hint').val('');
+		})
+		.blur(function() {
+			if($.trim(el.val()) != '') return;
+			el.addClass('hint').val(el.data('default'));
+		})
+		.addClass('hint');
+	},
+	fadeUp: function(speed) {
+		$(this).css({'position':'relative'}).animate({top:"-150px", opacity: 0}, speed, function() { $(this).remove(); })
+		return $(this);
+	}
+});
+
+$.extend({
+	log: function()	{
+		if (typeof console == 'undefined') {
+			// do nothing
+		} else {
+			console.log(arguments);
+		}
+	},
+	timestamp: function() {
+		return Math.floor(new Date().getTime()/1000);
+	}
+});
+
+// authenticity tokens
+// http://www.viget.com/extend/ie-jquery-rails-and-http-oh-my
+$(function() {
+	$(document).ajaxSend(function(event, request, settings) {
+	  if (settings.type == 'GET' || settings.type == 'get' || typeof(AUTH_TOKEN) == "undefined") return;
+	  // settings.data is a serialized string like "foo=bar&baz=boink" (or null)
+	  settings.data = settings.data || "";
+	  settings.data += (settings.data ? "&" : "") + "authenticity_token=" + encodeURIComponent(AUTH_TOKEN);
+	});
+});
+
+var Base = {
+	popup: function (link,title,width,height) {
+		return window.open(link,title,"height="+height+",width="+width+",status=no,toolbar=no,menubar=no,location=no");
+	},
+	urlify: function(title) {
+		// self.downcase.gsub(/(_|-|\/|\\|\&|,| )/,'_')[0..40]
+		return title.toString().strip().toLowerCase().gsub(/ /, '_').gsub(/[^a-z0-9\-_]/,'').truncate(40,'');
+	},
+	copyTextToClipboard: function(text) {
+		// create form element
+		var form_element = $('clipboard_holder') ? $('clipboard_holder') : new Element('input',{'type':'hidden','id':'clipboard_holder','name':'clipboard_holder','value':text});
+	  if (form_element.createTextRange) {
+	    var range = form_element.createTextRange();
+	    if (range && BodyLoaded==1)
+	     range.execCommand('Copy');
+	  } else {
+	    var flashcopier = $('flashcopier') ? $('flashcopier') : new Element('div',{id: 'flashcopier'});
+			$(flashcopier).innerHTML = '<embed src="/swf/_clipboard.swf" FlashVars="clipboard='+escape(form_element.value)+'" width="0" height="0" type="application/x-shockwave-flash"></embed>';
+			document.body.appendChild(flashcopier);
+	 }
+	},
+	images: {
+		hover_suffix: '_on',
+		active_suffix: '_on',
+		deactive_suffix: '_off',
+		swap: function(for_el,to) {
+			$(for_el).attr('src', to);
+		},
+		activate: function (for_el) {
+			return this.swap(for_el,this.activateSrc(for_el));
+		},
+		deactivate: function (for_el) {
+			return this.swap(for_el,this.deactivateSrc(for_el));		
+		},
+		hover: function (for_el) {
+			return this.swap(for_el,this.hoverSrc(for_el));
+		},
+		replaceSrc: function (for_el,search,replace_with) {
+			return $(for_el).attr('src').replace(search,replace_with);
+		},
+		activateSrc: function (for_el) {
+			return this.replaceSrc(for_el,this.deactive_suffix,this.active_suffix);
+		},
+		deactivateSrc: function (for_el) {
+			return this.replaceSrc(for_el,this.active_suffix,this.deactive_suffix);
+		},
+		hoverSrc: function (for_el) {
+			return this.replaceSrc(for_el,this.deactive_suffix,this.hover_suffix);
+		},
+		restore: function (for_el) {
+			MM_swapImgRestore();
+		}
+	}
+};
+
+$.extend({
+	param: function( a, nest_in ) {
+		var s = [ ];
+		// check for nest
+		if (typeof nest_in == 'undefined') nest_in = false;
+		
+		function nested(key) {
+			if (nest_in)
+				return nest_in + '[' + key + ']';
+			else
+				return key;
+		}
+		function add( key, value ){
+			key = nested(key)
+			s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
+		};
+		// If an array was passed in, assume that it is an array
+		// of form elements
+		if ( jQuery.isArray(a) || a.jquery )
+			// Serialize the form elements
+			jQuery.each( a, function(){
+				add( this.name, this.value );
+			});
+
+		// Otherwise, assume that it's an object of key/value pairs
+		else
+			// Serialize the key/values
+			for ( var j in a )
+				// If the value is an array then the key names need to be repeated
+				if ( jQuery.isArray(a[j]) )
+					jQuery.each( a[j], function(){
+						add( j, this );
+					});
+				else if (a[j].constructor == Object)
+					s.push($.param(a[j], nested(j)));
+				else
+					add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
+
+		// Return the resulting serialization
+		return s.join("&").replace(/%20/g, "+");
+	},
+	shove: function(fn, object) {
+    return function() {
+      return fn.apply(object, arguments);
+    }
+	}
+});