Code Master Blog

Thanks for sharing these!

Great post! I appreciate all the linked references, too. Thanks a lot.

Cool, working great. Thanks a lot!

You're welcome.

By the way, I just updated the article and project to improve and fix a few issues.

Details are in the project Change Log.

In summary, the glimmer-dsl-swt gem has been upgraded to v4.24.4.1, which includes table data-binding improvements and optimizations like auto-inferred column attributes by convention.

And, the following files were updated:

- app/contact_manager/model/contact.rb
- app/contact_manager/model/contact_presenter.rb
- app/contact_manager/view/contact_table.rb

	migrate_dir = File.expand_path('../migrate', __FILE__)
	Dir.glob(File.join(migrate_dir, '*', '.rb')).each {\|migration\| require migration}

	ActiveRecord::Migration[6.1].descendants.each do \|migration\|
	begin
	migration.migrate(:up)
	rescue => e
	raise e unless e.full_message.match(/table "[^"]+" already exists/)
	end
	end

	require 'active_record'

	class CreateContacts < ActiveRecord::Migration[6.1]
	def change
	create_table :contacts do \|t\|
	t.string :first_name
	t.string :last_name
	t.string :email
	t.string :phone
	t.string :street
	t.string :city
	t.string :state_or_province
	t.string :zip_or_postal_code
	t.string :country
	end
	end
	end

	require 'active_record'
	require 'jdbc/sqlite3'
	Jdbc::SQLite3.load_driver
	require 'activerecord-jdbcsqlite3-adapter' if defined? JRUBY_VERSION
	@connection = ActiveRecord::Base.establish_connection(
	adapter: 'sqlite3',
	database: File.join(Dir.home, 'db/contact_manager.sqlite3')
	)
	require 'db/migrate'

	require 'db/db'

	class Contact < ActiveRecord::Base
	STATES = [ 'AK', 'AL', 'AR', 'AZ', 'CA', 'CO', 'CT', 'DC', 'DE', 'FL', 'GA',
	'HI', 'IA', 'ID', 'IL', 'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME',
	'MI', 'MN', 'MO', 'MS', 'MT', 'NC', 'ND', 'NE', 'NH', 'NJ', 'NM',
	'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 'TN', 'TX',
	'UT', 'VA', 'VT', 'WA', 'WI', 'WV', 'WY']
	PROVINCES = ['NL', 'PE', 'NS', 'NB', 'QC', 'ON', 'MB', 'SK', 'AB', 'BC', 'YT', 'NT', 'NU']

	validates :first_name, presence: true
	validates :last_name, presence: true
	validates :email, format: {with: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i, message: 'must be a valid email address'}, allow_blank: true
	validates :phone, format: {with: /\A[(]?[0-9]{3}[)]?[ -\.\/0-9]{7,9}\z/, message: 'must be a valid phone number'}, allow_blank: true
	validates :zip_or_postal_code, format: {with: /\A[a-z0-9][0-9][a-z0-9][ 0-9][a-z0-9][a-z0-9]?[0-9]?\z/i, message: 'must be a valid phone number'}, allow_blank: true
	validate :email_or_phone_is_present

	def address
	address_fields = [street, city, state_or_province, zip_or_postal_code, country]
	address_fields.map { \|field\| field.blank? ? nil : field }.compact.join(', ')
	end

	def country_options
	['', 'Canada', 'USA']
	end

	def state_or_province_options
	(PROVINCES + [''] + STATES)
	end

	def reset!
	return unless persisted? && changed?

	attributes.each do \|attribute, value\|
	# calling attribute writers explicitly notifies Glimmer GUI observers indirectly
	send("#{attribute}=", send("#{attribute}_was")) if send("#{attribute}_changed?")
	end
	end

	private

	def email_or_phone_is_present
	if email.blank? && phone.blank?
	errors.add(:email, 'must be present unless phone is present')
	errors.add(:phone, 'must be present unless email is present')
	end
	end
	end

	require 'singleton'
	require 'contact_manager/model/contact'

	class ContactRepository
	include Singleton

	def all
	Contact.all
	end

	def search(query_value)
	if query_value.present?
	attribute_names = Contact.new.attributes.keys
	conditions = attribute_names.reduce('') do \|conditions, attribute\|
	if conditions.blank?
	conditions += "lower(#{attribute}) like ?"
	else
	conditions += " OR lower(#{attribute}) like ?"
	end
	end
	Contact.where(conditions, (["%#{query_value.downcase}%"]attribute_names.count))
	else
	all
	end
	end

	def destroy_all_contacts
	Contact.destroy_all
	end
	end

Code Master Blog

