small code - ruby on ales 2014

Enable Labs @mark_menard

Small Code

Mark Menard

Ruby on Ales 2014

@mark_menard !Enable Labs

‘The great thing about writing shitty code that “just works,” is that it is too risky and too expensive to change, so it lives forever.’!

-Reginald Braithwaite @raganwald

Introduction

What do I mean by small?

It’s not about total line count.

It’s not about method count.

It’s not about class

count.

So, what do I mean by small?

Small methods! Small classes

Why should we strive for small code?

• We don’t know what the future will bring!• Raise the level of abstraction!• Create composable components!• Prefer delegation over inheritance

Why should we strive for small code?

• We don’t know what the future will bring!• Raise the level of abstraction!• Create composable components!• Prefer delegation over inheritance

Enable Future Change

What are the challenges of small code?

•Dependency Management!•Context Management

The goal: Small units of understandable code that are amenable to change.

Our Primary Tools

• Extract Method!

• Move Method!

• Extract Class

Let’s Look at Some Code

Enable Labs @mark_menard!14

% some_ruby_program -v -sfoo

options = CommandLineOptions.new(ARGV) do option :v option :s, :string end

if options.valid? if options.value(:v) # Do something end ! if (s_option = options.value(:s)) # Do something end end

# some_ruby_program -v -sfoo !options = CommandLineOptions.new(ARGV) do option :v option :s, :string end !if options.valid? if options.value(:v) # Do something end ! if (s_option = options.value(:s)) # Do something end end

