itinerary 0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjBmNTg1NjNhMTkzNDVmODJhZDBmYTJmODI0YzNmN2E1ZmI2ODdmYg==
+  data.tar.gz: !binary |-
+    M2EwMTEzMzUwNTk0NWJlOTQ3OTI5NDRhZGNlYzhmOWFkZDExMWUzZg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YmI4OTFmYWI0MzYwMDE0NTg0MjEyMWEyZTk1M2EzODlkNjY3YmQ5MzZlMzlj
+    MDA4Y2U2ZDJlNWU0Yjc5NDk3NTUzMDE3N2YzMWY1ZWFjZjliN2EyYjJkMDk4
+    Nzg2MTI0YWQyYWUzODM2NmFjZWY3MmFlNzZjYTYyMGE0MmEzZmY=
+  data.tar.gz: !binary |-
+    MDQ2MTM2ZTU3NjEwMDNiOTUyMmU2NWM4YmJlMDhlNDRkMDE0MDhjMGE1MTNi
+    MzAyYjBkYjcxZWI5MjkwN2ViYTEwZjkzNWZkZTBlZDFjNmY5ODFjZjNlNTE4
+    NTA1YmVmZTRhN2QzZGUyMjJhNjMyNzJmYmRlMTRhNTZmNGM1NjY=

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 John Labovitz
+
+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,29 @@
+# Itinerary
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'itinerary'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install itinerary
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/TODO.md

@@ -0,0 +1,32 @@
+  - implement coordinate fuzzing
+
+  - read all records at Itinerary instantiation
+    - cache (using Marshal)
+    - rebuild cache if new/deleted files, or files have changed
+
+  - expand routing
+    - multiple routes
+    - travel mode for each leg
+    - date for each node
+
+  - move briar cache to ~?
+
+  - add contact metadata?
+    - date/method/description
+
+  - add status/flags
+    - contacted, to-visit, visited
+
+  - make interactive web app
+    - query:
+      - by flags
+      - by location
+      - by name
+
+  - show private view of map/info, in addition to public view
+
+  - colorize placemark icons by status
+
+  - cluster placemarks by region to avoid clutter
+      http://www.google.ca/earth/outreach/tutorials/region.html
+      https://developers.google.com/kml/documentation/regions

data/bin/itinerary

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'itinerary'
+
+require 'itinerary/tool'
+
+require 'itinerary/tools/convert'
+require 'itinerary/tools/create'
+require 'itinerary/tools/find-dups'
+require 'itinerary/tools/import'
+require 'itinerary/tools/list'
+require 'itinerary/tools/scrape-briar'
+
+root = nil
+
+while ARGV.first =~ /^-(\w+)/
+  ARGV.shift
+  case $1
+  when 'd'
+    root = ARGV.shift
+  else
+    raise "Unknown flag: #{ARGV.inspect}"
+  end
+end
+
+raise "Must specify root" unless root
+
+itinerary = Itinerary.new(:root => root)
+cmd = ARGV.shift or raise "Command not specified"
+tool = itinerary.make_tool(cmd, ARGV) or raise "Unknown command: #{cmd.inspect}"
+tool.run
+
+at_exit do
+  itinerary.cleanup
+end

data/itinerary.gemspec

@@ -0,0 +1,33 @@
+#encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'itinerary/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'itinerary'
+  gem.version       = Itinerary::VERSION
+  gem.authors       = 'John Labovitz'
+  gem.email         = 'johnl@johnlabovitz.com'
+  gem.summary       = %q{Keep track of travel itineraries}
+  gem.description   = %q{A Ruby gem to keep track of travel itineraries.}
+  gem.homepage      = 'https://github.com/jslabovitz/itinerary.git'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake'
+
+  gem.add_runtime_dependency 'builder'
+  gem.add_runtime_dependency 'daybreak', '0.2.4'
+  gem.add_runtime_dependency 'faraday'
+  gem.add_runtime_dependency 'faraday_middleware'
+  gem.add_runtime_dependency 'geocoder'
+  gem.add_runtime_dependency 'hashstruct'
+  gem.add_runtime_dependency 'haversine'
+  gem.add_runtime_dependency 'nokogiri'
+  gem.add_runtime_dependency 'rack-cache'
+end

data/lib/itinerary.rb

