regexp-examples 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f72e32a8b9c2934cb90f1d32d3e50c8f735b0dac
-  data.tar.gz: fa76e5281143d5d14a9b7b3207ea2ea28915ea47
+  metadata.gz: 90a3c94b7ce9d60074ab46c196d6fab9cc19552c
+  data.tar.gz: 75f7bff2b43831f82dc0c5250a59adab1c993084
 SHA512:
-  metadata.gz: 72348eafa1f3257eca9761c088293057eef0018825541f773993c04f1d579279431b06389a3185f4f8e5bb98e7ce0f331ae89aa53750f20b6fccee0cac3b6187
-  data.tar.gz: d4e3ac8e6951a3707eed765ed2373d25949bc7ea32281a75c173da11df03db4962d71e0a2ca339f5fc74370b97b596331bd93d65632557c82081a2d2728db933
+  metadata.gz: 1a4eba9d6f17c34a9f482a4bf73bed58f2541dc5233c6582ac683053fba3b23b21a8672ad0dda631ad38562870e17aa5293e828f121e46b2c1408d893ba50756
+  data.tar.gz: 2de1f70fe0299072a07a60d86e549a3c71ba3f3ce31572e4e9df37acb7bb8e69a7f72ce2b568a95c2647bc1b47fa914605a41f3105c25ddc7131841e5751c916

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+tags

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -1,4 +1,6 @@
 source 'https://rubygems.org'
 
+gem 'rspec', group: :test
+
 # Specify your gem's dependencies in regexp-examples.gemspec
 gemspec

data/README.md

@@ -1,6 +1,29 @@
-# Regexp::Examples
+# regexp-examples
 
-TODO: Write a gem description
+Extends the Regexp class with the method: Regexp#examples
+
+This method generates a list of (some\*) strings that will match the given regular expression
+
+\* If the regex has an infinite number of possible srings that match it, such as `/a*b+c{2,}/`,
+or a huge number of possible matches, such as `/.\w/`, then only a subset of these will be listed.
+
+## Usage
+
+```ruby
+/a*/.examples #=> [''. 'a', 'aa']
+/b+/.examples #=> ['b', 'bb']
+/this|is|awesome/.examples #=> ['this', 'is', 'awesome']
+/foo-.{1,}-bar/.examples #=> ['foo-a-bar', 'foo-b-bar', 'foo-c-bar', 'foo-d-bar', 'foo-e-bar',
+  # 'foo-aa-bar', 'foo-bb-bar', 'foo-cc-bar', 'foo-dd-bar', 'foo-ee-bar', 'foo-aaa-bar', 'foo-bbb-bar',
+  # 'foo-ccc-bar', 'foo-ddd-bar', 'foo-eee-bar']
+/https?:\/\/(www\.)?github\.com/.examples #=> ['http://github.com',
+  # 'http://www.github.com', 'https://github.com', 'https://www.github.com']
+/(I(N(C(E(P(T(I(O(N)))))))))*/.examples #=> ["", "INCEPTION", "INCEPTIONINCEPTION"]
+/what about (backreferences\?) \1/.examples #=> ['what about backreferences? backreferences?']
+```
+
+The current version is still very much under development, and contains various bugs/missing features...
+However, when completed, this will hopefully work for ALL regular expressions, *except for lookarounds*!
 
 ## Installation
 
@@ -18,10 +41,6 @@ Or install it yourself as:
 
     $ gem install regexp-examples
 
-## Usage
-
-TODO: Write usage instructions here
-
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/regexp-examples/fork )
@@ -29,3 +48,4 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+6. Don't forget to add tests!!

data/lib/regexp-examples.rb

@@ -1,15 +1,2 @@
 Dir[File.dirname(__FILE__) + '/regexp-examples/*.rb'].each {|file| require file }
 
