bananajour 2.1.9

data/lib/bananajour/bonjour/person.rb

@@ -0,0 +1,21 @@
+class Bananajour::Bonjour::Person
+
+  attr_accessor :name, :email, :uri , :gravatar
+
+  def initialize(name, email, uri, gravatar)
+    @name, @email, @uri, @gravatar = name, email, uri, gravatar
+  end
+  
+  def ==(other)
+    self.uri == other.uri
+  end
+  
+  def hash
+    to_hash.hash
+  end
+  
+  def to_hash
+    {"name" => name, "email" => email, "uri" => uri, "gravatar" => gravatar}
+  end
+  
+end

data/lib/bananajour/bonjour/repository.rb

@@ -0,0 +1,39 @@
+class Bananajour::Bonjour::Repository
+
+  attr_accessor :name, :uri, :person 
+
+  def initialize(name, uri, person)
+    @name, @uri, @person = name, uri, person
+  end
+  
+  def html_id
+    Bananajour::Repository.html_id(name)
+  end
+
+  def ==(other)
+    self.uri == other.uri
+  end
+  
+  def hash
+    to_hash.hash
+  end
+  
+  def json_uri
+    "#{person.uri}#{name}.json"
+  end
+  
+  def web_uri
+    "#{person.uri}##{html_id}"
+  end
+  
+  def to_hash
+    {
+      "name" => name,
+      "uri" => uri,
+      "json_uri" => json_uri,
+      "web_uri" => web_uri,
+      "person" => person.to_hash
+    }
+  end
+
+end

data/lib/bananajour/bonjour/repository_browser.rb

@@ -0,0 +1,36 @@
+module Bananajour::Bonjour
+class RepositoryBrowser
+
+  def initialize
+    @browser = Browser.new('_bananajour._git._tcp')
+  end
+  
+  def repositories
+    @browser.replies.map do |reply|
+      Repository.new(
+        reply.text_record["name"],
+        reply.text_record["uri"],
+        Person.new(
+          reply.text_record["bjour-name"],
+          reply.text_record["bjour-email"],
+          reply.text_record["bjour-uri"],
+          reply.text_record["bjour-gravatar"]
+        )
+      )
+    end
+  end
+  
+  def other_repositories
+    repositories.reject {|r| Bananajour.repositories.any? {|my_rep| my_rep.name == r.name}}
+  end
+  
+  def repositories_similar_to(repository)
+    repositories.select {|r| r.name == repository.name}
+  end
+  
+  def repositories_for(person)
+    repositories.select {|r| r.person == person}
+  end
+  
+end
+end

data/lib/bananajour/commands.rb

@@ -0,0 +1,80 @@
+module Bananajour::Commands
+
+  def check_git!
+    if (version = `git --version`.strip) =~ /git version 1\.[12345]/
+      abort "You have #{version}, you need at least 1.6"
+    end
+  end
+  
+  def check_git_config!
+    config_message = lambda {|key, example| "You haven't set your #{key} in your git config yet. To set it: git config --global #{key} '#{example}'"}
+    abort(config_message["user.name", "My Name"]) if config.name.empty?
+    abort(config_message["user.email", "name@domain.com"]) if config.email.empty?
+  end
+  
+  def serve_web!
+    fork { exec "/usr/bin/env ruby #{File.dirname(__FILE__)}/../../sinatra/app.rb -p #{web_port} -e production" }
+    puts "* Started " + web_uri.foreground(:yellow)
+  end
+
+  def serve_git!
+    fork { exec "git daemon --base-path=#{repositories_path} --export-all" }
+    puts "* Started " + "#{git_uri}".foreground(:yellow)
+  end
+  
+  def advertise!
+    fork { Bananajour::Bonjour::Advertiser.new.go! }
+  end
+  
+  def add!(dir, name = nil)
+    dir = Fancypath(dir)
+
+    unless dir.join(".git").directory?
+      abort "Can't init project #{dir}, no .git directory found."
+    end
+
+    if name.nil?
+      default_name = dir.basename.to_s
+      print "Project Name?".foreground(:yellow) + " [#{default_name}] "
+      name = (STDIN.gets || "").strip
+      name = default_name if name.empty?
+    end
+
+    repo = Bananajour::Repository.for_name(name)
+
+    if repo.exists?
+      abort "You've already a project #{repo}."
+    end
+
+    repo.init!
+    Dir.chdir(dir) { `git remote add banana #{repo.path.expand_path}` }
+    puts init_success_message(repo.dirname)
+
+    repo
+  end
+  
+  def init_success_message(repo_dirname)
+    plain_init_success_message(repo_dirname).gsub("git push banana master", "git push banana master".foreground(:yellow))
+  end
+  
+  def plain_init_success_message(repo_dirname)
+    "Bananajour repository #{repo_dirname} initialised and remote banana added.\nNext: git push banana master"
+  end
+  
+  def clone!(url, clone_name)
+    dir = clone_name || File.basename(url).chomp('.git')
+
+    if File.exists?(dir)
+      abort "Can't clone #{url} to #{dir}, the directory already exists."
+    end
+
+    `git clone #{url} #{dir}`
+    if $? != 0
+      abort "Failed to clone bananajour repository #{url} to #{dir}."
+    else
+      puts "Bananajour repository #{url} cloned to #{dir}."
+      add!(dir, dir)
+    end
+  end
+
+end

