cartocss_helper 0.0.0

data/lib/cartocss_helper/style_specific/style_specific.rb

@@ -0,0 +1,11 @@
+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)
+      @min_z = min_z
+      @max_z = max_z
+      @list_of_documented_tags = list_of_documented_tags
+      @list_of_documented_compositions = list_of_documented_compositions
+    end
+  end
+end

data/lib/cartocss_helper/tag_lister.rb

@@ -0,0 +1,223 @@
+require_relative 'configuration.rb'
+require_relative 'image_generator.rb'
+include CartoCSSHelper::Configuration
+include CartoCSSHelper::Heuristic
+
+module CartoCSSHelper
+  class TagRenderingStatus
+    attr_accessor :key, :value, :state, :composite
+    def initialize(key, value, state, composite=nil)
+      @key = key
+      @value = value
+      @state = state
+      @composite = composite
+    end
+    def print
+      composite_string = ''
+      if composite
+        composite_string = "- rendered with #{@composite.to_s.gsub('=>', '=')}, maybe also other sets of tags"
+      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 << '),'
+      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
+      }
+      return nil
+    end
+
+    def print_render_state_of_tags(git_branch)
+      Git.checkout git_branch
+      get_render_state_of_tags.each { |state|
+        state.code_print
+      }
+    end
+
+    def get_render_state_of_tags
+      states = []
+      @last_composite = nil
+      Heuristic.get_tags.each { |tag|
+        key = tag[0]
+        value = tag[1]
+        #print_render_state_of_tag key, value
+        state = get_render_state_of_tag(key, value)
+        states.push(TagRenderingStatus.new(key, value, state, @last_composite))
+      }
+      return states
+    end
+
+    def get_render_state_of_tag(key, value)
+      if is_rendered key, value
+        @last_composite = nil
+        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
+      end
+    end
+
+    def print_render_state_of_tag(key, value)
+      if is_rendered key, value
+        @last_composite = nil
+        if value == get_generic_tag_value
+          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"
+        end
+      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 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
+            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)
+      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|
+          ['area', 'closed_way', 'way', 'node'].each{ |type|
+            if rendered_on_zlevel({key => value}, type, zlevel, on_water)
+              return true
+            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
+      return true
+    end
+
+    protected
+
+    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
+        }
+      }
+      if suggested_composite != nil
+        return how_rendered_as_composite key, value, nil
+      end
+      return nil
+    end
+
+    def rendered_on_zlevel(tags, type, zlevel, on_water)
+      empty = Scene.new({}, zlevel, on_water, type)
+      tested = Scene.new(tags, zlevel, on_water, type)
+      return tested.is_output_different(empty)
+    end
+
+    def how_rendered_on_zlevel_as_composite(tags, type, zlevel, on_water, suggested_composite)
+      if suggested_composite != nil
+        if is_rendered_with_this_composite tags, type, suggested_composite, zlevel, on_water
+          return suggested_composite
+        end
+        return nil
+      end
+      CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_compositions.each { |composite|
+        if is_rendered_with_this_composite tags, type, composite, zlevel, on_water
+          return composite
+        end
+      }
+      return nil
+    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|
+        if tags_with_composite[key] != nil
+          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
+    end
+  end
+end

data/lib/cartocss_helper/validator.rb

