Thursday, February 23, 2017

puts_debuggerer

puts_debuggerer

Ruby tools for improved puts debugging, automatically displaying bonus useful information such as file, line number and source code.
Partially inspired by this blog post: https://tenderlovemaking.com/2016/02/05/i-am-a-puts-debuggerer.html (Credit to Tenderlove.)

Instructions

Bundler

Add the following to bundler's Gemfile.
gem 'puts_debuggerer'

Manual

Or manually install and require library.
gem install puts_debuggerer
require 'puts_debuggerer'

Usage

Simple invoke global pd method anywhere you'd like to see line number and source code with output. If the argument is a pure string, the print out is simplified by not showing duplicate source.
Quickly find printed lines by running a find (e.g. CTRL+F) for "pd " or ".inspect => "
Happy puts debugging!
Example Code:
# /Users/User/finance_calculator_app/pd_test.rb # line 1
bug = 'beattle'                                 # line 2
pd "Show me the source of the bug: #{bug}"      # line 3
pd 'What line number am I?'                     # line 4
Example Printout:
pd /Users/User/finance_calculator_app/pd_test.rb:3 "Show me the source of the bug: #{bug}".inspect => "Show me the source of the bug: beattle"
pd /Users/User/finance_calculator_app/pd_test.rb:4 "What line number am I?"

More at puts_debuggerer

Wednesday, February 22, 2017

Ruby's Elegant Way of Dealing with The Array of Hashes vs Single Hash JSON Problem