data/lib/bananajour/gem_dependencies.rb

@@ -0,0 +1,34 @@
+module Bananajour
+  # DRYs version number dependencies and provides a simple way require them
+  module GemDependencies
+    DEPENDENCIES = [
+      %w( sinatra              0.9.2 ),
+      %w( json                 1.1.7 ),
+      %w( chrislloyd-fancypath 0.5.8 ),
+      %w( rainbow              1.0.1 ),
+      %w( mojombo-grit         1.1.1 ),
+      %w( dnssd                0.7.1 ),
+      %w( rack                 1.0.0 ),
+      %w( thin                 1.0.0 ),
+      %w( haml                 2.0.9 ),
+      %w( activesupport        2.3.2 )
+    ]
+    class Dependency < Struct.new(:name, :version)
+      def require_gem; gem name, version end
+    end
+    def self.all
+      DEPENDENCIES.map {|(name, version)| Dependency.new(name, version)}
+    end
+    def self.for_name(name)
+      all.find {|d| d.name == name }
+    end
+  end
+
+  def self.gem(name)
+    Bananajour::GemDependencies.for_name(name).require_gem
+  end
+  def self.require_gem(name, lib=nil)
+    self.gem(name)
+    Kernel.require(lib || name)
+  end
+end

data/lib/bananajour/grit_extensions.rb

@@ -0,0 +1,11 @@
+Grit::Commit.class_eval do
+  def ==(other)
+    self.id == other.id
+  end
+end
+
+Grit::Actor.class_eval do
+  def gravatar_uri
+    Bananajour.gravatar_uri(email)
+  end
+end

data/lib/bananajour/helpers.rb

