redactor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7930ab02836e02e6b1a54666b637cef619becde9
+  data.tar.gz: 5005ab98df807eed1cbecb5618b8db60be254629
+SHA512:
+  metadata.gz: 1ea215bfc5261dbbb927fe8d72dd0e6f206205ae4ac2e1b502034d14ae9799a045ce2a07c9fe1965e0b5380edcb414ccec58fb077d5bed9ff92e616a2fb6825e
+  data.tar.gz: 80ea8bbce965ea23c314b6c8e004f98617355dff8af5be3225f544b65d319354b775c7e3310bb9c2650597182d5a06c6d55d9174451df06e4efd5493cfee9ae2

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    redactor (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 10.4.2)
+  redactor!
+  rspec (~> 3.3.0)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Tim Petricola
+
+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,52 @@
+# redactor
+
+Redact parts of text defined by custom rules (e.g. emails, phone numbers).
+
+## Usage
+
+```rb
+require 'redactor'
+
+input = 'To ride a kayak, contact me: tim.petricola@gmail.com or 1 234 567 8901.'
+
+# these rules are only good enough for an example
+Redactor.define do
+  # US phone
+  rule :phone, /(\+?1[ \.-]?)?\(?\d{3}\)?[ \.-]?\d{3}[ \.-]?\d{4}/
+
+  # email
+  rule :email, /[\w\.]+(@|at)\w+(\.|dot)\w{1,3}/i
+
+  # palindrome
+  rule :palindrome do |input|
+    words = input.split(/\W+/)
+    palindromes = words.select { |w| w.length > 2 && w == w.reverse }
+    palindromes.map do |w|
+      start = input.index(w)
+      finish = start + w.length
+      [start, finish]
+    end
+  end
+end
+
+Redactor.format(input)
+# => "To ride a [REDACTED], contact me: [REDACTED] or [REDACTED]."
+
+Redactor.format(input) do |extract|
+  "[#{extract.reason.upcase}]"
+end
+# => "To ride a [PALINDROME], contact me: [EMAIL] or [PHONE]."
+
+Redactor.extract(input)
+# => [#<Redactor::Extract:0x007fc05c6b25a0
+#   @finish=70,
+#   @rule=#<Redactor::Rule:0x007fc05f203970 @block=nil, @reason=:phone, @regex=/(\+?1[ \.-]?)?\(?\d{3}\)?[ \.-]?\d{3}[ \.-]?\d{4}/>,
+#   @start=56,
+#   @value="1 234 567 8901">,
+#  #<Redactor::Extract:0x007fc05c6b2230 @finish=52, @rule=#<Redactor::Rule:0x007fc05f203948 @block=nil, @reason=:email, @regex=/[\w\.]+(@|at)\w+(\.|dot)\w{1,3}/i>, @start=29, @value="tim.petricola@gmail.com">,
+#  #<Redactor::Extract:0x007fc05c6b19c0
+#   @finish=15,
+#   @rule=#<Redactor::Rule:0x007fc05f2038d0 @block=#<Proc:0x007fc05f2038f8@/Users/Tim/Projects/redact/test.rb:13>, @reason=:palindrome, @regex=nil>,
+#   @start=10,
+#   @value="kayak">]
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/redactor/clear.rb

@@ -0,0 +1,5 @@
+module Redactor
+  def self.clear
+    self.rules = []
+  end
+end

data/lib/redactor/dsl.rb

@@ -0,0 +1,12 @@
+module Redactor
+  class DSL
+    def rule(reason, regex = nil, &block)
+      rule = Rule.new(reason, regex, &block)
+      Redactor.register_rule(rule)
+    end
+
+    def self.run(block)
+      new.instance_eval(&block)
+    end
+  end
+end

data/lib/redactor/extract.rb

@@ -0,0 +1,22 @@
+module Redactor
+  class Extract
+    attr_reader :rule, :value, :start, :finish
+
+    def initialize(rule:, value:, start:, finish:)
+      @rule = rule
+      @value = value
+      @start = start
+      @finish = finish
+    end
+
+    def reason
+      rule.reason
+    end
+
+    def collides?(extract)
+      [:start, :finish].any? do |m|
+        extract.send(m).between?(start, finish)
+      end
+    end
+  end
+end

data/lib/redactor/rule.rb

@@ -0,0 +1,49 @@
+module Redactor
+  class Rule
+    attr_reader :reason, :regex, :block
+
+    def initialize(reason, regex = nil, &block)
+      if regex && block_given?
+        raise ArgumentError, 'cannot have a regex and a block'
+      elsif !regex && !block_given?
+        raise ArgumentError, 'must have a regex or a block'
+      end
+
+      @reason = reason
+      @regex = regex
+      @block = block
+    end
+
+    def extract(input)
+      return extract_regex(input) if regex
+      return extract_block(input) if block
+    end
+
+    private
+
+    def extract_regex(input)
+      input.enum_for(:scan, regex).map do
+        match = Regexp.last_match
+        Extract.new(
+          rule: self,
+          value: match[0],
+          start: match.begin(0),
+          finish: match.end(0)
+        )
+      end
+    end
+
+    def extract_block(input)
+      Array(block.call(input)).map do |positions|
+        start, finish = positions
+
+        Extract.new(
+          rule: self,
+          value: input[start...finish],
+          start: start,
+          finish: finish
+        )
+      end
+    end
+  end
+end

data/lib/redactor/version.rb

@@ -0,0 +1,3 @@
+module Redactor
+  VERSION = '0.1.0'
+end

data/lib/redactor.rb

@@ -0,0 +1,45 @@
+require 'redactor/clear'
+require 'redactor/dsl'
+require 'redactor/extract'
+require 'redactor/rule'
+
+module Redactor
+  DEFAULT_REPLACEMENT = '[REDACTED]'.freeze
+
+  class << self
+    attr_accessor :rules
+    attr_accessor :default_replacement
+  end
+
+  self.rules = []
+  self.default_replacement = DEFAULT_REPLACEMENT
+
+  def self.define(&block)
+    DSL.run(block)
+  end
+
+  def self.register_rule(rule)
+    rules.push(rule)
+  end
+
+  # returns a list of Extract objects (including position and value)
+  # matching predefined rules
+  def self.extract(from)
+    rules.reduce([]) do |extracts, rule|
+      new_extracts = rule.extract(from).select do |extract|
+        # do not consider new extract if colliding with existing one
+        !extracts.any? { |e| e.collides?(extract) }
+      end
+      extracts.concat(new_extracts)
+    end
+  end
+
+  # replaces parts of text by [REDACTED]. The replacement string can be
+  # customized by passing a block taking the Extract object as an argument
+  def self.format(text, &block)
+    extract(text).each_with_object(text.clone) do |extract, redacted_text|
+      sub = block_given? ? block.call(extract) : default_replacement
+      redacted_text[extract.start...extract.finish] = sub
+    end
+  end
+end

data/redactor.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path '../lib/redactor/version', __FILE__
+
+Gem::Specification.new do |s|
+  s.authors       = ['Tim Petricola']
+  s.email         = ['tim.petricola@gmail.com']
+  s.summary       = 'Redact parts of text defined by custom rules (e.g. emails, phone numbers)'
+  s.license       = 'MIT'
+  s.homepage      = 'https://github.com/TimPetricola/redactor'
+  s.files         = `git ls-files`.split "\n"
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split "\n"
+  s.name          = 'redactor'
+  s.require_paths = ['lib']
+  s.version       = Redactor::VERSION
+
+  s.add_development_dependency 'rspec', '~> 3.3.0'
+  s.add_development_dependency 'rake', '~> 10.4.2'
+end

data/spec/lib/clear_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'clear' do
+  after { Redactor.clear }
+
+  it 'unload all rules' do
+    Redactor.clear
+    Redactor.register_rule(double)
+    expect { Redactor.clear }.to change { Redactor.rules.size }.from(1).to(0)
+  end
+end

data/spec/lib/dsl_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Redactor::DSL do
+  describe 'new rule' do
+    context 'with regex' do
+      it 'is registered' do
+        definitions = proc do
+          rule :foo, /foo/
+        end
+
+        rule = double('Redactor::Rule')
+        expect(Redactor::Rule).to(
+          receive(:new).with(:foo, /foo/).and_return(rule)
+        )
+        expect(Redactor).to receive(:register_rule).with(rule)
+
+        Redactor::DSL.run(definitions)
+      end
+    end
+
+    context 'with block' do
+      it 'is registered' do
+        proc = proc
+
+        definitions = proc do
+          rule(:foo, &proc)
+        end
+
+        rule = double('Redactor::Rule')
+        expect(Redactor::Rule).to(
+          receive(:new).with(:foo, nil) do |*_args, &block|
+            expect(proc).to be(block)
+            rule
+          end
+        )
+        expect(Redactor).to receive(:register_rule).with(rule)
+
+        Redactor::DSL.run(definitions)
+      end
+    end
+  end
+end

data/spec/lib/extract_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Redactor::Extract do
+  def extract_at(start, finish)
+    Redactor::Extract.new(rule: double, value: '', start: start, finish: finish)
+  end
+
+  describe '#collides?' do
+    let(:extract) { extract_at(10, 20) }
+
+    context 'no collision' do
+      it 'is false' do
+        expect(extract.collides?(extract_at(0, 9))).to be false
+      end
+    end
+
+    context 'lower collision' do
+      it 'is true' do
+        expect(extract.collides?(extract_at(0, 10))).to be true
+      end
+    end
+
+    context 'upper collision' do
+      it 'is true' do
+        expect(extract.collides?(extract_at(20, 25))).to be true
+      end
+    end
+  end
+end

data/spec/lib/redact_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Redactor do
+  before do
+    @foobar_rule = Redactor::Rule.new(:foobar, /foobar/)
+    @barbaz_rule = Redactor::Rule.new(:barbaz, /barbaz/)
+    Redactor.register_rule(@foobar_rule)
+    Redactor.register_rule(@barbaz_rule)
+  end
+
+  after { Redactor.clear }
+
+  describe '.extract' do
+    it 'return extracts' do
+      text = 'hello barbaz foobar'
+      results = Redactor.extract(text)
+      expect(results.first.rule).to be @foobar_rule
+      expect(results.first.value).to eq 'foobar'
+      expect(results.last.rule).to be @barbaz_rule
+      expect(results.last.value).to eq 'barbaz'
+    end
+
+    context 'colliding rules' do
+      it "only keep first defined rule's match" do
+        text = 'hello foobarbaz'
+        results = Redactor.extract(text)
+        expect(results.size).to eq 1
+        expect(results.first.rule).to be @foobar_rule
+      end
+    end
+  end
+
+  describe '.format' do
+    it 'replaces redacted parts' do
+      text = 'hello barbaz foobar'
+      expect(Redactor.format(text)).to eq 'hello [REDACTED] [REDACTED]'
+    end
+
+    it 'accepts a block for redacted strings' do
+      text = 'hello barbaz foobar'
+
+      redacted = Redactor.format(text) do |extract|
+        "[#{extract.reason.upcase}]"
+      end
+
+      expect(redacted).to eq 'hello [BARBAZ] [FOOBAR]'
+    end
+
+    it 'does not mutate original string' do
+      text = 'hello barbaz foobar'
+      Redactor.format(text)
+      expect(text).to eq 'hello barbaz foobar'
+    end
+  end
+end

data/spec/lib/rule_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Redactor::Rule do
+  it 'can be built with a regex' do
+    rule = Redactor::Rule.new(:foo, /foo/)
+    expect(rule.reason).to eq :foo
+    expect(rule.regex).to eq(/foo/)
+  end
+
+  it 'can be built with a block' do
+    rule = Redactor::Rule.new(:foo) { |input| input }
+    expect(rule.reason).to eq :foo
+    expect(rule.block).not_to be_nil
+  end
+
+  it 'needs a regex or a block' do
+    expect {
+      Redactor::Rule.new(:foo)
+    }.to raise_error(ArgumentError)
+  end
+
+  it 'can not have a regex and a block' do
+    expect {
+      Redactor::Rule.new(:foo, /foo/) { |input| input }
+    }.to raise_error(ArgumentError)
+  end
+
+  describe '#extract' do
+    context 'with regex' do
+      let(:text) do
+        'Lorem foo bar ipsum dolor sit amet, foobar adipiscing elit.'
+      end
+      let(:rule) { Redactor::Rule.new(:foo_bar, /foo ?bar/) }
+      let(:results) { rule.extract(text) }
+
+      it 'returns values and positions of first match' do
+        extract = results.first
+        expect(extract.rule).to be rule
+        expect(extract.value).to eq 'foo bar'
+        expect(extract.start).to eq 6
+        expect(extract.finish).to eq 13
+      end
+
+      it 'returns values and positions of others matches' do
+        extract = results[1]
+        expect(extract.rule).to be rule
+        expect(extract.value).to eq 'foobar'
+        expect(extract.start).to eq 36
+        expect(extract.finish).to eq 42
+      end
+    end
+
+    context 'with block' do
+      let(:text) do
+        'I want a kayak, a poney or a racecar.'
+      end
+
+      let(:rule) do
+        Redactor::Rule.new(:palindrome) do |input|
+          input.split(/\W+/)
+            .select { |w| w.length > 2 && w == w.reverse }
+            .map do |word|
+              start = input.index(word)
+              finish = start + word.length
+              [start, finish]
+            end
+        end
+      end
+
+      let(:results) { rule.extract(text) }
+
+      it 'returns values and positions of first match' do
+        extract = results.first
+        expect(extract.rule).to be rule
+        expect(extract.value).to eq 'kayak'
+        expect(extract.start).to eq 9
+        expect(extract.finish).to eq 14
+      end
+
+      it 'returns values and positions of others matches' do
+        extract = results[1]
+        expect(extract.rule).to be rule
+        expect(extract.value).to eq 'racecar'
+        expect(extract.start).to eq 29
+        expect(extract.finish).to eq 36
+      end
+    end
+  end
+end

data/spec/lib/rules_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec::Matchers.define :be_redacted do |reason|
+  match do |actual|
+    Redactor.extract(actual).any? do |extract|
+      extract.value == actual && extract.reason == reason
+    end
+  end
+end
+
+describe 'Redactor rules' do
+  before do
+    Redactor.define do
+      # US phone
+      rule :phone, /(\+?1[ \.-]?)?\(?\d{3}\)?[ \.-]?\d{3}[ \.-]?\d{4}/
+
+      # email
+      rule :email, /[\w\.]+ ?(@|at) ?\w+\ ?(\.|dot) ?\w{1,3}/i
+    end
+  end
+
+  after { Redactor.clear }
+
+  {
+    '1 234 567 8901' => :phone,
+    '12345678901' => :phone,
+    '1-234-567-8901' => :phone,
+    '1.234.567.8901' => :phone,
+    '+1-234-567-8901' => :phone,
+    '1-(234) 5678901' => :phone,
+    'foo@bar.baz' => :email,
+    'foo.bar@baz.qux' => :email,
+    'FOO@bar.baz' => :email,
+    'foo @ bar . baz' => :email,
+    'foo at bar dot baz' => :email,
+    'foo AT bar DOT baz' => :email
+  }.each do |value, reason|
+    describe(value) do
+      it { should be_redacted(reason) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'redactor'

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: redactor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Petricola
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+description: 
+email:
+- tim.petricola@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/redactor.rb
+- lib/redactor/clear.rb
+- lib/redactor/dsl.rb
+- lib/redactor/extract.rb
+- lib/redactor/rule.rb
+- lib/redactor/version.rb
+- redactor.gemspec
+- spec/lib/clear_spec.rb
+- spec/lib/dsl_spec.rb
+- spec/lib/extract_spec.rb
+- spec/lib/redact_spec.rb
+- spec/lib/rule_spec.rb
+- spec/lib/rules_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/TimPetricola/redactor
+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.2.0
+signing_key: 
+specification_version: 4
+summary: Redact parts of text defined by custom rules (e.g. emails, phone numbers)
+test_files:
+- spec/lib/clear_spec.rb
+- spec/lib/dsl_spec.rb
+- spec/lib/extract_spec.rb
+- spec/lib/redact_spec.rb
+- spec/lib/rule_spec.rb
+- spec/lib/rules_spec.rb
+- spec/spec_helper.rb