X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/e827a0460795bc076c115f941d074dca67decaa1..83e1700d2616d9920d358dcd2d330f719c19503d:/lib/potlatch.rb diff --git a/lib/potlatch.rb b/lib/potlatch.rb index cfb602817..165e37b0c 100644 --- a/lib/potlatch.rb +++ b/lib/potlatch.rb @@ -1,128 +1,166 @@ +require "stringio" + # The Potlatch module provides helper functions for potlatch and its communication with the server module Potlatch - # The AMF class is a set of helper functions for encoding and decoding AMF. class AMF - # Return two-byte integer - def self.getint(s) - s.getc*256+s.getc + def self.getint(s) + s.getbyte * 256 + s.getbyte end # Return four-byte long - def self.getlong(s) - ((s.getc*256+s.getc)*256+s.getc)*256+s.getc + def self.getlong(s) + ((s.getbyte * 256 + s.getbyte) * 256 + s.getbyte) * 256 + s.getbyte end - # Return string with two-byte length - def self.getstring(s) - len=s.getc*256+s.getc - s.read(len) + # Return string with two-byte length + def self.getstring(s) + len = s.getbyte * 256 + s.getbyte + str = s.read(len) + str.force_encoding("UTF-8") if str.respond_to?("force_encoding") + str end - # Return eight-byte double-precision float - def self.getdouble(s) - a=s.read(8).unpack('G') # G big-endian, E little-endian + # Return eight-byte double-precision float + def self.getdouble(s) + a = s.read(8).unpack("G") # G big-endian, E little-endian a[0] end # Return numeric array - def self.getarray(s) - len=getlong(s) - arr=[] - for i in (0..len-1) - arr[i]=getvalue(s) - end - arr + def self.getarray(s) + Array.new(getlong(s)) { getvalue(s) } end - # Return object/hash - def self.getobject(s) - arr={} - while (key=getstring(s)) - if (key=='') then break end - arr[key]=getvalue(s) + # Return object/hash + def self.getobject(s) + arr = {} + while (key = getstring(s)) + break if key == "" + arr[key] = getvalue(s) end - s.getc # skip the 9 'end of object' value + s.getbyte # skip the 9 'end of object' value arr end # Parse and get value - def self.getvalue(s) - case s.getc - when 0; return getdouble(s) # number - when 1; return s.getc # boolean - when 2; return getstring(s) # string - when 3; return getobject(s) # object/hash - when 5; return nil # null - when 6; return nil # undefined - when 8; s.read(4) # mixedArray - return getobject(s) # | - when 10;return getarray(s) # array - else; return nil # error + def self.getvalue(s) + case s.getbyte + when 0 then getdouble(s) # number + when 1 then s.getbyte # boolean + when 2 then getstring(s) # string + when 3 then getobject(s) # object/hash + when 5 then nil # null + when 6 then nil # undefined + when 8 then s.read(4) # mixedArray + getobject(s) # | + when 10 then getarray(s) # array end end # Envelope data into AMF writeable form - def self.putdata(index,n) - d =encodestring(index+"/onResult") - d+=encodestring("null") - d+=[-1].pack("N") - d+=encodevalue(n) + def self.putdata(index, n) + d = encodestring(index + "/onResult") + d += encodestring("null") + d += [-1].pack("N") + d += encodevalue(n) + d end # Pack variables as AMF - def self.encodevalue(n) + def self.encodevalue(n) case n.class.to_s - when 'Array' - a=10.chr+encodelong(n.length) + when "Array" + a = 10.chr + encodelong(n.length) n.each do |b| - a+=encodevalue(b) + a += encodevalue(b) end a - when 'Hash' - a=3.chr - n.each do |k,v| - a+=encodestring(k.to_s)+encodevalue(v) + when "Hash" + a = 3.chr + n.each do |k, v| + a += encodestring(k.to_s) + encodevalue(v) end - a+0.chr+0.chr+9.chr - when 'String' - 2.chr+encodestring(n) - when 'Bignum','Fixnum','Float' - 0.chr+encodedouble(n) - when 'NilClass' + a + 0.chr + 0.chr + 9.chr + when "String" + 2.chr + encodestring(n) + when "Bignum", "Fixnum", "Float" + 0.chr + encodedouble(n) + when "NilClass" 5.chr - when 'TrueClass' - 0.chr+encodedouble(1) - when 'FalseClass' - 0.chr+encodedouble(0) + when "TrueClass" + 0.chr + encodedouble(1) + when "FalseClass" + 0.chr + encodedouble(0) else - RAILS_DEFAULT_LOGGER.error("Unexpected Ruby type for AMF conversion: "+n.class.to_s) + Rails.logger.error("Unexpected Ruby type for AMF conversion: " + n.class.to_s) end end # Encode string with two-byte length - def self.encodestring(n) - a,b=n.size.divmod(256) - a.chr+b.chr+n + def self.encodestring(n) + n = n.dup.force_encoding("ASCII-8BIT") if n.respond_to?("force_encoding") + a, b = n.size.divmod(256) + a.chr + b.chr + n end - # Encode number as eight-byte double precision float - def self.encodedouble(n) - [n].pack('G') + # Encode number as eight-byte double precision float + def self.encodedouble(n) + [n].pack("G") end # Encode number as four-byte long - def self.encodelong(n) - [n].pack('N') + def self.encodelong(n) + [n].pack("N") end - end + # The Dispatcher class handles decoding a series of RPC calls + # from the request, dispatching them, and encoding the response + class Dispatcher + def initialize(request, &_block) + # Get stream for request data + @request = StringIO.new(request + 0.chr) + + # Skip version indicator and client ID + @request.read(2) + + # Skip headers + AMF.getint(@request).times do # Read number of headers and loop + AMF.getstring(@request) # | skip name + req.getbyte # | skip boolean + AMF.getvalue(@request) # | skip value + end + + # Capture the dispatch routine + @dispatch = Proc.new + end + + def each(&_block) + # Read number of message bodies + bodies = AMF.getint(@request) + + # Output response header + a, b = bodies.divmod(256) + yield 0.chr + 0.chr + 0.chr + 0.chr + a.chr + b.chr + + # Process the bodies + bodies.times do # Read each body + name = AMF.getstring(@request) # | get message name + index = AMF.getstring(@request) # | get index in response sequence + AMF.getlong(@request) # | get total size in bytes + args = AMF.getvalue(@request) # | get response (probably an array) + + result = @dispatch.call(name, *args) + + yield AMF.putdata(index, result) + end + end + end # The Potlatch class is a helper for Potlatch class Potlatch - # ----- getpresets # in: none # does: reads tag preset menus, colours, and autocomplete config files @@ -130,81 +168,95 @@ module Potlatch # [3] colours, [4] casing, [5] areas, [6] autotags # (all hashes) def self.get_presets - RAILS_DEFAULT_LOGGER.info(" Message: getpresets") + Rails.logger.info(" Message: getpresets") # Read preset menus - presets={} - presetmenus={}; presetmenus['point']=[]; presetmenus['way']=[]; presetmenus['POI']=[] - presetnames={}; presetnames['point']={}; presetnames['way']={}; presetnames['POI']={} - presettype='' - presetcategory='' + presets = {} + presetmenus = { "point" => [], "way" => [], "POI" => [] } + presetnames = { "point" => {}, "way" => {}, "POI" => {} } + presettype = "" + presetcategory = "" # StringIO.open(txt) do |file| - File.open("#{RAILS_ROOT}/config/potlatch/presets.txt") do |file| - file.each_line {|line| - t=line.chomp - if (t=~/(\w+)\/(\w+)/) then - presettype=$1 - presetcategory=$2 + File.open("#{Rails.root}/config/potlatch/presets.txt") do |file| + file.each_line do |line| + t = line.chomp + if t =~ %r{(\w+)/(\w+)} + presettype = Regexp.last_match(1) + presetcategory = Regexp.last_match(2) presetmenus[presettype].push(presetcategory) - presetnames[presettype][presetcategory]=["(no preset)"] - elsif (t=~/^([\w\s]+):\s?(.+)$/) then - pre=$1; kv=$2 + presetnames[presettype][presetcategory] = ["(no preset)"] + elsif t =~ /^([\w\s]+):\s?(.+)$/ + pre = Regexp.last_match(1) + kv = Regexp.last_match(2) presetnames[presettype][presetcategory].push(pre) - presets[pre]={} - kv.split(',').each {|a| - if (a=~/^(.+)=(.*)$/) then presets[pre][$1]=$2 end - } + presets[pre] = {} + kv.split(",").each do |a| + presets[pre][Regexp.last_match(1)] = Regexp.last_match(2) if a =~ /^(.+)=(.*)$/ + end end - } + end end # Read colours/styling - colours={}; casing={}; areas={} - File.open("#{RAILS_ROOT}/config/potlatch/colours.txt") do |file| - file.each_line {|line| - t=line.chomp - if (t=~/(\w+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)/) then - tag=$1 - if ($2!='-') then colours[tag]=$2.hex end - if ($3!='-') then casing[tag]=$3.hex end - if ($4!='-') then areas[tag]=$4.hex end - end - } + colours = {} + casing = {} + areas = {} + File.open("#{Rails.root}/config/potlatch/colours.txt") do |file| + file.each_line do |line| + next unless line.chomp =~ /(\w+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)/ + + tag = Regexp.last_match(1) + colours[tag] = Regexp.last_match(2).hex if Regexp.last_match(2) != "-" + casing[tag] = Regexp.last_match(3).hex if Regexp.last_match(3) != "-" + areas[tag] = Regexp.last_match(4).hex if Regexp.last_match(4) != "-" + end end # Read relations colours/styling - relcolours={}; relalphas={}; relwidths={} - File.open("#{RAILS_ROOT}/config/potlatch/relation_colours.txt") do |file| - file.each_line {|line| - t=line.chomp - if (t=~/(\w+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)/) then - tag=$1 - if ($2!='-') then relcolours[tag]=$2.hex end - if ($3!='-') then relalphas[tag]=$3.to_i end - if ($4!='-') then relwidths[tag]=$4.to_i end - end - } + relcolours = {} + relalphas = {} + relwidths = {} + File.open("#{Rails.root}/config/potlatch/relation_colours.txt") do |file| + file.each_line do |line| + next unless line.chomp =~ /(\w+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)/ + + tag = Regexp.last_match(1) + relcolours[tag] = Regexp.last_match(2).hex if Regexp.last_match(2) != "-" + relalphas[tag] = Regexp.last_match(3).to_i if Regexp.last_match(3) != "-" + relwidths[tag] = Regexp.last_match(4).to_i if Regexp.last_match(4) != "-" + end end - # Read auto-complete - autotags={}; autotags['point']={}; autotags['way']={}; autotags['POI']={}; - File.open("#{RAILS_ROOT}/config/potlatch/autocomplete.txt") do |file| - file.each_line {|line| - t=line.chomp - if (t=~/^([\w:]+)\/(\w+)\s+(.+)$/) then - tag=$1; type=$2; values=$3 - if values=='-' then autotags[type][tag]=[] - else autotags[type][tag]=values.split(',').sort.reverse end - end - } + # Read POI presets + icon_list = [] + icon_tags = {} + File.open("#{Rails.root}/config/potlatch/icon_presets.txt") do |file| + file.each_line do |line| + (icon, tags) = line.chomp.split("\t") + icon_list.push(icon) + icon_tags[icon] = Hash[*tags.scan(/([^;=]+)=([^;=]+)/).flatten] + end end + icon_list.reverse! + + # Read auto-complete + autotags = { "point" => {}, "way" => {}, "POI" => {} } + File.open("#{Rails.root}/config/potlatch/autocomplete.txt") do |file| + file.each_line do |line| + next unless line.chomp =~ %r{^([\w:]+)/(\w+)\s+(.+)$} - # Read internationalisation - localised = YAML::load(File.open("#{RAILS_ROOT}/config/potlatch/localised.yaml")) + tag = Regexp.last_match(1) + type = Regexp.last_match(2) + values = Regexp.last_match(3) + autotags[type][tag] = if values == "-" + [] + else + values.split(",").sort.reverse + end + end + end - [presets,presetmenus,presetnames,colours,casing,areas,autotags,relcolours,relalphas,relwidths,localised] + [presets, presetmenus, presetnames, colours, casing, areas, autotags, relcolours, relalphas, relwidths, icon_list, {}, icon_tags] end end - end -