merge master

lib/jam_ruby.rb

@@ -4,13 +4,13 @@ require "jampb"
 require 'uuidtools'
 require "jam_ruby/version"
 require "jam_ruby/message_factory"
-require "jam_ruby/models/jam_session_member"
+require "jam_ruby/models/music_session_client"
 require "jam_ruby/models/user"
 require "jam_ruby/models/musician"
 require "jam_ruby/models/band"
 require "jam_ruby/models/connection"
 require "jam_ruby/models/friendship"
-require "jam_ruby/models/jam_session"
+require "jam_ruby/models/music_session"
 
 include Jampb
 

lib/jam_ruby/message_factory.rb

@@ -41,28 +41,28 @@
       return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_ACK, :target => CLIENT_TARGET, :login_ack => login_ack)
     end
 
-    # create a jam session login message
-    def login_jam_session(jam_session)
-      login_jam_session = Jampb::LoginJamSession.new(:jam_session => jam_session)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_JAM_SESSION, :target => SERVER_TARGET, :login_jam_session => login_jam_session)
+    # create a music session login message
+    def login_music_session(music_session)
+      login_music_session = Jampb::LoginMusicSession.new(:music_session => music_session)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION, :target => SERVER_TARGET, :login_music_session => login_music_session)
     end
 
-    # create a jam session login message ack (success or on failure)
-    def login_jam_session_ack(error, error_reason)
-      login_jam_session_ack = Jampb::LoginJamSessionAck.new(:error => error, :error_reason => error_reason)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_JAM_SESSION_ACK, :target => CLIENT_TARGET, :login_jam_session_ack => login_jam_session_ack)
+    # create a music session login message ack (success or on failure)
+    def login_music_session_ack(error, error_reason)
+      login_music_session_ack = Jampb::LoginMusicSessionAck.new(:error => error, :error_reason => error_reason)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION_ACK, :target => CLIENT_TARGET, :login_music_session_ack => login_music_session_ack)
     end
 
-    # create a jam session 'leave session' message
-    def leave_jam_session(jam_session)
-      leave_jam_session = Jampb::LeaveJamSession.new(:jam_session => jam_session)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_JAM_SESSION, :target => SERVER_TARGET, :leave_jam_session => leave_jam_session)
+    # create a music session 'leave session' message
+    def leave_music_session(music_session)
+      leave_music_session = Jampb::LeaveMusicSession.new(:music_session => music_session)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION, :target => SERVER_TARGET, :leave_music_session => leave_music_session)
     end
 
-    # create a jam session leave message ack (success or on failure)
-    def leave_jam_session_ack(error, error_reason)
-      leave_jam_session_ack = Jampb::LeaveJamSessionAck.new(:error => error, :error_reason => error_reason)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_JAM_SESSION_ACK, :target => CLIENT_TARGET, :leave_jam_session_ack => leave_jam_session_ack)
+    # create a music session leave message ack (success or on failure)
+    def leave_music_session_ack(error, error_reason)
+      leave_music_session_ack = Jampb::LeaveMusicSessionAck.new(:error => error, :error_reason => error_reason)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION_ACK, :target => CLIENT_TARGET, :leave_music_session_ack => leave_music_session_ack)
     end
 
 		# create a server error
@@ -78,9 +78,9 @@
     end
 
     # create a user-joined session messag
-    def user_joined_jam_session(user_id, username)
-      joined = Jampb::UserJoinedJamSession.new(:user_id => user_id, :username => username)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_JOINED_JAM_SESSION, :target => CLIENT_TARGET, :user_joined_jam_session => joined)
+    def user_joined_music_session(user_id, username)
+      joined = Jampb::UserJoinedMusicSession.new(:user_id => user_id, :username => username)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_JOINED_MUSIC_SESSION, :target => CLIENT_TARGET, :user_joined_music_session => joined)
     end
 
 		# create a test message to send in session
@@ -111,7 +111,7 @@
        return msg.target == MessageFactory::CLIENT_TARGET
     end
 
