perambulate 0.0.3

data/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+Please include RSpec tests for contributions.
+
+That's It?!
+===========
+
+Perambulate is only a baby project at the moment... As of this writing it doesn't even work yet.  So putting up more
+barriers to contribution would be like erecting a gate for a pile of scrap.

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    perambulate (0.0.3)
+      lexr (~> 0.3.1)
+      rake (~> 0.9.2.2)
+      whittle (~> 0.0.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.3)
+    factory_girl (4.1.0)
+      activesupport (>= 3.0.0)
+    i18n (0.6.1)
+    lexr (0.3.1)
+    minitest (3.3.0)
+    multi_json (1.3.7)
+    rake (0.9.2.2)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    whittle (0.0.8)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  factory_girl (~> 4.1.0)
+  minitest (~> 3.3.0)
+  perambulate!
+  rspec (~> 2.10.0)

data/README

@@ -0,0 +1,36 @@
+Perambulate is a library for parsing addresses in natural language.
+
+As Seen On TV(tm), Perambulate makes it easier for you to get customer addresses in a normal, conversational form.
+No more thousands of input boxes, drop-downs and annoying conversational logic.  Simply ask for their address
+and run it through Perambulate.
+
+Limitations
+===========
+Currently, this tool does nothing.  It's still in very early stages and doesn't even have a concrete architecture yet.
+
+You *CAN* expect constant breaking changes on Master.
+
+The first iteration will not handle countries:  To make things simpler, you need to know what country address grammar you're
+attempting to parse before parsing it.
+
+The first iteration is being done on Australian style addresses because that's what I'm familiar with.  Sorry, Matz.
+
+Goals
+=====
+
+I want Perambulate to be an address management toolkit for developers.  Desired features are:
+
+* Chunk any given address
+* Offer a likilhood of any string being a specific set of address units
+* Validate that any chunk is a member of a valid set (ie restrict 'suburb' to a defined set)
+* Have a variety of address parsers to suit specific combinations of
+
+Architecture
+============
+
+This section was last updated for version: 0.0.1
+If this is not the latest version of the gem, this document is out of date.  You're most welcome to correct everything below
+this paragraph but please don't change the version without checking that the following is true.  I don't want to lie to
+other developers ;)
+
+Perambulate is the library module where all user interaction functions live, including configuration.

data/lib/perambulate/address/address.rb

@@ -0,0 +1,15 @@
+module Perambulate
+  class Address
+    attr_accessor :street_number, :street_name, :suburb, :designation, :postcode, :state
+
+    def initialize(options = {})
+      @street_number = options[:street_number]
+      @street_name = options[:street_name]
+      @designation = options[:designation]
+      @suburb = options[:suburb]
+      @postcode = options[:postcode]
+      @state = options[:state]
+    end
+
+  end
+end

data/lib/perambulate/designations.rb

@@ -0,0 +1,6 @@
+module Perambulate
+  class Designations
+    AVENUE = :avenue
+
+  end
+end

data/lib/perambulate/lexer/aussie_lexer.rb

@@ -0,0 +1,12 @@
+require "lexr"
+
+module Perambulate
+  AussieLexer = Lexr.that {
+    ignores /\s+/ => :whitespace
+
+    matches /\d+/ => :number
+    matches /Road|road|rd|Rd|RD/ => :designation
+    matches /[,\/-]/ => :separator
+    matches /[a-zA-Z]+/ => :place_word
+  }
+end

data/lib/perambulate/parser/parser.rb

@@ -0,0 +1,62 @@
+require "whittle"
+
+module Perambulate
+  class Parser < Whittle::Parser
+
+    # Terminal Symbols -- ORDER MATTERS
+    rule(:wsp => /\s+/).skip!
+    rule(:number => /\d+/)
+    rule(:unit_symbol => /Unit|Num|Number|No/i)
+    rule(:unit_separator => /\/|-|,/)
+    rule(:street_separator => /,/)
+    rule(:designation => /Street/)
+
+    rule(:word => /[a-zA-Z]+/)
+
+    rule(:unit_prefix) do |r|
+      r[]
+      r[:unit_symbol]
+
+    end
+
+    rule(:unit_number) do |r|
+      r[:unit_prefix, :number, :unit_separator].as {|_, b, _| b}
+      r[:number, :unit_separator].as {|a, _| a}
+    end
+
+    rule(:street_number_block) do |r|
+      r[:unit_number, :number].as {|a,b| {:unit_number => a, :street_number => b}}
+      r[:number].as {|a| {:street_number => a}}
+    end
+
+    rule(:name) do |r|
+      r[:name, :word].as {|a,b| "#{a} #{b}"}
+      r[:word]
+    end
+
+    rule(:street_specification) do |r|
+      r[:name, :designation].as {|a,b| {:street_name => a, :designation => b}}
+    end
+
+    rule(:street_block) do |r|
+      r[:street_number_block, :street_specification].as {|a,b| a.merge(b)}
+      r[:street_specification]
+    end
+
+    rule(:addr) do |r|
+      r[:street_block, :optional_suburb_separator, :name].as {|a,_,b| a.merge({:suburb => b})}
+      r[:street_block, :name].as {|a,b| a.merge({:suburb => b})}
+      r[:street_block]
+      r[:name].as {|a| {:suburb => a}}
+    end
+
+    rule(:optional_suburb_separator) do |r|
+      r[:street_separator]
+      r[:unit_separator]
+
+
+    end
+
+    start(:addr)
+  end
+end