@@ -0,0 +1,100 @@
+require 'md5'
+
+module Bananajour
+  module GravatarHelpers
+    def gravatar
+      gravatar_uri(self.config.email)
+    end
+    def gravatar_uri(email)
+      "http://gravatar.com/avatar/#{MD5.md5(email)}.png"
+    end
+  end
+  
+  # Lifted from Rails
+  module DateHelpers
+    # Reports the approximate distance in time between two Time or Date objects or integers as seconds.
+    # Set <tt>include_seconds</tt> to true if you want more detailed approximations when distance < 1 min, 29 secs
+    # Distances are reported based on the following table:
+    #
+    #   0 <-> 29 secs                                                             # => less than a minute
+    #   30 secs <-> 1 min, 29 secs                                                # => 1 minute
+    #   1 min, 30 secs <-> 44 mins, 29 secs                                       # => [2..44] minutes
+    #   44 mins, 30 secs <-> 89 mins, 29 secs                                     # => about 1 hour
+    #   89 mins, 29 secs <-> 23 hrs, 59 mins, 29 secs                             # => about [2..24] hours
+    #   23 hrs, 59 mins, 29 secs <-> 47 hrs, 59 mins, 29 secs                     # => 1 day
+    #   47 hrs, 59 mins, 29 secs <-> 29 days, 23 hrs, 59 mins, 29 secs            # => [2..29] days
+    #   29 days, 23 hrs, 59 mins, 30 secs <-> 59 days, 23 hrs, 59 mins, 29 secs   # => about 1 month
+    #   59 days, 23 hrs, 59 mins, 30 secs <-> 1 yr minus 1 sec                    # => [2..12] months
+    #   1 yr <-> 2 yrs minus 1 secs                                               # => about 1 year
+    #   2 yrs <-> max time or date                                                # => over [2..X] years
+    #
+    # With <tt>include_seconds</tt> = true and the difference < 1 minute 29 seconds:
+    #   0-4   secs      # => less than 5 seconds
+    #   5-9   secs      # => less than 10 seconds
+    #   10-19 secs      # => less than 20 seconds
+    #   20-39 secs      # => half a minute
+    #   40-59 secs      # => less than a minute
+    #   60-89 secs      # => 1 minute
+    #
+    # ==== Examples
+    #   from_time = Time.now
+    #   distance_of_time_in_words(from_time, from_time + 50.minutes)        # => about 1 hour
+    #   distance_of_time_in_words(from_time, 50.minutes.from_now)           # => about 1 hour
+    #   distance_of_time_in_words(from_time, from_time + 15.seconds)        # => less than a minute
+    #   distance_of_time_in_words(from_time, from_time + 15.seconds, true)  # => less than 20 seconds
+    #   distance_of_time_in_words(from_time, 3.years.from_now)              # => over 3 years
+    #   distance_of_time_in_words(from_time, from_time + 60.hours)          # => about 3 days
+    #   distance_of_time_in_words(from_time, from_time + 45.seconds, true)  # => less than a minute
+    #   distance_of_time_in_words(from_time, from_time - 45.seconds, true)  # => less than a minute
+    #   distance_of_time_in_words(from_time, 76.seconds.from_now)           # => 1 minute
+    #   distance_of_time_in_words(from_time, from_time + 1.year + 3.days)   # => about 1 year
+    #   distance_of_time_in_words(from_time, from_time + 4.years + 15.days + 30.minutes + 5.seconds) # => over 4 years
+    #
+    #   to_time = Time.now + 6.years + 19.days
+    #   distance_of_time_in_words(from_time, to_time, true)     # => over 6 years
+    #   distance_of_time_in_words(to_time, from_time, true)     # => over 6 years
+    #   distance_of_time_in_words(Time.now, Time.now)           # => less than a minute
+    #
+    def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
+      from_time = from_time.to_time if from_time.respond_to?(:to_time)
+      to_time = to_time.to_time if to_time.respond_to?(:to_time)
+      distance_in_minutes = (((to_time - from_time).abs)/60).round
+      distance_in_seconds = ((to_time - from_time).abs).round
+
+      case distance_in_minutes
+        when 0..1
+          return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+          case distance_in_seconds
+            when 0..4   then 'less than 5 seconds'
+            when 5..9   then 'less than 10 seconds'
+            when 10..19 then 'less than 20 seconds'
+            when 20..39 then 'half a minute'
+            when 40..59 then 'less than a minute'
+            else             '1 minute'
+          end
+
+        when 2..44           then "#{distance_in_minutes} minutes"
+        when 45..89          then 'about 1 hour'
+        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+        when 1440..2879      then '1 day'
+        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+        when 43200..86399    then 'about 1 month'
+        when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
+        when 525600..1051199 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525600).round} years"
+      end
+    end
+
+    # Like distance_of_time_in_words, but where <tt>to_time</tt> is fixed to <tt>Time.now</tt>.
+    #
+    # ==== Examples
+    #   time_ago_in_words(3.minutes.from_now)       # => 3 minutes
+    #   time_ago_in_words(Time.now - 15.hours)      # => 15 hours
+    #   time_ago_in_words(Time.now)                 # => less than a minute
+    #
+    #   from_time = Time.now - 3.days - 14.minutes - 25.seconds     # => 3 days
+    def time_ago_in_words(from_time, include_seconds = false)
+      distance_of_time_in_words(from_time, Time.now, include_seconds)
+    end
+  end
+end

data/lib/bananajour/repository.rb

