cartocss_helper 1.2.1 → 4.0.0

data/lib/cartocss_helper/style_specific/style_specific.rb

@@ -1,11 +1,12 @@
 module CartoCSSHelper
   class StyleSpecificData
-    attr_reader :min_z, :max_z, :list_of_documented_tags, :list_of_documented_compositions
-    def initialize(min_z, max_z, list_of_documented_tags, list_of_documented_compositions)
+    attr_reader :min_z, :max_z, :list_of_documented_tags, :list_of_documented_compositions, :name_label_is_not_required
+    def initialize(min_z, max_z, list_of_documented_tags, list_of_documented_compositions, name_label_is_not_required)
       @min_z = min_z
       @max_z = max_z
       @list_of_documented_tags = list_of_documented_tags
       @list_of_documented_compositions = list_of_documented_compositions
+      @name_label_is_not_required = name_label_is_not_required
     end
   end
-end
+end

data/lib/cartocss_helper/tag_lister.rb

@@ -6,12 +6,13 @@ include CartoCSSHelper::Heuristic
 module CartoCSSHelper
   class TagRenderingStatus
     attr_accessor :key, :value, :state, :composite
-    def initialize(key, value, state, composite=nil)
+    def initialize(key, value, state, composite = nil)
       @key = key
       @value = value
       @state = state
       @composite = composite
     end
+
     def print
       composite_string = ''
       if composite
@@ -19,60 +20,103 @@ module CartoCSSHelper
       end
       puts "#{@key}=#{@value} #{@state} #{composite_string}"
     end
+
     def code_print
       string = "Status.new('#{@key}', '#{@value}', :#{@state}"
-      if @composite != nil
-        string << ", #{@composite.to_s}"
-      end
+      string << ", #{@composite}" if @composite != nil
       string << '),'
       puts string
     end
   end
 
   class Info
-    def get_expected_composite(key, value)
-      CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_tags.each { |documented|
-        if documented.key == key
-          if documented.value == value
-            return documented.composite
-          end
-        end
-      }
+    def self.get_expected_state(key, value)
+      CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_tags.each do |documented|
+        next unless documented.key == key
+        return documented.state if documented.value == value
+      end
+      return nil
+    end
+
+    def self.get_expected_composite(key, value)
+      CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_tags.each do |documented|
+        next unless documented.key == key
+        return documented.composite if documented.value == value
+      end
       return nil
     end
 
     def print_render_state_of_tags(git_branch)
       Git.checkout git_branch
-      get_render_state_of_tags.each { |state|
+      get_render_state_of_tags.each do |state|
         state.code_print
-      }
+      end
     end
 
-    def get_render_state_of_tags
+    def get_render_state_of_tags(quick_and_more_prone_to_errors)
       states = []
       @last_composite = nil
-      Heuristic.get_tags.each { |tag|
+      Heuristic.get_tags.each do |tag|
         key = tag[0]
         value = tag[1]
-        #print_render_state_of_tag key, value
-        state = get_render_state_of_tag(key, value)
+        # print_render_state_of_tag key, value
+        state = get_render_state_of_tag(key, value, quick_and_more_prone_to_errors)
         states.push(TagRenderingStatus.new(key, value, state, @last_composite))
-      }
+      end
       return states
     end
 
-    def get_render_state_of_tag(key, value)
-      if is_rendered key, value
+    def get_render_state_of_tag(key, value, quick_and_more_prone_to_errors)
+      if Info.get_expected_state(key, value) == :ignored
         @last_composite = nil
+        return :ignored
+      end
+      zlevels = [22, 13] # TODO: - this is specially tuned for Default
+      expected_composite = Info.get_expected_composite(key, value)
+      if quick_and_more_prone_to_errors
+        return get_render_state_of_tag_quick_heurestic(key, value, expected_composite, zlevels)
+      end
+      return get_render_state_of_tag_thorough(key, value, expected_composite, zlevels)
+    end
+
+    def get_render_state_of_tag_quick_heurestic
+      if expected_composite != nil
+        return assume_that_only_this_composite_can_match(key, value, zlevels, expected_composite)
+      else
+        return asssume_that_no_composite_will_match(key, value, zlevels)
+      end
+    end
+
+    def assume_that_only_this_composite_can_match(key, value, zlevels, expected_composite)
+      if is_rendered_as_composite key, value, expected_composite, zlevels
+        @last_composite = how_rendered_as_composite key, value, expected_composite, zlevels
+        return :composite
+      else
+        @last_composite = nil
+        return :ignored
+      end
+    end
+
+    def asssume_that_no_composite_will_match(key, value, zlevels)
+      @last_composite = nil
+      if is_rendered key, value, zlevels
         return :primary
       else