data/lib/perambulate/version.rb

@@ -0,0 +1,3 @@
+module Perambulate
+  VERSION = "0.0.3"
+end

data/lib/perambulate.rb

@@ -0,0 +1,25 @@
+# Require ALL THE THINGS
+require "perambulate/address/address"
+require "perambulate/lexer/aussie_lexer"
+require "perambulate/parser/parser"
+require "perambulate/designations"
+
+
+  module Perambulate
+
+    @@configuration = {:default_parser => "Australian"}
+
+    def self.config
+      return @@configuration
+    end
+
+    def self.configure(&block)
+      yield @@configuration
+    end
+
+    def self.create_address(address_string)
+      lexemes = AussieLexer.new(address_string)
+
+    end
+  end
+

data/perambulate.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "perambulate/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = 'perambulate'
+  spec.version     = Perambulate::VERSION
+  spec.date        = '2012-11-28'
+  spec.summary     = "Take addresses as a string.  Get back useful details."
+  spec.description = "Perambulate is an address parsing library for natural language addresses.  It provides a broken-down
+                      version of a passed address, allowing you to get one input value and do useful things on the chunks."
+  spec.authors     = ["Dylan Lacey"]
+  spec.email       = 'perambulate@dylanlacey.com'
+  spec.files       = `git ls-files`.split("\n")
+  spec.homepage    = "http://www.github.com/dylanlacey/Perambulate"
+
+
+  spec.add_runtime_dependency "lexr", '~> 0.3.1'
+  spec.add_runtime_dependency "rake", '~> 0.9.2.2'
+  spec.add_runtime_dependency "whittle", '~> 0.0.8'
+
+  spec.add_development_dependency "minitest", '~> 3.3.0'
+  spec.add_development_dependency "rspec", '~> 2.10.0'
+  spec.add_development_dependency "factory_girl", '~> 4.1.0'
+
+end

data/test/factories/address_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :address, :class => Perambulate::Address do
+
+  end
+end

data/test/spec/address_integration_spec.rb

@@ -0,0 +1,36 @@
+require "rspec"
+require "lib/perambulate"
+require "factory_girl"
+
+FactoryGirl.find_definitions
+
+describe "Address Parsing Interface" do
+
+  describe "Given Australian addresses" do
+    it "Should deal with a compact Australia address" do
+      test_address = "75 Boston Avenue, Coorparoo QLD"
+
+      expected = FactoryGirl.build(:address, :street_number => "75",
+                             :street_name => "Boston",
+                             :designation => Perambulate::Designations::AVENUE,
+                             :suburb => "Coorparoo",
+                             :state => "Queensland"
+      )
+    end
+
+    it "Should deal with an expanded Australian address" do
+      test_address = "75 Boston Avenue, Coorparoo Queensland"
+    end
+
+    it "Should deal with a unit number compact Australiam address" do
+      test_address = "Unit 1, 75 Boston Avenue, Coorparoo QLD"
+    end
+
+    it "Should deal with a post code" do
+      test_address = "73 Boston Avenue, Coorparoo QLD 4234"
+
+    end
+
+  end
+
+end

data/test/spec/address_model_spec.rb