-# TODO: DEBUG. DELETE THIS.
-#require 'pry'
-#RegexpExamples::show(/a*/)
-#RegexpExamples::show(/a+/)
-#RegexpExamples::show(/a?/)
-#RegexpExamples::show(/a{1,2}/)
-#RegexpExamples::show(/a{1,}/)
-#RegexpExamples::show(/https?:\/\/(www\.)?google\.com/) # AWWW YEEEAHH!
-#RegexpExamples::show(/a|b/)
-#RegexpExamples::show(/(a)/)
-#RegexpExamples::show(/((a))\1\2/)
-#
-#binding.pry

data/lib/regexp-examples/backreferences.rb

@@ -1,22 +1,53 @@
 module RegexpExamples
-  class BackReferenceTracker
-    @filled_groups = {}
-    class << self
-      attr_accessor :filled_groups
+  class CaptureGroupResult < String
+    attr_reader :group_id, :subgroups
+    def initialize(group_id, subgroups, values)
+      @group_id = group_id
+      @subgroups = subgroups
+      super(values)
+    end
 
-      def add_filled_group(num, group)
-        @filled_groups[num] = group
-      end
+    # Overridden in order to preserve the @group_id and @subgroups
+    def *(int)
+      self.class.new(group_id, subgroups, super)
+    end
+    def gsub(regex)
+      self.class.new(group_id, subgroups, super)
     end
   end
 
   class BackReferenceReplacer
-    def substitute_backreferences(full_example)
-      # TODO: Update this for named capture groups
-      # TODO: Define this magic __X__ pattern as a constant? Maybe?
-      full_example.gsub!(/__(\d+)__/) do |_|
-        BackReferenceTracker.filled_groups[$1.to_i]
+    def substitute_backreferences(full_examples)
+      full_examples.map! do |full_example|
+        if full_example.is_a? String
+          [full_example]
+        else
+          full_example.map! do |partial_example|
+            partial_example.gsub(/__(\d+)__/) do |match|
+              find_backref_for(full_example, $1.to_i)
+            end
+          end
+        end
+      end
+      full_examples
+    end
+
+    private
+    def find_backref_for(full_example, group_id)
+      full_example.each do |partial_example|
+        next unless partial_example.respond_to?(:group_id)
+        case
+        when partial_example.group_id == group_id
+          return partial_example
+        when sub_partial_example = find_backref_for(partial_example.subgroups, group_id)
+          # TODO: This line does NOT work for all nested backreference groups
+          # Need to revisit this logic and find a better solution, if possible
+          return sub_partial_example.result.detect{|sub_partial_result| partial_example.include? sub_partial_result}
+        end
       end
+      nil
     end
+
   end
+
 end

data/lib/regexp-examples/constants.rb

@@ -2,10 +2,36 @@ module RegexpExamples
   # Number of times to repeat for Star and Plus repeaters
   TIMES = 2
 
-  # Set of chars for Dot and negated [^] char groups
-  #CHARS = [("a".."z").to_a, ("A".."Z").to_a, ".", ",", ";"].flatten
-  #TODO: Make these character sets more complete
-  #e.g. Sets for \d, \w, \h, \s
-  CHARS = %w{a b c d e}
+  # Maximum number of characters returned from a char set, to reduce output spam
+  # For example:
+  # If MaxGroupResults = 5, then
+  # \d = [0, 1, 2, 3, 4]
+  MaxGroupResults = 5
+
+  module CharSets
+    Lower = Array('a'..'z')
+    Upper = Array('A'..'Z')
+    Digit = Array('0'..'9')
+    Punct = [33..47, 58..64, 91..96, 123..126].map { |r| r.map { |val| val.chr } }.flatten
+    Any = Lower | Upper | Digit | Punct
+  end
+
+  # Map of special regex characters, to their associated character sets
+  BackslashCharMap = {
+    'd' => CharSets::Digit,
+    'D' => CharSets::Lower | CharSets::Upper | CharSets::Punct,
+    'w' => CharSets::Lower | CharSets::Upper | CharSets::Digit | ['_'],
+    'W' => CharSets::Punct.reject { |val| val == '_' },
+    's' => [' ', "\t", "\n", "\r", "\v", "\f"],
+    'S' => CharSets::Any - [' ', "\t", "\n", "\r", "\v", "\f"],
+
+    't' => ["\t"], # tab
+    'n' => ["\n"], # new line
+    'r' => ["\r"], # carriage return
+    'f' => ["\f"], # form feed
+    'a' => ["\a"], # alarm
+    'v' => ["\v"], # vertical tab
+    'e' => ["\e"], # escape
+  }
 end
 

