parsenum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e18dfce9821ee32e9b72667ae07e74ff38bb9888
+  data.tar.gz: 72803f8588db14512b8fcd3301d61422ee04eba3
+SHA512:
+  metadata.gz: e515e020483084c73a3b6ea3e621799c45ae07bf8b3470cc8dc6add2a01b0a45cc6154d3e79f2605996e7408a01a7395c5cf96c58203df3482602ec727ae100b
+  data.tar.gz: 8eb175187fe66fe2f63f5c5fc11b5a627a2194397e9e643063aeed523cccff79e7dafc87faccba9b346007f91a7641e4a69baf79868f2d0ff464e0aae2cb7a2a

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andy Kent
+
+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,45 @@
+Parsenum
+========
+
+Because sometimes you just want to get numbers out of strings damnit.
+
+This acutally happens a surprising amount. Usually when reading a CSV or scraping a webpage you want extract a number out of a test string. Sure in the simple case .to_i and .to_f work fine but often there's pesky things like commas or pond signs getting in the way.
+
+This library is pretty dumb as parsers go but it's just an attempt to hide all the string ugliness so you can get to the numbers you need.
+
+
+Simple examples
+---------------
+
+    "123".number                => 123
+    "1.23".number               => 1.23
+    "£3.99".number              => 3.99
+    "28.5%".number              => 0.285
+    "$1.99".number              => 1.99
+    "got 99 problems".number    => 99
+    "8 out of 10 cats".numbers  => [8, 10]
+
+
+Advenaced Examples
+------------------
+
+  number = Parsenum.parse("$3.99")
+  number.value      => 3.99
+  number.currency?  => true
+  number.currency   => 'USD'
+
+  number = Parsenum.parse("68%")
+  number.value        => 0.68
+  number.percentage?  => true
+
+  numbers = Parsenum.parse_all("8 out of 10 cats")
+  numbers.size               => 2
+  numbers.first.value        => 8
+  numbers.first.integer?     => true
+
+
+TODO
+----
+
+- support for more currencies
+- bigdecimel support

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/**/*_spec.rb']
+end

data/lib/parsenum.rb

@@ -0,0 +1,36 @@
+require "parsenum/version"
+
+module Parsenum
+  INTEGER     = 'integer'
+  NIL         = 'nil'
+  FLOAT       = 'float'
+  PERCENTAGE  = 'percentage'
+  CURRENCY    = 'currency'
+
+  def parse(str)
+    candidate = Parsenum::Scanner.new(str).candidates.first
+    Parsenum::Parser.new(candidate)
+  end
+  module_function :parse
+
+  def parse_all(str)
+    Parsenum::Scanner.new(str).candidates.map do |candidate|
+      Parsenum::Parser.new(candidate)
+    end
+  end
+  module_function :parse_all
+
+  def value(str)
+    parse(str).value
+  end
+  module_function :value
+
+  def values(str)
+    parse_all(str).map(&:value)
+  end
+  module_function :values
+end
+
+require "parsenum/scanner"
+require "parsenum/parser"
+require "parsenum/core_ext"

data/lib/parsenum/core_ext.rb

@@ -0,0 +1,9 @@
+class String
+  def number
+    Parsenum.parse(self).value
+  end
+
+  def numbers
+    Parsenum.parse_all(self).map(&:value)
+  end
+end

data/lib/parsenum/parser.rb

@@ -0,0 +1,86 @@
+class Parsenum::Parser
+  attr_reader :source, :value, :type
+
+  def initialize(source, type=nil)
+    @source = source
+    @value = nil
+    @type = nil
+    run
+  end
+
+  def currency
+    return nil unless type == Parsenum::CURRENCY
+    return 'GBP' if @source =~ /£/
+    return 'USD' if @source =~ /\$/
+    "other"
+  end
+
+  def nil?
+    @type == Parsenum::NIL
+  end
+
+  def percentage?
+    @type == Parsenum::PERCENTAGE
+  end
+
+  def currency?
+    @type == Parsenum::CURRENCY
+  end
+
+  def float?
+    @type == Parsenum::FLOAT
+  end
+
+  def integer?
+    @type == Parsenum::INTEGER
+  end
+
+  private
+
+  def run
+    @type ||= estimate_type(@source)
+    @value = extract(@source, @type)
+  end
+
+  def estimate_type(str)
+    return Parsenum::NIL        if str.nil?
+    return Parsenum::PERCENTAGE if str =~ /%/
+    return Parsenum::CURRENCY   if str =~ /\$|£/
+    return Parsenum::FLOAT      if str =~ /\d\.\d/
+    return Parsenum::INTEGER    if str =~ /\d/
+    Parsenum::NIL
+  end
+
+  def extract(str, t=nil)
+    t ||= estimate_type(str)
+    self.send(:"extract_#{t}", str)
+  end
+
+  def extract_nil(str)
+    nil
+  end
+
+  def extract_integer(str)
+    strip_commas(str).to_i
+  end
+
+  def extract_float(str)
+    strip_commas(str).to_f
+  end
+
+  def extract_percentage(str)
+    str = str.sub('%', '')
+    extract_float(str) / 100.0
+  end
+
+  def extract_currency(str)
+    matches = str.match(/(\$|£)([\d\,\.]+)/)
+    return 0 unless matches
+    extract(matches[2])
+  end
+
+
+  def strip_commas(str)
+    str.gsub(',', '')
+  end
+end