@@ -0,0 +1,180 @@
+require 'pp'
+require 'pathname'
+
+require 'geocoder'
+require 'hashstruct'
+require 'haversine'
+require 'builder'
+require 'daybreak'
+
+require 'itinerary/version'
+require 'itinerary/record'
+require 'itinerary/view'
+require 'itinerary/views/html'
+require 'itinerary/views/kml'
+require 'itinerary/views/tab'
+require 'itinerary/views/text'
+# require 'itinerary/briar_scraper'
+
+class Itinerary
+
+  DefaultRadius = 100
+
+  attr_accessor :name
+  attr_accessor :root
+  attr_accessor :route
+
+  def initialize(options={})
+    @name = options[:name]
+    @root = options[:root] or raise "Must specify root"
+    @root = Pathname.new(@root).expand_path
+    @geocoding_cache_path = options[:geocoding_cache] || '.geocoding-cache'
+    setup_geocoding_cache
+    @entries = []
+    read_entries
+    read_routes
+  end
+
+  def cleanup
+    @geocoding_cache.close
+  end
+
+  def entries_path
+    @root + 'entries'
+  end
+
+  def route_path
+    @root + 'route'
+  end
+
+  def read_entries
+    ;;warn "[initialize] reading entries from #{entries_path}"
+    entries_path.find do |path|
+      import_entry(path) if path.file? && path.basename.to_s[0] != '.'
+    end
+    sort_entries
+    ;;warn "[initialize] read #{@entries.length} entries"
+  end
+
+  def sort_entries
+    @entries.sort_by! { |r| r.visited || r.contacted || DateTime.now }
+  end
+
+  def import_entry(path)
+    @entries << Record.load(path)
+  end
+
+  def read_routes
+    ;;warn "[initialize] reading route from #{route_path}"
+    if route_path.exist?
+      @route = route_path.readlines.map { |p| geocode_search(p) }
+    end
+    ;;warn "[initialize] read #{@route.length} legs of route"
+  end
+
+  def setup_geocoding_cache
+    @geocoding_cache = Daybreak::DB.new(@geocoding_cache_path)
+    @geocoding_cache.compact
+    Geocoder.configure(:cache => @geocoding_cache)
+  end
+
+  def geocode_search(place)
+    begin
+      results = Geocoder.search(place)
+      @geocoding_cache.flush
+      result = results.first or raise "No geocoding result for place #{place.inspect}"
+      HashStruct.new(
+        :city => result.city,
+        :state => result.state_code,
+        :country => result.country_code,
+        :latitude => result.coordinates[0],
+        :longitude => result.coordinates[1])
+    rescue => e
+      warn "Error when geocoding place #{place.inspect}: #{e}"
+      nil
+    end
+  end
+
+  def make_tool(cmd, args)
+    if (klass = Tool.find_tool(cmd))
+      klass.new(self, args)
+    end
+  end
+
+  def entries(filters=nil)
+    matched = @entries.dup
+    ;;warn "[entries] filtering #{matched.length} entries: #{filters.inspect}"
+    if filters
+      filters.each do |key, value|
+        case key
+        when :near
+          coordinates = case value
+          when Array
+            value
+          when Pathname
+            rec = self[value] or raise "Record #{value.inspect} not found"
+            raise "#{rec.path} is not geocoded" unless rec.geocoded?
+            rec.coordinates
+          when String
+            results = Geocoder.search(value)
+            result = results.first or raise "Can't find location #{value.inspect}"
+            result.coordinates
+          end
+          raise "No coordinates found for #{value.inspect}" unless coordinates
+          matched.select! { |r| r.near(coordinates, filters[:radius] || DefaultRadius) }
+        when :radius
+          # ignored here -- used above
+        when :flags
+          matched.select! do |rec|
+            value.find { |v| rec.method("#{v}?").call }
+          end
+        else
+          raise "Unknown field: #{key.inspect}" unless Record.field(key) || Record.instance_methods.include?(key)
+          matched.select! { |r| r[key] == value }
+        end
+      end
+    end
+    ;;warn "[entries] filtered #{matched.length} entries: #{filters.inspect}"
+    matched
+  end
+
+  def near(coords, radius)
+    matches = {}
+    @entries.each do |rec|
+      if (distance = rec.near(coords, radius))
+        matches[distance] ||= []
+        matches[distance] << rec
+      end
+    end
+    matches
+  end
+
+  def [](path)
+    @entries.find { |r| r.path == path }
+  end
+
+  def parse_params(params)
+    filters = HashStruct.new
+    options = HashStruct.new
+    params.select.each do |key, value|
+      case key.to_sym
+      when :near
+        filters.near = value
+      when :radius
+        filters.radius = value.to_f
+      when :flags
+        filters.flags = value.split(',').map { |f| f.to_sym }
+      when :show_fields
+        options.show_fields = value.split(',').map { |f| f.to_sym }
+      when :hide_fields
+        options.hide_fields = value.split(',').map { |f| f.to_sym }
+      # when :fuzz
+      #   options.fuzz_placemarks = value
+      else
+        filters[key.to_sym] = value
+      end
+    end
+    [filters, options]
+  end
+
+end

