livedata 0.2.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 siddick
+
+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

@@ -0,0 +1,43 @@
+== LiveData
+  LiveData is a rubygem. This gem is used to implement the applications like chat, live process montior, etc.,
+
+
+== Installation
+  Step 1 :-
+  	Add the livedata gem in config/environment.rb
+		  config.gem "livedata"
+  Step 2 :-
+	Add the following configuration in the config/environments/development.rb, config/environments/production.rb and config/environments/test.rb
+		config.threadsafe!
+
+== Example
+	Class MainController < ApplicationController
+
+	  def get_msg
+	    user_id = params[:id] || "test"
+	    chat = LiveData.get_channel('chat') || LiveData.create_channel('chat')
+	    user = chat.get_user( user_id ) || chat.create_user( user_id )
+	    render :text => user.read
+	  end
+
+	  def send_msg
+	    user_id = params[:id] || "test"
+	    message = params[:msg] || "Nothing"
+
+	    chat = LiveData.get_channel('chat') || LiveData.create_channel('chat')
+	    user = chat.get_user( user_id ) || chat.create_user( user_id )
+
+	    user.write( message )
+	    render :text => 'Finesh'
+	  end
+	end
+
+	== Run Webrick Server
+		ruby script/server -b 0.0.0.0 -p 3000
+	== Browser
+		Open two tabs in the web browser
+		First tab :-
+			http://localhost:3000/main/get_msg/tester
+		Second Tab :-
+			http://localhost:3000/main/send_msg/tester?msg=Hello World
+

data/Rakefile