@@ -0,0 +1,37 @@
+require "rspec"
+require "lib/perambulate"
+
+describe "A new address" do
+  describe "Passed an options hash" do
+    let(:address) {Perambulate::Address.new(  :street_number => "75",
+                                              :street_name=>"Boston",
+                                              :designation => Perambulate::Designations::AVENUE,
+                                              :suburb => "Coorparoo",
+                                              :postcode => "4104",
+                                              :state => "QLD"
+    )}
+
+    it "should have instantiated with its values set" do
+      address.street_number.should == "75"
+      address.street_name.should == "Boston"
+      address.designation.should == Perambulate::Designations::AVENUE
+      address.suburb.should == "Coorparoo"
+      address.postcode.should == "4104"
+      address.state.should == "QLD"
+    end
+
+  end
+
+  describe "Not passed an options hash" do
+    let (:address) {Perambulate::Address.new()}
+
+    it "should have nils for all options" do
+      address.street_number.should be_nil
+      address.street_name.should be_nil
+      address.designation.should be_nil
+      address.suburb.should be_nil
+      address.postcode.should be_nil
+      address.state.should be_nil
+    end
+  end
+end

data/test/spec/aussie_lexer_spec.rb

@@ -0,0 +1,76 @@
+require "test/spec/spec_helper"
+
+describe "AussieLexer" do
+
+  context "Single Words" do
+
+    it "should return separator" do
+      parsed = Perambulate::AussieLexer.new(",").next
+
+      parsed.type.should eql :separator
+      parsed.value.should eql ","
+    end
+
+    it "should return separator" do
+      parsed = Perambulate::AussieLexer.new("-").next
+
+      parsed.type.should eql :separator
+      parsed.value.should eql "-"
+    end
+
+    it "should return separator" do
+      parsed = Perambulate::AussieLexer.new("/").next
+
+      parsed.type.should eql :separator
+      parsed.value.should eql "/"
+    end
+  end
+
+  context "Normal Street Address" do
+    let(:lexer) {Perambulate::AussieLexer.new("775 London Road Chandler")}
+
+    it "should return four components" do
+      number = lexer.next
+      number.type.should eql :number
+      number.value.should eql "775"
+
+      street = lexer.next
+      street.type.should eql :place_word
+      street.value.should eql "London"
+
+      designation = lexer.next
+      designation.type.should eql :designation
+      designation.value.should eql "Road"
+
+      suburb = lexer.next
+      suburb.type.should eql :place_word
+      suburb.value.should eql "Chandler"
+    end
+  end
+
+  context "Separated Street Address" do
+    let (:lexer) {Perambulate::AussieLexer.new("775 London Road, Chandler")}
+
+    it "should return all components" do
+      expected_results = [
+          [:number, "775"],
+          [:place_word, "London"],
+          [:designation, "Road"],
+          [:separator, ","],
+          [:place_word, "Chandler"]
+      ]
+      expected_iterator = expected_results.each
+      actual = lexer.next
+
+      until lexer.end?
+        result = expected_iterator.next
+
+        puts "Actual: #{actual} expected #{result}"
+        actual.type.should eql result[0]
+        actual.value.should eql result[1]
+
+        actual = lexer.next
+      end
+    end
+  end
+end

data/test/spec/parser_spec.rb