@@ -0,0 +1,85 @@
+Bananajour.require_gem 'mojombo-grit', 'grit'
+
+module Bananajour
+  class Repository
+    def self.for_name(name)
+      new(Bananajour.repositories_path.join(name + ".git"))
+    end
+    def self.html_id(name)
+      name.gsub(/[^A-Za-z-]+/, '').downcase
+    end
+    def initialize(path)
+      @path = Fancypath(path)
+    end
+    def ==(other)
+      other.respond_to?(:path) && self.path == other.path
+    end
+    attr_reader :path
+    def exists?
+      path.exists?
+    end
+    def init!
+      path.create_dir
+      Dir.chdir(path) { `git init --bare` }
+    end
+    def name
+      dirname.sub(".git",'')
+    end
+    def html_id
+      self.class.html_id(name)
+    end
+    def dirname
+      path.split.last.to_s
+    end
+    def to_s
+      name
+    end
+    def uri
+      Bananajour.git_uri + dirname
+    end
+    def web_uri
+      Bananajour.web_uri + "#" + html_id
+    end
+    def grit_repo
+      @grit_repo ||= Grit::Repo.new(path)
+    end
+    def recent_commits
+      @commits ||= grit_repo.commits(nil, 10)
+    end
+    def readme_file
+      grit_repo.tree.contents.find {|c| c.name =~ /readme/i}
+    end
+    def rendered_readme
+      case File.extname(readme_file.name)
+      when /\.md/i, /\.markdown/i
+        require 'rdiscount'
+        RDiscount.new(readme_file.data).to_html
+      when /\.textile/i
+        require 'redcloth'
+        RedCloth.new(readme_file.data).to_html(:textile)
+      end
+    rescue LoadError
+      ""
+    end
+    def remove!
+      path.rmtree
+    end
+    def to_hash
+      heads = grit_repo.heads
+      {
+        "name" => name,
+        "html_friendly_name" => html_id, # TODO: Deprecate in v3. Renamed to html_id since 2.1.4
+        "html_id" => html_id,
+        "uri" => uri,
+        "heads" => heads.map {|h| h.name},
+        "recent_commits" => recent_commits.collect do |c|
+          c.to_hash.merge(
+            "head" => (head = heads.find {|h| h.commit == c}) && head.name,
+            "gravatar" => c.author.gravatar_uri
+          )
+        end,
+        "bananajour" => Bananajour.to_hash
+      }
+    end
+  end
+end

data/lib/bananajour/version.rb

@@ -0,0 +1,3 @@
+module Bananajour
+  VERSION = '2.1.9'
+end

data/sinatra/app.rb

@@ -0,0 +1,87 @@
+Thread.abort_on_exception = true
+
+__DIR__ = File.dirname(__FILE__)
+
+require 'rubygems'
+
+require "#{__DIR__}/../lib/bananajour"
+
+Bananajour.require_gem 'rack'
+
+# Must require 'sinatra' from this file for Sinatra's magic to pick up lots of free stuff
+Bananajour::GemDependencies.for_name('sinatra').require_gem
+require 'sinatra'
+
+Bananajour.require_gem 'haml'
+Bananajour.require_gem 'json'
+
+Bananajour.gem 'activesupport'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/array'
+
+require 'forwardable' # Fix for issue #8 - Thin borking on uninitialized constant Forwardable
+
+set :server, 'thin' # Things go weird with anything else - let's lock it down to thin
+set :haml, {:format => :html5, :attr_wrapper => '"'}
+set :logging, false
+
+require "#{__DIR__}/lib/browsers" # to prevent reloading
+require "#{__DIR__}/lib/mock_browsers" if Sinatra::Application.development?
+before do
+  @bananajour_browser = BANANAJOUR_BROWSER
+  @repository_browser = REPO_BROWSER
+end
+
+load "#{__DIR__}/lib/diff_helpers.rb"
+helpers DiffHelpers
+
+require "bananajour/helpers"
+helpers Bananajour::GravatarHelpers, Bananajour::DateHelpers
+
+helpers do
+  def json(body)
+    content_type "application/json"
+    params[:callback] ? "#{params[:callback]}(#{body});" : body
+  end
+  def local?
+    [
+      "0.0.0.0",
+      "127.0.0.1",
+      Socket.getaddrinfo(request.env["SERVER_NAME"], nil).map {|a| a[3]}
+    ].flatten.include? request.env["REMOTE_ADDR"]
+  end
+  def pluralize(number, singular, plural)
+    "#{number} #{number == 1 ? singular : plural}"
+  end
+end
+
+get "/" do
+  @my_repositories     = Bananajour.repositories
+  @other_repos_by_name = @repository_browser.other_repositories.group_by {|r| r.name}
+  @people              = @bananajour_browser.other_bananajours
+  haml :home
+end
+
+get "/:repository/readme" do
+  @repository      = Bananajour::Repository.for_name(params[:repository])
+  readme_file      = @repository.readme_file
+  @rendered_readme = @repository.rendered_readme
+  @plain_readme    = readme_file.data
+  haml :readme
+end
+
+get "/:repository/:commit" do
+  @repository = Bananajour::Repository.for_name(params[:repository])
+  @commit     = @repository.grit_repo.commit(params[:commit])
+  haml :commit
+end
+
+get "/index.json" do
+  json Bananajour.to_hash.to_json
+end
+
+get "/:repository.json" do
+  response = Bananajour::Repository.for_name(params[:repository]).to_hash
+  response["recent_commits"].map! { |c| c["committed_date_pretty"] = time_ago_in_words(Time.parse(c["committed_date"])).gsub("about ","") + " ago"; c }
+  json response.to_json
+end