barton 0.0.2 → 0.0.3

data/lib/barton.rb

@@ -2,12 +2,21 @@ require "barton/core"
 
 module Barton
   class << self
-    def data_loaded
-      @@data_loaded ||= false
+    def environment
+      @@environment = ENV['BARTON'] || 'development'
     end
-    
-    def data_loaded=(bool)
-      @@data_loaded = bool
+
+    def environment=(env)
+      ENV['BARTON'] = env
+      @@environment = env
+    end
+
+    def api_url
+      @@api_url ||= 'http://localhost:4567'
+    end
+
+    def api_url=(env)
+      @@api_url = env
     end
   end
 end

data/lib/barton/app.rb

@@ -1,20 +1,22 @@
 require 'sinatra'
 require 'json'
+require 'uri'
 require 'barton'
 require 'barton/core'
 
-module Barton  
+module Barton
   class App < Sinatra::Base
-    
-    #   routes    
+
+    #   routes
 		allowed_formats = ['', 'json']
 
-		get '/' do
-			"this is the Barton home page"
+		# helpers
+		before do
+      Barton.api_url = "#{request.base_url }"
 		end
 
-		get '/docs' do
-			"this is the docs page"
+		get '/' do
+			File.read( 'lib/barton/docs.html' )
 		end
 
 		#	electorate resource
@@ -23,10 +25,12 @@ module Barton
 			geo, tags, address = params[:geo], params[:tags], params[:address]
 			tags = tags.split(',') unless tags.nil?
 			raise Sinatra::NotFound unless allowed_formats.include?( format )
-      geo = Barton::Data.address( address ) if address
 			if not id.empty?
 				results = Barton.electorates( {:id => id} )
 				prepare_response( results )
+			elsif address
+				results = Barton.electorates( {:tags => tags, :address => address} )
+				prepare_response( results )
 			elsif geo or tags
 				results = Barton.electorates( {:tags => tags, :geo => geo} )
 				prepare_response( results )
@@ -35,31 +39,53 @@ module Barton
 			end
 		end
 
+		#	electorate resource
+		get %r{^/api/members/?(\w*)/?.?([A-z]*)} do
+			id, format = params[:captures]
+			geo, tags, address = params[:geo], params[:tags], params[:address]
+			tags = tags.split(',') unless tags.nil?
+			raise Sinatra::NotFound unless allowed_formats.include?( format )
+			if not id.empty?
+				results = Barton.members( {:id => id} )
+				prepare_response( results )
+			elsif address
+				results = Barton.members( {:tags => tags, :address => address} )
+				prepare_response( results )
+			elsif geo or tags
+				results = Barton.members( {:tags => tags, :geo => geo} )
+				prepare_response( results )
+			else
+				prepare_response
+			end
+		end
+
+
 		#	base api
 		get %r{^/api/?.?([A-z]*)$} do
 			prepare_response
 		end
-		
+
 		#   views
-		
+
 		#	Prepares and array of results for the API response
 		def prepare_response( args=nil )
 			#	add generic API meta data
-			app_url = 'http://barton.experimentsindemocracy.org'
 			response = {}
 			response[:name] = "Barton API"
-			response[:disclaimer] = "This data is crowded sourced and provided free of charge for informational purposes only. No guarantees whatsoever regarding data quality are made excluding its sheer awesomeness."
+			response[:disclaimer] = "This data is crowded sourced and provided free of charge for informational purposes only. No guarantees regarding data quality are made whatsoever apart from it's rather considerable coolness."
 			response[:license] = "MIT License http://www.opensource.org/licenses/mit-license.php"
 			unless args.nil?
-        response[:result_count] = args.length 
+        response[:result_count] = args.length
   			response[:results] = args
+  			status 404 if args.length == 0
 			end
