bplgeo 0.0.1

data/lib/bplgeo/tgn.rb

@@ -0,0 +1,314 @@
+module Bplgeo
+  class TGN
+
+    def self.bplgeo_config
+      root = Rails.root || './test/dummy'
+      env = Rails.env || 'test'
+      @bplgeo_config ||= YAML::load(ERB.new(IO.read(File.join(root, 'config', 'bplgeo.yml'))).result)[env].with_indifferent_access
+    end
+
+    def self.getty_username
+      bplgeo_config[:getty_username] || '<username>'
+    end
+
+    def self.getty_password
+      bplgeo_config[:getty_password] || '<password>'
+    end
+
+    # retrieve data from Getty TGN to populate <mods:subject auth="tgn">
+    def self.get_tgn_data(tgn_id)
+      tgn_response = Typhoeus::Request.get('http://vocabsservices.getty.edu/TGNService.asmx/TGNGetSubject?subjectID=' + tgn_id, userpwd: self.getty_username + ':' + self.getty_password)
+      unless tgn_response.code == 500
+        tgnrec = Nokogiri::XML(tgn_response.body)
+        #puts tgnrec.to_s
+
+        # coordinates
+        if tgnrec.at_xpath("//Coordinates")
+          coords = {}
+          coords[:latitude] = tgnrec.at_xpath("//Latitude/Decimal").children.to_s
+          coords[:longitude] = tgnrec.at_xpath("//Longitude/Decimal").children.to_s
+          coords[:combined] = coords[:latitude] + ',' + coords[:longitude]
+        else
+          coords = nil
+        end
+
+        hier_geo = {}
+
+        #main term
+        if tgnrec.at_xpath("//Terms/Preferred_Term/Term_Text")
+          tgn_term_type = tgnrec.at_xpath("//Preferred_Place_Type/Place_Type_ID").children.to_s
+          pref_term_langs = tgnrec.xpath("//Terms/Preferred_Term/Term_Languages/Term_Language/Language")
+          # if the preferred term is the preferred English form, use that
+          if pref_term_langs.children.to_s.include? "English"
+            tgn_term = tgnrec.at_xpath("//Terms/Preferred_Term/Term_Text").children.to_s
+          else # use the non-preferred term which is the preferred English form
+            if tgnrec.xpath("//Terms/Non-Preferred_Term")
+              non_pref_terms = tgnrec.xpath("//Terms/Non-Preferred_Term")
+              non_pref_terms.each do |non_pref_term|
+                non_pref_term_langs = non_pref_term.children.css("Term_Language")
+                # have to loop through these, as sometimes languages share form
+                non_pref_term_langs.each do |non_pref_term_lang|
+                  if non_pref_term_lang.children.css("Preferred").children.to_s == "Preferred" && non_pref_term_lang.children.css("Language").children.to_s == "English"
+                    tgn_term = non_pref_term.children.css("Term_Text").children.to_s
+                  end
+                end
+              end
+            end
+          end
+          # if no term is the preferred English form, just use the preferred term
+          tgn_term ||= tgnrec.at_xpath("//Terms/Preferred_Term/Term_Text").children.to_s
+        end
+        if tgn_term && tgn_term_type
+          case tgn_term_type
+            when '29000/continent'
+              hier_geo[:continent] = tgn_term
+            when '81010/nation'
+              hier_geo[:country] = tgn_term
+            when '81161/province'
+              hier_geo[:province] = tgn_term
+            when '81165/region', '82193/union', '80005/semi-independent political entity'
+              hier_geo[:region] = tgn_term
+            when '81175/state', '81117/department', '82133/governorate'
+              hier_geo[:state] = tgn_term
+            when '81125/national district'
+              if tgn_term == 'District of Columbia'
+                hier_geo[:state] = tgn_term
+              else
+                hier_geo[:territory] = tgn_term
+              end
+            when '81181/territory', '81021/dependent state', '81186/union territory'
+              hier_geo[:territory] = tgn_term
+            when '81115/county'
+              hier_geo[:county] = tgn_term
+            when '83002/inhabited place'
+              hier_geo[:city] = tgn_term
+            when '84251/neighborhood'
+              hier_geo[:city_section] = tgn_term
+            when '21471/island'
+              hier_geo[:island] = tgn_term
+            when '81101/area', '22101/general region', '83210/deserted settlement', '81501/historical region', '81126/national division'
+              hier_geo[:area] = tgn_term
+            else
+              non_hier_geo = tgn_term
+          end
+        end
+
+        # parent data for <mods:hierarchicalGeographic>
+        if tgnrec.at_xpath("//Parent_String")
+          parents = tgnrec.at_xpath("//Parent_String").children.to_s.split('], ')
+          parents.each do |parent|
+            if parent.include? '(continent)'
+              hier_geo[:continent] = parent
+            elsif parent.include? '(nation)'
+              hier_geo[:country] = parent
+            elsif parent.include? '(province)'
+              hier_geo[:province] = parent
+            elsif (parent.include? '(region)') || (parent.include? '(union)') || (parent.include? '(semi-independent political entity)')
+              hier_geo[:region] = parent
+            elsif (parent.include? '(state)') || (parent.include? '(department)') || (parent.include? '(governorate)') || (parent.include?('(national district)') && parent.include?('District of Columbia'))
+              hier_geo[:state] = parent
+            elsif (parent.include? '(territory)') || (parent.include? '(dependent state)') || (parent.include? '(union territory)') || (parent.include? '(national district)')
+              hier_geo[:territory] = parent
+            elsif parent.include? '(county)'
+              hier_geo[:county] = parent
+            elsif parent.include? '(inhabited place)'
+              hier_geo[:city] = parent
+            elsif parent.include? '(neighborhood)'
+              hier_geo[:city_section] = parent
+            elsif parent.include? '(island)'
+              hier_geo[:island] = parent
+            elsif (parent.include? '(area)') || (parent.include? '(general region)') || (parent.include? '(deserted settlement)') || (parent.include? '(historical region)') || (parent.include? '(national division)')
+              hier_geo[:area] = parent
+            end
+          end
+          hier_geo.each do |k,v|
+            hier_geo[k] = v.gsub(/ \(.*/,'')
+          end
+        end
+
+        tgn_data = {}
+        tgn_data[:coords] = coords
+        tgn_data[:hier_geo] = hier_geo.length > 0 ? hier_geo : nil
+        tgn_data[:non_hier_geo] = non_hier_geo ? non_hier_geo : nil
+
+      else
+
+        tgn_data = nil
+
+      end
+
+      return tgn_data
+
+    end
+
+    def self.tgn_id_from_geo_hash(geo_hash)
+      return nil if Bplgeo::TGN.getty_username == '<username>'
+
+      geo_hash = geo_hash.clone
+
+      max_retry = 3
+      sleep_time = 60 # In seconds
+      retry_count = 0
+
+      return_hash = {}
+
+      state_part = geo_hash[:state_part]
+
+      country_code = Bplgeo::Constants::COUNTRY_TGN_LOOKUP[geo_hash[:country_part]][:tgn_id] unless Bplgeo::Constants::COUNTRY_TGN_LOOKUP[geo_hash[:country_part]].blank?
+      country_code ||= ''
+
+
+      country_part = Bplgeo::Constants::COUNTRY_TGN_LOOKUP[geo_hash[:country_part]][:tgn_country_name] unless Bplgeo::Constants::COUNTRY_TGN_LOOKUP[geo_hash[:country_part]].blank?
+      country_part ||= geo_hash[:country_part]
+      country_part ||= ''
+
+      city_part = geo_hash[:city_part]
+
+      neighborhood_part = geo_hash[:neighborhood_part]
+
+      top_match_term = ''
+      match_term = nil
+
+      if city_part.blank? && state_part.blank?
+        # Limit to nations
+        place_type = 81010
+        top_match_term = ['']
+        second_top_match_term = ''
+        match_term = country_part.to_ascii.downcase
+      elsif state_part.present? && city_part.blank? && country_code == 7012149
+        #Limit to states
+        place_type = 81175
+        top_match_term = ["#{country_part.to_ascii.downcase} (nation)"]
+        second_top_match_term = ["#{country_part.to_ascii.downcase} (nation)"]
+        match_term = state_part.to_ascii.downcase
+      elsif state_part.present? && city_part.blank?
+        #Limit to regions
+        place_type = 81165
+        top_match_term = ["#{country_part.to_ascii.downcase} (nation)"]
+        second_top_match_term = ["#{country_part.to_ascii.downcase} (nation)"]
+        match_term = state_part.to_ascii.downcase
+      elsif state_part.present? && city_part.present? && neighborhood_part.blank?
+        #Limited to only inhabited places at the moment...
+        place_type = 83002
+        sp = state_part.to_ascii.downcase
+        top_match_term = ["#{sp} (state)", "#{sp} (department)", "#{sp} (governorate)", "#{sp} (territory)", "#{sp} (dependent state)", "#{sp} (union territory)", "#{sp} (national district)",  "#{sp} (province)"]
+        second_top_match_term = ["#{country_part.to_ascii.downcase} (nation)"]
+        match_term = city_part.to_ascii.downcase
+      elsif state_part.present? && city_part.present? && neighborhood_part.present?
+        #Limited to only to neighborhoods currently...
+        place_type = 84251
+        top_match_term = ["#{city_part.to_ascii.downcase} (inhabited place)"]
+        sp = neighborhood_part.to_ascii.downcase
+        second_top_match_term = ["#{sp} (state)", "#{sp} (department)", "#{sp} (governorate)", "#{sp} (territory)", "#{sp} (dependent state)", "#{sp} (union territory)", "#{sp} (national district)",  "#{sp} (province)"]
+        match_term = neighborhood_part.to_ascii.downcase
+      else
+        return nil
+      end
+
+      begin
+        if retry_count > 0
+          sleep(sleep_time)
+        end
+        retry_count = retry_count + 1
+
+        tgn_response = Typhoeus::Request.get("http://vocabsservices.getty.edu/TGNService.asmx/TGNGetTermMatch?placetypeid=#{place_type}&nationid=#{country_code}&name=" + CGI.escape(match_term), userpwd: self.getty_username + ':' + self.getty_password)
+
+
+      end until (tgn_response.code != 500 || retry_count == max_retry)
+
+      unless tgn_response.code == 500
+        parsed_xml = Nokogiri::Slop(tgn_response.body)
+
+        #This is ugly and needs to be redone to achieve better recursive...
+        if parsed_xml.Vocabulary.Count.text == '0'
+          if neighborhood_part.present?
+            geo_hash[:neighborhood_part] = nil
+            geo_hash = tgn_id_from_geo_hash(geo_hash)
+          elsif city_part.present?
+            geo_hash[:city_part] = nil
+            geo_hash = tgn_id_from_geo_hash(geo_hash)
+          end
+
+          return nil
+        end
+
+        #If only one result, then not array. Otherwise array....
+        if parsed_xml.Vocabulary.Subject.first.blank?
+          subject = parsed_xml.Vocabulary.Subject
+
+          current_term = subject.Preferred_Term.text.gsub(/\(.*\)/, '').to_ascii.downcase.strip
+          alternative_terms = subject.elements.any? { |node| node.name == 'Term' } ? subject.Term : ''
+
+          #FIXME: Term should check for the correct level... temporary fix...
+          if current_term == match_term && top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+            return_hash[:id] = subject.Subject_ID.text
+          #Check alternative term ids
+          elsif alternative_terms.present? && alternative_terms.children.any? { |alt_term| alt_term.text.to_ascii.downcase.strip == match_term} && top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+            return_hash[:id] = subject.Subject_ID.text
+          elsif current_term == match_term && second_top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+            return_hash[:id] = subject.Subject_ID.text
+          elsif alternative_terms.present? && alternative_terms.children.any? { |alt_term| alt_term.text.to_ascii.downcase.strip == match_term} && second_top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+            return_hash[:id] = subject.Subject_ID.text
+          end
+        else
+         parsed_xml.Vocabulary.Subject.each do |subject|
+
+            current_term = subject.Preferred_Term.text.gsub(/\(.*\)/, '').to_ascii.downcase.strip
+            alternative_terms = subject.elements.any? { |node| node.name == 'Term' } ? subject.Term : ''
+
+            if current_term == match_term && top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+              return_hash[:id] = subject.Subject_ID.text
+            end
+          end
+
+          if return_hash[:id].blank?
+            parsed_xml.Vocabulary.Subject.each do |subject|
+              current_term = subject.Preferred_Term.text.gsub(/\(.*\)/, '').to_ascii.downcase.strip
+              alternative_terms = subject.elements.any? { |node| node.name == 'Term' } ? subject.Term : ''
+
+              if alternative_terms.present? && alternative_terms.children.any? { |alt_term| alt_term.text.to_ascii.downcase.strip == match_term} && top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+                return_hash[:id] = subject.Subject_ID.text
+              end
+            end
+          end
+
+          if return_hash[:id].blank?
+            parsed_xml.Vocabulary.Subject.each do |subject|
+              current_term = subject.Preferred_Term.text.gsub(/\(.*\)/, '').to_ascii.downcase.strip
+              alternative_terms = subject.elements.any? { |node| node.name == 'Term' } ? subject.Term : ''
+
+              if current_term == match_term && second_top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+                return_hash[:id] = subject.Subject_ID.text
+              end
+            end
+          end
+
+          if return_hash[:id].blank?
+            parsed_xml.Vocabulary.Subject.each do |subject|
+              current_term = subject.Preferred_Term.text.gsub(/\(.*\)/, '').to_ascii.downcase.strip
+              alternative_terms = subject.elements.any? { |node| node.name == 'Term' } ? subject.Term : ''
+
+              if alternative_terms.present? && alternative_terms.children.any? { |alt_term| alt_term.text.to_ascii.downcase.strip == match_term} && second_top_match_term.any? { |top_match| subject.Preferred_Parent.text.to_ascii.downcase.include? top_match }
+                return_hash[:id] = subject.Subject_ID.text
+              end
+            end
+          end
+        end
+
+      end
+
+      if tgn_response.code == 500
+        raise 'TGN Server appears to not be responding for Geographic query: ' + term
+      end
+
+      if return_hash.present?
+        return_hash[:original_string_differs] = Bplgeo::Standardizer.parsed_and_original_check(geo_hash)
+        return return_hash
+      else
+        return nil
+      end
+    end
+
+
+  end
+end

data/lib/bplgeo/town_lookup.rb

@@ -0,0 +1,19 @@
+module Bplgeo
+  class TownLookup
+    #Only returns one result for now...
+    #Need to avoid cases like "Boston" and "East Boston"
+    def self.state_town_lookup(state_key, string)
+      return_tgn_id = nil
+      matched_terms_count = 0
+      matching_towns = Bplgeo::Constants::STATE_TOWN_TGN_IDS[state_key.to_sym].select {|hash| string.include?(hash[:location_name])}
+      matching_towns.each do |matching_town|
+        if matching_town[:location_name].split(' ').length > matched_terms_count
+          return_tgn_id = matching_town[:tgn_id]
+          matched_terms_count = matched_terms_count
+        end
+      end
+
+      return return_tgn_id
+    end
+  end
+end

data/lib/bplgeo/version.rb

@@ -0,0 +1,3 @@
+module Bplgeo
+  VERSION = "0.0.1"
+end

data/lib/bplgeo.rb

@@ -0,0 +1,35 @@
+module Bplgeo
+  require "bplgeo/constants"
+  require "bplgeo/parser"
+  require "bplgeo/standardizer"
+  require "bplgeo/tgn"
+  require "bplgeo/geonames"
+  require "bplgeo/town_lookup"
+  require "geocoder"
+  require "countries"
+  require "unidecoder"
+  require "typhoeus"
+  require "nokogiri"
+
+  def self.parse(term,parse_term=false)
+    return {} if term.blank?
+
+    return_hash = Bplgeo::Parser.parse_mapquest_api(term, parse_term)
+
+    if return_hash.blank?
+      return_hash = Bplgeo::Parser.parse_bing_api(term, parse_term)
+    end
+
+    if return_hash.blank?
+      return_hash = Bplgeo::Parser.parse_google_api(term, parse_term)
+    end
+
+    if return_hash.present?
+      return_hash[:tgn] = Bplgeo::TGN.tgn_id_from_geo_hash(return_hash)
+      return_hash[:geonames] = Bplgeo::Geonames.geonames_id_from_geo_hash(return_hash)
+    end
+
+    return return_hash
+
+  end
+end

data/lib/tasks/bplgeo_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :bplgeo do
+#   # Task goes here
+# end

data/test/bplgeo_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+class BplgeoTest < ActiveSupport::TestCase
+
+  def test_parse
+    result = Bplgeo.parse('Boston, MA')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7013445', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'                 
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal '4930956', result[:geonames][:id] if Bplgeo::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Bplgeo::Geonames.geonames_username != '<username>'
+
+    result = Bplgeo.parse('New York, NY')
+    assert_equal 'New York', result[:city_part]
+    assert_equal 'New York', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7007567', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal '5128638', result[:geonames][:id] if Bplgeo::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Bplgeo::Geonames.geonames_username != '<username>'
+
+    result = Bplgeo.parse('Washington, DC')
+    assert_equal 'Washington', result[:city_part]
+    assert_equal 'District of Columbia', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7013962', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal '4140963', result[:geonames][:id] if Bplgeo::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Bplgeo::Geonames.geonames_username != '<username>'
+
+    result = Bplgeo.parse('Roxbury (Boston, Mass.)')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal 'Roxbury', result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7015002', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+    #FIXME?
+    assert_equal '4949151', result[:geonames][:id] if Bplgeo::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Bplgeo::Geonames.geonames_username != '<username>'
+
+    result = Bplgeo.parse('Roxbury, Mass.')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal 'Roxbury', result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7015002', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+    #FIXME?
+    assert_equal '4949151', result[:geonames][:id] if Bplgeo::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Bplgeo::Geonames.geonames_username != '<username>'
+
+    result = Bplgeo.parse('Vietnam')
+    assert_equal nil, result[:city_part]
+    assert_equal nil, result[:state_part]
+    assert_equal 'Vietnam', result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal '1000145', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal nil, result[:street_part]
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+
+    result = Bplgeo.parse('Soviet Union')
+    assert_equal nil, result[:city_part]
+    assert_equal nil, result[:state_part]
+    assert_equal nil, result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal nil, result[:tgn]
+    assert_equal nil, result[:street_part]
+
+    #FIXME: Should eventually still return Fenway even if not a TGN neighborhood... rewrite pending.
+    result = Bplgeo.parse('Fenway (Boston, Mass.)')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal '7013445', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal 'TODO: Not Implemented for Google Results', result[:street_part]
+    assert_equal true, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+
+    #Should find the Michigan Atlanta over the Georgia Atlanta
+    #State part from an API giving me Atlanta????
+    result = Bplgeo.parse('Atlanta, MI')
+    assert_equal 'Atlanta', result[:city_part]
+    assert_equal 'Michigan', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal '2051159', result[:tgn][:id] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal false, result[:tgn][:original_string_differs] if Bplgeo::TGN.getty_username != '<username>'
+    assert_equal '4984500', result[:geonames][:id] if Bplgeo::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Bplgeo::Geonames.geonames_username != '<username>'
+
+
+
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application", media: "all", "data-turbolinks-track" => true %>
+  <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/test/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/test/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/test/dummy/config/application.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require(*Rails.groups)
+require "bplgeo"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+  end
+end
+

data/test/dummy/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
+
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)