data/lib/regexp-examples/groups.rb

@@ -18,13 +18,17 @@ module RegexpExamples
         @negative = false
       end
 
-      # TODO: Can I make this more legible?
-      # Ranges a-b
+      init_backslash_chars
+      init_ranges
+    end
+
+    def init_ranges
       # save first and last "-" if present
       first = nil
       last = nil
       first = @chars.shift if @chars.first == "-"
       last = @chars.pop if @chars.last == "-"
+      # Replace all instances of e.g. ["a" "-" "z"] with ["a", "b", ..., "z"]
       while i = @chars.index("-")
         @chars[i-1..i+1] = (@chars[i-1]..@chars[i+1]).to_a
       end
@@ -32,9 +36,24 @@ module RegexpExamples
       @chars.unshift(first) if first
       @chars.push(last) if last
     end
+
+    def init_backslash_chars
+      @chars.each_with_index do |char, i|
+        if char == "\\"
+          if BackslashCharMap.keys.include?(@chars[i+1])
+            @chars[i..i+1] = BackslashCharMap[@chars[i+1]]
+          elsif @chars[i+1] == "\\"
+            @chars.delete_at(i+1)
+          else
+            @chars.delete_at(i)
+          end
+        end
+      end
+    end
+
     def result
       if @negative
-        CHARS - @chars
+        CharSets::Any - @chars
       else
         @chars
       end
@@ -43,25 +62,26 @@ module RegexpExamples
 
   class DotGroup
     def result
-      CHARS
+      CharSets::Any
     end
   end
 
   class MultiGroup
-    attr_reader :group_num
-    def initialize(groups, group_num)
+    attr_reader :group_id
+    def initialize(groups, group_id)
       @groups = groups
-      @group_num = group_num
+      @group_id = group_id
     end
 
     # Generates the result of each contained group
     # and adds the filled group of each result to
     # itself
     def result
-      strings = @groups.map {|x| x.result}
-      result = RegexpExamples::permutations_of_strings(strings)
-      result.each {|x| BackReferenceTracker.add_filled_group(@group_num, x)}
-      result
+      strings = @groups.map {|repeater| repeater.result}
+      subgroups = @groups.select{ |repeater| repeater.group.respond_to? :group_id}.map{|repeater| repeater.group}
+      RegexpExamples::permutations_of_strings(strings).map do |result|
+        group_id ? CaptureGroupResult.new(group_id, subgroups, result) : result
+      end
     end
   end
 
@@ -72,15 +92,14 @@ module RegexpExamples
   end
 
   class OrGroup
-    def initialize(repeaters)
-      @repeaters = repeaters
+    def initialize(left_repeaters, right_repeaters)
+      @repeaters = left_repeaters.concat(right_repeaters)
     end
 
     def result
-      repeaters_results = @repeaters.map do |repeater|
-        repeater.result
+      @repeaters.map do |repeater|
+        RegexpExamples::permutations_of_strings(repeater.result)
       end
-      RegexpExamples::permutations_of_strings(repeaters_results)
     end
   end
 

data/lib/regexp-examples/helpers.rb

@@ -7,10 +7,12 @@ module RegexpExamples
   # For example:
   # permutations_of_strings [ ['a'], ['b'], ['c', 'd', 'e'] ] #=> ['acb', 'abd', 'abe']
   # permutations_of_strings [ ['a', 'b'], ['c', 'd'] ] #=> [ 'ac', 'ad', 'bc', 'bd' ]
-  def self.permutations_of_strings(arrays_of_strings)
-    return arrays_of_strings[0] if arrays_of_strings.size == 1
+  def self.permutations_of_strings(arrays_of_strings, options={})
     first = arrays_of_strings.shift
