Gray Soft

23
MAY
2015
Rich Methods

Some APIs provide collections of dirt simple methods that just do one little thing.

This approach in less common in Ruby though, especially in the core and standard library of the language itself. Ruby often gives us rich methods with lots of switches we can toggle and half hidden behaviors.

Let's look at some examples of what I am talking about.

Get a Line at a Time

I suspect most Rubyists have used gets() to read lines of input from some kind of IO. Here's the basic usage:
```
>> require "stringio"
=> true
>> f = StringIO.new(<<END_STR)
<xml>
  <tags>Content</tags>
</xml>
END_STR
=> #<StringIO:0x007fd5a264fa08>
>> f.gets
=> "<xml>\n"
>> f.gets
=> "  <tags>Content</tags>\n"
```
I didn't want to mess with external files for these trivial examples, so I just loaded StringIO from the standard library. It allows us to wrap a simple String (defined in this example using the heredoc syntax) in the IO interface. In other words, I'm calling gets() here for a String just as I could with a File or $stdin.
Read more…
In: Ruby Voodoo | Tags: Hidden Features & Parsing | 0 Comments

20

MAR
2015

A Curses Application

I've now written two articles covering low-level curses and some higher abstractions. We know what curses can do at this point, but we haven't really seen how to put everything together and build a full application. Let's do that today by examining an example of moderate size.

I have written the beginnings of a command-line Twitter client using curses. To make this easier, I developed a super simple wrapper over the raw curses API, called Rurses. Rurses, for Ruby curses, provides more Ruby-like abstractions over the clunky C API. Here's how the Twitter client looks in action:

┌─JEG2─────────────────────────────────┐  @
│                                     ↑│
│Alex Harms @onealexh… 20/03/2015 14:57│ Clayton Flesher @Cal… 19/03/2015 20:52
│RT @postsecret: http://t.co/LrV0IIYgUM│ @TrevorBramble its inspired by, as in
│                                      │ I played it once for about ten minutes
│SimKlabnik 2000 @ste… 20/03/2015 14:57│ and then @JEG2 said 'go make your
│the closure docs are finally flowing  │ version of that'.
│from my fingertips, it seems          │
│                                      │ Mandy Moore @theruby… 19/03/2015 18:31
│ashe dryden @ashedry… 20/03/2015 14:57│ Thanks to @JEG2 I now want a MiP robot
│Can anyone recommend  an interestingly│ in the worst kind of way!!!
│written (not dry) history of Haiti?   │
│Preferably written by a Haitian.      │ Sam Livingston-Gray … 19/03/2015 14:23
│                                      │ @avdi @JEG2 hush! Keep this up and
│Jessica Lord @jllord  20/03/2015 14:57│ EVERYONE WILL KNOW
│RT @PDX44: Welcome to Portland, where │ https://t.co/deJBBjoOTV
│the old airport carpet is dressed up  │
│as a human and named Grand Marshal of │ Josh Susser @joshsus… 19/03/2015 14:06
│a parade. http://t.co/aTCicqSzEI      │ @geeksam @jeg2 @avdi POLS issue. No
│                                      │ standard == no way to avoid surprising
│Garann Means @garannm 20/03/2015 14:56│ many developers
│RT @verge: Robyn launches tech        │
│                                     ↓│                                      ↓
└──────────────────────────────────────┘

25

SEP
2014

Regex Code Equivalency

#!/usr/bin/env ruby -w

Name = "Gray, James"

!!(Name =~ /\AGray/)      # => true
Name.start_with?("Gray")  # => true

!!(Name =~ /James\z/)    # => true
Name.end_with?("James")  # => true

!!(Name =~ /Dana/)     # => false
Name.include?("Dana")  # => false

!!(Name =~ /\A\z/)  # => false
Name.empty?         # => false

!!(Name =~ /\AGray, James\z/)  # => true
Name == "Gray, James"          # => true

!!(Name =~ /\A(?:Gray, James|Gray, Dana)\z/)  # => true
["Gray, James", "Gray, Dana"].include?(Name)  # => true

Name =~ /\A\w+/ && $&  # => "Gray"
Name[/\A\w+/]          # => "Gray"

Name =~ /\A(\w+),\s*(\w+)\z/ && $2  # => "James"
Name[/\A(\w+),\s*(\w+)\z/, 2]       # => "James"

Name =~ /\A(?<last>\w+),\s*(?<first>\w+)\z/ && $~[:first]  # => "James"
Name[/\A(?<last>\w+),\s*(?<first>\w+)\z/, :first]          # => "James"

Name.scan(/^.*\n?/)  # => ["Gray, James"]
Name.lines           # => ["Gray, James"]