@@ -0,0 +1,67 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require File.join(File.dirname(__FILE__), 'lib', 'live_data', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'livedata'
+PKG_VERSION   = LiveData::VERSION + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the live_data plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the live_data plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LiveData'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+dist_dirs = [ "lib", "test", "examples" ]
+
+spec = Gem::Specification.new do |s|
+	s.platform = Gem::Platform::RUBY
+	s.name = PKG_NAME
+	s.version = PKG_VERSION
+	s.summary = "Handle live data"
+	s.description = %q{Using the livedata plugin, we can implement application like chat, status monitoring, etc.}
+
+	s.files = [ "Rakefile","MIT-LICENSE", "install.rb", "README", "CHANGELOG" ]
+	dist_dirs.each do |dir|
+		s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+	end
+
+	s.require_path = 'lib'
+	s.autorequire = 'live_data'
+
+	s.has_rdoc = true
+	s.extra_rdoc_files = %w( README )
+	s.rdoc_options.concat ['--main',  'README']
+
+	s.author = "Mohammed Siddick. E"
+	s.email = "siddick007@yahoo.co.in"
+	s.homepage = "http://siddick.github.com/"
+	#s.rubyforge_project = "live_data"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.gem_spec = spec
+	p.need_tar = true
+	p.need_zip = true
+end
+

data/lib/live_data/channel.rb

@@ -0,0 +1,102 @@
+
+module LiveData
+
+   # Channel is used to maintain users, groups and user-group relation
+   class Channel
+
+      attr :users, :groups, :user_in_groups, :group_have_users, :name
+
+      # Create a new channel
+      def initialize( name = nil )
+         @name   = name || self
+         @users  = {}
+         @groups = {}
+         @user_in_groups = {}
+         @group_have_users = {}
+      end
+
+      # Write yaml data
+      # ==== Parameters
+      # * +yaml_data+  - String which contain data in yaml format
+      def write_yaml( yaml_data )
+         @users.each{|user_name, user|
+            user.write_yaml( yaml_data )
+         }
+      end
+
+      # Write json data
+      # ==== Parameters
+      # * +json_data+  - String which contain data in json format
+      def write_json( json_data )
+         @users.each{|user_name, user|
+            user.write_json( json_data )
+         }
+      end
+
+      # Write data in any format
+      # ==== Parameters
+      # * +data+    - it may be any Object. 
+      def write( data )
+         @users.each{|user_name, user|
+            user.write( data )
+         }
+      end
+
+      # Create a user, if he is not present in the user list
+      # ==== Parameters
+      # * +name+   - User name 
+      def create_user( name )
+         unless( @users[name] ) 
+            @users[name] = LiveData::User.new( name, self )
+            @user_in_groups[name] = @users[name].groups
+         end
+         return @users[name]
+      end
+
+      # Create a group, if the group is not present in the group list
+      # ==== Parameters
+      # * +name+    - Group name
+      def create_group( name )
+         unless( @groups[name] ) 
+            @groups[name] = LiveData::Group.new( name, self )
+            @group_have_users[name] = @groups[name].users
+         end
+         return @groups[name]
+      end
+
+      # Get user object
+      def get_user( name )
+         @users[name]
+      end
+
+      # Get group object
+      def get_group( name )
+         @groups[name]
+      end
+
+      # Destroy a user
+      # ==== Parameters
+      # * +name+   - User name 
+      def destroy_user( name )
+         @users[name].destroy()
+      end
+
+
+      # Destroy a group
+      # ==== Parameters
+      # * +name+   - Group name 
+      def destroy_group( name )
+         @groups[name].destroy()
+      end
+
+      # Destroy current channel
+      def destroy
+         @users.each{|name,obj|
+            obj.destroy()
+         }
+         @groups.each{|name,obj|
+            obj.destroy()
+         }
+      end
+   end
+end

data/lib/live_data/group.rb

@@ -0,0 +1,74 @@
+module LiveData
+
+   # Group is used to maintain collection of users
+   # ==== Example 
+   #
+   #    chat     = LiveData::Channel.new
+   #    guest1   = chat.create_user('guest1')
+   #    guest2   = chat.create_user('guest2')
+   #   user_grp = chat.create_group('user')
+   #
+   #   user_grp.add_user( guest1 )
+   #   user_grp.add_user( guest2 )
+   #
+   #   user_grp.write( { :title => "Greeting", 
+   #      :message => "Wecome to LiveData" } )
+   #
+   #   group1.read      #  { :title => "Greeti..... }
+   #   group2.read      #  { :title => "Greeti..... }
+   class Group
+
+      attr :users, :name
+
+      # Create a group
+      def initialize( name = nil, channel = nil )
+         @name    = name || self
+	 @channel = channel
+         @users = []
+      end
+
+      # Write data, which contain yaml format
+      def write_yaml( yaml_data )
+         @users.each{|user|
+            user.write_yaml( yaml_data )
+         }
+      end
+
+      # Write data, which contain json format
+      def write_json( json_data )
+         @users.each{|user|
+            user.write_json( json_data )
+         }
+      end
+
+      # Write any object
+      def write( data )
+         @users.each{|user|
+            user.write( data )
+         }
+      end
+
+      # Add user to the group
+      def add_user( user )
+         @users.push( user )
+         user.groups.push( self )
+      end
+
+      # Delete user from the group
+      def remove_user( user )
+         @users.delete( user )
+         user.groups.delete( self )
+      end
+
+      def destroy
+         @users.each{|user|
+            user.groups.delete( self )
+         }
+	 if( @channel )
+		 @channel.groups.delete( @name ) 
+		 @channel.group_have_users.delete( @name )
+	 end
+      end
+   end
+end
+

data/lib/live_data/user.rb

@@ -0,0 +1,94 @@
+
+module LiveData
+   class User
+
+      IntegerPackCode = "I"
+
+      attr :groups, :name
+
+      # Create a user object
+      def initialize( name = nil, channel = nil )
+         @name    = name || self
+	 @channel = channel
+         @lock                     = Mutex.new
+         @read_pipe, @write_pipe = IO.pipe
+         @groups       = []
+      end
+
+      # Reset the write pipe and read pipe
+      def reset
+         begin
+            @write_pipe.close
+            @read_pipe.close
+         rescue => err
+         end
+         @read_pipe, @write_pipe = IO.pipe
+      end
+
+      # Clean the Contain in the pipe
+      def clean
+         begin
+            while( @read_pipe.read_nonblock( 10000 ) )
+            end
+         rescue => err
+         end
+      end
+
+      # Read json contain
+      def read_json
+         @read_pipe.gets()
+      end
+
+      # Read yaml contain
+      def read_yaml
+         len, etc = @read_pipe.read(4).unpack( IntegerPackCode )
+         @read_pipe.read( len )
+      end
+
+      # read a Object
+      def read
+          YAML.load( read_yaml )
+      end
+
+      # Write a string, which contain json format
+      # ==== Parameters
+      # * +json_data+ - json string
+      def write_json( json_data )
+         @write_pipe.write( json_data + "\n" )         
+      end
+
+      # Write a string, which contain yam format
+      # ==== Parameters
+      # * +yaml_data+ - yaml string
+      def write_yaml( yaml_data )
+         return unless yaml_data and yaml_data.class == String
+         len = [ yaml_data.length ].pack( IntegerPackCode )
+         @write_pipe.write( len )
+         @write_pipe.write( yaml_data )
+      end
+
+      # Write a Object
+      # ==== Parameters
+      # * +data+ - any Object
+      def write( data )
+         write_yaml( data.to_yaml )
+      end
+
+      # Destroy the user
+      def destroy
+         @groups.dup.each{|grp|
+            grp.remove_user( self )
+         }
+	 if( @channel )
+		 @channel.users.delete( @name )
+		 @channel.user_in_groups.delete( @name )
+	 end
+         begin
+            @read_pipe.close
+            @write_pipe.close
+         rescue => err
+         end
+      end
+
+   end
+end

data/lib/live_data/version.rb

@@ -0,0 +1,4 @@
+
+module LiveData
+   VERSION      = '0.2.1'
+end

data/lib/live_data.rb

@@ -0,0 +1,38 @@
+# LiveData
+
+require 'thread'
+require 'yaml'
+require 'json'
+
+require 'live_data/version'
+require 'live_data/channel'
+require 'live_data/user'
+require 'live_data/group'
+module LiveData
+   Channels    = {}
+
+   def self.create_channel( name )
+      unless( Channels[name] )
+         Channels[name] = LiveData::Channel.new( name )
+      end
+      return Channels[name]
+   end
+
+   def self.destroy_channel( name )
+      channel = self.get_channel( name )
+      channel.destroy()
+   end
+
+   def self.get_channel( name, create = true )
+      channel = Channels[name]
+      if( !channel and create )
+         channel = LiveData.create_channel( name )
+      end
+      return channel
+   end
+
+   def self.check_channel( name )
+      Channels[name]
+   end
+   
+end

data/lib/livedata.rb

@@ -0,0 +1 @@
+require 'live_data'

data/test/live_data_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class LiveDataTest < Test::Unit::TestCase
+
+	def test_channel
+		chat = LiveData.create_channel( 'chat' )
+
+		assert chat.class == LiveData::Channel
+		assert chat.name == 'chat'
+		assert chat == LiveData.get_channel( 'chat' )
+	end
+
+	def test_user
+		chat 	= LiveData.create_channel( 'chat' )
+		guest1 	= chat.create_user( 'guest1' )
+
+		assert guest1.class == LiveData::User
+		assert guest1.name == 'guest1' 
+		assert guest1 == chat.get_user( 'guest1' )
+		assert guest1 == chat.create_user( 'guest1' )
+		
+		chat.destroy_user( 'guest1' )
+
+		assert chat.get_user( 'guest1') == nil 
+		assert chat.users['guest1'] == nil 
+		assert chat.user_in_groups['guest1'] == nil 
+
+
+	end
+
+	def test_group
+		chat 	  = LiveData.create_channel( 'chat' )
+		users_grp = chat.create_group( 'users' )
+
+		assert users_grp.class == LiveData::Group
+		assert users_grp.name  == 'users'
+		assert users_grp == chat.get_group( 'users' )
+		assert users_grp == chat.create_group( 'users' )
+
+		guest1 	= chat.create_user( 'guest1' )
+		users_grp.add_user( guest1 )
+		assert users_grp.users.include? guest1
+		assert guest1.groups.include? users_grp 
+
+		users_grp.remove_user( guest1 )
+		assert !users_grp.users.include?(guest1)
+		assert !guest1.groups.include?(users_grp)
+
+		chat.destroy_group( 'users' )
+
+		assert chat.get_group('users' ) == nil
+		assert chat.group_have_users['users'] == nil
+	end
+
+	def test_process_data
+		chat 	= LiveData.create_channel( 'chat' )
+		guest1 	= chat.create_user( 'guest1' )
+		guest2  = chat.create_user( 'guest2' )
+		grp	= chat.create_group( 'users')
+		data    = { :title => "Greating", :message => "Welcome you all" }
+		data1   = { :title => "Greating1", :message => "Welcome you all" }
+		data2   = { :title => "Greating2", :message => "Welcome you all" }
+		grp.add_user( guest1 )
+		grp.add_user( guest2 )
+
+		guest1.write( data )
+		assert data == guest1.read
+
+		guest2.write( data1 )
+		tmp_data = guest2.read
+		assert data1 == tmp_data 
+		assert data  != tmp_data 
+
+
+		grp.write( data2 )
+		assert data2 == guest1.read
+		assert data2 == guest2.read
+
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'live_data'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: livedata
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Mohammed Siddick. E
+autorequire: live_data
+bindir: bin
+cert_chain: []
+
+date: 2010-02-13 00:00:00 +05:30
+default_executable: 
+dependencies: []
+
+description: Using the livedata plugin, we can implement application like chat, status monitoring, etc.
+email: siddick007@yahoo.co.in
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Rakefile
+- MIT-LICENSE
+- install.rb
+- README
+- CHANGELOG
+- lib/live_data/channel.rb
+- lib/live_data/group.rb
+- lib/live_data/user.rb
+- lib/live_data/version.rb
+- lib/livedata.rb
+- lib/live_data.rb
+- test/live_data_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://siddick.github.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Handle live data
+test_files: []
+