@@ -0,0 +1,92 @@
+require "test/spec/spec_helper"
+
+describe "Parser" do
+  context "When short-circuited with single terminals" do
+    let(:parser){Perambulate::Parser.new()}
+    it "should return a digit for street number" do
+      parser.parse("48", :rule => :street_number_block).should eql({:street_number => "48"})
+
+    end
+
+    it "should return street for Zigzag" do
+      parser.parse("Zigzag", :rule => :name).should eql "Zigzag"
+    end
+
+    it "should not return anything" do
+      parser.parse("48a", :rule => :street_number_block).should raise_exception (Whittle::ParseError)
+    end
+
+    it "should correctly parse a designation" do
+      parser.parse("Street", :rule => :designation).should eql "Street"
+    end
+  end
+
+  context "When short-circuited with street names" do
+    let(:parser){Perambulate::Parser.new()}
+
+    it "should return a hash with the name and number" do
+      parser.parse("48 Zigzag Street", :rule=>:street_block).should eql({:street_number => "48", :street_name => "Zigzag", :designation => "Street"})
+    end
+  end
+
+  context "When given unit numbers" do
+    let(:parser){Perambulate::Parser.new()}
+
+    it "should return a unit and street number for slashes" do
+      parser.parse("1/65", :rule => :street_number_block).should eql({:unit_number => "1", :street_number => "65"})
+    end
+
+    it "should return a unit and street number for dashes" do
+      parser.parse("1-65", :rule => :street_number_block).should eql({:unit_number => "1", :street_number => "65"})
+    end
+
+    it "should return a unit and street number for commas" do
+      parser.parse("1,65", :rule => :street_number_block).should eql({:unit_number => "1", :street_number => "65"})
+    end
+
+    it "should return a unit and street number when surrounded by spaces" do
+      parser.parse("1 / 65", :rule => :street_number_block).should eql({:unit_number => "1", :street_number => "65"})
+    end
+
+    it "should return a unit and street number when preceeded by unit" do
+      parser.parse("Unit 5 / 65", :rule => :street_number_block).should eql({:unit_number => "5", :street_number => "65"})
+    end
+
+  end
+  context "Parsing completely" do
+    let(:parser){Perambulate::Parser.new()}
+
+    it "should return a hash with just street details" do
+      parser.parse("Zigzag Street").should eql({:street_name => "Zigzag", :designation => "Street"})
+    end
+
+    its "should return a hash with just number, street details" do
+      parser.parse("48 Zigzag Street").should eql({:street_number => "48", :street_name => "Zigzag", :designation => "Street"})
+    end
+
+    it "should return a hash with just a suburb" do
+      parser.parse("Red Hill").should eql({:suburb => "Red Hill"})
+    end
+
+    it "should return a hash with street name and suburb" do
+      parser.parse("Zigzag Street, Red Hill").should eql({:street_name => "Zigzag", :designation => "Street", :suburb => "Red Hill"})
+    end
+
+    it "should return a hash with street name and suburb without a comma" do
+      parser.parse("Zigzag Street Red Hill").should eql({:street_name => "Zigzag", :designation => "Street", :suburb => "Red Hill"})
+    end
+
+    it "should return a hash with everything" do
+      parser.parse("48 Zigzag Street, Red Hill").should eql({:street_number => "48", :street_name => "Zigzag", :designation => "Street", :suburb=>"Red Hill"})
+    end
+
+    it "should return a unit number for a street address" do
+      parser.parse("1/48 Zigzag Street, Red Hill").should eql({:unit_number => "1", :street_number=>"48", :street_name => "Zigzag", :designation=>"Street", :suburb=>"Red Hill"})
+    end
+
+    it "should return a unit number for a street address starting with unit" do
+      parser.parse("Unit 1/48 Zigzag Street, Red Hill").should eql({:unit_number => "1", :street_number=>"48", :street_name => "Zigzag", :designation=>"Street", :suburb=>"Red Hill"})
+    end
+
+  end
+end

data/test/spec/perambulate_spec.rb

@@ -0,0 +1,47 @@
+require "test/spec/spec_helper"
+
+describe "Perambulate" do
+  describe "As newly included" do
+    it "should have 'Australian' as the default parsing strategy" do
+      Perambulate.config[:default_parser].should eq "Australian"
+    end
+  end
+
+  it "should have a Config hash" do
+    Perambulate.config.class.to_s.should == "Hash"
+  end
+
+  it "should take a Config block" do
+    lambda {
+      Perambulate.configure do |config|
+
+      end
+    }.should_not raise_error
+  end
+
+  describe "with a custom configuration" do
+    before(:each) do
+      Perambulate.configure do |config|
+        config[:default_parser] = "Finnish"
+      end
+    end
+
+    it "should persist configuration values" do
+      Perambulate.config[:default_parser].should eq "Finnish"
+    end
+  end
+
+  describe ".create_address" do
+
+    context "Given a standard Australian Address with no postcode" do
+      let(:address) {Perambulate.create_address("75 London Road, Chandler")}
+
+      it "parses a street name, designation and suburb" do
+        address.street_name.should eql "London"
+        address.street_number.should eql "75"
+        address.designation.should eql "Road"
+        address.suburb.should eql "Chandler"
+      end
+    end
+  end
+end

data/test/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "rspec"
+require "lib/perambulate"

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "../", "lib")
+
+require "perambulate"

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: perambulate
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Dylan Lacey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lexr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: whittle
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: ! "Perambulate is an address parsing library for natural language addresses.
+  \ It provides a broken-down\n                      version of a passed address,
+  allowing you to get one input value and do useful things on the chunks."
+email: perambulate@dylanlacey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CONTRIBUTING.md
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- lib/perambulate.rb
+- lib/perambulate/address/address.rb
+- lib/perambulate/designations.rb
+- lib/perambulate/lexer/aussie_lexer.rb
+- lib/perambulate/parser/parser.rb
+- lib/perambulate/version.rb
+- perambulate.gemspec
+- test/factories/address_factory.rb
+- test/spec/address_integration_spec.rb
+- test/spec/address_model_spec.rb
+- test/spec/aussie_lexer_spec.rb
+- test/spec/parser_spec.rb
+- test/spec/perambulate_spec.rb
+- test/spec/spec_helper.rb
+- test/test_helper.rb
+homepage: http://www.github.com/dylanlacey/Perambulate
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Take addresses as a string.  Get back useful details.
+test_files: []