Name.scan(/./m)  # => ["G", "r", "a", "y", ",", " ", "J", "a", "m", "e", "s"]
Name.chars       # => ["G", "r", "a", "y", ",", " ", "J", "a", "m", "e", "s"]

Name.gsub(/[aeiou]/, "")  # => "Gry, Jms"
Name.delete("aeiou")      # => "Gry, Jms"

Name.gsub(/[aeiou]/, "X") # => "GrXy, JXmXs"
Name.tr("aeiou", "X")     # => "GrXy, JXmXs"

# For the destructive operations that follow you can drop the `dup()` and
# switch `sub()` to `sub!()`, as long as you don't care about the return value.

Name.sub(/(?=,)/, " II")                 # => "Gray II, James"
Name.dup.insert(Name.index(","), " II")  # => "Gray II, James"

Name.sub(/\A/, "Name:  ")    # => "Name:  Gray, James"
Name.dup.prepend("Name:  ")  # => "Name:  Gray, James"

Name.sub(/\A.*\z/m, "Gray, Dana")  # => "Gray, Dana"
Name.dup.replace("Gray, Dana")     # => "Gray, Dana"

Name.sub(/\A.*\z/m, "")  # => ""
Name.dup.clear           # => ""



Spacey = "\tsome    space\r\n"

Spacey.sub(/\A\s+/, "")  # => "some    space\r\n"
Spacey.lstrip            # => "some    space\r\n"

Spacey.sub(/\s+\z/, "")  # => "\tsome    space"
Spacey.rstrip            # => "\tsome    space"

Spacey.sub(/\A\s*(.+?)\s*\z/m, '\1')  # => "some    space"
Spacey.strip                          # => "some    space"

Spacey.sub(/(?:\r?\n|\r)\z/m, "")  # => "\tsome    space"
Spacey.chomp                       # => "\tsome    space"

Spacey.sub(/(?:\r\n|.)\z/m, "")  # => "\tsome    space"
Spacey.chop                      # => "\tsome    space"

Spacey.gsub(/ +/, " ")  # => "\tsome space\r\n"
Spacey.squeeze(" ")     # => "\tsome space\r\n"

In: Deadly Regular Expressions | Tags: Regular Expression, Style & Syntax | 2 Comments

22

SEP
2014

A Regex Can't Match Balanced Parentheses

Can we do math with regular expressions?

#!/usr/bin/env ruby -w

def build_preparation_regex(number_regex, ops)
  %r{
    (?<number>             #{number_regex}                                   ){0}
    (?<operator>           [#{ops.map(&Regexp.method(:escape)).join}]        ){0}
    (?<term_operator_term> \g<term> \s* \g<operator> \s* \g<term>            ){0}
    (?<term>               \g<number> | \( \s* \g<term_operator_term> \s* \) ){0}

    \g<term_operator_term>(?=\s*\z|[^)])
  }x
end

NUMBER_REGEX               = %r{
  -?            # an optional minus
  \d+           # an integer
  (?: \. \d+)?  # an optional fractional bit
}x
PREPARE_MULT_AND_DIV_REGEX = build_preparation_regex(NUMBER_REGEX, %w[* /])
PREPARE_ADD_AND_SUB_REGEX  = build_preparation_regex(NUMBER_REGEX, %w[* / + -])
CHECK_REGEX                = %r{
  \A                   # the start of the expression
  (?<term>             # a term, which is:
    #{NUMBER_REGEX}    # a number
    |                  # or
    \( \s*             # a parenthesized group of
      \g<term>         # a term
      \s* [*/+\-] \s*  # an operator
      \g<term>         # and another term
    \s* \)             # the end of the parenthesized group
  )
  \z                   # the end of the expression
}x
MATH_REGEX                 = %r{
  \( \s*
  (?<left>     #{NUMBER_REGEX} )
  \s*
  (?<operator> [*/+\-]         )
  \s*
  (?<right>    #{NUMBER_REGEX} )
  \s* \)
}x

verbose = ARGV.delete("-v")
problem = ARGV.first.strip or abort "USAGE:  #{$PROGRAM_NAME} MATH_EXPRESSION"
steps   = [ ]

[PREPARE_MULT_AND_DIV_REGEX, PREPARE_ADD_AND_SUB_REGEX].each do |preparation|
  loop do
    steps << problem.dup if verbose
    problem.sub!(preparation) { |term| "(#{term})" } or break
  end
end

problem =~ CHECK_REGEX or abort "Error:  Invalid expression"

solution = problem.dup
loop do
  steps << solution.dup if verbose
  solution.sub!(MATH_REGEX) {
    $~[:left].to_f.public_send($~[:operator], $~[:right].to_f)
  } or break
end

puts steps.uniq[0..-2] if verbose
puts solution.sub(/\.0+\z/, "")