class CommandLineOptions ! attr_accessor :argv attr_reader :options ! def initialize (argv = [], &block) @options = {} @argv = argv instance_eval &block end ! def option (option_flag, option_type = :boolean) options[option_flag] = option_type end ! def valid? options.each do |option_flag, option_type| raw_value = argv.find { |arg| arg =~ /^-#{option_flag}/ } return false if option_type == :string && raw_value && raw_value.length < 3 end end ! def value (option_flag) raw_option_value = argv.find { |arg| arg =~ /^-#{option_flag}/ } return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string end !end

class CommandLineOptions ! … def initialize (argv = [], &block) @options = {} @argv = argv instance_eval &block end ! … !end

# In some_ruby_program options = CommandLineOptions.new(ARGV) do option :v option :s, :string end

class CommandLineOptions ! … def option (option_flag, option_type = :boolean) options[option_flag] = option_type end ! … !end # In some_ruby_program

options = CommandLineOptions.new(ARGV) do option :v option :s, :string end

class CommandLineOptions ! … ! def valid? options.each do |option_flag, option_type| raw_value = argv.find { |arg| arg =~ /^-#{option_flag}/ } return false if option_type == :string && raw_value && raw_value.length < 3 end end ! … !end

class CommandLineOptions ! … ! def value (option_flag) raw_option_value = argv.find { |arg| arg =~ /^-#{option_flag}/ } return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string end ! … !end

CommandLineOptions boolean options are true if present are false if absent string options must have content are valid if there is content are valid if not in argv can return the value return nil if not in argv!Finished in 0.00401 seconds7 examples, 0 failures

Methods

“The object programs that live best and longest are those with

short methods.”!! ! ! ! ! ! -Refactoring by Fields, Harvey, Fowler, Black

The first rule of methods:

Do one thing. Do it well. Do only that thing.

One level of abstraction per method.

Use Descriptive Names

The fewer arguments the better.

Separate Queries from Commands

Don’t Repeat Yourself

class CommandLineOptions ! … ! def valid? options.each do |option_flag, option_type| raw_value = argv.find { |arg| arg =~ /^-#{option_flag}/ } return false if option_type == :string && raw_value && raw_value.length < 3 end end ! def value (option_flag) raw_option_value = argv.find { |arg| arg =~ /^-#{option_flag}/ } return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string end ! … !end

Extract Method Refactoringdef print_invoice_for_amount (amount) print_header puts "Name: #{@name}" puts "Amount: #{amount}" end

High level of abstraction

Low level of abstraction

def print_invoice_for_amount (amount) print_header print_details (amount) end !def print_details (amount) puts "Name: #{@name}" puts "Amount: #{amount}" end

Move this to here

Same level of abstraction

Move this to here

class CommandLineOptions ! … def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) return false if option_type == :string && raw_option_value && raw_option_value.length < 3 end end ! def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string end ! def raw_value_for_option (option_flag) argv.find { |arg| arg =~ /^-#{option_flag}/ } end ! … !end

class CommandLineOptions ! … def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) return false if option_type == :string && raw_option_value && raw_option_value.length < 3 end end ! def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string end ! … !end

class CommandLineOptions ! … def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) return false if option_type == :string && !string_option_valid?(raw_option_value) end end ! def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return extract_content(raw_option_value) if option_type == :string end ! … !end

# some_ruby_program -v -efoo -i100 !options = CommandLineOptions.new(ARGV) do option :v option :e, :string option :i, :integer end !verbose = options.value(:v) expression = options.value(:e) iteration_count = options.value(:i) || 1

class CommandLineOptions ! attr_accessor :argv attr_reader :options ! def initialize (argv = [], &block) @options = {} @argv = argv instance_eval &block end ! def option (option_flag, option_type = :boolean) options[option_flag] = option_type end ! def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) return false if (option_type == :string || option_type == :integer) && raw_option_value && raw_option_value.length < 3 return false if option_type == :integer && raw_option_value && !(Integer(raw_option_value[2..-1]) rescue false) end end ! def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string return (Integer(raw_option_value[2..-1])) if option_type == :integer end ! private def raw_value_for_option (option_flag) argv.find { |arg| arg =~ /^-#{option_flag}/ } end !end

CommandLineOptions boolean options are true if present are false if absent string options must have content are valid if there is content are valid if not in argv can return the value return nil if not in argv integer options must have content are valid if there is content and it's an integer are invalid if the content is not an integer are valid if not in argv can return the value return nil if not in argv!Finished in 0.00338 seconds13 examples, 0 failures

class CommandLineOptions ! … ! def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) return false if (option_type == :string || option_type == :integer) && raw_option_value && raw_option_value.length < 3 return false if option_type == :integer && raw_option_value && !(Integer(raw_option_value[2..-1]) rescue false) end end ! … !end

class CommandLineOptions ! … ! def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string return (Integer(raw_option_value[2..-1])) if option_type == :integer end ! … !end

class CommandLineOptions ! … ! def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) ! case(option_type) when :string return false if raw_option_value && raw_option_value.length < 3 when :integer return false if raw_option_value && raw_option_value.length < 3 return false if raw_option_value && !(Integer(raw_option_value[2..-1]) rescue false) end end end ! … !end

class CommandLineOptions ! … ! def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] ! return case(option_type) when :string raw_option_value[2..-1] when :integer (Integer(raw_option_value[2..-1])) when :boolean return true if option_type == :boolean && raw_option_value end end ! … !end

How do we write small classes?

• Write small methods!

• Talk to the class!

• Find a good name!

• Isolate Responsibilities!

• Find cohesive sets of variables/properties!

• Extract Class!

• Move method

What are the characteristics of a well designed small class?

• Single responsibility!

• Cohesive properties!

• Small public interface (preferably a handful of methods at the most)!

• Implements a single Use Case if possible!

• Primary logic is expressed in a composed method!

class CommandLineOptions ! attr_accessor :argv attr_reader :options ! def initialize (argv = [], &block) @options = {} @argv = argv instance_eval &block end ! def valid? options.all?(&:valid) end ! def value (option_flag) options[option_flag].value end ! private def option (option_flag, option_type = :boolean) options[option_flag] = build_option(option_flag, option_type) end ! def build_option # Need to write this. end !end

class CommandLineOptions ! … ! def valid? options.all?(&:valid?) end ! def value (option_flag) options[option_flag].value end ! def build_option # Need to write this. end !end

Dependencies

How do we deal with Dependencies?

• Dependency Inversion!

• Depend on Stable Abstractions

