I’ve set up a script called k to do this.

k stands for ‘keep it running’.

I’ve put it on GitHub if you’re interested in trying it out:

https://github.com/seanlerner/k

Enjoy!

They spend time trying to understand the original poster’s specific problem.

I advise them to skip the question and go straight to the answer.

The steps are:

1. skip the question title and body
2. look at the number of points for the first and second answers
3. read the answer with the most points
4. if needed, read the answer’s comments and read other answers in order of point value

The first answer is what the original poster marked as their solution. But occasionally the second answer has more value due to either a better quality answer or the passage of time has changed what the best answer now is.

Most importantly, don’t read the original question: it’s likely not worth the amount effort it takes to get into the head of a distant struggling programmer’s problem.

Enjoy!

Instead of this:

[{ name: 'Taylor', age: 36 }]

You can do this:

[name: 'Taylor', age: 36]

The result for both of those will be:

[{:name=>"Taylor", :age=>36}]

This falls under the “at first it seems immoral to do this, but the more I do it, the more I feel this is how the world should be” category.

I find this approach most useful in tests: what I’m testing takes an array of hashes, and for testing purposes I only need a single hash in the array.

Enjoy!

gdb='git branch --merged | egrep -v "(^\*|master)" | xargs git branch -d'

It’s gdb and stands for Git Delete Branches

Here it is in action:

❯ git branch
  feature/BACK-507-rg-sg1-m
  feature/BACK-508-rg-sg1-n
  feature/BACK-512-rg-sg1-r
  feature/BACK-513-rg-sg1-s
* master
❯ gdb
Deleted branch feature/BACK-507-rg-sg1-m (was 411d530).
Deleted branch feature/BACK-512-rg-sg1-r (was 0dc7159).
Deleted branch feature/BACK-513-rg-sg1-s (was 01ab717).
❯ git branch
  feature/BACK-508-rg-sg1-n
* master
❯

feature/BACK-508-rg-sg1-n hadn’t been merged into master yet, so it remained.

Add the alias to your .bashrc (linux), .bash_profile (mac), or .zshrc (either O/S).

If you’re not sure how to add an alias, let me google that for you.

Enjoy!

irb> a = [1, 2, 3]
=> [1, 2, 3]
irb> b = 1, 2, 3
=> [1, 2, 3]
irb> a == b
=> true

This seems so simple that I wonder if I learned about this a long time ago and forgot?

Enjoy!

After you install and set this up, from within irb and pry, you can type:

MyClass.im
  # &
my_instance.im

to see all the interesting methods available to you on those objects.

To Set Up

First install the gem:

gem install interesting_methods

Then create irb and pry rc files if they don’t already exist:

touch ~/.irbrc
touch ~/.pryrc

Edit each of those rc files and add the following code:

if Gem::Specification.find_all_by_name('interesting_methods').any?
  require 'interesting_methods'
end

You’re all set up now!

To Use

Load up either irb or pry from your command line.

Add .im to any object to see its interesting methods.

Example

Load up pry:

$ pry

You should be at the pry prompt now:

pry >

Paste the following code into pry:

class Animal

  @@all = []

  attr_reader :type, :sound

  def initialize(type, sound)
    @type  = type
    @sound = sound
    @@all << self
  end

  def speak_loudly
    puts @sound.upcase
  end

  def speak
    puts @sound
  end

  def self.all
    @@all
  end

  def self.report
    puts "#{'Type'.rjust(15)} #{'Sound'.rjust(15)}"
    puts "#{'----'.rjust(15)} #{'-----'.rjust(15)}"
    all.each do |animal|
      puts "#{animal.type.rjust(15)} #{animal.sound.rjust(15)}"
    end
  end

end

cow = Animal.new('cow', 'moo')

Now check out the methods on both Animal and cow (an instance of Animal):

pry > Animal.im
=> [:all, :report]

pry > cow.im
=> [:sound, :speak, :speak_loudly, :type]

Repo

You can find the repo at https://github.com/seanlerner/interesting_methods

In my next post, you’ll find a screencast that illustrates a technique I call, Method Driven Development using the gem.

Enjoy!

(I’m sure many people use this technique, though I don’t know if there’s a name for it.)

Using MDD, I explore the Geocoder gem with the goal of finding the distance between Toronto and Chicago.

After watching this video, you’ll understand the ins and outs of MDD, including how to:

• investigate the methods that are available on each Ruby object
• sift through those methods and quickly find the method you want
• pull up docs on the method without leaving pry
• use Ruby’s grep method

Plus, you’ll also learn the basics of the geocoder gem: searching, distance between, working with kilometeres and miles.

Ready to give it a try? Install the interesting_methods gem I’ve just released and then code along as you watch this video.

Update:

There’s a few thoughtful pry tips on a reddit thread for this screencast:

https://www.reddit.com/r/ruby/comments/86vncl/method_driven_development_with_the_new/

Most useful is that pry has an ls command to show just the useful stuff about an object.

Let’s say you have an Animal class that speaks:

class Animal
  def speak
    puts 'Moo'
  end
end

Meanwhile in pry:

pry> ls Animal
Object.methods: yaml_tag
Animal#methods: speak

Here’s what Rails looks like:

pry> ls Rails
constants:
  Application  Configuration  ConsoleMethods  Engine      Html  InfoController  LineFiltering      Paths  Railtie  TestUnit         VERSION
  Command      Console        Dom             Generators  Info  Initializable   MailersController  Rack   Secrets  TestUnitRailtie  WelcomeController