-        if is_rendered_as_composite key, value, get_expected_composite(key, value)
-          @last_composite = how_rendered_as_composite key, value, get_expected_composite(key, value)
-          return :composite
-        else
-          @last_composite = nil
-          return :ignored
-        end
+        return :ignored
+      end
+    end
+
+    def get_render_state_of_tag_thorough(key, value, expected_composite, zlevels)
+      if is_rendered key, value, zlevels
+        @last_composite = nil
+        return :primary
+      end
+      if is_rendered_as_composite key, value, expected_composite
+        @last_composite = how_rendered_as_composite key, value, expected_composite
+        return :composite
+      else
+        @last_composite = nil
+        return :ignored
       end
     end
 
@@ -83,82 +127,69 @@ module CartoCSSHelper
           puts "#{key}=#{value} - primary generic tag value"
         elsif is_key_rendered_and_value_ignored(key, value)
           puts "#{key}=#{value} - primary, but rendering the same as generic value"
-        elsif
-        puts "#{key}=#{value} - primary"
-        end
-      else
-        if is_rendered_as_composite key, value, @last_composite
-          @last_composite = how_rendered_as_composite key, value, @last_composite
-          puts "#{key}=#{value} - composite with #{@last_composite} - and maybe other tags"
         else
-          @last_composite = nil
-          puts "#{key}=#{value} - not displayed"
+          puts "#{key}=#{value} - primary"
         end
+      elsif is_rendered_as_composite key, value, @last_composite
+        @last_composite = how_rendered_as_composite key, value, @last_composite
+        puts "#{key}=#{value} - composite with #{@last_composite} - and maybe other tags"
+      else
+        @last_composite = nil
+        puts "#{key}=#{value} - not displayed"
       end
     end
 
     def is_key_rendered_and_value_ignored(key, value)
-      if not is_rendered key,get_generic_tag_value
-        return false
-      end
-      [false, true].each { |on_water|
-        [Configuration.get_max_z].each { |zlevel|
-          ['area', 'closed_way', 'way', 'node'].each{ |type|
-            if CartoCSSHelper::Info.rendered_on_zlevel({key => value}, type, zlevel, on_water)
-              if !is_key_rendered_and_value_ignored_set(key, value, type, zlevel, on_water)
-                return false
-              end
+      return false if notis_rendered key, get_generic_tag_value
+      [false, true].each do |on_water|
+        [Configuration.get_max_z].each do |zlevel|
+          ['area', 'closed_way', 'way', 'node'].each do |type|
+            next unless CartoCSSHelper::Info.rendered_on_zlevel({ key => value }, type, zlevel, on_water)
+            unless is_key_rendered_and_value_ignored_set(key, value, type, zlevel, on_water)
+              return false
             end
-          }
-        }
-      }
+          end
+        end
+      end
       return true
     end
 
     def is_key_rendered_and_value_ignored_set(key, value, type, zlevel, on_water)
-      with_tested_value = Scene.new({key => value}, zlevel, on_water, type)
-      with_generic_value = Scene.new({key => get_generic_tag_value}, zlevel, on_water, type)
+      with_tested_value = Scene.new({ key => value }, zlevel, on_water, type, true)
+      with_generic_value = Scene.new({ key => get_generic_tag_value }, zlevel, on_water, type, true)
       return !with_tested_value.is_output_different(with_generic_value)
     end
 
-    def is_rendered(key, value)
-      [false, true].each { |on_water|
-        [Configuration.get_max_z].each { |zlevel| #TODO - note that some tags may be rendered up to X zoom level, but checking all zlevels would take too much time
-          ['area', 'closed_way', 'way', 'node'].each{ |type|
-            if CartoCSSHelper::Info.rendered_on_zlevel({key => value}, type, zlevel, on_water)
+    def is_rendered(key, value, zlevels = [Configuration.get_max_z]) # TODO: - note that some tags may be rendered up to X zoom level, but checking all zlevels would take too much time
+      [false, true].each do |on_water|
+        zlevels.each do |zlevel| #
+          ['area', 'closed_way', 'way', 'node'].each do |type|
+            if CartoCSSHelper::Info.rendered_on_zlevel({ key => value }, type, zlevel, on_water)
               return true
             end
-          }
-        }
-      }
+          end
+        end
+      end
       return false
     end
 
