regularity 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22344c2dea3e06de87e19734043692518fd889d0
+  data.tar.gz: 4399ef19020b4f183a5d989270eece627dd35835
+SHA512:
+  metadata.gz: 7fff9de17ab25f58f59293c038e232bf2625e70f6df3bb529f782b8219ce3bd2e0aaa41c412511b900cad0e981b8555c58478f04754d74cbe2d0b0e239f8ddc1
+  data.tar.gz: c1ececc9d8080212871bd642d4e0d9c64b95419d556790bc344956addff1c4b00f61a58cab961b0e8bb575a3a2b9dab71ee1246937c75de67c4dce9d706a1f37

data/lib/regularity.rb

@@ -0,0 +1,128 @@
+class Regularity
+
+  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 = ''
+  end
+
+  def start_with(*args)
+    raise Regularity::Error.new('#start_with? called multiple times') unless @str.empty?
+    write '^%s' % interpret(*args)
+  end
+
+  def append(*args)
+    write interpret(*args)
+  end
+  alias_method :then, :append
+
+  def end_with(*args)
+    write '%s$' % interpret(*args)
+  end
+
+  def maybe(*args)
+    write '%s?' % interpret(*args)
+  end
+
+  def one_of(ary)
+    write '[%s]' % ary.map { |c| escape(c) }.join('|')
+  end
+
+  def between(range, pattern)
+    raise Regularity:Error.new('must provide an array of 2 integers') unless range.length == 2
+    write '%s{%s,%s}' % [interpret(pattern), range[0], range[1]]
+  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
+    "#<Regularity:#{object_id} regex=/#{@str}/>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  private
+
+  def write(str)
+    @str << str
+    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 Regularity::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/regularity/version.rb

@@ -0,0 +1,3 @@
+class Regularity
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: regularity
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Berls
+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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' Regularity provides a flexible syntax for constructing regular expressions
+  by chaining Ruby method calls instead of deciphering cryptic syntax. '
+email: andrew.berls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/regularity/version.rb
+- lib/regularity.rb
+homepage: https://github.com/andrewberls/regularity
+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.0.7
+signing_key: 
+specification_version: 4
+summary: A friendly regular expression builder for Ruby
+test_files: []