-			response[:resources] = { :home => app_url, :api => "#{app_url}/api", :electorates => "#{app_url}/api/electorates" }
-			response[:examples] = { :electorates => {
-						:resource_id => "#{app_url}/api/electorates/ccbfd1",
-						:geo => "#{app_url}/api/electorates?geo=151.2054563,-33.8438383",
-						:tags => "#{app_url}/api/electorates?tags=sydney,jurisidction:local",
-						:mixed => "#{app_url}/api/electorates?geo=151.2054563,-33.8438383&tags=federal", }}
+			response[:resources] = { :home => Barton.api_url, :api => "#{Barton.api_url}/api", :electorates => "#{Barton.api_url}/api/electorates", :members => "#{Barton.api_url}/api/members" }
+			response[:examples] = {
+						:id => "#{Barton.api_url}/api/members/0db2ec",
+						:geo => "#{Barton.api_url}/api/electorates?geo=151.2054563,-33.8438383",
+						:tags => "#{Barton.api_url}/api/members?tags=sydney,local",
+						:mixed => "#{Barton.api_url}/api/electorates?geo=151.2054563,-33.8438383&tags=federal",
+						}
 			#	format
 			content_type 'application/json;charset=utf-8'
 			JSON.pretty_generate( response )

data/lib/barton/core.rb

@@ -5,7 +5,7 @@ require 'json'
 require 'barton/app'
 
 module Barton
-  
+
   #  Returns an array of electorates matching the search criteria
   #    Accepts a hash of criteria
   #      :id
@@ -13,50 +13,75 @@ module Barton
   #      :geo
   #      :address
   #    Returns an array of hashes
-  def Barton.electorates( query = {} )
+  def self.electorates( query = {} )
     Find.electorates( query )
   end
-  
+
   #  Returns an array of member matching the search criteria
   #    Accepts a hash of criteria
-  #    Returns an array of hashes				
-  def members
-    # TBA
+  #    Returns an array of hashes
+  def self.members( query={} )
+    Find.members( query )
   end
-   
+
     #  Loads electoral data from the yaml files into elasticsearch
   def self.setup
-    Data.config
     Data.purge_es
     Dir['data/*.yaml'].each do |f|
       Setup.load_file( f )
     end
-    Barton.data_loaded = true
   end
-  
-  #  Configuration options for the Gem
+
   def self.config
-    #puts ENV['RAKE_ENV']
-    #Data.config
+    Data.config
   end
-  
+
   module Find
-		def self.electorates( query={} )
+    def self.electorates( query )
+      docs = Find.documents( query, 'electorate' )
+      # remove unwanted fields
+      docs.each do |e|
+        e.keys.each { |k| e.delete( k ) if k.match( /_|geobox|boundaries|highlight|sort/ ) }
+        e[:url] = "#{Barton.api_url}/api/electorates/#{e[:id]}"
+        members = Array.new
+        if e.has_key?( :members )
+          e[:members].each do |m|
+            m = m.to_hash
+            m[:url] = "#{Barton.api_url}/api/members/#{m[:id]}"
+            m.delete( :id )
+            members.push( m )
+          end
+        end
+        e[:members] = members if members.length > 0
+      end
+      docs
+    end
+
+    def self.members( query )
+      results = Array.new
+      docs = Find.documents( query, 'member' )
+      docs.each do |m|
+        m.keys.each { |k| m.delete( k ) if k.match( /_|highlight|sort/ ) }
+        m[:url] = "#{Barton.api_url}/api/members/#{m[:id]}"
+        e = m[:electorate].to_hash
+        e[:url] = "#{Barton.api_url}/api/electorates/#{e[:id]}"
+        e.delete( :id )
+        m[:electorate] = e
+      end
+      docs
+    end
+
+    def self.documents( query={}, type=nil )
       results = Array.new
       terms = ["id:#{query[:id]}"] if query.has_key?( :id )
       terms = query[:tags] if query.has_key?( :tags )
       geo = query[:geo] if query.has_key?( :geo )
       geo = self.address( query[:address] ) if query.has_key?( :address ) and not query.has_key?( :geo )
-      s = Data.search( terms, geo )
-      s.results.each do |e|
-        e = e.to_hash
-        e.keys.each { |k| e.delete( k ) if k.match( /_|geobox|boundaries|highlight|sort/ ) }
-        e[:url] = "#{@api_url}/electorates/#{e[:id]}"
-        results.push( e )
-      end
+      s = Data.search( terms, geo, type )
+      s.results.each { |e| results.push( e.to_hash ) }
       results