-    def is_rendered_as_composite(key, value, suggested_composite=nil)
-      reason = how_rendered_as_composite key, value, suggested_composite
-      if reason == nil
-        return false
-      end
+    def is_rendered_as_composite(key, value, suggested_composite = nil, zlevels = [Configuration.get_max_z]) # TODO: - note that some tags may be rendered up to X zoom level, but checking all zlevels would take too much time
+      reason = how_rendered_as_composite key, value, suggested_composite, zlevels
+      return false if reason == nil
       return true
     end
 
-    def how_rendered_as_composite(key, value, suggested_composite)
-      [false, true].each { |on_water|
-        [Configuration.get_max_z].each { |zlevel|
-          result = how_rendered_on_zlevel_as_composite({key => value}, 'closed_way', zlevel, on_water, suggested_composite)
-          if result != nil
-            return result
-          end
-          result = how_rendered_on_zlevel_as_composite({key => value}, 'way', zlevel, on_water, suggested_composite)
-          if result != nil
-            return result
-          end
-          result = how_rendered_on_zlevel_as_composite({key => value}, 'node', zlevel, on_water, suggested_composite)
-          if result != nil
-            return result
-          end
-        }
-      }
+    def how_rendered_as_composite(key, value, suggested_composite, zlevels = [Configuration.get_max_z]) # TODO: - note that some tags may be rendered up to X zoom level, but checking all zlevels would take too much time
+      [false, true].each do |on_water|
+        zlevels.each do |zlevel|
+          result = how_rendered_on_zlevel_as_composite({ key => value }, 'closed_way', zlevel, on_water, suggested_composite)
+          return result if result != nil
+          result = how_rendered_on_zlevel_as_composite({ key => value }, 'way', zlevel, on_water, suggested_composite)
+          return result if result != nil
+          result = how_rendered_on_zlevel_as_composite({ key => value }, 'node', zlevel, on_water, suggested_composite)
+          return result if result != nil
+        end
+      end
       if suggested_composite != nil
         return how_rendered_as_composite key, value, nil
       end
@@ -166,8 +197,8 @@ module CartoCSSHelper
     end
 
     def self.rendered_on_zlevel(tags, type, zlevel, on_water)
-      empty = Scene.new({}, zlevel, on_water, type)
-      tested = Scene.new(tags, zlevel, on_water, type)
+      empty = Scene.new({}, zlevel, on_water, type, true)
+      tested = Scene.new(tags, zlevel, on_water, type, true)
       return tested.is_output_different(empty)
     end
 
@@ -180,44 +211,37 @@ module CartoCSSHelper
         end
         return nil
       end
-      CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_compositions.each { |composite|
+      CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_compositions.each do |composite|
         if is_rendered_with_this_composite tags, type, composite, zlevel, on_water
           return composite
         end
-      }
+      end
       return nil
     end
 
+    def deep_clone(input)
+      return Marshal.load(Marshal.dump(input))
+    end
+
     def is_rendered_with_this_composite(tags, type, provided_composite, zlevel, on_water)
-      #puts "<<<\n#{tags}\n#{composite}<<<\n\n"
-      # noinspection RubyResolve
-      # see https://youtrack.jetbrains.com/issue/RUBY-16061
-      tags_with_composite = Marshal.load(Marshal.dump(tags))
-      # noinspection RubyResolve
-      # see https://youtrack.jetbrains.com/issue/RUBY-16061
-      composite = Marshal.load(Marshal.dump(provided_composite))
-      composite.each { |key, value|
+      tags_with_composite = deep_clone(tags)
+      composite = deep_clone(provided_composite)
+      composite.each do |key, value|
         if tags_with_composite[key] != nil
-          return false #shadowing
+          return false # shadowing
         end
         tags_with_composite[key] = value
-      }
-      with_composite = Scene.new(tags_with_composite, zlevel, on_water, type)
-      only_composite = Scene.new(composite, zlevel, on_water, type)
-      empty = Scene.new({}, zlevel, on_water, type)
-      if with_composite.is_output_different(empty)
-        if with_composite.is_output_different(only_composite)
-          if composite['area'] != nil
-            return true
-          end
-          composite['area'] = 'yes'
-          composite_interpreted_as_area = Scene.new(composite, zlevel, on_water, type)
-          if with_composite.is_output_different(composite_interpreted_as_area)
-            return true
-          end
-        end
       end
