errata_slip 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88a005e10ceb0c161901897acf2c1d0da547f256
+  data.tar.gz: 7b2de1b5b7f817bf3254fdfbbb441b07c09d2373
+SHA512:
+  metadata.gz: 83315ea4d175e6cde80706a5497ccc44d7c912bf3b87ea96560915b47c7254c3ed281b44bd291721c172c3717d84abae26d7267d096230f01a7e33960b0eb43d
+  data.tar.gz: 7c9492566a17aae7f3049e4e91e5281f7ee1f35e5d5ea099c6691ecbe3e4c93a180a2f0c53483970ee414370c04a298296b3d4792f8d1085d9373019a819af0b

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in errata_slip.gemspec
+gemspec
+
+group :test do
+  if ENV["CI"]
+    gem "coveralls", require: false
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Artem Fedorov
+
+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,244 @@
+# ErrataSlip [![Build Status](https://travis-ci.org/artemf/errata_slip.png?branch=master)](https://travis-ci.org/artemf/errata_slip) [![Coverage Status](https://coveralls.io/repos/artemf/errata_slip/badge.png)](https://coveralls.io/r/artemf/errata_slip)
+
+Apply corrections from yaml file to array of records. Useful in scraping/parsing when one needs to apply errata to the scraped data.
+
+#### Use case 1 - Easily apply fixes to scraped data
+
+**errata.yaml:**
+
+```YAML
+- city:  "LasVegas"
+  ~city:   "Las Vegas"
+- city:  "LosAngeles"
+  ~city:   "Los Angeles"
+```
+
+**apply_errata.rb:**
+
+```ruby
+records = [ { city: 'LasVegas', population: '596424' },
+            { city: 'LosAngeles', population: '3857799' } ]
+ErrataSlip::load_file('errata.yaml').correct!(records)
+p records
+=> [ { city: 'Las Vegas', population: '596424' },
+     { city: 'Los Angeles', population: '3857799' } ]
+```
+
+#### Use case 2 - Add additional metadata to your data
+
+**errata.yaml:**
+
+```YAML
+- city:    "Los Angeles"
+  country: "USA"
+  ~state:    "California"
+- city:    "Los Angeles"
+  country: "USA"
+  ~state:    "Nevada"
+```
+
+**apply_errata.rb:**
+
+```ruby
+records = [ { city: 'Las Vegas',   country: 'USA' },
+            { city: 'Los Angeles', country: 'USA' } ]
+ErrataSlip::load_file('errata.yaml').correct!(records)
+p records
+=> [ { city: 'Las Vegas',   country: 'USA', state: 'Nevada' },
+     { city: 'Los Angeles', country: 'USA', state: 'California' } ]
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'errata_slip'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install errata_slip
+
+## Usage
+
+You are expected to have array of hashes as an input and corrections are applied to it.
+
+#### Errata file
+
+You create ErrataSlip from yaml file with errata
+```ruby
+e = ErrataSlip::load_file('errata.yaml')
+```
+
+Errata file is array of hashes, which has 'match' fields and 'correct' fields. 'Match' fields are used
+to find the record to correct, 'correct' fields are used to apply changes to the record. 'Correct' fields
+are prefixed with tilde (~):
+
+```YAML
+- fieldname:  "Value of fieldname to find"
+  ~fieldname:   "Value of fieldname to replace"
+```
+
+For example, if your records have key 'name', errata file might look like this: 
+
+```YAML
+- name:  "Name to find"
+  ~name:   "Name to replace with"
+```
+
+'Correct' fields can introduce new fields to your records:
+
+```YAML
+- name:  "Name to find"
+  ~name:            "Name to replace with"
+  ~applied_errata:  true
+```
+
+#### Applying errata to all records
+
+You use correct! method to correct all records in-place
+
+```ruby
+scraped_records = [ { :name => 'Adam'}, { :name => 'Eve' } ]
+ErrataSlip::load_file('errata.yaml').correct!(scraped_records)
+```
+
+#### Applying errata to single record
+
+You use correct_item! method to correct one hash in-place
+
+```ruby
+scraped_records = [ { :name => 'Adam'}, { :name => 'Eve' } ]
+errata = ErrataSlip::load_file('errata.yaml')
+scraped_records.map { |record| errata.correct_item!(record) }
+```
+
+#### Works with both symbolic and string hash keys
+
+While errata file is written with string hash keys, correction works on both string-keyed hashed and symbol-keyed hashes.
+
+So it doesn't matter if you have 
+
+```ruby
+scraped_records = [ { :name => 'Adam'}, { :name => 'Eve' } ]
+```
+
+or
+
+```ruby
+scraped_records = [ { 'name' => 'Adam'}, { 'name' => 'Eve' } ]
+```
+
+ErrataSlip will autodetect format and apply errata correctly.
+
+## Examples
+
+#### Easily fix missplelings or inaccuracies in scraped data
+
+In this example we change all names from 'Adaam' to 'Adam'
+
+errata.yaml
+```YAML
+- name:  "Adaam"
+  ~name:   "Adam"
+```
+
+apply_errata.rb
+```ruby
+records = [
+             { name: 'Adaam' },
+             { name: 'Andrew' }
+          ]
+ErrataSlip::load_file('errata.yaml').correct!(records)
+p records
+=> [
+      { name: 'Adam' },
+      { name: 'Andrew' }
+   ]
+```
+
+#### You can match several fields and correct several fields at the same time
+
+We search for all records with name 'Hillary' and surname 'Clinton' and change them to 'Monika' and 'Lewinsky'
+respectively.
+
+errata.yaml
+```YAML
+- name:    "Hillary"
+  surname: "Clinton"
+  ~name:     "Monika"
+  ~surname:  "Lewinsky"
+```
+
+apply_errata.rb
+```ruby
+records = [
+             { name: 'Bill', surname: 'Clinton' },
+             { name: 'Hillary', surname: 'Clinton' }
+          ]
+ErrataSlip::load_file('errata.yaml').correct!(records)
+p records
+=> [
+      { name: 'Bill', surname: 'Clinton' },
+      { name: 'Monika', surname: 'Lewinsky' }
+   ]
+```
+
+#### 'Match' fields and 'correct' fields shouldn't be the same
+
+This example searches all records with name 'Adam' and changes surname to 'Smith' and book to 'The Wealth of Nations'.
+
+errata.yaml
+```YAML
+- name:    "Adam"
+  ~surname:  "Smith"
+  ~book:     "The Wealth of Nations"
+```
+
+apply_errata.rb
+```ruby
+records = [
+             { name: 'Adam', surname: 'Mansbach', book: 'Go the F**k to Sleep' }
+          ]
+ErrataSlip::load_file('errata.yaml').correct!(records)
+p records
+=> [
+      { name: 'Adam', surname: 'Smith', book: 'The Wealth of Nations' }
+   ]
+```
+
+#### We can not only change existing fields, but also add new ones
+
+The syntax is the same.
+
+errata.yaml
+```YAML
+- name:    "Adam"
+  surname: "Smith"
+  ~book:     "The Wealth of Nations"
+```
+
+apply_errata.rb
+```ruby
+records = [
+             { name: 'Adam', surname: 'Smith' },
+             { name: 'Adam', surname: 'Mansbach', book: 'Go the F**k to Sleep' }
+          ]
+ErrataSlip::load_file('errata.yaml').correct!(records)
+p records
+=> [
+      { name: 'Adam', surname: 'Smith', book: 'The Wealth of Nations'  },
+      { name: 'Adam', surname: 'Sandler', book: 'Go the F**k to Sleep' }
+   ]
+```
+
+## Compatibility
+
+ErrataSlip is tested against MRI 1.9.3, 2.0.0 and 2.1.0
+
+## Credits
+
+Artem Fedorov: artemf at mail dot ru

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/errata_slip.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'errata_slip/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "errata_slip"
+  spec.version       = ErrataSlip::VERSION
+  spec.authors       = ["Artem Fedorov"]
+  spec.email         = ["artemf@mail.ru"]
+  spec.summary       = %q{Apply corrections from yaml file to array of records}
+  spec.description   = %q{Apply corrections from yaml file to array of records. Useful in scraping/parsing when one needs to apply errata to the scraped data.}
+  spec.homepage      = "https://github.com/artemf/errata_slip"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.5"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+end

data/lib/errata_slip.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+require 'errata_slip/version'
+require 'yaml'
+
+class ErrataSlip
+
+  # @return [ErrataSlip]
+  def self.load_file(filename)
+    ErrataSlip.new(YAML::load_file(filename))
+  end
+
+  attr_reader :errata
+
+  def initialize(errata)
+    @errata = errata
+  end
+
+  # @param [Array] items -
+  def correct!(items)
+    items.each do |item|
+      correct_item!(item)
+    end
+  end
+
+  def correct_item!(item)
+    @errata.each do |errata|
+      hash_key_is_symbol = nil
+      item.each_key { |k| hash_key_is_symbol = k.is_a?(Symbol); break }
+      next unless item_matches_errata(item, errata, hash_key_is_symbol)
+      change_fields = errata.keys.select { |field| field[0] == '~' }
+      change_fields.map! { |field| field[1..-1]}
+      change_fields.each do |field|
+        hash_field = hash_key_is_symbol ? field.to_sym : field
+        item[hash_field] = errata["~#{field}"]
+      end
+    end
+    item
+  end
+
+  def item_matches_errata(hash, errata, hash_key_is_symbol = false)
+    find_fields = errata.keys.select { |field| field[0] != '~' }
+    find_fields.each do |key|
+      hash_key = hash_key_is_symbol ? key.to_sym : key
+      return false if hash[hash_key] != errata[key]
+    end
+    true
+  end
+end

data/lib/errata_slip/version.rb

@@ -0,0 +1,3 @@
+class ErrataSlip
+  VERSION = "1.0.0"
+end

data/spec/errata_slip/errata_slip_spec.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe ErrataSlip do
+
+  context '.correct_item!' do
+
+    tests =
+        [
+            {
+                it: 'should not correct when errata doesn' 't match',
+                errata: [{ 'name' => 'Adam', '~name' => 'Brian' }],
+                item: { 'name' => 'NoSuchName' },
+                expected: { 'name' => 'NoSuchName' }
+            },
+            {
+                it: 'should change fields',
+                errata: [{ 'name' => 'Adam', '~name' => 'Brian' }],
+                item: { 'name' => 'Adam' },
+                expected: { 'name' => 'Brian' }
+            },
+            {
+                it: 'should leave unmentioned fields intact',
+                errata: [{ 'name' => 'Adam', '~name' => 'Brian' }],
+                item: { 'name' => 'Adam', 'surname' => 'Other' },
+                expected: { 'name' => 'Brian', 'surname' => 'Other' }
+            },
+            {
+                it: 'should add new fields',
+                errata: [{ 'name' => 'Adam', '~country' => 'Honduras' }],
+                item: { 'name' => 'Adam' },
+                expected: { 'name' => 'Adam', 'country' => 'Honduras' }
+            },
+            {
+                it: 'should change (symbolic) fields',
+                errata: [{ 'name' => 'Adam', '~name' => 'Brian' }],
+                item: { :name => 'Adam' },
+                expected: { :name => 'Brian' }
+            },
+            {
+                it: 'should add new (symbolic) fields',
+                errata: [{ 'name' => 'Adam', '~country' => 'Honduras' }],
+                item: { :name => 'Adam' },
+                expected: { :name => 'Adam', :country => 'Honduras' }
+            },
+            {
+                it: 'should match multiple fields',
+                errata: [{ 'name' => 'Adam', 'surname' => 'Smith', '~name' => 'Brian' }],
+                item: { 'name' => 'Adam', 'surname' => 'Smith' },
+                expected: { 'name' => 'Brian', 'surname' => 'Smith' }
+            },
+            {
+                it: 'should not match partial multiple fields matches',
+                errata: [{ 'name' => 'Adam', 'surname' => 'Smith', '~name' => 'Brian' }],
+                item: { 'name' => 'Adam', 'surname' => 'Klien' },
+                expected: { 'name' => 'Adam', 'surname' => 'Klien' }
+            }
+
+    ]
+
+    tests.each do |test|
+      it test[:it] do
+        ErrataSlip.new(test[:errata]).correct_item!(test[:item])
+        test[:item].should eq test[:expected]
+      end
+    end
+
+    it 'should return the modified item too' do
+      errata = [ { 'name' => 'Adam', '~name' => 'Brian' } ]
+      item = { 'name' => 'Adam' }
+      expected = { 'name' => 'Brian' }
+      result = ErrataSlip.new(errata).correct_item!(item)
+      result.should eq expected
+      item.should eq expected
+      result.should eq item
+    end
+
+  end
+
+  context '.correct!' do
+    let(:errata) { [{ 'name' => 'Adam', '~name' => 'Brian' }, { 'name' => 'Arthur', '~name' => 'Bob' }] }
+    let(:input) { [{ 'name' => 'Adam' }, { 'name' => 'Arthur' }] }
+    let(:expected) { [{ 'name' => 'Brian' }, { 'name' => 'Bob' }] }
+
+    it 'should change fields' do
+      ErrataSlip.new(errata).correct!(input)
+      input.should eq expected
+    end
+
+    let(:input) { [{ 'name' => 'Adam' }, { 'name' => 'Arthur' }, { 'name' => 'Alex' }] }
+    let(:expected) { [{ 'name' => 'Brian' }, { 'name' => 'Bob' }, { 'name' => 'Alex' }] }
+
+    it 'should change fields, except when errata doesn' 't match' do
+      ErrataSlip.new(errata).correct!(input)
+      input.should eq expected
+    end
+
+    let(:errata) { [{ 'name' => 'Adam', '~country' => 'Honduras' }, { 'name' => 'Arthur', '~country' => 'Guatemala' }] }
+    let(:expected) { [{ 'name' => 'Adam', 'country' => 'Honduras' }, { 'name' => 'Arthur', 'country' => 'Guatemala' }, { 'name' => 'Alex' }] }
+
+    it 'should add new fields, except when errata doesn' 't match' do
+      ErrataSlip.new(errata).correct!(input)
+      input.should eq expected
+    end
+
+    let(:errata) { [{ 'name' => 'Adam', '~name' => 'Brian' }, { 'name' => 'Arthur', '~country' => 'Guatemala' }] }
+    let(:expected) { [{ 'name' => 'Brian' }, { 'name' => 'Arthur', 'country' => 'Guatemala' }, { 'name' => 'Alex' }] }
+
+    it 'should both change fields and add new fields' do
+      ErrataSlip.new(errata).correct!(input)
+      input.should eq expected
+    end
+
+  end
+
+  context '::load_file' do
+    it 'should load errata from file' do
+      expected_errata = [{ 'name' => 'Adam', '~name' => 'Brian' }, { 'name' => 'Arthur', '~name' => 'Bob' }]
+      slip = ErrataSlip::load_file(File.expand_path(File.join(File.dirname(__FILE__), '..', 'fixtures', 'errata.yaml')))
+      slip.errata.should eq expected_errata
+    end
+  end
+end

data/spec/fixtures/errata.yaml

@@ -0,0 +1,4 @@
+- name:  "Adam"
+  ~name:   "Brian"
+- name:  "Arthur"
+  ~name:   "Bob"

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+if ENV['CI']
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'rspec'
+
+require 'errata_slip'
+

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: errata_slip
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Artem Fedorov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Apply corrections from yaml file to array of records. Useful in scraping/parsing
+  when one needs to apply errata to the scraped data.
+email:
+- artemf@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- errata_slip.gemspec
+- lib/errata_slip.rb
+- lib/errata_slip/version.rb
+- spec/errata_slip/errata_slip_spec.rb
+- spec/fixtures/errata.yaml
+- spec/spec_helper.rb
+homepage: https://github.com/artemf/errata_slip
+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: Apply corrections from yaml file to array of records
+test_files:
+- spec/errata_slip/errata_slip_spec.rb
+- spec/fixtures/errata.yaml
+- spec/spec_helper.rb