ghaki-match 2011.11.30.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Gerald Kalafut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,23 @@
+= Ghaki Match - Regexp helpers
+
+Ghaki Match is a collection of regular expression automation helpers.
+
+== Download
+
+The latest version of Ghaki Match can be found at
+
+* git@github.com:ghaki/ghaki-match.git
+
+== Installation
+
+The preferred method of installing Ghaki Match is through its GEM file.
+
+  % [sudo] gem install ghaki-match-0.0.1.gem
+
+== License
+
+Ghaki App is released under the MIT license.
+
+== Support
+
+Contact mailto:gerald@kalafut.org

data/lib/ghaki/match/finder.rb

@@ -0,0 +1,31 @@
+module Ghaki #:nodoc:
+module Match #:nodoc:
+
+# Match against list of regular expressions.
+class Finder
+
+  attr_accessor :lookups
+
+  # Given list of regular expressions
+  def initialize arg_rx_list
+    @lookups = arg_rx_list
+  end
+
+  # Matches string against saved regexps.
+  def match_text text
+    @lookups.each do |rx_curr|
+      return true if text =~ rx_curr
+    end
+    false
+  end
+
+  # Matches any line against saved regexps.
+  def match_lines lines
+    lines.each do |text|
+      return true if self.match_text( text )
+    end
+    false
+  end
+
+end
+end end

data/lib/ghaki/match/mixin/auto_boolean.rb

@@ -0,0 +1,32 @@
+require 'ghaki/match/parser/boolean'
+
+module Ghaki  #:nodoc:
+module Match  #:nodoc:
+module Mixin  #:nodoc:
+
+module AutoBoolean
+
+  attr_writer :auto_boolean_matcher
+
+  def auto_boolean_matcher
+    @auto_boolean_matcher ||= Ghaki::Match::Parser::Boolean.new
+  end
+
+  def auto_boolean_fields
+    auto_boolean_matcher.boolean_fields
+  end
+
+  def auto_boolean_fields= val
+    auto_boolean_matcher.boolean_fields = val
+  end
+
+  def auto_boolean_value val, opts={}, &block
+    auto_boolean_matcher.parse_value( val, opts, &block )
+  end
+
+  def auto_boolean_field key, val, opts={}, &block
+    auto_boolean_matcher.parse_field( key, val, opts, &block )
+  end
+
+end
+end end end

data/lib/ghaki/match/mixin/auto_rename.rb

@@ -0,0 +1,49 @@
+require 'ghaki/bool/accessors'
+
+module Ghaki #:nodoc:
+module Match #:nodoc:
+module Mixin #:nodoc:
+
+module AutoRename
+  extend Ghaki::Bool::Accessors
+
+  bool_accessor :auto_rename_to_token
+  attr_writer   :auto_rename_fields
+
+  def auto_rename_fields
+    @auto_rename_fields || {}
+  end
+
+  # Converts 'HTTP Compression' into :http_compression
+  def auto_field_name key
+    key.downcase.gsub(%r{[^A-Z0-9]+}xoi,' ').strip.gsub(' ','_')
+  end
+
+  # Given a string, convert it using #easy_name
+  # - if the rename table does not exist, return the converted string
+  # - if the rename table exists, and has an entry for that converted value
+  #   - if the entry is a token, return the table's token entry
+  #   - if the entry is true, then just tokenize the converted string
+  #   - if the entry is false, then pass through the converted string
+  #   - otherwise, complain about the invalid value
+  # - if the rename table exists, and does NOT have an entry
+  #   - return the string
+
+  def auto_rename_field dirty_key, opts={}
+    do_token = opts[:auto_rename_to_token]
+    do_token = self.auto_rename_to_token? if do_token.nil?
+    to_field = opts[:auto_rename_fields] || self.auto_rename_fields
+    clean_key = auto_field_name(dirty_key)
+    field_key = to_field[clean_key]
+    field_key = do_token if field_key.nil? and (not do_token.nil?)
+    case field_key
+    when Symbol then field_key
+    when true   then clean_key.to_sym
+    when false  then clean_key
+    else
+      raise ArgumentError, "Unknown Auto Rename Field Value: #{clean_key}"
+    end
+  end
+
+end
+end end end

