irregular 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f2dbff84b804fafca7e56fae65349aadc8a6dee
+  data.tar.gz: c937a4f1dd5f49569dabc4c2f9d49e4aa09a91e0
+SHA512:
+  metadata.gz: 88ce77d8d1440735f0af491a15221ed0fd684bc287b2320058daed418f63206d82091592d28f54e3faac25f9819427284363de1f18dc156bf71049e7f5a732c1
+  data.tar.gz: 4865baf5efbe22aed8ce103b26e6157e250f904566d25b6d5f27404dfaf969d8807b5bb3fe2dd011d8dcdaca0f5e2a4cb7d0d6cb56cc3987aeeb3a12ae14bc6b

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/bin/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in irregular.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Stephen Scott
+
+MIT License
+
+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.md

@@ -0,0 +1,93 @@
+# Irregular
+
+Regular expressions are very powerful, but their syntax can get large and archaic quickly. Irregular is a simple templating language for regular expressions. It helps you abstract chunks of your regular expressions into methods to help make them more readable.
+
+irregular-rb is based on [irregular-js](https://github.com/suchipi/irregular-js). 
+
+## Usage Example
+
+```ruby
+class CatRegexp
+  include Irregular
+
+  def cat_names
+    names = ['betty', 'joyce', 'franklin', 'peter']
+    "(#{names.join '|'})"
+  end
+end
+
+irregular = CatRegexp.new
+
+# insert results of method calls using backticks
+regexp = irregular.compile_regexp(/I love my cat `cat_names`!/i)
+p regexp # => /I love my cat (betty|joyce|franklin|peter)!/i
+
+# use your regexp as normal
+regexp =~ "I love my cat Joyce!" # => 0
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'irregular'
+```
+
+And then execute:
+```
+$ bundle
+```
+
+Or install it yourself as:
+```
+$ gem install irregular
+```
+
+## API
+
+### Irregular
+
+A module that provides functionality for compiling Irregular Expressions.
+Does nothing on its own; include or extend it into your class/module.
+
+### Irregular.compile_regexp
+```
+compile_regexp(regexp, options = 0)
+compile_regexp(string, options = 0)
+```
+
+Method that compiles an irregular expression into a Regexp. (returns Regexp)
+
+#### Parameters
+
+`regexp`
+
+A regular expression to use the source pattern and options of for compilation.
+
+`string`
+
+A string to use as the source pattern for compilation.
+
+`options`
+
+A list or or-ed Regexp options to apply to the resulting Regexp.
+
+If passed with a Regexp object, it will be or-ed against the Regexp's existing options.
+
+## Contributing
+
+Pull requests, bug reports welcome.
+
+This library tries to mirror compilation behavior of irregular-js as much as possible- if you notice behavior you think might be a bug, test if it behaves the same in irregular-js first. If you still think it's a bug, the report should be filed against irregular-js, and then once it is resolved there, a bug report should be filed here.
+
+## Running tests
+
+Tests are written using Rspec. To run:
+```
+$ bundle install rspec spec
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/irregular.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'irregular/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "irregular"
+  spec.version       = Irregular::VERSION
+  spec.authors       = ["Stephen Scott"]
+  spec.email         = ["me@suchipi.com"]
+  spec.summary       = "Abstracted, human-readable regular expressions"
+  spec.description   = "Module providing a method to compile regular expressions from templates."
+  spec.homepage      = "http://github.com/suchipi/irregular-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+end

data/lib/irregular/version.rb

@@ -0,0 +1,5 @@
+module Irregular
+  # Attempt to keep in sync with the earliest irregular-js
+  # version that exhibits the same compilation behavior
+  VERSION = "1.0.1"
+end

data/lib/irregular.rb

@@ -0,0 +1,35 @@
+require "irregular/version"
+
+module Irregular
+  def compile_regexp(regexp_or_string, options = 0)
+    if regexp_or_string.is_a? Regexp
+      source = regexp_or_string.source
+      options |= regexp_or_string.options
+    end
+
+    if regexp_or_string.is_a? String
+      source = regexp_or_string
+    end
+
+    # Ruby regular expressions don't support the global flag,
+    # so we scan to collect results then gsub them in
+    # instead of passing a block directly to match.
+
+    template_regexp = /`(\w+)`/
+
+    compiled_results = {}
+    source.scan(template_regexp) do
+      compiled_results[$1] = if respond_to?($1)
+        send($1)
+      else
+        "`#{$1}`"
+      end
+    end
+
+    compiled_source = source.gsub(template_regexp) do
+      compiled_results[$1]
+    end
+
+    Regexp.new(compiled_source, options)
+  end
+end

data/spec/irregular_spec.rb

@@ -0,0 +1,91 @@
+require "irregular"
+
+RSpec.describe Irregular do
+  class IrregularTestClass
+    include Irregular
+
+    def test1
+      "result1"
+    end
+
+    def test2
+      "result2"
+    end
+  end
+
+  it "version is defined" do
+    expect(Irregular::VERSION).to_not be_nil
+  end
+
+  describe "#compile_regexp" do
+    let(:instance) { IrregularTestClass.new }
+    let(:input_regexp) { /bla `test1` `test2` `test1`/i }
+    let(:input_string) { "bla `test1` `test2` `test1`" }
+    let(:input_options) { Regexp::MULTILINE }
+
+    shared_examples_for "regexp compilation" do
+      it "returns a Regexp" do
+        expect(@result).to be_a(Regexp)
+      end
+
+      it "compiles the source of the input regexp" do
+        expect(@result.source).to eq("bla result1 result2 result1")
+      end
+    end
+
+    context "regexp passed" do
+      before do
+        @result = instance.compile_regexp(input_regexp)
+      end
+
+      include_examples "regexp compilation"
+
+      it "resultant Regexp has the same options as the input regexp" do
+        expect(@result.options).to eq(input_regexp.options)
+      end
+    end
+
+    context "regexp and options passed" do
+      before do
+        @result = instance.compile_regexp(input_regexp, input_options)
+      end
+
+      include_examples "regexp compilation"
+
+      it "resultant Regexp's options are a combination of the provided options and the input regexp's options" do
+        expect(@result.options & input_options).to be input_options
+        expect(@result.options & input_regexp.options).to be input_regexp.options
+      end
+    end
+
+    context "string passed" do
+      before do
+        @result = instance.compile_regexp(input_string)
+      end
+
+      include_examples "regexp compilation"
+
+      it "resultant Regexp has no set options" do
+        expect(@result.options).to eq(0)
+      end
+    end
+
+    context "string and options passed" do
+      before do
+        @result = instance.compile_regexp(input_string, input_options)
+      end
+
+      include_examples "regexp compilation"
+
+      it "resultant Regexp's options are the passed options" do
+        expect(@result.options).to eq(input_options)
+      end
+    end
+
+    it "trying to compile a non-existent method does nothing" do
+      expect(instance).to_not respond_to(:foo)
+      regexp = instance.compile_regexp(/`foo`/)
+      expect(regexp.source).to eq("`foo`")
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: irregular
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Stephen Scott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: Module providing a method to compile regular expressions from templates.
+email:
+- me@suchipi.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- irregular.gemspec
+- lib/irregular.rb
+- lib/irregular/version.rb
+- spec/irregular_spec.rb
+homepage: http://github.com/suchipi/irregular-rb
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Abstracted, human-readable regular expressions
+test_files:
+- spec/irregular_spec.rb