@@ -0,0 +1,172 @@
+# encoding: UTF-8
+require_relative 'heuristic.rb'
+require_relative 'image_generator.rb'
+require_relative 'configuration.rb'
+require_relative 'tag_lister.rb'
+
+include CartoCSSHelper::Heuristic
+include CartoCSSHelper::Configuration
+
+module CartoCSSHelper
+  module Validator
+    def run_tests(git_branch)
+      run_expected_rendering_test(git_branch)
+      run_dy_test(git_branch)
+      run_closed_way_test(git_branch)
+    end
+
+    def run_expected_rendering_test(git_branch)
+      Git.checkout git_branch
+      puts 'unexpectedly rendered/unrendered keys:'
+      compare_expected_with_real_rendering
+      puts
+    end
+
+    def run_dy_test(git_branch)
+      Git.checkout git_branch
+      puts "bad dy values (tall names like 'É' are not displayed, short names like 'a' are):"
+      run_global_check(:check_dy)
+      puts
+    end
+
+    def run_closed_way_test(git_branch)
+      Git.checkout git_branch
+      puts 'failed display of closed way, unlosed way works:'
+      run_global_check(:check_problems_with_closed_line)
+      puts
+    end
+
+    def compare_expected_with_real_rendering
+      list_of_documented = CartoCSSHelper::Configuration.get_style_specific_data.list_of_documented_tags
+      info = Info.new
+      list_of_rendered = info.get_render_state_of_tags
+
+      ensure_that_tags_documented_and_rendered_have_the_same_state(list_of_documented, list_of_rendered)
+      ensure_that_all_rendered_tags_are_documented(list_of_documented, list_of_rendered)
+      ensure_that_all_documented_are_really_rendered(list_of_documented, list_of_rendered)
+    end
+
+    def ensure_that_tags_documented_and_rendered_have_the_same_state(list_of_documented, list_of_rendered)
+      list_of_rendered.each { |tag_info|
+        compare_expected_with_tag_data list_of_documented, tag_info
+      }
+    end
+
+    def ensure_that_all_rendered_tags_are_documented(list_of_documented, list_of_rendered)
+      list_of_rendered.each { |tag_info|
+        if tag_info.state != :ignored
+          if !is_tag_documented(list_of_documented, tag_info.key, tag_info.value)
+            puts 'documented'
+            puts "\tmissing"
+            puts 'real'
+            print "\t"
+            tag_info.print
+            puts
+          end
+        end
+      }
+    end
+
+    def ensure_that_all_documented_are_really_rendered(list_of_documented, list_of_rendered)
+      list_of_documented.each { |documented|
+        if !is_tag_documented(list_of_rendered, documented.key, documented.value)
+          puts 'documented'
+          print "\t"
+          documented.print
+          puts 'real'
+          puts "\tmissing"
+          puts
+        end
+      }
+    end
+
+    def is_tag_documented(list, key, value)
+      list.each { |tag_info|
+        if key == tag_info.key
+          if value == tag_info.value
+            return true
+          end
+        end
+      }
+      return false
+    end
+
+    def compare_expected_with_tag_data(list_of_expected, tag_info)
+      list_of_expected.each { |expected|
+        if expected.key == tag_info.key
+          if expected.value == tag_info.value
+            if expected.equal? tag_info
+              puts 'expected'
+              print "\t"
+              expected.print
+              puts 'real'
+              print "\t"
+              tag_info.print
+              puts
+            end
+            return
+          end
+        end
+      }
+    end
+
+    def run_global_check(function)
+      Heuristic.get_tags.each { |element|
+        (Configuration.get_max_z..Configuration.get_max_z).each { |zlevel| #get_min_z should be used - but as renderer is extremely slow this hack was used TODO
+          send(function, element[0], element[1], zlevel)
+        }
+      }
+    end
+
+    #TODO - what about composite tags?
+    def check_problems_with_closed_line(key, value, zlevel, on_water = false)
+      way = Scene.new({key => value}, zlevel, on_water, 'way')
+      closed_way = Scene.new({key => value}, zlevel, on_water, 'closed_way')
+      empty = Scene.new({}, zlevel, on_water, 'node')
+      if way.is_output_different(empty)
+        if !closed_way.is_output_different(empty)
+          puts key+'='+value
+        end
+      end
+    end
+
+    def check_dy(key, value, zlevel, interactive=false, on_water=false)
+      if !is_object_displaying_anything key, value, zlevel, on_water
+        #puts key+"="+value+" - not displayed as node on z#{zlevel}"
+        return
+      end
+      if !is_object_displaying_name key, value, 'a', zlevel, on_water
+        #puts key+"="+value+" - label is missing on z#{zlevel} nodes"
+        return
+      end
+      test_name = 'ÉÉÉÉÉÉ ÉÉÉÉÉÉ ÉÉÉÉÉÉ'
+      while !is_object_displaying_name key, value, test_name, zlevel, on_water
+        puts key+'='+value+" - name is missing for name '#{test_name}' on z#{zlevel}"
+        if interactive
+          puts 'press enter'
+          gets
+        else
+          return
+        end
+        with_name = Scene.new({key => value, 'name' => test_name}, zlevel, on_water, 'node')
+        with_name.flush_cache
+        puts 'calculating'
+      end
+      #puts key+"="+value+" - name is OK for name '#{name}'"
+    end
+
+    def is_object_displaying_name(key, value, name, zlevel, on_water)
+      name_tags = {key => value, 'name' => name}
+      with_name = Scene.new(name_tags, zlevel, on_water, 'node')
+      nameless_tags = {key => value}
+      nameless = Scene.new(nameless_tags, zlevel, on_water, 'node')
+      return with_name.is_output_different(nameless)
+    end
+
+    def is_object_displaying_anything(key, value, zlevel, on_water)
+      object = Scene.new({key => value}, zlevel, on_water, 'node')
+      empty = Scene.new({}, zlevel, on_water, 'node')
+      return object.is_output_different(empty)
+    end
+  end
+end

data/lib/cartocss_helper/visualise_changes_diff_from_images.rb