data/test/dummy/config/bplgeo.yml

@@ -0,0 +1,23 @@
+development:
+  #scanned_image_drive: /home/bluewolf/mapped/scan_images/BPLDC/_
+  #getty_username: bplib
+  getty_password: 8{83N78kO;B)2
+  geonames_username: boston_library
+  mapquest_key: Fmjtd%7Cluubn1utn0%2Ca2%3Do5-90b00a
+  bing_key: Avmp8UMpfYiAJOYa2D-6_cykJoprZsvvN5YLv6SDalvN-BZnW9KMlCzjIV7Zrtmn
+  timeout: 100
+test: &TEST
+  #scanned_image_drive: /home/bluewolf/mapped/scan_images/BPLDC/_
+  #getty_username: bplib
+  getty_password: 8{83N78kO;B)2
+  geonames_username: boston_library
+  mapquest_key: Fmjtd%7Cluubn1utn0%2Ca2%3Do5-90b00a
+  bing_key: Avmp8UMpfYiAJOYa2D-6_cykJoprZsvvN5YLv6SDalvN-BZnW9KMlCzjIV7Zrtmn
+  timeout: 100
+production:
+  getty_username: bplib
+  getty_password: 8{83N78kO;B)2
+  geonames_username: boston_library
+  mapquest_key: Fmjtd%7Cluubn1utn0%2Ca2%3Do5-90b00a
+  bing_key: Avmp8UMpfYiAJOYa2D-6_cykJoprZsvvN5YLv6SDalvN-BZnW9KMlCzjIV7Zrtmn
+  timeout: 7