railsquest 0.1

data/lib/railsquest/bonjour/advertiser.rb

@@ -0,0 +1,66 @@
+require 'dnssd'
+
+class Railsquest::Bonjour::Advertiser
+  def initialize
+    @services = []
+  end
+
+  def go!
+    register_app
+    register_quests
+  end
+
+  private
+    def register_app
+      STDOUT.puts "Registering #{Railsquest.web_uri}"
+      tr = DNSSD::TextRecord.new
+      tr["name"] = Railsquest.config.name
+      tr["email"] = Railsquest.config.email
+      tr["uri"] = Railsquest.web_uri
+      tr["gravatar"] = Railsquest.gravatar
+      tr["version"] = Railsquest::VERSION
+      DNSSD.register("#{Railsquest.config.name}'s railsquest", "_http._tcp,_railsquest", nil, Railsquest.web_port, tr)
+    end
+
+    def register_quests
+      loop do
+        stop_old_services
+        register_new_quests
+        sleep(1)
+      end
+    end
+
+    def stop_old_services
+      old_services.each do |old_service|
+        STDOUT.puts "Unregistering #{old_service.quest.uri}"
+        old_service.stop
+        @services.delete(old_service)
+      end
+    end
+
+    def old_services
+      @services.reject {|s| Railsquest.quests.include?(s.quest)}
+    end
+
+    def register_new_quests
+      new_quests.each do |new_quest|
+        STDOUT.puts "Registering #{new_quest.uri}"
+        tr = DNSSD::TextRecord.new
+        tr["name"] = new_quest.name
+        tr["uri"] = new_quest.uri
+        tr["bjour-name"] = Railsquest.config.name
+        tr["bjour-email"] = Railsquest.config.email
+        tr["bjour-uri"] = Railsquest.web_uri
+        tr["bjour-gravatar"] = Railsquest.gravatar
+        tr["bjour-version"] = Railsquest::VERSION
+        service = DNSSD.register(new_quest.name, "_git._tcp,_railsquest", nil, 9877, tr)
+        service.class.instance_eval { attr_accessor(:quest) }
+        service.quest = new_quest
+        @services << service
+      end
+    end
+
+    def new_quests
+      Railsquest.quests.select {|quest| !@services.any? {|s| s.quest == quest } }
+    end
+end

data/lib/railsquest/bonjour/browser.rb

@@ -0,0 +1,58 @@
+require 'dnssd'
+
+require 'thread'
+require 'timeout'
+
+Thread.abort_on_exception = true
+
+# Generic bonjour browser
+#
+# Example use:
+#
+#   browser = BonjourBrowser.new("_git._tcp,_railsquest")
+#   loop do
+#     sleep(1)
+#     pp browser.replies.map {|r| r.name}
+#   end
+#
+# Probably gem-worthy
+class Railsquest::Bonjour::Browser
+  def initialize(service)
+    @service = service
+    @mutex = Mutex.new
+    @replies = {}
+    watch!
+  end
+
+  def replies
+    @mutex.synchronize { @replies.values }
+  end
+
+  private
+    def watch!
+      Thread.new(@service, @mutex, @replies) do |service, mutex, replies|
+        begin
+          DNSSD.browse!(service) do |reply|
+            Thread.new(reply, replies, mutex) do |reply, replies, mutex|
+              begin
+                DNSSD.resolve!(reply.name, reply.type, reply.domain) do |resolve_reply|
+                  mutex.synchronize do
+                    if reply.flags.add?
+                      replies[reply.fullname] = resolve_reply
+                    else
+                      replies.delete(reply.fullname)
+                    end
+                  end
+                  resolve_reply.service.stop unless resolve_reply.service.stopped?
+                end
+              rescue DNSSD::BadParamError
+                # Ignore em
+              end
+            end
+          end
+        rescue DNSSD::BadParamError
+          # Ignore em
+        end
+      end
+    end
+end

data/lib/railsquest/bonjour/person.rb