-      return false
+      with_composite = Scene.new(tags_with_composite, zlevel, on_water, type, true)
+      only_composite = Scene.new(composite, zlevel, on_water, type, true)
+      empty = Scene.new({}, zlevel, on_water, type, true)
+      return false if with_composite.is_output_identical(empty)
+      return false if with_composite.is_output_identical(only_composite)
+      return true if composite['area'] != nil
+      composite['area'] = 'yes'
+      composite_interpreted_as_area = Scene.new(composite, zlevel, on_water, type, true)
+      return false if with_composite.is_output_identical(composite_interpreted_as_area)
+      return true
     end
   end
-end
+end

data/lib/cartocss_helper/util/filehelper.rb

@@ -3,4 +3,4 @@ module FileHelper
   def self.make_string_usable_as_filename(string)
     return string.gsub(/[\x00\/\\:\*\?\"<>\|]/, '_')
   end
-end
+end

data/lib/cartocss_helper/util/generic_cached_downloader.rb

@@ -0,0 +1,49 @@
+require_relative 'generic_downloader.rb'
+
+class GenericCachedDownloader
+  def initialize(timeout: 20, error_message: nil, stop_on_timeout: true, wrapper: RestClientWrapper.new)
+    @request_timeout = timeout
+    @error_message = error_message
+    @stop_on_timeout = stop_on_timeout
+    @wrapper = wrapper
+  end
+
+  def get_specified_resource(url, cache_filename, description: nil, invalidate_cache: false)
+    cache = read_from_cache(cache_filename)
+    cache = nil if invalidate_cache
+    return cache if cache != nil
+    response = download(url, description)
+    write_cache(response, cache_filename)
+
+    return response
+  end
+
+  def read_from_cache(cache_filename)
+    if File.exist?(cache_filename)
+      file = File.new(cache_filename)
+      cached = file.read
+      file.close
+      return cached
+    end
+    return nil
+  end
+
+  def get_cache_timestamp(cache_filename)
+    return nil unless File.exist?(cache_filename)
+    f = File.new(cache_filename)
+    timestamp = f.mtime.to_i
+    f.close
+    return timestamp
+  end
+
+  def download(url, description)
+    downloader = GenericDownloader.new(timeout: @request_timeout, error_message: @error_message, stop_on_timeout: @stop_on_timeout, wrapper: @wrapper)
+    return downloader.get_specified_resource(url, description: description)
+  end
+
+  def write_cache(response, cache_filename)
+    file = File.new(cache_filename, 'w')
+    file.write response
+    file.close
+  end
+end

data/lib/cartocss_helper/util/generic_downloader.rb

@@ -0,0 +1,65 @@
+require 'ruby-progressbar'
+require_relative 'rest-client_wrapper.rb'
+require_relative 'logger.rb'
+
+class BuggyRestClient < StandardError
+end
+
+class ExceptionWithResponse < StandardError
+  attr_accessor :http_code, :response
+end
+
+class ExceptionWithoutResponse < StandardError
+  attr_accessor :http_code, :response
+end
+
+class RequestTimeout < StandardError
+end
+
+class GenericDownloader
+  def initialize(timeout: 20, error_message: nil, stop_on_timeout: true, wrapper: RestClientWrapper.new)
+    @request_timeout = timeout
+    @retry_count = 0
+    @error_message = error_message
+    @stop_on_timeout = stop_on_timeout
+    @wrapper = wrapper
+  end
+
+  def max_retry_count
+    5
+  end
+
+  def output_shared_error_part(url, e)
+    Log.warn @error_message unless @error_message.nil?
+    Log.warn
+    Log.warn url
+    Log.warn
+    Log.warn e.class
+    Log.warn e
+  end
+
+  def retry_allowed(exception_with_response)
+    raise exception_with_response if @retry_count > max_retry_count
+    if @stop_on_timeout
+      raise exception_with_response if exception_with_response.is_a?(RequestTimeout)
+    end
+    if [429, 503, 504].include?(exception_with_response.http_code)
+      @retry_count += 1
+      return true
+    end
+    raise exception_with_response
+  end
+
+  def get_specified_resource(url, description: nil)
+    Log.info description if description
+    return @wrapper.fetch_data_from_url(url, @request_timeout)
+  rescue ExceptionWithResponse => e
+    output_shared_error_part(url, e)
+    Log.warn e.response
+    Log.warn e.http_code
+    get_specified_resource(url) if retry_allowed(e)
+  rescue ExceptionWithoutResponse => e
+    output_shared_error_part(url, e)
+    raise e
+  end
+end