I'm sure you've encountered REST Web Service APIs that operate as follows:
HTTP Request: =>
GET /people
<= 1 person JSON Response:
{"first_name":"karim","last_name":"akram","city":"Dubai"}
HTTP Request: =>
GET /people
<= 3 people JSON Response:
[{"first_name":"karim","last_name":"akram","city":"Dubai"}, {"first_name":"muhsen","last_name":"asaad","city":"Amman"}, {"first_name":"assaf","last_name":"munir","city":"Qatar"}]
How do you work with the varied JSON responses in Ruby?
One approach for an app that needs to count people in cities:
city_counts = {}
json_response = people_http_request
if json_response.is_a?(Hash)
  city_counts[json_response["city"]] ||= 0
  city_counts[json_response["city"] += 1
elsif json_response.is_a?(Array)
  json_response.each do |person|
    city_counts[person["city"]] ||= 0
    city_counts[person["city"]] += 1
  end
end
Not only is the code above repetitive (unDRY) and complicated, but it also breaks common Ruby and object oriented development standards by relying on explicit type checking instead of duck-typing, polymorphism, or design patterns.
A slightly better version relying on duck-typing would be:
city_counts = {}
json_response = people_http_request
if json_response.respond_to?(:each_pair)
  city_counts[json_response["city"]] ||= 0
  city_counts[json_response["city"] += 1
elsif json_response.respond_to?(:each_index)
  json_response.each do |person|
    city_counts[person["city"]] ||= 0
    city_counts[person["city"]] += 1
  end
end
A slightly clearer version relying on design patterns (Strategy) and parametric polymorphism (functional) would be:
city_counts = {}
city_counting_strategies = {
  Hash: -> { |json_response|
    city_counts[json_response["city"]] ||= 0
    city_counts[json_response["city"] += 1
  },
  Array: -> { |json_response|
    json_response.each do |person|
      city_counts[person["city"]] ||= 0
      city_counts[person["city"]] += 1
    end
  }
}
json_response = people_http_request
city_counting_strategies[json_response.class].call(json_response)
A more radical version relying on object-oriented polymorphism and Ruby open-classes would be:
Hash.class_eval do
  def process_json_response(&processor)
    processor.call(self)
  end
end

Array.class_eval do
  def process_json_response(&processor)
    each(&processor)
  end
end

city_counts = {}
json_response = people_http_request
json_response.process_json_response do |person|
  city_counts[person["city"]] ||= 0
  city_counts[person["city"]] += 1
end
This version is quite elegant, clear, and Ruby idiomatic, but aren't we using a Nuclear device against a fly that sometimes comes as a swarm of flies? I'm sure we can have a much simpler solution, especially in a language like Ruby.
Well, how about this functional solution?
city_counts = {}
[people_http_request].flatten.each do |person|
  city_counts[person["city"]] ||= 0
  city_counts[person["city"]] += 1
end
Yes, hybrid functional/object-oriented programming to the rescue.
One may wonder what to do if the response comes in as nil or includes nil values in an array. Well, this approach can scale to handle that too should ignoring nil be the requirement.
city_counts = {}
[people_http_request].flatten.compact.each do |person|
  city_counts[person["city"]] ||= 0
  city_counts[person["city"]] += 1
end
Can we generalize this elegant solution beyond counting cities? After all, the key problem with the code on top is it gets quite expensive to maintain in a real-world production app containing many integrations with REST Web Service APIs.
This functional generalization should work by allowing you to switch json_response variable and process_json_response proc anyway you want:
[json_response].flatten.compact.each(&:process_json_response)
Example:
[cities_json_response].flatten.compact.each(&:group_by_country)
How about go one step further and bake this into all objects using our previous approach of object-oriented polymorphism and Ruby open-classes? That way, we don't just collapse the difference between dealing with arrays of hashes vs hashes but also arrays of objects vs singular objects by adding. Note the use of flatten(1) below to prevent arrays or arrays from collapsing more than one level.
Object.class_eval do
  def to_collection
    [self].flatten(1).compact
  end
end
Example usage (notice how more readable this is than the explicit version above by hiding flatten and compact):
city_counts = {}
people_http_request.to_collection.each do |person|
  city_counts[person["city"]] ||= 0
  city_counts[person["city"]] += 1
end
A refactored version including optional compacting would be:
Object.class_eval do
  def to_collection(compact=true)
    collection = [self].flatten(1)
    compact ? collection.compact : collection
  end
end
Example usage of to_collection(compact) to count bad person hashes coming as nil:
bad_people_count = 0
city_counts = {}
people_http_request.to_collection(false).each do |person|
  if person.nil?
    bad_people_count += 1
  else
    city_counts[person["city"]] ||= 0
    city_counts[person["city"]] += 1
  end
end
You asked for "Elegant" didn't you? I hope that was what you were looking for.

Grab this as a Ruby gem library at: https://github.com/AndyObtiva/to_collection

Wednesday, February 08, 2017

Easily Typable Gemified and Updated to Support Rails

Easily Typable:

Although polymorphism is a recommended standard in Object-Oriented programming for invoking varied behavior in an inheritance hierarchy, sometimes it is still useful to verify if a particular model belongs to a certain type when the behavior concerned does not belong to the model and is too small to require a Design Pattern like Strategy.
A common example in Rails is checking user roles before rendering certain parts of the view:
<% if user.is_a?(Admin) %>
  <%= link_to 'Admin', admin_dashboard_path %>
<% end %>
To avoid the model.is_a?(CertainType) syntax, a more readable approach that developers resort to is to add an English-like method that hides the details of type checking model.certain_type?.
The Rails example above would then become:
<% if user.admin? %>
  <%= link_to 'Admin', admin_dashboard_path %>
<% end %>
Implementing such methods manually gets repetitive after a while, so an easier way to get these methods automatically is to mixin the EasilyTypable module.
This was originally released back in 2009 when I worked at Obtiva, but not in Gem form, so I've gemified it and updated to support Rails lazy-loading of Models.

Example:

require 'easily_typable'

class TypeA
  include EasilyTypable
end

class TypeB < TypeA
end

class TypeC < TypeB
end

## RSpec of Easily Typable
require 'spec_helper'

describe EasilyTypable do
  it "adds type_a? method to TypeA object" do
    expect(TypeA.new.type_a?).to be_truthy
  end
  it "adds type_b? method to TypeA object" do
    expect(TypeA.new.type_b?).to be_falsey
  end
  it "adds type_c? method to TypeA object" do
    expect(TypeA.new.type_c?).to be_falsey
  end
  it "adds type_a? method to TypeB object" do
    expect(TypeB.new.type_a?).to be_truthy
  end
  it "adds type_b? method to TypeB object" do
    expect(TypeB.new.type_b?).to be_truthy
  end
  it "adds type_c? method to TypeB object" do
    expect(TypeB.new.type_c?).to be_falsey
  end
  it "adds type_a? method to TypeC object" do
    expect(TypeC.new.type_a?).to be_truthy
  end
  it "adds type_b? method to TypeC object" do
    expect(TypeC.new.type_b?).to be_truthy
  end
  it "adds type_c? method to TypeC object" do
    expect(TypeC.new.type_c?).to be_truthy
  end
end

Tuesday, May 03, 2016

SuperModule 2 Beta (v1.2.0)

SuperModule 2 has long been overdue. It was almost out a year ago, and then my MacBook Air got stolen with the near-finished code at a Second Cup cafe in Montreal (won't mention which one, but let's just say don't leave your laptop unattended in Downtown Montreal). Fortunately, I got parts of the code stored in a remote Git branch (yeah Git for the rescue!), so I just released SuperModule 2 as beta today to use on my employer's client project.

Feature Summary:
  • New super_module(name) syntax
  • Much simpler implementation with guaranteed correctness and no performance hit
  • Less memory footprint by not requiring method_source Ruby gem for v2 syntax
  • Backwards compatibility with v1 syntax
No need to remember to include SuperModule anymore with the use of the v2 super_module method. Much simpler usage as a result as per popular demand.

Since this version is beta, I'm very curious about user feedback. Let me know how it goes for you.

Enjoy Ruby Modules again!!! Write as simply as any superclass with all of the power of multiple mixins!!!

Cheers... Andy

Sunday, March 20, 2016

Cycle.js Model View Intent in Conference Room Booker

Conference Room Booker has been refactored to the Cycle.js recommended Model View Intent pattern (as shown in this code structure screenshot):


In other words, it has been simplified to the bare essence of a pure decomposable reactive JavaScript function staring with sources of data and ending with sinks.

Intents: represent user action sources, such as keyboard presses and mouse clicks.

Intent Example (bookingDurationSource.es6):


The intent above captures keyboard input for the duration of booking, and outputs duration/time hash.

Models: aggregate data into meaningful structures.

Model Example (bookedRoomTimingSource.es6):


This model aggregates elapsing time, booked room data, and entered duration into a bookedRoomTiming hash structure, which later gets used in rendering the view.

Views: render data into HTML using Virtual-DOM-based Hypersrcipt terse syntax.

View Example (bookingView.es6):


This view renders the top part of the screen shown below.

Conference Room Booker Example Screenshot (Entering Duration):




Conference Room Booker Example Screenshot (Booking Timer Started by Clicking Room):



Conference Room Booker Example Screenshot (Time Elapsing/Booked Room Color Fading):



Check out the codebase over here for more details: Conference Room Booker

Have you had experience with pure functional reactive programming using Cycle.js yet? If so, please share your experience in the comments or ask any questions you might have otherwise.

Wednesday, March 02, 2016

Cycle.js Application Structure (Conference Room Booker)

Added to Conference Room Booker HTTP requests and responses via Cycle.js HTTP driver, obtaining room names (e.g. France, Canada, etc...) and showing them within the floor map SVG.  



A side-effect to my work was refactoring the structure of the app, breaking components out of the main cycle function, primarily the following:

Sources:
- Models
  - roomCollection
- Streams
  - initialStream
Sinks:
- Views
  - bookingView
  - floorPlanView
Cycles (Both Sources & Sinks):
- roomRequest

Has anybody else been experimenting with Cycle.js's pure functional style of development?.  

Sunday, February 14, 2016

Ultra Light Wizard v0.1.0 (beta)

As promised, I rolled out a new update to Ultra Light Wizard (v0.1.0) that is finally feature complete, and thus labeled as beta. Please install, test, and report feedback on GitHub.

In the meantime, here are a few more tasks I'd like to tackle before it is v1.0.0 (production):

  • (must) Write automated tests
  • (optional) Support for nested resources
  • (optional) Modularize (perhaps extracting sub-generators)
  • (optional) General refactorings

Cheers and happy Rails coding!!