-    first.product( permutations_of_strings(arrays_of_strings) ).map {|x| x.flatten.join}
+    return first if arrays_of_strings.empty?
+    first.product( permutations_of_strings(arrays_of_strings, options) ).map do |result|
+      options[:no_join] ? result.flatten : result.flatten.join
+    end
   end
 
   # TODO: For debugging only!! Delete this before v1.0

data/lib/regexp-examples/parser.rb

@@ -10,8 +10,9 @@ module RegexpExamples
     def parse
       repeaters = []
       while @current_position < regexp_string.length
-        group = parse_group
+        group = parse_group(repeaters)
         break if group.is_a? MultiGroupEnd
+        repeaters = [] if group.is_a? OrGroup
         @current_position += 1
         repeaters << parse_repeater(group)
       end
@@ -20,7 +21,7 @@ module RegexpExamples
 
     private
 
-    def parse_group
+    def parse_group(repeaters)
       char = regexp_string[@current_position]
       case char
       when '('
@@ -32,7 +33,7 @@ module RegexpExamples
       when '.'
         group = parse_dot_group
       when '|'
-        group = parse_or_group
+        group = parse_or_group(repeaters)
       when '\\'
         group = parse_after_backslash_group
       else
@@ -43,13 +44,17 @@ module RegexpExamples
 
     def parse_after_backslash_group
       @current_position += 1
-      case regexp_string[@current_position..-1]
-      when /^(\d+)/
+      case
+      when regexp_string[@current_position..-1] =~ /^(\d+)/
         group = parse_backreference_group($&)
+      when BackslashCharMap.keys.include?(regexp_string[@current_position])
+        group = CharGroup.new(
+          BackslashCharMap[regexp_string[@current_position]])
+        # TODO: There are also a bunch of multi-char matches to watch out for:
+        # http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Literals
       else
         group = parse_single_char_group( regexp_string[@current_position] )
-        # TODO: What about cases like \n, \(, \^, etc?
-        # SpecialCharsAfterBackslash ?
+        # TODO: What about cases like \A, \z, \Z ?
       end
       group
     end
@@ -88,9 +93,19 @@ module RegexpExamples
     def parse_char_group
       chars = []
       @current_position += 1
-      # TODO: What about the sneaky edge case of /...[]a-z].../ ?
-      until regexp_string[@current_position].chr == ']'
-        chars << regexp_string[@current_position].chr
+      if regexp_string[@current_position] == ']'
+        # Beware of the sneaky edge case:
+        # /[]]/ (match "]")
+        chars << ']'
+        @current_position += 1
+      end
+      until regexp_string[@current_position] == ']' \
+        && !regexp_string[0..@current_position-1].match(/[^\\](\\{2})*\\\z/)
+        # Beware of having an ODD number of "\" before the "]", e.g.
+        # /[\]]/ (match "]")
+        # /[\\]/ (match "\")
+        # /[\\\]]/ (match "\" or "]")
+        chars << regexp_string[@current_position]
         @current_position += 1
       end
       CharGroup.new(chars)
@@ -100,10 +115,10 @@ module RegexpExamples
       DotGroup.new
     end
 
-    def parse_or_group
+    def parse_or_group(left_repeaters)
       @current_position += 1
-      repeaters = parse
-      OrGroup.new(repeaters)
+      right_repeaters = parse
+      OrGroup.new(left_repeaters, right_repeaters)
     end
 
 

data/lib/regexp-examples/regexp_extensions.rb

@@ -1,14 +1,14 @@
 class Regexp
 module Examples
   def examples
-    regexp_string = self.inspect[1..-2]
     partial_examples =
-      RegexpExamples::Parser.new(regexp_string)
+      RegexpExamples::Parser.new(source)
         .parse
         .map {|repeater| repeater.result}
-    full_examples = RegexpExamples::permutations_of_strings(partial_examples)
-    full_examples.map{ |full_example| RegexpExamples::BackReferenceReplacer.new.substitute_backreferences(full_example)}
-    full_examples
+    full_examples = RegexpExamples::permutations_of_strings(partial_examples.dup, no_join: true)
+    full_examples_with_backrefs = \
+      RegexpExamples::BackReferenceReplacer.new.substitute_backreferences(full_examples)
+    full_examples_with_backrefs.map(&:join)
   end
 end
   include Examples