@@ -0,0 +1,25 @@
+class Railsquest::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
+  
+  def host_name
+    uri.gsub(/http:\/\//, '').gsub(/:9876/, '')
+  end
+  
+end

data/lib/railsquest/bonjour/quest.rb

@@ -0,0 +1,39 @@
+class Railsquest::Bonjour::Quest
+
+  attr_accessor :name, :uri, :person 
+
+  def initialize(name, uri, person)
+    @name, @uri, @person = name, uri, person
+  end
+  
+  def html_id
+    Railsquest::Quest.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/railsquest/bonjour/quest_browser.rb

@@ -0,0 +1,36 @@
+module Railsquest::Bonjour
+class QuestBrowser
+
+  def initialize
+    @browser = Browser.new('_git._tcp,_railsquest')
+  end
+
+  def quests
+    @browser.replies.map do |reply|
+      Quest.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_quests
+    quests.reject {|r| Railsquest.quests.any? {|my_quest| my_quest.name == r.name}}
+  end
+  
+  def quests_similar_to(quest)
+    quests.select {|r| r.name == quest.name}
+  end
+  
+  def quests_for(person)
+    quests.select {|r| r.person == person}
+  end
+  
+end
+end

data/lib/railsquest/bonjour/railsquest_browser.rb

@@ -0,0 +1,32 @@
+module Railsquest::Bonjour
+class RailsquestBrowser
+
+  def initialize
+    @browser = Browser.new('_http._tcp,_railsquest')
+  end
+
+  def railsquests
+    @browser.replies.map do |reply|
+      Person.new(
+        reply.text_record["name"],
+        reply.text_record["email"],
+        reply.text_record["uri"],
+        reply.text_record["gravatar"]
+      )
+    end
+  end
+  
+  def other_railsquests
+    railsquests.reject {|b| b.uri == Railsquest.web_uri}
+  end
+  
+  def all_railsquests
+      railsquests
+  end
+  
+  def find_person(hostname)
+    railsquests.find { |u| u.uri =~ /hostname/}
+  end
+  
+end
+end

data/lib/railsquest/commands.rb

@@ -0,0 +1,53 @@
+require 'rainbow'
+require 'pathname'
+
+module Railsquest::Commands
+
+  # Start sinatra app.
+  def serve_web!
+    puts "* Starting " + web_uri.foreground(:yellow)
+    fork do
+      ENV["RACK_ENV"] ||= "production"
+      require "railsquest/../../sinatra/app"
+      Sinatra::Application.set :port, web_port
+      Sinatra::Application.set :server, "thin"
+      Sinatra::Application.run!
+    end
+  end
+
+  def advertise!
+    fork { Railsquest::Bonjour::Advertiser.new.go! }
+  end
+
+  def add!(port, name = nil)
+
+    if name.nil?
+      default_name = "My Awesome Quest"
+      print "Quest Name?".foreground(:yellow) + " [#{default_name}] "
+      name = (STDIN.gets || "").strip
+      name = default_name if name.empty?
+    end
+
+    quest = Railsquest::Quest.for_name(name)
+    quest.port = port
+
+    if quest.exist?
+      abort "You've already a quest #{quest}."
+    end
+
+    quest.init!
+
+    puts init_success_message(quest.dirname)
+
+    quest
+  end
+
+  def init_success_message(quest_dirname)
+    plain_init_success_message(quest_dirname)
+  end
+
+  def plain_init_success_message(quest_dirname)
+    "Railsquest quest #{quest_dirname} created."
+  end
+
+end

data/lib/railsquest/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
+    Railsquest.gravatar_uri(email)
+  end
+end

data/lib/railsquest/helpers.rb

@@ -0,0 +1,100 @@
+require 'digest/md5'
+
+module Railsquest
+  module GravatarHelpers
+    def gravatar
+      gravatar_uri(self.config.email)
+    end
+    def gravatar_uri(email)
+      "http://gravatar.com/avatar/#{Digest::MD5.hexdigest(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 questrted 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/railsquest/quest.rb

@@ -0,0 +1,86 @@
+require 'grit'
+require 'pathname'
+require 'json'
+
+module Railsquest
+  class Quest
+
+    attr_accessor :name, :port
+    attr_reader :secret
+
+    def self.for_name(name)
+        n = name.gsub(/[^A-Za-z-]+/, '_')
+        q = new(Railsquest.quests_path.join(n + ".quest"))
+        q.name = n
+        q
+    end
+
+    def self.html_id(name)
+      name.gsub(/[^A-Za-z-]+/, '').downcase
+    end
+
+    def initialize(path)
+      @path = Pathname(path)
+    end
+
+    def ==(other)
+      other.respond_to?(:path) && self.path == other.path
+    end
+
+    attr_reader :path
+
+    def exist?
+      path.exist?
+    end
+
+    def init!
+      secret = `uuidgen`.strip
+      contents =  '{\"secret\" : \"' + secret + '\", \"port\" : ' + port +  '}'
+      Dir.chdir(Railsquest.quests_path) { `echo "#{contents}" >> #{path}` }
+    end
+
+    def uri
+      Railsquest.quest_uri.gsub(/\/$/, '') + ':' + File.open(path) { |f| JSON.parse(f.gets)["port"].to_s }
+    end
+
+    def secret
+      File.open(path) { |f| JSON.parse(f.gets)["secret"] }
+    end
+
+    def name
+      dirname.sub(".quest",'')
+    end
+
+    def html_id
+      self.class.html_id(name)
+    end
+
+    def dirname
+      path.split.last.to_s
+    end
+
+    def to_s
+      name
+    end
+
+    def web_uri
+      Railsquest.web_uri + "#" + html_id
+    end
+
+    def attempts
+        
+    end
+
+    def remove!
+      path.rmtree
+    end
+
+    def to_hash
+      {
+        "name" => name,
+        "uri" => uri,
+        "host_name" => Railsquest.host_name
+      }
+    end
+  end
+end