@@ -0,0 +1,158 @@
+require 'RMagick'
+
+module CartoCSSHelper
+  class ImageForComparison
+    attr_reader :file_location, :description
+    def initialize(file_location, description)
+      @file_location = file_location
+      @description = description
+    end
+    def identical(another_image)
+      #Returns true if the contents of a file A and a file B are identical.
+      return FileUtils.compare_file(self.file_location, another_image.file_location)
+    end
+  end
+
+  class PairOfComparedImages
+    attr_reader :left_file_location, :right_file_location
+    attr_accessor :description
+    def initialize(left_image, right_image)
+      raise 'description mismatch' unless left_image.description == right_image.description
+      @left_file_location = left_image.file_location
+      @right_file_location = right_image.file_location
+      @description = left_image.description
+    end
+    def merge_description_from_next_image(image)
+      @description << ', ' << image.description
+    end
+  end
+
+  class FullSetOfComparedImages
+    def initialize(before, after, header, filename, image_size)
+      @header = header
+      @filename = filename
+      @compared = compress(before, after)
+
+      @image_size = image_size
+      @margin = 20
+      @standard_pointsize = 10
+      @header_space = @standard_pointsize*1.5
+      @diff_note_space = @standard_pointsize
+
+      render
+    end
+
+    def compress(before, after)
+      returned = [PairOfComparedImages.new(before[0], after[0])]
+      (1...before.length).each { |i|
+        if before[i].identical(before[i-1]) && after[i].identical(after[i-1])
+          returned[-1].merge_description_from_next_image(before[i])
+        else
+          returned.push(PairOfComparedImages.new(before[i], after[i]))
+        end
+      }
+      return returned
+    end
+
+    def render
+      create_canvas
+      offset = 0
+      render_header
+      offset += @header_space + @margin*1.5
+      render_diff_note offset
+      offset += @diff_note_space + @margin*0.5
+      render_images_with_labels offset
+      offset += (@compared.length)*(@margin + @image_size)
+      render_footer offset
+    end
+
+    def create_canvas
+      y = get_needed_y
+      x = @image_size*2+3*@margin
+
+      @canvas = Magick::Image.new(x, y)
+    end
+
+    def get_needed_y
+      y = 0
+      y += @header_space
+      y += @margin*1.5
+      y += @diff_note_space
+      y += @margin*0.5
+      y += (@compared.length) * (@image_size + @margin)
+      y += @diff_note_space
+      return y
+    end
+
+    def render_header
+      header_drawer = Magick::Draw.new
+      header_drawer.pointsize(@header_space*3/5)
+      header_drawer.text(@margin, @header_space, @header)
+      header_drawer.draw(@canvas)
+    end
+
+    def render_diff_note(y_offset)
+      drawer = Magick::Draw.new
+      drawer.pointsize(@diff_note_space)
+      #drawer.text(@margin, y_offset, 'before')
+      drawer.draw(@canvas)
+      #drawer.text(@margin*2 + @image_size, y_offset, 'after')
+      drawer.draw(@canvas)
+    end
+
+    def render_images_with_labels(y_offset)
+      (0...@compared.length).each { |i|
+        render_row_of_labelled_images(@compared[i], y_offset + i * (@margin + @image_size))
+      }
+    end
+
+    def render_row_of_labelled_images(processed, y_offset)
+      left_image = Magick::Image.read(processed.left_file_location)[0]
+      right_image = Magick::Image.read(processed.right_file_location)[0]
+      drawer = Magick::Draw.new
+      drawer.pointsize(@diff_note_space*4/5)
+      if left_image == right_image
+        drawer.text(@margin + @image_size/2, y_offset, "#{processed.description} - unchanged")
+        drawer.draw(@canvas)
+      else
+        drawer.text(@margin, y_offset, "#{processed.description} - before")
+        drawer.draw(@canvas)
+        drawer.text(@margin*2 + @image_size, y_offset, "#{processed.description} - after")
+        drawer.draw(@canvas)
+      end
+      render_row_of_images(y_offset, left_image, right_image)
+    end
+
+    def render_label(y_offset, label)
+      label_drawer = Magick::Draw.new
+      label_drawer.pointsize(@standard_pointsize)
+      label_drawer.text(@margin, y_offset, label)
+      label_drawer.draw(@canvas)
+    end
+
+    # noinspection RubyResolve
+    def render_row_of_images(y_offset, left_image, right_image)
+      if left_image == right_image
+        @canvas.composite!(left_image, @margin*1.5 + @image_size/2, y_offset, Magick::OverCompositeOp)
+      else
+        @canvas.composite!(left_image, @margin, y_offset, Magick::OverCompositeOp)
+        @canvas.composite!(right_image, @margin*2+@image_size, y_offset, Magick::OverCompositeOp)
+      end
+    end
+
+    def render_footer(y_offset)
+      label_drawer = Magick::Draw.new
+      label_drawer.pointsize(@standard_pointsize)
+      label_drawer.text(@margin, y_offset, 'generated using https://github.com/mkoniecz/CartoCSSHelper')
+      label_drawer.draw(@canvas)
+    end
+
+    def popup
+      @canvas.display
+    end
+
+    def save
+      @canvas.write(@filename)
+    end
+  end
+end