-		end
-		
+    end
+
 		#   Geocode lookup to google
 		def self.address( address )
       # http://maps.googleapis.com/maps/api/geocode/json?address=address&sensor=false&region=au
@@ -73,7 +98,7 @@ module Barton
         puts e
       end
 		end
-		
+
  		#	  Ray casting algorithm to find if point is in polygon
 		def self.point_in_poly?( geo, boundaries )
 			#	get pairs of points of boundaries
@@ -102,19 +127,93 @@ module Barton
 			ax, ay, bx, by = ax.to_f, ay.to_f, bx.to_f, by.to_f
 			return 0 if ay < long and by < long
 			return ( ( ax < lat and lat < bx ) or ( bx < lat and lat < ax ) ) ? 1 : 0
-		end		
+		end
   end
-  
+
+  module Data
+    @index_name = 'electorates'
+
+    #  Set elasticsearch config
+    def self.config
+      case Barton.environment
+      when 'test'
+        @index_name = 'test_electorates'
+      when ENV['FOUNDELASTICSEARCH_URL']
+        Tire::Configuration.url ENV['FOUNDELASTICSEARCH_URL']
+        @index_name = 'electorates'
+      else
+        @index_name = 'electorates'
+      end
+      #if ENV['BONSAI_INDEX_URL']
+      #  Tire.configure do
+      #    url "http://index.bonsai.io"
+      #  end
+      #  @index_name = ENV['BONSAI_INDEX_URL'][/[^\/]+$/]
+      #end
+      return Barton.environment
+    end
+
+		#   Purge electorate data from elasticsearch
+		def self.purge_es
+      self.query_es( 'purge' )
+		end
+
+		#   Load electorate data to elasticsearch
+		def self.update_es( data )
+      self.query_es( 'update', data )
+		end
+
+		#   Query elasticsearch
+		def self.query_es( action, data=nil )
+      self.config
+      begin
+        Tire.index "#{@index_name}" do
+          delete if action == 'purge'
+          create if action == 'purge'
+          import data if action == 'update' and not data.nil?
+        end
+      rescue Exception => e
+        puts "Elasticsearch error: #{e}"
+      end
+		end
+
+		def self.search( terms, geo, type=nil )
+      self.config
+      s = Tire.search "#{@index_name}" do
+ 				query do
+					boolean do
+						if geo
+							long, lat = geo.split( ',' )
+							must { range :north, { :gte => lat } }
+							must { range :south, { :lte => lat } }
+							must { range :east, { :gte => long } }
+							must { range :west, { :lte => long } }
+						elsif terms
+							terms.each { |t| must { string t } }
+						end
+						must { string "type:#{type}" } if type
+					end
+				end
+				#	apply filters only with geo search
+				filter :terms, :_all => terms if geo and terms
+				size 100
+      end
+      s
+    end
+  end
+
   module Setup
     #   Parses a electorate yaml file, merges it with a geo yaml file,
     #     loads them to the datastore and resaves the yaml files
     def self.parse_yaml( filename )
-      data = YAML::load_file( filename ) if File.exist?( filename )
+      data = Array.new
+      electorates = YAML::load_file( filename ) if File.exist?( filename )
       geofile = "#{File.dirname( filename )}/geo/#{File.basename( filename )}"
       geo = YAML::load_file( geofile ) if File.exist?( geofile )
-      if data.respond_to?( 'each' )
-        data.each do |e|
-          e['id'] = Digest::SHA1.hexdigest( [e['name'], e['tags'].join].join )[0..5] unless e['id'] or not e['name'] or not e['tags']
+      if electorates.respond_to?( 'each' )
+        electorates.each do |e|
+          # id is the first 6 digits of a hash of object name with file name EG BulimbaQLD-State.yaml
+          e['id'] = Digest::SHA1.hexdigest( [e['name'], filename].join )[0..5].force_encoding('utf-8') unless e['id'] or not e['name']
           # make geobox and update geo.yaml if boundaries present
           if e.has_key?( 'boundaries')
             e['geobox'] = self.create_geobox( e['boundaries'] )
@@ -123,14 +222,37 @@ module Barton
             e['boundaries'] = geo[e['id']]['boundaries']
             e['geobox'] = geo[e['id']]['geobox']
           end
