English to Arabic Vocabulary makes it easy to practice and learn both the english & arabic language. The application contains a big list of english words and their arabic translation. After searching for a certain word, you are able to hear the pronunciation of the word in both english and arabic.
SQLite Maker
SQLite Maker is a small utility that makes the creation of SQLite databases simpler and more fun. Create a database, its tables and columns using your fingertips. You can then easily transfer and/or send the created database to you or to the person who will have it.
Notice that the tool does not contain functionality for executing SQL queries against the created databases. The only purpose of the tool is to create plain sqlite database files.
For support & bug reporting, click here to contact me
A tool for installing the Assyrian fonts & keyboard layout on mac OS
Please follow the steps below;
1. Open your mac’s security and privacy settings. Open Settings -> Security and privacy setting.
2. Under the General tab, click on (Anywhere) under (Allow applications downloaded from:). See the image.
3. Download the tool from here
4. Extract the file and place the tool on your Desktop. Please do not run the tool from an USB device because it will not work.
5. To install the fonts, press the install fonts button. You will be asked for the user’s password.
6. To install the keyboard layout, press the install keyboard layout button. You will be asked for the user’s password.
7. Go to settings -> Keyboard. Press on the input sources and press the add button. A window will pop up. In the search box, type assyrian. An entry in the list will show up. Select it and press Add.
8. Now Assyrian is added.
A simple Configuration class in Ruby
Just in case you never heard of OpenStruct…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
require 'ostruct' module Application class Config < OpenStruct end class << self def config @config ||= Config.new end def configure yield config end end end |
And this is how it can be implemented…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Application.configure do |c| c.name = "Abu Lewis" c.single = false c.number_of_children = 3 c.email = "foo@bar.com" end puts Application.config.name puts Application.config.single puts Application.config.number_of_children puts Application.config.email |
IceCube => Ruby Date Recurrence Library
I love that i found it :). Check it at ice_cube github repo.
This is my first playing around code;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
require 'ice_cube' # "Yearly in February on the 7th day of the month on Mondays" rule = IceCube::Rule.yearly.month_of_year(:february).day_of_month(7).day(:monday) # Create a new Schedule object schedule = IceCube::Schedule.new # Load the schedule with the rule above schedule.add_recurrence_rule(rule) # Print the dates in which the rule above occures, starting from today untill 30 years in the future puts schedule.occurrences_between(Date.today, Date.today >> 12*30) |
The output would look like this
|
1 2 3 4 5 6 |
2022-02-07 12:56:03 +0100 2028-02-07 12:56:03 +0100 2033-02-07 12:56:03 +0100 2039-02-07 12:56:03 +0100 |
When to write modules in Ruby!?
To be short and concise, As soon as you have identified a behavior that is or may be shared between different objects, at that time it is a good idea to push that behavior in its own module.
So lets fabricate a use case;
You are given the task to write a little program for a zoo. They need to register the type of food and the time for which the different animals are fed. The zoo has a wide variety of animals, like big cats, fishes, reptiles etc.
So as a good programmer, we do know that all these animals ”eat” (Common behavior). So eating is a good candidate to be separated in a module. The different animals may implemented differently depending on the type, race etc.
So if we define an module and call it EatingBehavior that would look like this;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
module EatingBehavior def eat(food, time) food_list.push({:food => food, :time => time}) end def present_eaten_food() food_list.each do |food| puts food[:time].to_s + " => " + food[:food] end end private def food_list @food_list ||= [] end end |
We can later define a Lion and a Fish class that may look like these;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
require_relative "eating_behavior" class Lion attr_reader :name include EatingBehavior def initialize(name) @name = name end end |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
require_relative "eating_behavior" class Fish attr_reader :type include EatingBehavior def initialize(type) @type = type end end |
The both objects are now ”eaters” and if we would define more animals, we should just repeat the same ”including” process….
To test the implementation;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
lion = Lion.new("MrT") lion.eat("Raw meat", Time.now) lion.eat("Raw chicken", Time.now) puts "The lion ate" lion.present_eaten_food fish = Fish.new("Salmon") fish.eat("Worms", Time.now) fish.eat("Shrimps", Time.now) puts "The fish ate" fish.present_eaten_food |
Creating a Ruby service using the dRuby module to be called within a Rails application
To simplify things, lets fabricate a use case scenario;
Imagine that you have to control a password’s strength when the user is registering a new account. The controlling of the password is done using a password list file obtained from https://wiki.skullsecurity.org/index.php?title=Passwords. I’m using the best available one according to the site, which is rockyou.txt.bz2.
To use the list, I have extracted the list and copied it to /usr/share/wordlists/. Once that is done, the shell command ”grep” can easily be used;
|
1 2 3 |
$ grep -x hacker /usr/share/wordlists/rockyou.txt |
The command will check if the password ”hacker” exists or not in the file. And to use the same command in our ruby applications, we can construct a class like this one.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
class PasswordChecker # The constructor. Pass a password list file to it to match against. def initialize(password_list_file) raise RuntimeError, "Password list file does not exist." unless File.file?(password_list_file) @password_file = password_list_file end # Check if the password is good or not. # Notice that it will use *NIX grep command to execute (faster) the operation. # The method takes a password as parameter and returns true/false def good_password?(password) cmd = "grep -x '#{password}' #{@password_file}" %x[#{cmd}].empty? end # Just to make it convenient, it is the opposite to good_password? def bad_password?(password) !good_password?(password) end end |
And to make things look like beautiful, We write an dRuby runner class as this one;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
require 'drb/drb' class DRbRunner # Constructor. It takes the ip address and port to listen to. # And the object to act as a front object. def initialize(listen_address, listen_port, front_object) @server_uri = "druby://#{listen_address}:#{listen_port}" @front_object = front_object end # Fire the dRuby server with the front object passed to it as a server. def run! shutdown_on_trapped_signal! DRb.start_service(@server_uri, @front_object) DRb.thread.join end private # Shutdown when TERM & INT signals are trapped. def shutdown_on_trapped_signal! ['TERM', 'INT'].each do |signal| trap(signal) do DRb.stop_service end end end end |
To bootstrap and run, we will do so;
|
1 2 3 4 5 6 7 8 9 10 11 |
require_relative 'password_checker' require_relative 'drb_runner' puts "Running the Password Checker Service now...." puts "To shutdown, press CTRL-C" password_checker = PasswordChecker.new('/usr/share/wordlists/rockyou.txt') drb_runner = DRbRunner.new('192.168.1.26', 8787, password_checker) drb_runner.run! |
Now the server part is up and running. To test our client, we can do so;
|
1 2 3 4 5 6 7 8 |
require 'drb/drb' SERVER_URI="druby://192.168.1.26:8787" DRb.start_service server_object = DRbObject.new_with_uri(SERVER_URI) puts server_object.good_password?("hacker") |
The client part can be implemented in your rails application as well!
Connecting IOS socket client to a Ruby socket server using Swift & Ruby’s eventmachine gem.
To demonstrate, I have written a server that has one task. It reads a word and sends it back to the client in a reversed form.
The server code in few lines ;/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
# Make sure to "gem install eventmachine" require 'eventmachine' # Define the receive_data in it's own module. # The module will be injected when the server is started. # receive_data will read the sent data from the client and send it back # reversed to the same client. module ReverseServer def receive_data data send_data data.reverse # To close the client connection after writing, call; # close_connection_after_writing() end end # When the server's process is being killed, shutdown the server... ['TERM', 'INT'].each do |signal| trap(signal) do EventMachine::stop() end end # Start the server on the port 2299... EventMachine::run { puts 'Starting the server...' EventMachine::start_server "127.0.0.1", 2299, ReverseServer } |
The client, which is written as a part of an IOS application in Swift;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
import Foundation class ReverseClient: NSObject, NSStreamDelegate { // The server host to connect to. private var host:String? // Server's port private var port:Int? // Socket stream to read from private var inputStream: NSInputStream? // Socket stream to write to private var outputStream: NSOutputStream? // Lets declare a callback func to spit out when new data is read. // This func is assigned each time a data is written to the server. Se (reverseWord func) private var dataReadCallback:((dataReceived:String)->Void)? // To connect to the server func connect(host: String, port: Int) { self.host = host self.port = port NSStream.getStreamsToHostWithName(host, port: port, inputStream: &self.inputStream, outputStream: &self.outputStream) if self.inputStream != nil && self.outputStream != nil { self.inputStream!.delegate = self self.outputStream!.delegate = self self.inputStream!.scheduleInRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) self.outputStream!.scheduleInRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) self.inputStream!.open() self.outputStream!.open() } } // This is a call back func that takes care of I/O from/to the server. // Read about this func. There are many event codes to handle. // I just wanted to make it simple. func stream(aStream: NSStream, handleEvent eventCode: NSStreamEvent) { if aStream != inputStream { return } if eventCode == .HasBytesAvailable { self.read() } } // When it's time to read from the server. // It is called internally in the stream delegate function (se above). private func read() -> String { var buffer = [UInt8](count: 1024, repeatedValue: 0) var output: String = "" while (self.inputStream!.hasBytesAvailable){ let bytesRead: Int = inputStream!.read(&buffer, maxLength: buffer.count) if bytesRead >= 0 { output += NSString(bytes: UnsafePointer(buffer), length: bytesRead, encoding: NSUTF8StringEncoding)! as String } } self.dataReadCallback!(dataReceived: output) return output } // When writing to the server... // The first argument is the word to reverse. // The second argument is a function callback. The argument (dataReceived) is assigned // when the reversed word is received. func reverseWord(word:String) -> Int{ if self.outputStream == nil { NSException(name: "Not connected to the server", reason: "Make sure to connect first", userInfo: nil).raise() } let data:NSData = word.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)! let bytesWritten:Int = self.outputStream!.write(UnsafePointer(data.bytes), maxLength: data.length) return bytesWritten } // When data is received from the server. func onDataReceived(dataReadCallback:((dataReceived:String) -> Void)) { self.dataReadCallback = dataReadCallback } // When it is time to close the connection to the server. func close() -> Bool { if ( self.inputStream == nil) || (self.outputStream == nil) {return false } self.inputStream?.removeFromRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) self.outputStream?.removeFromRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) inputStream?.close() outputStream?.close() inputStream = nil outputStream = nil return true } } |
The demo application that I wrote is a single view-based IOS-application, with 1 textfield, label and button.
An instance of ReverseClient is created in the ViewController…
|
1 2 3 4 5 |
class ViewController: UIViewController { let reverseClient:ReverseClient = ReverseClient() ... |
And when the button is pressed;
|
1 2 3 4 5 6 7 8 9 10 11 |
@IBAction func btnClicked(sender: UIButton) { reverseClient.connect("127.0.0.1", port: 2299) reverseClient.reverseWord(self.textField.text!) reverseClient.onDataReceived { (dataReceived) -> Void in self.resultLabel.text = dataReceived self.reverseClient.close() } } |
Do not forget to start the server!
Monitor your ruby server process using bash scripting.
After writing a server socket in ruby, I had to find out a solution to monitor its process in any way. I knew that there is a gem for that called God. I also new that scheduling jobs in NIX systems are quit easy using the crontab tool. The problem was though how I would handle the process monitoring part. I had heard of Bash scripting but never buried myself in it.
After a day or so, I ended up with the script below. It is well documented and in case of learning, this is a nice tutorial. The use case of this script would be to schedule it using the crontab tool.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
#!/bin/bash # Process name, the string to search for when doing ps ... process_name="server.rb" # Full path of the process. process_path="./server.rb" # Full path to the log file. log_file="/tmp/server.log" # Checks if the process is running or not. # Argument (1): The process path to check. # Return: 0 (true) if the process is running. Otherwise 1 (false). function is_process_running () { if pgrep -f $1 > /dev/null; then return 0 fi return 1 } # Exit if the process is running. if is_process_running $process_name; then exit; fi # Current date/time stamp. current_date=$(date) # Run the process. $process_path & # Sleep for 3 seconds. sleep 3 # Check once again if the process is running. # If it is NOT, log a message to the log file. if ! is_process_running $process_name; then message="$current_date - Could not start the server" echo $message >> $log_file fi |
Adding the Assyrian Language to OS X (Mac)
To be able to write in Assyrian on Mac’s OS X system. You will need to download:
1. A keyboard layout (click to download)
2. The fonts (click to download)
Download the both compressed files and decompress them both. Use the path of your desktop to access them easily.
We start installing the keyboard layout by copying the content of AssyrianKeyboard to the folder ”/Library/Keyboard\ Layouts”. This can be done in finder.
Check the screen presentations which I made. Notice that the language of my system is Swedish. I just translated the menu alternatives to English roughly.
Next step is to install the fonts. The easiest way to do it is to open the folder ”melthofonts” and highlight all the files having the extension ”otf”. Right-click on the highlighted files and choose ”Open with”. The program ”Fonts Book” Should be listed there so click on it.
Many “windows” will popup now. On each of them, there will be an ”Install font” button, Click on these buttons to install the fonts.
The final step is to setup the system to handle the Assyrian language. To do that, follow the steps in this video.