data/lib/itinerary/briar_scraper.rb

@@ -0,0 +1,91 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'rack/cache'
+
+require 'itinerary/record'
+require 'parse_html'
+require 'cache'
+
+class BriarScraper
+
+  CacheDir = Pathname.new(__FILE__).dirname + '../cache'
+
+  def initialize
+    @cache = Cache.new(CacheDir)
+    @base_uri = URI.parse('http://www.briarpress.org')
+    @conn = Faraday.new(:url => @base_uri) do |c|
+      # c.use Faraday::Response::Logger
+      c.use FaradayMiddleware::ParseHTML
+      c.use FaradayMiddleware::Caching, @cache
+      c.adapter Faraday.default_adapter
+    end
+  end
+
+  def scrape_state(state)
+    # ;;warn "Scraping state #{state.inspect}"
+    scrape_state_with_uri(uri_for_state(state))
+  end
+
+  private
+
+  def scrape_state_with_uri(state_uri, options={})
+    follow = options.has_key?(:follow) ? options[:follow] : true
+    # ;;warn "Scraping state URI #{state_uri.inspect} (follow = #{follow.inspect})"
+    resp = @conn.get(state_uri)
+    html = resp.body
+    recs = html.xpath("//a[@class='card']").map { |a| scrape_listing(@base_uri + a['href']) }
+    if follow
+      seen = [state_uri]
+      html.xpath('//span[@class="pager-list"]/a').each do |a|
+        if a.text =~ /^\d+$/
+          # ;;warn "Following link #{a.text.inspect} to #{state_uri.inspect}"
+          state_uri = @base_uri + a['href']
+          unless seen.include?(state_uri)
+            recs += scrape_state_with_uri(state_uri, :follow => false)
+            seen << state_uri
+          end
+        end
+      end
+    end
+    recs
+  end
+
+  def uri_for_state(state)
+    "/yellowpages/browse?c=222&s=#{state}"
+  end
+
+  def scrape_listing(listing_uri)
+    # ;;warn "Scraping listing URI #{listing_uri.inspect}"
+    resp = @conn.get(listing_uri)
+    html = resp.body
+    detail = html.at_xpath('//div[@class="detail"]')
+    person = detail.at_xpath("div[@class='card']/div[@class='prop sans']").text.strip.squeeze(' ')
+    organization = detail.at_xpath('//h1').children.map { |e| (n = e.text.strip).empty? ? nil : n }.compact.join(': ').squeeze(' ')
+    if (description = detail.at_xpath("//p[@class='intro']"))
+      description = description.text.strip.squeeze(' ')
+    end
+    uri = nil
+    address = nil
+    detail.xpath("//ul[@id='address']/li").each do |li|
+      if (a = li.at_xpath("a[@target='_blank']"))
+        uri = URI.parse(a['href'].gsub(/\s+/, ''))
+      elsif li.text =~ /^\s*(Tel|Fax)\b/
+        # ignore
+      else
+        address = li.children.select { |e| e.name != 'br' && e.text != ', ' && !e.text.empty? }.map { |e| (a = e.text.strip).empty? ? nil : a }.compact.join(', ').squeeze(' ')
+      end
+    end
+    rec = Record.new(
+      :person => person,
+      :organization => organization,
+      :address => address,
+      :uri => uri,
+      :description => description,
+      :group => 'Briar')
+    rec.clean!
+    rec.geocode
+    # ;;warn "Scraped #{rec.make_path} from #{listing_uri.inspect}"
+    rec
+  end
+
+end