+
+          ei = e.clone   # this will be the electorate that is indexed
+          ei['type'] = 'electorate'
+
+          if e.has_key?( 'members' )
+            # create seperate types for member details
+            members = Array.new
+            e['members'].each do |m|
+              m['role'] = "Member for #{e['name']}" unless m['role']
+              m['id'] = Digest::SHA1.hexdigest( [m['role'], filename].join )[0..5].force_encoding('utf-8') unless m['id'] or not m['role']
+              # only add this for indexing
+              mi = m.clone
+              mi['type'] = 'member'
+              mi['tags'] = [] unless m.has_key?( 'tags' )
+              mi['tags'] |= e['tags'] if e.has_key?( 'tags' )
+              mi['electorate'] = {'name' => e['name'], 'id' => e['id']}
+              data.push( mi )
+              members.push( {'role' => m['role'], 'name' => m['name'], 'id' => m['id']})
+            end
+            # only index limited member data
+            ei['members'] = members
+          end
+          data.push( ei )
         end
         # save parsed yaml
         data_yaml = Array.new
         geo_yaml = Hash.new
-        data.each do |e|
+        electorates.each do |e|
           # remove geo from data
           geo_yaml[e['id']] = Hash['boundaries' => e['boundaries'], 'geobox' => e['geobox']] if e.has_key?( 'boundaries' )
-          data_yaml.push( e.select { |k,v| not ['boundaries', 'geobox'].include? k } )
+          data_yaml.push( e.select { |k,v| not ['boundaries', 'geobox', 'type'].include? k } )
         end
         File.open( filename, 'w+' ) { |f| f.puts( YAML.dump( data_yaml ) ) }
         File.open( geofile, 'w+' ) { |f| f.puts( YAML.dump( geo_yaml ) ) }
@@ -139,7 +261,7 @@ module Barton
         nil
       end
     end
-    
+
     #		Creates a minimum bounded box encapsulating the boundary polygons
     def self.create_geobox( boundaries )
       return nil unless boundaries.instance_of? Array
@@ -155,79 +277,14 @@ module Barton
       end
       box
     end
-    
+
     # Load data from yaml source file
     def self.load_file( filename )
-      puts "Loading data from #{filename}....."
+      puts "Loading data from #{filename} to #{Barton.environment}....."
       electorates = self.parse_yaml( filename )
       puts "Failed to load #{filename}" if electorates.nil?
       connected = Data.update_es( electorates )
       abort "Connection to Elasticsearch failed" if connected.nil?
     end
   end
-  
-  
-  module Data
-    
-    @index_name = ENV['RAKE_ENV']
-    
-    #  Set elasticsearch config
-    def self.config
-      @index_name = ENV['RAKE_ENV']
-      if ENV['BONSAI_INDEX_URL']
-        Tire.configure do
-          url "http://index.bonsai.io"
-        end
-        @index_name = ENV['BONSAI_INDEX_URL'][/[^\/]+$/]
-      end
-    end
-    
-		#   Purge electorate data from elasticsearch
-		def self.purge_es
-      self.query_es( 'purge' )
-		end
-		
-		#   Load electorate data to elasticsearch
-		def self.update_es( data )
-      self.query_es( 'update', data )
-		end
-		
-		#   Query elasticsearch
-		def self.query_es( action, data=nil )
-       begin
-        Tire.index "#{@index_name}-electorates" do
-          delete if action == 'purge'
-          create if action == 'purge'
-          import data if action == 'update' and not data.nil?
-        end
-      rescue => e
-        puts e
-        nil
-      end     
-		end
-		
-		def self.search( terms, geo )
-      s = Tire.search "#{@index_name}-electorates" do
- 				query do
-					boolean do
-						if geo
-							long, lat = geo.split( ',' )
-							must { range :north, { :gte => lat } }
-							must { range :south, { :lte => lat } }
-							must { range :east, { :gte => long } }
-							must { range :west, { :lte => long } }
-						elsif terms
-							terms.each { |t| must { string t } }
-						end
-					end
-				end
-				#	apply filters only with geo search
-				if geo and terms
-					filter :terms, :_all => terms
-				end
-				size 100
-      end
-      s
-    end
-  end
 end