private def option (option_flag, option_type = :boolean) options[option_flag] = case (option_type) when :boolean return BooleanOption.new(option_flag, nil) when :string return StringOption.new(option_flag, nil) when :integer return IntegerOption.new(option_flag, nil) end end

class CommandLineOptions ! … ! def build_option (option_flag, option_type) "#{option_type}_option".camelize.constantize.new(option_flag, raw_value_for_option(option_flag)) end ! … !end

class Option ! attr_reader :flag, :raw_value ! def initialize (flag, raw_value) @flag = flag @raw_value = raw_value end !end !class StringOption < Option ! def valid? return true unless raw_value raw_value && raw_value.length > 2 end ! def value return nil unless raw_value raw_value[2..-1] end end

class IntegerOption < Option ! def valid? return true unless raw_value (raw_value && raw_value.length > 2) && (Integer(raw_value[2..-1]) rescue false) end ! def value return nil unless raw_value Integer(raw_value[2..-1]) end end !class BooleanOption < Option ! def valid? true end ! def value !!raw_value end end

class StringOption < Option ! def valid? return true unless raw_value raw_value && raw_value.length > 2 end ! def value return nil unless raw_value raw_value[2..-1] end end !class IntegerOption < Option ! def valid? return true unless raw_value (raw_value && raw_value.length > 2) && (Integer(raw_value[2..-1]) rescue false) end ! def value return nil unless raw_value Integer(raw_value[2..-1]) end end

def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) ! case(option_type) when :string return false if raw_option_value && raw_option_value.length < 3 when :integer return false if raw_option_value && raw_option_value.length < 3 return false if raw_option_value && !(Integer(raw_option_value[2..-1]) rescue false) end end end

def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] ! return case(option_type) when :string raw_option_value[2..-1] when :integer (Integer(raw_option_value[2..-1])) when :boolean return true if option_type == :boolean && raw_option_value end end

class StringOption < Option ! def valid? return true unless raw_value raw_value && raw_value.length > 2 end ! def value return nil unless raw_value raw_value[2..-1] end end !class IntegerOption < Option ! def valid? return true unless raw_value (raw_value && raw_value.length > 2) && (Integer(raw_value[2..-1]) rescue false) end ! def value return nil unless raw_value Integer(raw_value[2..-1]) end end

class CommandLineOptions ! … ! def valid? options.all?(&:valid?) end ! def value (option_flag) options[option_flag].value end !end

Option classes Option stores it's flag stores it's raw value BooleanOption is true if the raw value is present is false if the raw value is nil is valid StringOption invalid when there is no content is valid if there is content is valid if raw value is nil can return the value value is nil if raw value is nil IntegerOption is invalid without content is invalid if the content is not an integer is valid if there is content and it's an integer is valid if raw value is nil can return the value returns nil if raw value is nil!Finished in 0.00495 seconds22 examples, 0 failures, 6 pending

How do we isolate abstractions?

Separate the “what” from the “how”.

def valid? options.values.all?(&:valid?) end

def valid? options.each do |option_flag, option_type| raw_option_value = raw_value_for_option(option_flag) ! case(option_type) when :string return false if raw_option_value && raw_option_value.length < 3 when :integer return false if raw_option_value && raw_option_value.length < 3 return false if raw_option_value && !(Integer(raw_option_value[2..-1]) rescue false) end end end

def value (option_flag) options[option_flag].value end

def value (option_flag) raw_option_value = raw_value_for_option(option_flag) return nil unless raw_option_value option_type = options[option_flag] return true if option_type == :boolean && raw_option_value return raw_option_value[2..-1] if option_type == :string return (Integer(raw_option_value[2..-1])) if option_type == :integer end