#<Module:0x00007faa75953720>#methods: reachable?
ActiveSupport::Autoload#methods: autoload  autoload_at  autoload_under  autoloads  eager_autoload  eager_load!
Rails.methods:
  app_class   application   backtrace_cleaner  cache=         env   gem_version  initialize!   logger   public_path  version
  app_class=  application=  cache              configuration  env=  groups       initialized?  logger=  root
instance variables: @_at_path  @_autoloads  @_eager_autoload  @_env  @_under_path  @app_class  @application  @cache  @logger

Enjoy!

About this app

Users simply visit the homepage, enter their name, and then enter the chat room.

The messages from users will appear as a streaming message feed.

Let’s get started!

Create a new rails app

$ rails new simple-chat
$ cd simple-chat

Remove coffee script

Find the coffee-rails gem in your Gemfile:

/Gemfile

...

# Use CoffeeScript for .coffee assets and views
gem 'coffee-rails', '~> 4.2'

...

And then comment it out:

...

# Use CoffeeScript for .coffee assets and views
# gem 'coffee-rails', '~> 4.2'

...

Run bundle:

$ bundle

Generate a home controller and index page

$ rails generate controller home index --no-assets --no-test-framework --no-helper

Generate a chat channel

$ rails generate channel chat

Start server

$ rails server

Configure routes

Replace your routes file with the following:

/config/routes.rb

Rails.application.routes.draw do
  root 'home#index'
end

Configure the server side of the channel

Replace the Ruby chat channel file with the following:

/app/channels/chat_channel.rb

class ChatChannel < ApplicationCable::Channel

  def subscribed
    stream_from 'chat'
  end

  def receive(data)
    ActionCable.server.broadcast('chat', data)
  end

end

Configure the client side of the channel

Replace the JavaScript chat channel file with the following:

/app/assets/javascripts/channels/chats.js

App.chat =
  App.cable.subscriptions.create('ChatChannel', {
    received: prepend_msg
  })

addEventListener('turbolinks:load', function () {
  join_chat_form.addEventListener('submit', join_chat)
  message_form.addEventListener('submit', send_msg)
})

function join_chat(event) {
  event.preventDefault()

  if (!username.value)
    return

  enter_name_container.style.display = 'none'
  messages_container.style.display   = 'block'

  const msg = `${username.value} joined the chat`
  App.chat.send({ msg })

  message.focus()
}

function send_msg(event) {
  event.preventDefault()

  const msg = `${username.value}: ${message.value}`
  App.chat.send({ msg })

  message.value = ''
}

function prepend_msg(data) {
  const p = document.createElement('p')
  add_time_stamp(p)
  p.append(data.msg)
  messages.prepend(p)
}

function add_time_stamp(p) {
  const
    time = new Date().toLocaleTimeString(),
    pre  = document.createElement('pre')

  pre.append(time)
  p.append(pre)
}

Add view

Replace the index erb template with the following:

/app/views/home/index.html.erb

<div id=enter_name_container>

  <p>Enter your name:<p>

  <%= form_tag '', id: 'join_chat_form' do %>
    <%= text_field_tag :username %>
    <br><br>
    <%= submit_tag 'Enter chat', data: { disable_with: false } %>
  <% end %>

</div>

<div id=messages_container style='display: none'>

  <%= form_tag '', id: 'message_form' do %>
    <%= text_field_tag :message %>
  <% end %>

  <div id=messages>
  </div>

</div>

Add styles

Replace the existing stylesheet with the following:

/app/assets/stylesheets/application.css

/*
*= require_tree .
*= require_self
*/

body {
  background: beige;
  font-family: sans-serif;
  margin: 0 auto;
  padding: 2rem;
  width: 400px;
}

pre {
  margin: 0;
}

input {
  padding: .5rem;
}

#message {
  width: 250px;
}

Try it out

Open two separate browser windows to http://localhost:3000 and have a nice conversation with yourself.

Your browsers should look something like this. In my example, I demo my two cats “Ray” and “Egon” chatting:

For next steps, google “rails action cable tutorial” for more guides and examples that delve deeper into Action Cable.

Enjoy!

It’s called edit_output or eo for short.

It takes the output of your last command issued on the command line and opens it up in your editor. I find it’s useful when I’d like to copy a part of the output to my clipboard.

“eo” helps keep my hands on the keyboard and away from the mouse.

How to setup and use

You’ll need iTerm2 (on a Mac) for this to work.

Save the following to the file eo and put it in a bin folder that’s in your PATH.

#!/usr/bin/env osascript

tell application "iTerm2"
  tell current session of current window
    tell application "System Events" to keystroke "a" using {command down, shift down}
    tell application "System Events"
      key code 53
    end tell
  end tell
end tell

tell application "Sublime Text"
   activate
end tell

tell application "System Events" to keystroke "n" using {command down}
tell application "System Events" to keystroke "v" using {command down}

return " Last output copied to your editor"

My editor is Sublime Text. If you use a different editor, you’ll need to change the editor specified in the script accordingly.

For me, the path of the script is:

~/bin/eo

After you save eo, make it an executable script:

$ chmod +x ~/bin/eo

Test it out

From the command line, type a command that produces output, like the following:

$ ls -al

Then type:

eo

The output of your command should be in your editor.

Enjoy!

For example, let’s say you’re developing a website and need some Bacon Ipsum. From your text editor you would:

1. Copy the shortcode to your clipboard. In this case it’s bc.
2. Wait a second while Bacon Ipsum is retrieved from the Bacon Ipsum API.
3. Paste your clipboard contents.
4. See Bacon Ipsum!

If you’d like to give it a try (currently it’s only for Mac and is “alpha”), download it from here.

The main repo is at:
https://github.com/seanlerner/clip-trigger

Enjoy!