-    # is this message directed to a (jam) session?
+    # is this message directed to a (music) session?
     def session_directed? msg
        return msg.target.start_with? MessageFactory::SESSION_TARGET_PREFIX
     end

lib/jam_ruby/models/jam_session.rb

@@ -1,20 +0,0 @@
-module JamRuby
-  class JamSession < ActiveRecord::Base
-
-    self.primary_key = 'id'
-    belongs_to :creator, :inverse_of => :jam_sessions, :class_name => "JamRuby::User", :foreign_key => "user_id"
-
-    has_many :jam_session_members, :class_name => "JamRuby::JamSessionMember"
-    has_many :users, :through => :jam_session_members, :class_name => "JamRuby::User"
-         
-    # Verifies that the specified user can join this jam session
-    def access?(user)
-        return self.public || self.users.exists?(user)
-    end
-
-    def to_s
-        return name
-    end
-
-  end
-end

lib/jam_ruby/models/jam_session_member.rb

@@ -1,14 +0,0 @@
-module JamRuby
-  class JamSessionMember < ActiveRecord::Base
-
-		self.primary_key = 'id'
-    belongs_to :user, :class_name => "JamRuby::User"
-    belongs_to :jam_session, :class_name => "JamRuby::JamSession"
-
-		def to_s
-			return self.user.to_s
-		end
-
-    
-  end
-end

lib/jam_ruby/models/music_session.rb

@@ -0,0 +1,21 @@
+module JamRuby
+  class MusicSession < ActiveRecord::Base
+
+    self.primary_key = 'id'
+    belongs_to :creator, :inverse_of => :music_sessions, :class_name => "JamRuby::User", :foreign_key => "user_id"
+
+    has_many :music_session_clients, :class_name => "JamRuby::MusicSessionClient"
+    has_many :users, :through => :music_session_clients, :class_name => "JamRuby::User"
+         
+    # Verifies that the specified user can join this jam session
+    def access?(user)
+        #return self.public || self.users.exists?(user)
+        return true
+    end
+
+    def to_s
+        return description
+    end
+
+  end
+end

lib/jam_ruby/models/music_session_client.rb

@@ -0,0 +1,14 @@
+module JamRuby
+  class MusicSessionClient < ActiveRecord::Base
+    self.primary_key = 'id'
+
+    belongs_to :user, :class_name => "JamRuby::User"
+    belongs_to :music_session, :class_name => "JamRuby::MusicSession"
+
+		def to_s
+			return "#{self.user.to_s}:#{self.ip_address}"
+		end
+
+    
+  end
+end

lib/jam_ruby/models/user.rb

@@ -2,10 +2,10 @@ module JamRuby
   class User < ActiveRecord::Base
 
     attr_accessible :name, :email, :password, :password_confirmation
-		attr_accessor :updating_password
+    attr_accessor :updating_password
 
-		self.primary_key = 'id'
-    
+    self.primary_key = 'id'
+        
     # re-visit later (used for multiple table inheritance w/ Musician model)
     # belongs_to :biz, :polymorphic => true
     
@@ -16,9 +16,9 @@ module JamRuby
     has_many :inverse_friendships, :class_name => "JamRuby::Friendship", :foreign_key => "friend_id"
     has_many :inverse_friends, :through => :inverse_friendships, :source => :user
     
-    has_many :jam_session_members, :class_name => "JamRuby::JamSessionMember"
-    has_many :created_jam_sessions, :foreign_key => "user_id", :inverse_of => :user, :class_name => "JamRuby::JamSession" # sessions *created* by the user
-    has_many :jam_sessions, :through => :jam_session_members, :class_name => "JamRuby::JamSession"
+    has_many :music_session_clients, :class_name => "JamRuby::MusicSessionClient"
+    has_many :created_music_sessions, :foreign_key => "user_id", :inverse_of => :user, :class_name => "JamRuby::MusicSession" # sessions *created* by the user
+    has_many :music_sessions, :through => :music_session_clients, :class_name => "JamRuby::MusicSession"
     
     has_secure_password
 