data/lib/parsenum/scanner.rb

@@ -0,0 +1,10 @@
+class Parsenum::Scanner
+  def initialize(str)
+    @source = str
+  end
+
+  def candidates
+    return [] if @source.nil?
+    @source.scan(/[\£\$\d\.\,\%]+/)
+  end
+end

data/parsenum.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "parsenum"
+  spec.version       = '0.1.0'
+  spec.authors       = ["Andy Kent"]
+  spec.email         = ["andy.kent@me.com"]
+  spec.summary       = %q{Simple parsing of numeric values from strings}
+  spec.homepage      = "https://github.com/andykent/parsenum"
+  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.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/spec/parsenum_spec.rb

@@ -0,0 +1,126 @@
+require_relative './spec_helper'
+
+describe "Non-number Parsing" do
+  it "doesn't blow up on nil values" do
+    result = Parsenum.parse(nil)
+    assert_equal Parsenum::NIL, result.type
+    assert_equal nil, result.value
+  end
+
+  it "doesn't blow up on empty strings" do
+    result = Parsenum.parse('')
+    assert_equal Parsenum::NIL, result.type
+    assert_equal nil, result.value
+  end
+
+  it "doesn't blow up on strings with no numbers present" do
+    result = Parsenum.parse('hello world')
+    assert_equal Parsenum::NIL, result.type
+    assert_equal nil, result.value
+  end
+end
+
+describe "Integer Parsing" do
+  it "parses basic integers" do
+    result = Parsenum.parse('123')
+    assert_equal Parsenum::INTEGER, result.type
+    assert_equal 123, result.value
+  end
+
+  it "parses integers with comma delimiters" do
+    result = Parsenum.parse('123,456')
+    assert_equal Parsenum::INTEGER, result.type
+    assert_equal 123_456, result.value
+  end
+
+  it "parses integers out of text strings" do
+    result = Parsenum.parse('got 99 problems')
+    assert_equal Parsenum::INTEGER, result.type
+    assert_equal 99, result.value
+  end
+
+    it "parses the first integer out of text" do
+    result = Parsenum.parse('8 out of 10 cats')
+    assert_equal Parsenum::INTEGER, result.type
+    assert_equal 8, result.value
+  end
+end
+
+describe "Float Parsing" do
+  it "parses basic floats" do
+    result = Parsenum.parse('1.23')
+    assert_equal Parsenum::FLOAT, result.type
+    assert_equal 1.23, result.value
+  end
+
+  it "parses floats with comma delimiters" do
+    result = Parsenum.parse('123,456.7')
+    assert_equal Parsenum::FLOAT, result.type
+    assert_equal 123_456.7, result.value
+  end
+end
+
+describe "Percentage Parsing" do
+  it "parses basic percentages" do
+    result = Parsenum.parse('12%')
+    assert_equal Parsenum::PERCENTAGE, result.type
+    assert_in_epsilon 0.12, result.value, 0.001
+  end
+
+  it "parses percentages with decimal places" do
+    result = Parsenum.parse('12.3%')
+    assert_equal Parsenum::PERCENTAGE, result.type
+    assert_in_epsilon 0.123, result.value, 0.0001
+  end
+end
+
+describe "Currency Parsing" do
+  it "parses £" do
+    result = Parsenum.parse('£123')
+    assert_equal Parsenum::CURRENCY, result.type
+    assert_equal 'GBP', result.currency
+    assert_equal 123, result.value
+  end
+
+  it "parses £ with pence" do
+    result = Parsenum.parse('£12.34')
+    assert_equal Parsenum::CURRENCY, result.type
+    assert_equal 'GBP', result.currency
+    assert_in_epsilon 12.34, result.value, 0.001
+  end
+end
+
+describe "Currency Parsing" do
+  it "parses $" do
+    result = Parsenum.parse('$123')
+    assert_equal Parsenum::CURRENCY, result.type
+    assert_equal 'USD', result.currency
+    assert_equal 123, result.value
+  end
+
+  it "parses $ with cents" do
+    result = Parsenum.parse('$12.34')
+    assert_equal Parsenum::CURRENCY, result.type
+    assert_equal 'USD', result.currency
+    assert_in_epsilon 12.34, result.value, 0.001
+  end
+end
+
+describe "parse_all" do
+  it "parses multiple numbers" do
+    result = Parsenum.parse_all('8 out of 10 cats')
+    assert_equal result.size, 2
+    assert_equal result[0].value, 8
+    assert_equal result[1].value, 10
+  end
+end
+
+describe "String extensions" do
+  it "adds a 'number' method" do
+    assert_equal 8, "8 out of 10 cats".number
+  end
+
+  it "adds a 'numbers' method" do
+    assert_equal [8, 10], "8 out of 10 cats".numbers
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/autorun'
+
+require_relative "../lib/parsenum"

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: parsenum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy Kent
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: 
+email:
+- andy.kent@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/parsenum.rb
+- lib/parsenum/core_ext.rb
+- lib/parsenum/parser.rb
+- lib/parsenum/scanner.rb
+- lib/parsenum/version.rb
+- parsenum.gemspec
+- spec/parsenum_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/andykent/parsenum
+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.2
+signing_key: 
+specification_version: 4
+summary: Simple parsing of numeric values from strings
+test_files:
+- spec/parsenum_spec.rb
+- spec/spec_helper.rb