simple_regex 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4cdb3c7de307a3117543bbe93423f34f4386206c
+  data.tar.gz: 5d01fde5da692cbae69d8385b02dfe76d4fe9b3b
+SHA512:
+  metadata.gz: 1364a4dc2c303d1a1f7b258062e1d0ab504fa2d83fdb78de5a52d1ecf6805c377620d1f28500c64ea47161065f8aa12bdee243634db2183f213ccd22f730ac25
+  data.tar.gz: 5e82e7bc9f76de2cddf23e8338471f4d5b69083d75ea58a12e5082ed6493aaa2bd193f596665c8c25cd0d4d042f7f78b6833fb67784b256168afe8514ccb3c12

data/lib/simple_regex.rb

@@ -0,0 +1,155 @@
+class SimpleRegex
+
+  class Error < StandardError; end
+
+  PATTERNS = {
+    'digit'        => '[0-9]',
+    'lowercase'    => '[a-z]',
+    'uppercase'    => '[A-Z]',
+    'letter'       => '[A-Za-z]',
+    'alphanumeric' => '[A-Za-z0-9]',
+    'whitespace'   => '\s',
+    'space'        => ' ',
+    'tab'          => '\t'
+  }
+
+  ESCAPED_CHARS = %w(
+    * . ? ^ + $ | ( ) [ ] { }
+  )
+
+  def initialize
+    @str = ''
+    @ended = false
+  end
+
+  def start_with(*args)
+    raise SimpleRegex::Error.new('#start_with? called multiple times') unless @str.empty?
+    write '^%s', args
+  end
+
+  def append(*args)
+    write interpret(*args)
+  end
+  alias_method :then, :append
+
+  def end_with(*args)
+    write '%s$', args
+    @ended = true
+    self
+  end
+
+  def maybe(*args)
+    write '%s?', args
+  end
+  
+  def not(*args)
+    write '(?!%s)', args
+  end
+
+  def one_of(ary)
+    write '[%s]' % ary.map { |c| escape(c) }.join('|')
+  end
+
+  def between(range, pattern)
+    unless range.length == 2 && range.any? { |i| i.is_a?(Integer) }
+      raise SimpleRegex:Error.new('must provide an array of 2 elements, one of them must be an integer')
+    end
+
+    write '%s{%s,%s}' % [interpret(pattern), range[0], range[1]]
+  end
+
+  def at_least(times, pattern)
+    between [times, nil], pattern
+  end
+
+  def at_most(times, pattern)
+    between [nil, times], pattern
+  end
+
+  def zero_or_more(pattern)
+    write '%s*', pattern
+  end
+
+  def one_or_more(pattern)
+    write '%s+', pattern
+  end
+
+  def regex
+    Regexp.new(@str)
+  end
+  alias_method :get, :regex
+
+  def =~(other)
+    regex =~ other
+  end
+
+  def method_missing(meth, *args, &block)
+    regex.send(meth, *args, &block)
+  end
+
+  def respond_to?(meth)
+    regex.respond_to?(meth) || super
+  end
+
+  def to_s
+    "#<SimpleRegex:#{object_id} regex=/#{@str}/>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  private
+
+  def write(str, args=nil)
+    raise SimpleRegex::Error.new('#end_with has already been called') if @ended
+    @str << (args.nil? ? str : str % interpret(*args))
+    self
+  end
+
+  # Translate/escape characters etc and return regex-ready string
+  def interpret(*args)
+    case args.length
+    when 2 then numbered_constraint(*args)
+    when 1 then patterned_constraint(*args)
+    else raise ArgumentError
+    end
+  end
+
+  # Ex: (2, 'x') or (3, :digits)
+  def numbered_constraint(count, type)
+    pattern = patterned_constraint(type)
+    raise SimpleRegex::Error.new('Unrecognized pattern') if pattern.nil? || pattern.empty?
+    '%s{%s}' % [pattern, count]
+  end
+
+  # Ex: ('aa') or ('$')
+  def patterned_constraint(pattern)
+    escape translate(pattern)
+  end
+
+  # Remove a trailing 's', if there is one
+  def singularize(word)
+    str = word.to_s
+    str.end_with?('s') ? str[0..-2] : str
+  end
+
+  # Escape special regex characters in a string
+  #
+  # Ex:
+  #   escape("one.two")
+  #   # => "one\.two"
+  #
+  def escape(pattern)
+    pattern.to_s.gsub(/.+/) do |char|
+      ESCAPED_CHARS.include?(char) ? "\\#{char}" : char
+    end
+  end
+
+  # Translate an identifier such as :digits to [0-9], etc
+  # Returns the original identifier if no character class found
+  def translate(pattern)
+    PATTERNS[singularize(pattern)] || pattern
+  end
+
+end

data/lib/simple_regex/version.rb

@@ -0,0 +1,3 @@
+class SimpleRegex
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: simple_regex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Berls
+- Puru Dahal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: " SimpleRegex provides a flexible syntax for constructing regular expressions
+  by chaining Ruby method calls instead of deciphering cryptic syntax. "
+email:
+- andrew.berls@gmail.com
+- puru@dahal.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/simple_regex.rb
+- lib/simple_regex/version.rb
+homepage: https://github.com/superpowr/simple_regex
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Simple Regular Expression
+test_files: []