data/lib/regexp-examples/repeaters.rb

@@ -1,15 +1,16 @@
 module RegexpExamples
   class BaseRepeater
+    attr_reader :group
     def initialize(group)
       @group = group
     end
 
     def result(min_repeats, max_repeats)
-      group_result = @group.result
+      group_results = @group.result[0 .. MaxGroupResults-1]
       results = []
       min_repeats.upto(max_repeats) do |repeats|
-        group_result.each do |result|
-          results << result * repeats
+        group_results.each do |group_result|
+          results << group_result * repeats
         end
       end
       results.uniq

data/lib/regexp-examples/version.rb

@@ -1,3 +1,3 @@
 module RegexpExamples
-  VERSION = '0.0.0'
+  VERSION = '0.0.1'
 end

data/spec/regexp-examples_spec.rb

@@ -0,0 +1,89 @@
+describe Regexp, "#examples" do
+  def self.examples_exist_and_match(*regexps)
+    regexps.each do |regexp|
+      it do
+        regexp_examples = regexp.examples
+        expect(regexp_examples).not_to be_empty
+        regexp_examples.each { |example| expect(example).to match(/\A(?:#{regexp.source})\z/) }
+        # Note: /\A...\z/ is used, to prevent misleading examples from passing the test.
+        # For example, we don't want things like:
+        # /a*/.examples to include "xyz"
+        # /a|b/.examples to include "bad"
+      end
+    end
+  end
+
+  context 'returns matching strings' do
+    context "for basic repeaters" do
+      examples_exist_and_match(
+        /a/,
+        /a*/,
+        /a+/,
+        /a?/,
+        /a{1}/,
+        /a{1,}/,
+        /a{1,2}/
+      )
+    end
+
+    context "for basic groups" do
+      examples_exist_and_match(
+        /[a]/,
+        /(a)/,
+        /a|b/,
+        /./
+      )
+    end
+
+    context "for complex char groups (square brackets)" do
+      examples_exist_and_match(
+        /[abc]/,
+        /[a-c]/,
+        /[abc-e]/,
+        /[^a-zA-Z]/,
+        /[\w]/,
+        /[]]/, # TODO: How to suppress annoying warnings on this test?
+        /[\]]/,
+        /[\\]/,
+        /[\\\]]/,
+        /[\n-\r]/,
+        /[\-]/,
+        /[%-+]/ # This regex is "supposed to" match some surprising things!!!
+      )
+    end
+
+    context "for escaped characters" do
+      examples_exist_and_match(
+        /\w/,
+        /\s/,
+        /\d/,
+        /\t/,
+        /\n/,
+        /\f/,
+        /\a/,
+        /\v/,
+        /\e/
+      )
+    end
+
+    context "for backreferences" do
+      examples_exist_and_match(
+        /(repeat) \1/,
+        /(ref1) (ref2) \1 \2/,
+        /((ref2)ref1) \1 \2/,
+        /((ref1and2)) \1 \2/
+      )
+    end
+
+    context "for complex patterns" do
+      # Longer combinations of the above
+      examples_exist_and_match(
+        /https?:\/\/(www\.)github\.com/,
+        /(I(N(C(E(P(T(I(O(N)))))))))*/,
+        /[\w]{1}/,
+        /((a?b*c+)) \1/,
+        /((a?b*c+)?) \1/
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require './lib/regexp-examples.rb'
+require 'pry'
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: regexp-examples
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Tom Lord
@@ -45,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -59,6 +60,8 @@ files:
 - lib/regexp-examples/repeaters.rb
 - lib/regexp-examples/version.rb
 - regexp-examples.gemspec
+- spec/regexp-examples_spec.rb
+- spec/spec_helper.rb
 homepage: http://rubygems.org/gems/regexp-examples
 licenses:
 - MIT
@@ -83,4 +86,6 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Extends the Regexp class with '#examples'
-test_files: []
+test_files:
+- spec/regexp-examples_spec.rb
+- spec/spec_helper.rb