Saturday, June 04, 2022

Using ActiveRecord with SQLite DB in a JRuby Desktop App

Requirements:

1- Store contacts having the following attributes:

2- List stored contacts

3- Search stored contacts by any of the contact attributes.

4- Sort contacts by First Name, Last Name, Email, Phone, or Full Address

5- Edit a stored contact

6- Delete a stored contact

7- Delete all stored contacts

Implementation:

1- Gem Install

2- Scaffolding

3- Add ActiveRecord gems to Gemfile

4- Add an ActiveRecord migration for the contacts database table

5- Add a SQLite database with ActiveRecord

6- Add the Contact ActiveRecord model

7- Add the ContactRepository model

8- Add the ContactPresenter model

9- Add the ContactForm custom widget view

10- Add the ContactTable custom widget view

11- Add the ContactManagerMenuBar custom widget view

12- Update the AppView

Update app/contact_manager/view/app_view.rb by replacing all code with the following:

13- Update the ContactManager entry point

14- Replace app icons

15- Run

16- Package Native Executable

Software Architecture & Design

Reference Project at GitHub

4 comments:

	gem 'activerecord', '~> 6.1.5'
	gem 'activerecord-jdbcsqlite3-adapter', '~> 61.1', :platform => :jruby

	require 'contact_manager/model/contact'
	require 'contact_manager/model/contact_repository'

	# ContactPresenter is an enhanced Controller that also
	# enables bidirectional data-binding of contact attributes
	class ContactPresenter
	attr_accessor :contacts, :query, :current_contact

	def initialize
	renew_current_contact
	refresh_contacts

	# Monitor Contact collection changes
	# the after_commit hook executes the block under a different object
	# binding, so we must use `this` to access self
	this = self
	Contact.after_commit(on: [:create, :update, :destroy]) do
	this.refresh_contacts
	end
	end

	def query=(query_value)
	@query = query_value
	refresh_contacts
	end

	def current_contact=(new_contact)
	# first, reset current contact in case it was changed but not saved
	@current_contact&.reset!
	# next, update current contact
	@current_contact = new_contact
	end

	def refresh_contacts
	if query
	new_contacts = ContactRepository.instance.search(query)
	else
	new_contacts = ContactRepository.instance.all
	end

	if new_contacts != contacts
	self.contacts = new_contacts.to_a
	refresh_current_contact
	end
	end

	def refresh_current_contact
	current_contact_index = contacts.index(current_contact)
	self.current_contact = contacts[current_contact_index] if current_contact_index
	end

	def renew_current_contact
	self.current_contact = Contact.new
	end

	def save_current_contact
	current_contact.save.tap do \|saved\|
	renew_current_contact if saved
	end
	end

	def destroy_current_contact
	if current_contact&.persisted?
	current_contact.destroy
	renew_current_contact
	end
	end

	def destroy_all_contacts
	ContactRepository.instance.destroy_all_contacts
	end
	end

	class ContactManager
	module View
	class ContactForm
	include Glimmer::UI::CustomWidget

	options :contact_presenter

	body {
	composite {
	grid_layout {
	num_columns 2
	make_columns_equal_width true
	margin_width 0
	margin_height 0
	vertical_spacing 0
	}

	form_column {
	form_field(:first_name)
	form_field(:last_name)
	form_field(:email)
	form_field(:phone)
	}

	form_column {
	form_field(:street)
	form_field(:city)
	form_field(:state_or_province, editor: :combo, editor_args: :read_only, property: :selection)
	form_field(:zip_or_postal_code)
	form_field(:country, editor: :combo, editor_args: :read_only, property: :selection)
	}

	composite { # having a composite ensures padding around button
	layout_data {
	horizontal_span 2
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	}

	grid_layout {
	margin_height 0
	}

	button {
	layout_data {
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	}

	text 'Save Contact'

	on_widget_selected do
	save_contact
	end
	}
	}
	}
	}

	def form_column(&content)
	composite { \|the_composite\|
	layout_data {
	horizontal_alignment :fill
	vertical_alignment :fill
	grab_excess_horizontal_space true
	grab_excess_vertical_space true
	}

	grid_layout {
	num_columns 2
	make_columns_equal_width false
	}

	content.call(the_composite)
	}
	end

	def form_field(field, editor: :text, editor_args: [], property: :text)
	@form_field_labels \|\|= {}
	@form_field_labels[field] = label {
	layout_data {
	width_hint 120
	}

	text field.to_s.gsub('_', ' ').titlecase
	}

	@form_field_texts \|\|= {}
	@form_field_texts[field] = send(editor, *editor_args) {
	layout_data {
	width_hint 150
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	}

	# use nested data-binding to monitor change of contact
	# in addition to contact field
	send(property) <=> [contact_presenter, "current_contact.#{field}"]

	on_key_pressed do \|event\|
	save_contact if event.keyCode == swt(:cr)
	end
	}
	end

	def save_contact
	if contact_presenter.save_current_contact
	reset_validations
	else
	show_validations
	end
	end

	def reset_validations
	contact_presenter.current_contact.attributes.keys.each do \|attribute_name\|
	@form_field_labels[attribute_name.to_sym]&.foreground = :black
	@form_field_labels[attribute_name.to_sym]&.tool_tip_text = nil
	end
	focus_first_field
	end

	def show_validations
	contact_presenter.current_contact.errors.errors.each do \|error\|
	@form_field_labels[error.attribute].foreground = :red
	@form_field_labels[error.attribute].tool_tip_text = error.full_message
	end
	end

	def focus_first_field
	@form_field_texts[:first_name].set_focus
	end
	end
	end
	end

	class ContactManager
	module View
	class ContactTable
	include Glimmer::UI::CustomWidget

	options :contact_presenter, :reset_validations_action

	body {
	composite {
	grid_layout {
	margin_height 0
	}

	text(:search) {
	layout_data {
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	}

	text <=> [contact_presenter, :query]
	}

	table {
	layout_data {
	height_hint 250
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	vertical_alignment :fill
	grab_excess_vertical_space true
	}

	table_column {
	text 'First Name'
	width 120
	}
	table_column {
	text 'Last Name'
	width 120
	}
	table_column {
	text 'Email'
	width 180
	}
	table_column {
	text 'Phone'
	width 120
	}
	table_column {
	text 'Address'
	width 320
	}

	items <=> [contact_presenter, :contacts]

	selection <=> [contact_presenter, :current_contact, after_write: reset_validations_action]

	menu {
	menu_item {
	text '&Delete...'

	on_widget_selected do
	result = message_box(:yes, :no) {
	text 'Delete'
	message 'Are you sure you want to delete the selected contact?'
	}.open
	contact_presenter.destroy_current_contact if result == swt(:yes)
	end
	}
	}
	}
	}
	}
	end
	end
	end

	require 'contact_manager/model/contact_presenter'

	require 'contact_manager/view/contact_manager_menu_bar'
	require 'contact_manager/view/contact_form'
	require 'contact_manager/view/contact_table'

	class ContactManager
	module View
	class AppView
	include Glimmer::UI::Application

	before_body do
	@contact_presenter = ContactPresenter.new

	@display = display {
	on_about do
	display_about_dialog
	end

	on_preferences do
	display_about_dialog
	end
	}
	end

	body {
	shell {
	grid_layout

	image File.join(APP_ROOT, 'icons', 'windows', "Contact Manager.ico") if OS.windows?
	image File.join(APP_ROOT, 'icons', 'linux', "Contact Manager.png") unless OS.windows?
	text "Contact Manager"

	@contact_form = contact_form(contact_presenter: @contact_presenter) {
	layout_data {
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	}
	}

	contact_table(
	contact_presenter: @contact_presenter,
	reset_validations_action: @contact_form.method(:reset_validations),
	) {
	layout_data {
	horizontal_alignment :fill
	grab_excess_horizontal_space true
	vertical_alignment :fill
	grab_excess_vertical_space true
	}
	}

	contact_manager_menu_bar(
	contact_presenter: @contact_presenter,
	about_action: method(:display_about_dialog),
	save_contact_action: @contact_form.method(:save_contact),
	reset_validations_action: @contact_form.method(:reset_validations),
	)
	}
	}

	def display_about_dialog
	message_box(body_root) {
	text 'About'
	message "Contact Manager #{VERSION}\n\n#{LICENSE}"
	}.open
	end
	end
	end
	end

	$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
	$LOAD_PATH.unshift(File.expand_path('../..', __FILE__))

	begin
	require 'bundler/setup'
	Bundler.require(:default)
	rescue
	# this runs when packaged as a gem (no bundler)
	require 'glimmer-dsl-swt'
	# add more gems if needed
	require 'active_record'
	require 'activerecord-jdbcsqlite3-adapter'
	end

	class ContactManager
	include Glimmer

	APP_ROOT = File.expand_path('../..', __FILE__)
	VERSION = File.read(File.join(APP_ROOT, 'VERSION'))
	LICENSE = File.read(File.join(APP_ROOT, 'LICENSE.txt'))
	Display.app_name = 'Contact Manager'
	Display.app_version = ContactManager::VERSION
	end

	require 'contact_manager/view/app_view'