class CommandLineOptions ! attr_accessor :argv attr_reader :options ! def initialize (argv = [], &block) @options = {} @argv = argv instance_eval &block end ! def valid? options.values.all?(&:valid?) end ! def value (option_flag) options[option_flag].value end ! private ! def option (option_flag, option_type = :boolean) options[option_flag] = build_option(option_flag, option_type) end ! def build_option (option_flag, option_type) "#{option_type}_option".camelize.constantize.new(option_flag, raw_value_for_option(option_flag)) end ! def raw_value_for_option (option_flag) argv.find { |arg| arg =~ /^-#{option_flag}/ } end !end

def valid? options.values.all?(&:valid?) end !

def value (option_flag) options[option_flag].value end

CommandLineOptions builds an option object for each defined option (PENDING: Not yet implemented) is valid if all options are valid (PENDING: Not yet implemented) is invalid if any option is invalid (PENDING: Not yet implemented) option object conventions uses a StringOption for string options (PENDING: Not yet implemented) uses a BooleanOption for boolean options (PENDING: Not yet implemented) uses an IntegerOption for integer options (PENDING: Not yet implemented)

describe CommandLineOptions do it "builds an option object for each defined option" do options = CommandLineOptions.new([ "-v" ]) { option :v } expect(options.options.values.size).to eq(1) end ! it "is valid if all options are valid" do options = CommandLineOptions.new([ "-sfoo" ]) { option :s, :string } expect(options.valid?).to be_true end ! it "is invalid if any option is invalid" do options = CommandLineOptions.new([ "-s" ]) { option :s, :string } expect(options.valid?).to be_false end ! describe "option object conventions" do ! it "uses a StringOption for string options" do options = CommandLineOptions.new([ "-s" ]) { option :s, :string } expect(options.options[:s].class).to eq(StringOption) end ! it "uses a BooleanOption for boolean options" do options = CommandLineOptions.new([ "-s" ]) { option :v } expect(options.options[:v].class).to eq(BooleanOption) end ! it "uses an IntegerOption for integer options" do options = CommandLineOptions.new([ "-s" ]) { option :i, :integer } expect(options.options[:i].class).to eq(IntegerOption) end end end

CommandLineOptions builds an option object for each defined option is valid if all options are valid is invalid if any option is invalid option object conventions uses a StringOption for string options uses a BooleanOption for boolean options uses an IntegerOption for integer options

some_ruby_program -v -efoo -i100 -afoo,bar,baz

describe "array options" do it "can return the value as an array" do expect(CommandLineOptions.new([ "-afoo,bar,baz" ]) { option :a, :array }.value(:a)).to eq(["foo", "bar", "baz"]) end end

class ArrayOption < OptionWithContent def value return nil if option_unset? extract_value_from_raw_value.split(",") end end

CommandLineOptions boolean options are true if present are false if absent string options must have content is valid when there is content can return the value return nil if not in argv integer options must have content must be an integer can return the value as an integer returns nil if not in argv array options can return the value as an array!OptionWithContent has a flag is valid when it has no raw value is valid when it has a value can return it's value when present returns nil if the flag has no raw value

Now We’re Done!!Let them implement their own

option classes. It’s easy.

Credits• Syntax highlighting: pbpaste | highlight --syntax=rb --style=edit-xcode --

out-format=rtf | pbcopy!

• Command line option example inspiration Uncle Bob.

Start Todayhttp://www.enablelabs.com/

info@enablelabs.com866-895-8189

Enable Labs@mark_menard

small code - ruby on ales 2014

option option

value option

mark menard

value raw

end end endenable labs

type end

inheritanceenable labs

string endenable labs

Technology

fresadoras convenconi ales conventional milling …

ales 204 - march 19 lecture

ruby on rails [ ruby on rails.ppt ] - [ruby-doc.org:...

ruby on rails [ ruby on rails.ppt ] - [ruby - [ruby-doc.org

ales 204 introduction slideshare

ales & talesales & tales

ales 204 presentation nov 4

hazard planning for hospitals large and small darrell ruby,...

bi no mi ales

ales bulir | home

conf 20 ornament ales

new client questionnaire - house of ruby interior...

brown ales

sigmafine 4.0 – the next generation ( uc2003 ales soudek)...

can ales 2

ruby on rails small application demo

small ruby webstack

ales hrdlicka 1940

beerhouse: pale ales

season ales packaging ideas