@@ -31,21 +31,21 @@ module JamRuby
               uniqueness: {case_sensitive: false}
     validates_length_of :password, minimum: 6, maximum: 100, :if => :should_validate_password?
 
-		validates_presence_of :password_confirmation, :if => :should_validate_password?
+    validates_presence_of :password_confirmation, :if => :should_validate_password?
     #validates :password_confirmation, presence: true
-		validates_confirmation_of :password, :if => :should_validate_password?
+    validates_confirmation_of :password, :if => :should_validate_password?
 
-		def should_validate_password?
-			updating_password || new_record?
-		end
+    def should_validate_password?
+      updating_password || new_record?
+    end
 
-		def to_s
-			return email unless email.nil?
-			return name unless name.nil?
-			return id
-		end
+    def to_s
+      return email unless email.nil?
+      return name unless name.nil?
+      return id
+    end
 
-		private
+    private
       def create_remember_token
         self.remember_token = SecureRandom.urlsafe_base64
       end

spec/factories.rb

@@ -10,12 +10,11 @@ FactoryGirl.define do
     end
   end
 
-  factory :jam_session, :class => JamRuby::JamSession do
-    sequence(:name) { |n| "Jam Session #{n}" }
-    public false
+  factory :music_session, :class => JamRuby::MusicSession do
+    sequence(:description) { |n| "Music Session #{n}" }
   end
 
-  factory :jam_session_member, :class => JamRuby::JamSessionMember do
+  factory :music_session_client, :class => JamRuby::MusicSessionClient do
     
   end
 end

spec/jam_ruby/models/jam_session_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe JamSession do
-
-  it 'can grant access to valid user' do
-
-    user1 = FactoryGirl.create(:user)  # in the jam session
-    user2 = FactoryGirl.create(:user)  # in the jam session
-    user3 = FactoryGirl.create(:user)  # not in the jam session
-
-    jam_session = FactoryGirl.create(:jam_session, :creator => user1)
-
-    jam_session_member1 = FactoryGirl.create(:jam_session_member, :user => user1, :jam_session => jam_session)
-    jam_session_member2 = FactoryGirl.create(:jam_session_member, :user => user2, :jam_session => jam_session)
-
-    jam_session.access?(user1).should == true
-    jam_session.access?(user2).should == true
-    jam_session.access?(user3).should == false
-  end
-end

spec/jam_ruby/models/music_session_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe MusicSession do
+
+  it 'can grant access to valid user' do
+
+    user1 = FactoryGirl.create(:user)  # in the jam session
+    user2 = FactoryGirl.create(:user)  # in the jam session
+    user3 = FactoryGirl.create(:user)  # not in the jam session
+
+    music_session = FactoryGirl.create(:music_session, :creator => user1)
+
+    music_session_member1 = FactoryGirl.create(:music_session_client, :user => user1, :music_session => music_session, :ip_address => "1.1.1.1")
+    music_session_member2 = FactoryGirl.create(:music_session_client, :user => user2, :music_session => music_session, :ip_address => "2.2.2.2")
+
+    music_session.access?(user1).should == true
+    music_session.access?(user2).should == true
+    #music_session.access?(user3).should == false -- wait until we have finalized access models in place
+  end
+end

spec/spec_db.rb

@@ -3,9 +3,9 @@ class SpecDb
   TEST_DB_NAME="jam_ruby_test"
 
   def self.recreate_database
-    conn = PG::Connection.open("dbname=postgres user=postgres password=postgres")
+    conn = PG::Connection.open("dbname=postgres user=postgres password=postgres host=localhost")
     conn.exec("DROP DATABASE IF EXISTS #{TEST_DB_NAME}")
     conn.exec("CREATE DATABASE #{TEST_DB_NAME}")
-    JamDb::Migrator.new.migrate(:dbname => TEST_DB_NAME, :user => "postgres", :password => "postgres")
+    JamDb::Migrator.new.migrate(:dbname => TEST_DB_NAME, :user => "postgres", :password => "postgres", :host => "localhost")
   end
 end