data/lib/ghaki/match/parser/base.rb

@@ -0,0 +1,66 @@
+module Ghaki  #:nodoc:
+module Match  #:nodoc:
+module Parser #:nodoc:
+
+# Matches against paired regular expressions and returned values.
+class Base
+
+  attr_accessor :lookups, :default_value
+
+  def initialize pairs={}, opts={}
+    @lookups = pairs
+    @default_value = opts[:default_value]
+    add_words( opts[:match_words] ) if opts.has_key?(:match_words)
+  end
+
+  # Add simple words with return values to match pairs.
+  # - Keys are return values, values are words to turn into regexps.
+  #
+  # Given:
+  #
+  #   add_words :up => %w{ ON UP }, :down => %w{ DOWN OFF }
+  # 
+  # This will match against 'ON' and 'UP' and return :up
+  # and match against 'DOWN' and 'OFF' and return :down
+  def add_words pairs
+    pairs.each_pair do |val,keyz|
+      keyz.each do |key|
+        @lookups[ %r{\b#{key}\b}i ] = val
+      end
+    end
+  end
+
+  # Matches lines against regexp keys returning paired value.
+  # - Yields on not found or returns default value.
+  def match_lines lines, opts={}
+    @lookups.each_pair do |rx_curr,ret_val|
+      lines.each do |text|
+        return ret_val if text =~ rx_curr
+      end
+    end
+    if block_given?
+      yield
+    elsif opts.has_key?(:default_value)
+      opts[:default_value]
+    else
+      @default_value
+    end
+  end
+
+  # Matches string against regexp keys returning paired value.
+  # - Yields on not found or returns default value.
+  def match_text text, opts={}
+    @lookups.each_pair do |rx_curr,ret_val|
+      return ret_val if text =~ rx_curr
+    end
+    if block_given?
+      yield
+    elsif opts.has_key?(:default_value)
+      opts[:default_value]
+    else
+      @default_value
+    end
+  end
+
+end
+end end end

data/lib/ghaki/match/parser/boolean.rb

@@ -0,0 +1,51 @@
+require 'ghaki/match/parser/base'
+
+module Ghaki  #:nodoc:
+module Match  #:nodoc:
+module Parser #:nodoc:
+
+class Boolean < Base
+
+  DEFAULT_VALUES = {
+    true  => %w{ TRUE  YES ON  ENABLED  },
+    false => %w{ FALSE NO  OFF DISABLED },
+  }
+
+  attr_accessor :boolean_fields
+
+  def initialize opts={}; super( {}, opts )
+    opts_boolean opts
+  end
+
+  def opts_boolean opts
+    @boolean_fields = opts[:boolean_fields] || []
+    add_trues(  opts[:boolean_trues ]  ) unless opts[:boolean_trues].nil?
+    add_falses( opts[:boolean_falses]  ) unless opts[:boolean_falses].nil?
+    add_words(  DEFAULT_VALUES         ) unless opts[:skip_boolean_defaults]
+  end
+
+  def add_trues *list
+    add_words( true => [list].flatten )
+  end
+
+  def add_falses *list
+    add_words( false => [list].flatten )
+  end
+
+  # Determine truthiness, return if it is.
+  # - Otherwise return original value or yield if block is given.
+  def parse_value val, opts={}, &block
+    match_text( val, { :default_value => val }.merge(opts), &block )
+  end
+
+  # Check whether key is a known boolean field, if so, get truthiness.
+  def parse_field key, val, opts={}, &block
+    if @boolean_fields.member?(key)
+      parse_value( val, opts, &block )
+    else
+      val
+    end
+  end
+
+end
+end end end

data/spec/ghaki/match/finder_spec.rb

@@ -0,0 +1,32 @@
+require 'ghaki/match/finder'
+
+module Ghaki module Match module Finder_Testing
+describe Ghaki::Match::Finder do
+
+  subject do
+    Ghaki::Match::Finder.new([
+      %r{\bquack\b},
+      %r{\bmoo\b},
+    ])
+  end
+
+  describe '#match_text' do
+    it 'should match' do
+      subject.match_text('moo cow').should == true
+    end
+    it 'should not match' do
+      subject.match_text('zip zap').should == false
+    end
+  end
+
+  describe '#match_lines' do
+    it 'should match' do
+      subject.match_lines(['quick quack']).should == true
+    end
+    it 'should not match' do
+      subject.match_lines(['zip zap']).should == false
+    end
+  end
+
+end
+end end end

data/spec/ghaki/match/mixin/auto_boolean_spec.rb

@@ -0,0 +1,86 @@
+require 'ghaki/match/mixin/auto_boolean'
+
+module Ghaki module Match module Mixin module AutoBoolean_Testing
+describe AutoBoolean do
+
+  GOOD_KEY = 'EXPECTED'
+  GOOD_TRUE = 'TRUE'
+  MISS_KEY = 'INVALID'
+  MISS_VAL = 'BOGUS'
+  FIELDS_EXP = [GOOD_KEY]
+
+  class UsingAuto
+    include AutoBoolean
+  end
+
+  subject { UsingAuto.new }
+
+  it { should respond_to :auto_boolean_matcher= }
+
+  describe '#auto_boolean_matcher' do
+    it 'creates when not initialized' do
+      subject.auto_boolean_matcher.should be_kind_of(Parser::Boolean)
+    end
+    it 'accepts initialized value' do
+      parser = Parser::Boolean.new
+      subject.auto_boolean_matcher = parser
+      subject.auto_boolean_matcher.should == parser
+    end
+  end
+
+  describe '#auto_boolean_fields' do
+    it 'defaults to empty list' do
+      subject.auto_boolean_fields.should be_empty
+    end
+    it 'returns truthiness when field is present' do
+      subject.auto_boolean_fields = FIELDS_EXP
+      subject.auto_boolean_fields.should == FIELDS_EXP
+      subject.auto_boolean_field( GOOD_KEY, GOOD_TRUE ).should be_true
+    end
+    it 'returns orginal when field is missing' do
+      subject.auto_boolean_fields = FIELDS_EXP
+      subject.auto_boolean_fields.should == FIELDS_EXP
+      subject.auto_boolean_field( MISS_KEY, GOOD_TRUE ).should == GOOD_TRUE
+    end
+  end
+
+  describe '#auto_boolean_value' do
+
+    context 'using defaults' do
+      context 'with known values' do
+        Parser::Boolean::DEFAULT_VALUES[true].each do |item|
+          it "returns true for: #{item}" do
+              subject.auto_boolean_value(item).should be_true
+            end
+          end
+        end
+        Parser::Boolean::DEFAULT_VALUES[false].each do |item|
+          it "returns false for: #{item}" do
+              subject.auto_boolean_value(item).should be_false
+          end
+        end
+      end
+      context 'with unknown values' do
+        it 'returns original value' do
+          subject.auto_boolean_value(MISS_VAL).should == MISS_VAL
+        end
+      end
+
+  end
+
+  describe '#auto_boolean_field' do
+    context 'with present field' do
+      it 'converts value to boolean' do
+        subject.auto_boolean_fields = FIELDS_EXP
+        subject.auto_boolean_field(GOOD_KEY,GOOD_TRUE).should be_true
+      end
+    end
+    context 'with invalid field' do
+      it 'returns original value' do
+        subject.auto_boolean_field(MISS_KEY,MISS_VAL).should == MISS_VAL
+      end
+    end
+  end
+
+end
+end end end end

data/spec/ghaki/match/mixin/auto_rename_spec.rb

@@ -0,0 +1,131 @@
+require 'ghaki/match/mixin/auto_rename'
+
+module Ghaki module Match module Mixin module AutoRename_Testing
+describe AutoRename do
+
+  FIELD_CLEANUP_EXAMPLES = {
+    'accepts numbers and letters' => {
+      'phasellus_tortor_elementum'   => 'phasellus_tortor_elementum',
+      'Nulla Nisl 801 Leo Porta Et'  => 'nulla_nisl_801_leo_porta_et',
+    },
+    'removes garbage' => {
+      'Lorem ipsum dolor-sit amet.'   => 'lorem_ipsum_dolor_sit_amet',
+      'Fermentum / Augue (FRINGILLA)' => 'fermentum_augue_fringilla',
+    },
+  }
+
+  class UsingAuto
+    include AutoRename
+  end
+  before(:each) do
+    @subj = UsingAuto.new
+  end
+  subject { @subj }
+
+  it { should respond_to :auto_rename_to_token? }
+  it { should respond_to :auto_rename_to_token! }
+
+  it { should respond_to :auto_rename_fields= }
+  describe '#auto_rename_fields' do
+    it 'defaults empty hash' do
+      subject.auto_rename_fields.should == {}
+    end
+    it 'returns set value' do
+      thing = { 'zip' => 'zap' }
+      subject.auto_rename_fields = thing
+      subject.auto_rename_fields.should == thing
+    end
+  end
+
+  describe '#auto_field_name' do
+    FIELD_CLEANUP_EXAMPLES.each_pair do |reason,examples|
+     it reason do
+        examples.each_pair do |key,val|
+          subject.auto_field_name(key).should == val
+        end
+      end
+    end
+  end
+
+  describe '#auto_rename_field' do
+
+    ARF_RULES = {
+      'phasellus_tortor_elementum' => true,                   # clean and token
+      'lorem_ipsum_dolor_sit_amet' => :amet_lorem_dolor_sit,  # set specific
+      'nulla_nisl_801_porta'       => false,                  # just clean
+    }
+
+    ARF_EXPECTED = {
+      'cleans and tokenizes' => {
+        'phasellus_tortor_elementum' => :phasellus_tortor_elementum,
+      },
+      'renames to specific' => {
+        'Lorem ipsum dolor sit amet.' => :amet_lorem_dolor_sit,
+      },
+      'cleans only' => {
+        'Nulla Nisl 801 Porta' => 'nulla_nisl_801_porta',      # clean
+      },
+    }
+
+    before(:each) do
+      subject.auto_rename_fields = ARF_RULES
+    end
+
+    context 'with matched' do
+      ARF_EXPECTED.each_pair do |reason,examples|
+        it "#{reason} by rule" do
+          examples.each_pair do |get,put|
+            subject.auto_rename_field(get).should == put
+          end
+        end
+      end
+    end
+
+    context 'with unknown' do
+      let(:get_field) { 'UNKNOWN' }
+      let(:put_token) { :unknown }
+      let(:put_clean) { 'unknown' }
+
+      context 'using set :auto_rename_to_token' do
+
+        it 'translates unknown into Symbol' do
+          subject.auto_rename_to_token! true
+          subject.auto_rename_field(get_field).should == put_token
+        end
+
+        it 'translates unknown into String' do
+          subject.auto_rename_to_token! false
+          subject.auto_rename_field(get_field).should == put_clean
+        end
+
+        it 'fails when not set' do
+          lambda do
+            subject.auto_rename_field('missing')
+          end.should raise_error( ArgumentError, 'Unknown Auto Rename Field Value: missing' )
+        end
+
+      end
+
+      context 'using option :auto_rename_to_token' do
+
+        it 'accepts :auto_rename_to_token when true' do
+          subject.auto_rename_field( get_field , :auto_rename_to_token => true ).should == put_token
+        end
+
+        it 'accepts :auto_rename_to_token when false' do
+          subject.auto_rename_field( get_field, :auto_rename_to_token => false ).should == put_clean
+        end
+
+        it 'fails when not set' do
+          lambda do
+            subject.auto_rename_field('missing')
+          end.should raise_error( ArgumentError, 'Unknown Auto Rename Field Value: missing' )
+        end
+      end
+
+    end
+
+  end
+
+end
+end end end end

data/spec/ghaki/match/parser/base_spec.rb

@@ -0,0 +1,101 @@
+require 'ghaki/match/parser/base'
+
+module Ghaki module Match module Parser module Base_Testing
+describe Base do
+  FIND_KEY = 'FOUND'
+  FIND_VAL = 'RETURNED'
+  GOOD_TEXT = 'SHOULD BE FOUND BY PARSER'
+  MISS_TEXT = 'INVALID'
+  MISS_DEF = 'PASS_BACK'
+
+  subject do
+    Base.new({
+      %r{\b#{FIND_KEY}\b} => FIND_VAL,
+    })
+  end
+
+  describe '#initialize' do
+    context 'using option :match_words' do
+      it 'accepts' do
+        @subj = Base.new( :match_words => { FIND_VAL => [FIND_KEY] } )
+        subject.match_text(GOOD_TEXT).should == FIND_VAL
+      end
+    end
+  end
+
+  describe '#add_words' do
+    subject { Base.new }
+    it 'generates match pairs' do
+      subject.add_words FIND_VAL => [FIND_KEY]
+      subject.match_text(GOOD_TEXT).should == FIND_VAL
+    end
+  end
+
+  describe '#match_text' do
+
+    context 'when matched' do
+      it 'passes specified value' do
+        subject.match_text(GOOD_TEXT).should == FIND_VAL
+      end
+    end
+
+    context 'when unmatched' do
+      let(:text) { MISS_TEXT }
+      it 'returns nil without default' do
+        subject.match_text(text).should == nil
+      end
+      it 'returns default if present' do
+        subject.default_value = MISS_DEF
+        subject.match_text(text).should == MISS_DEF
+      end
+      it 'yields to block if present' do
+        yielded_action = false
+        subject.match_text(text) do
+          yielded_action = true
+          MISS_DEF
+        end.should == MISS_DEF
+        yielded_action.should be_true
+      end
+      it 'passed default overrides existing' do
+        subject.default_value = 'IGNORE'
+        subject.match_text( text, :default_value => MISS_DEF ).should == MISS_DEF
+      end
+    end
+
+  end
+
+  describe '#match_lines' do
+
+    context 'when matched' do
+      it 'should match' do
+        subject.match_lines([GOOD_TEXT]).should == FIND_VAL
+      end
+    end
+
+    context 'when unmatched' do
+      let(:lines) { [MISS_TEXT] }
+      it 'returns nil without default' do
+        subject.match_lines(lines).should == nil
+      end
+      it 'returns default if present' do
+        subject.default_value = MISS_DEF
+        subject.match_lines(lines).should == MISS_DEF
+      end
+      it 'passed default overrides existing' do
+        subject.default_value = 'IGNORE'
+        subject.match_lines( lines, :default_value => MISS_DEF ).should == MISS_DEF
+      end
+      it 'yields to block if present' do
+        yielded_action = false
+        subject.match_lines(lines) do
+          yielded_action = true
+          MISS_DEF
+        end.should == MISS_DEF
+        yielded_action.should be_true
+      end
+    end
+
+  end
+
+end
+end end end end

data/spec/ghaki/match/parser/boolean_spec.rb

@@ -0,0 +1,136 @@
+require 'ghaki/match/parser/boolean'
+
+module Ghaki module Match module Parser module Boolean_Testing
+describe Boolean do
+
+  FIELDS_EXP = ['EXPECTED']
+  EXTRA_KEY = 'ZAP'
+  EXTRA_TEXT = 'ZIP ZAP ZOOM'
+
+  it { should respond_to :boolean_fields }
+  it { should respond_to :boolean_fields= }
+
+  describe '#initialize' do
+
+    context 'using option :boolean_fields' do
+      it 'accepts when given' do
+        @subj = Boolean.new( :boolean_fields => FIELDS_EXP )
+        @subj.boolean_fields.should == FIELDS_EXP
+      end
+      it 'defaults as empty' do
+        @subj = Boolean.new
+        @subj.boolean_fields.should be_empty
+      end
+    end
+
+    context 'using option :skip_boolean_defaults' do
+      it 'ignores defaults when specified' do
+        @subj = Boolean.new( :skip_boolean_defaults => true )
+        @subj.lookups.should be_empty
+      end
+      it 'imports defaults when missing' do
+        @subj = Boolean.new
+        @subj.lookups.should_not be_empty
+      end
+    end
+
+    context 'using option :boolean_trues' do
+      it 'accepts when given' do
+        @subj = Boolean.new( :boolean_trues => EXTRA_KEY )
+        @subj.match_text(EXTRA_TEXT).should be_true
+      end
+    end
+
+    context 'using option :boolean_falses' do
+      it 'accepts when given' do
+        @subj = Boolean.new( :boolean_falses => EXTRA_KEY )
+        @subj.match_text(EXTRA_TEXT).should be_false
+      end
+    end
+
+  end
+
+  describe '#parse_value' do
+
+    subject { Boolean.new }
+
+    context 'when unmatched' do
+      let(:text) { 'INVALID' }
+      it 'passes through original value' do
+        subject.parse_value(text).should == text
+      end
+      it 'yields to block if present' do
+        yielded = false
+        subject.parse_value(text) do
+          yielded = true
+          'RETURNED'
+        end.should == 'RETURNED'
+        yielded.should be_true
+      end
+    end
+
+    context 'using matched defaults' do
+      Boolean::DEFAULT_VALUES[true].each do |item|
+        it "returns true given: #{item}" do
+          subject.parse_value(item).should be_true
+        end
+      end
+      Boolean::DEFAULT_VALUES[false].each do |item|
+        it "returns false given: #{item}" do
+          subject.parse_value(item).should be_false
+        end
+      end
+    end
+
+  end
+
+  describe '#parse_field' do
+
+    subject { Boolean.new :boolean_fields => FIELDS_EXP }
+
+    context 'with present field' do
+
+      let(:field) { FIELDS_EXP.first }
+
+      context 'when unmatched' do
+        let(:text) { 'NOT_FOUND' }
+        it 'passes through original value' do
+          subject.parse_field( field, text ).should == text
+        end
+        it 'yields to block if present' do
+          yielded = false
+          subject.parse_field( field, text ) do
+            yielded = true
+            'PASSED_BACK'
+          end.should == 'PASSED_BACK'
+          yielded.should be_true
+        end
+      end
+
+      context 'using matched defaults' do
+        Boolean::DEFAULT_VALUES[true].each do |item|
+          it "returns true given: #{item}" do
+            subject.parse_field( field, item ).should be_true
+          end
+        end
+        Boolean::DEFAULT_VALUES[false].each do |item|
+          it "returns false given: #{item}" do
+            subject.parse_field( field, item ).should be_false
+          end
+        end
+      end
+
+    end
+
+    context 'with missing field' do
+      let(:field) { 'INVALID' }
+      let(:text)  { 'PASSED_BACK' }
+      it 'passes through original value' do
+        subject.parse_field( field, text ).should == text
+      end
+    end
+
+  end
+
+end
+end end end end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'mocha'
+
+RSpec.configure do |cfg|
+  cfg.mock_with :mocha
+  cfg.color_enabled = true
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: ghaki-match
+version: !ruby/object:Gem::Version
+  version: 2011.11.30.1
+  prerelease: 
+platform: ruby
+authors:
+- Gerald Kalafut
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ghaki-bool
+  requirement: &73929750 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2011.11.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *73929750
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &73929530 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *73929530
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &73929290 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.9.4
+  type: :development
+  prerelease: false
+  version_requirements: *73929290
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &73929030 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: *73929030
+description: Collection of helpers for regular expression helpers.
+email: gerald@kalafut.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- lib/ghaki/match/finder.rb
+- lib/ghaki/match/parser/boolean.rb
+- lib/ghaki/match/parser/base.rb
+- lib/ghaki/match/mixin/auto_rename.rb
+- lib/ghaki/match/mixin/auto_boolean.rb
+- README
+- LICENSE
+- spec/ghaki/match/parser/base_spec.rb
+- spec/ghaki/match/parser/boolean_spec.rb
+- spec/ghaki/match/mixin/auto_rename_spec.rb
+- spec/ghaki/match/mixin/auto_boolean_spec.rb
+- spec/ghaki/match/finder_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ghaki
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: ghaki-match
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Regular expression automation helpers
+test_files:
+- spec/ghaki/match/parser/base_spec.rb
+- spec/ghaki/match/parser/boolean_spec.rb
+- spec/ghaki/match/mixin/auto_rename_spec.rb
+- spec/ghaki/match/mixin/auto_boolean_spec.rb
+- spec/ghaki/match/finder_spec.rb
+- spec/spec_helper.rb