active_road 0.0.2 → 0.0.3

data/app/models/active_road/physical_road_filter.rb

@@ -1,41 +0,0 @@
-# Filter Physical Road by : 
-#  - constraints
-class ActiveRoad::PhysicalRoadFilter
-  attr_accessor :relation, :constraints
-
-  def initialize(constraints = {}, relation = ActiveRoad::PhysicalRoad.scoped ) 
-    @relation, @constraints = relation, constraints
-  end
-
-  # Must define an sql request with forbidden tags
-  def sql_request
-    sql_request = ""
-    constraints.each do |key, value|
-      if !( (constraints.keys.first.present? && constraints.keys.first == key) )  
-        sql_request += " AND "
-      end
-  
-      sql_request += "(tags -> '#{new_key}')::int > :#{key}"
-      
-      # if key.to_s.include? "min_" 
-      #   new_key = key.to_s.gsub("min_", "")
-      #   sql_request += "(tags -> '#{new_key}')::int > :#{key}"
-      # elsif key.to_s.include? "max_"
-      #   new_key = key.to_s.gsub("max_", "")
-      #   sql_request += "(tags -> '#{new_key}')::int < :#{key}"
-      # else
-      #   sql_request += "tags -> '#{key}' != :#{key}" 
-      # end
-    end
-    sql_request
-  end
-
-  def filter
-    if constraints.present?      
-      @relation = @relation.where(constraints)
-    else
-      @relation
-    end
-  end
-
-end

data/app/models/active_road/terra_import.rb

@@ -1,148 +0,0 @@
-module ActiveRoad
-  class TerraImport
-    attr_reader :parser
-
-    def initialize(xml_file)
-      @parser = ::Saxerator.parser(File.new(xml_file))
-    end
-
-    def extract
-      parser.for_tag(:LogicalRoad).each do |logical_road|
-        LogicalRoadXml.new(logical_road).import
-      end 
-
-      parser.for_tag(:TrajectoryArc).each do |physical_road|
-        TrajectoryArcXml.new(physical_road).import      
-      end
-
-      parser.for_tag(:TrajectoryNode).each do |junction|
-        TrajectoryNodeXml.new(junction).import      
-      end
-
-      parser.for_tag(:StreetNumber).each do |street_number|
-        StreetNumberXml.new(street_number).import      
-      end
-      
-    end
-
-    class ElementXml
-      attr_reader :xml
-      
-      def initialize(xml)
-        @xml = xml
-      end
-
-      def objectid
-        xml['ObjectId']
-      end
-
-      def geometry
-        GeoRuby::SimpleFeatures::Geometry.from_ewkt( xml['Geometry'] ) 
-      end
-      
-    end
-
-    class LogicalRoadXml < ElementXml
-      
-      def name
-        xml['Name']
-      end   
-
-      def import
-        ActiveRoad::LogicalRoad.create :name => name, :objectid => objectid
-      end
-      
-    end
-
-    class TrajectoryArcXml < ElementXml
-      
-      def logical_road
-        ActiveRoad::LogicalRoad.find_by_objectid( logical_road_id )
-      end   
-
-      def logical_road_id
-        xml['LogicalRoadRef']
-      end
-
-      def minimum_width
-        xml['MinimumWidth']
-      end
-
-      def length
-        xml['Length']
-      end
-
-      def tags
-        {}
-      end
-      
-      def import
-        ActiveRoad::PhysicalRoad.create(:geometry => geometry, :tags => tags, :logical_road_id => logical_road_id, :objectid => objectid, :minimum_with => minimum_width, :length_in_meter => length) if (geometry) #&& logical_road)
-      end
-      
-    end
-
-    class TrajectoryNodeXml < ElementXml
-      
-      def tags
-        {} #xml['Tags'].to_s
-      end
-
-      # def height
-      #   xml['Height'] || 0
-      # end
-
-      # def physical_road 
-      #   ActiveRoad::PhysicalRoad.find_by_objectid( physical_road_id )
-      # end
-
-      # def physical_road_id
-      #   xml['PhysicalRoadRef']
-      # end    
-
-      def physical_roads
-        physical_roads = []
-        if(xml['TrajectoryArcRef'].class == Saxerator::Builder::StringElement)
-          physical_roads << ActiveRoad::PhysicalRoad.find_by_objectid( xml['TrajectoryArcRef'].to_s ) 
-        else
-          xml['TrajectoryArcRef'].each do |trajectory_arc_ref|
-            physical_road = ActiveRoad::PhysicalRoad.find_by_objectid( trajectory_arc_ref.to_s )
-            physical_roads << physical_road if physical_road.present?        
-          end
-        end
-        physical_roads
-      end 
-
-      def import
-        junction = ActiveRoad::Junction.create :objectid => objectid, :tags => tags, :geometry => geometry
-        junction.physical_roads << physical_roads
-      end
-      
-    end
-
-    class StreetNumberXml < ElementXml
-      # TODO : Fix location_on_road value
-      def physical_road 
-        ActiveRoad::PhysicalRoad.find_by_objectid( physical_road_ref )
-      end
-
-      def physical_road_ref
-        xml['TrajectoryArcRef']
-      end
-
-      def number
-        xml['Number']
-      end
-
-      def location_on_road
-        xml['LocationOnRoad'] || 0
-      end
-      
-      def import
-        ActiveRoad::StreetNumber.create(:number => number , :objectid => objectid, :geometry => geometry, :location_on_road => location_on_road)#, :physical_road_id => physical_road.id)
-      end
-
-    end
-
-  end
-end

data/spec/models/active_road/physical_road_filter_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe ActiveRoad::PhysicalRoadFilter do
-
-  # describe "#sql_request" do
-    
-  #   it "should return sql_request with min key" do
-  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"min_size" => "2"})    
-  #     physical_road_filter.sql_request.should == "(tags -> 'size')::int > :min_size"
-  #   end
-
-  #   it "should return sql_request with max key" do
-  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"max_size" => "2"})    
-  #     physical_road_filter.sql_request.should == "(tags -> 'size')::int < :max_size"
-  #   end
-
-  #   it "should return sql_request with default key" do
-  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"pedestrian" => "true"})    
-  #     physical_road_filter.sql_request.should == "tags -> 'pedestrian' != :pedestrian"
-  #   end
-
-  #   it "should return sql_request with 3 parameter" do       
-  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"pedestrian" => "true", "max_size" => "2", "min_size" => "1"})    
-  #     physical_road_filter.sql_request.should == "tags -> 'pedestrian' != :pedestrian AND (tags -> 'size')::int < :max_size AND (tags -> 'size')::int > :min_size"
-  #   end
-
-  # end
-
-  describe "#filter" do
-    
-    let!( :physical_road )  { create( :physical_road ) }
-    let!( :physical_road2 ) { create( :physical_road ) } 
-    let!( :physical_road3 ) { create( :physical_road ) }     
-       
-    it "should return physical roads which contains minimum_width <= narrow" do
-      physical_road.update_attribute :minimum_width, :wide
-      physical_road2.update_attribute :minimum_width, :cramped
-
-      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:minimum_width => [:wide, :enlarged, :narrow]})
-      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
-    end
-
-    it "should return physical roads which contains slope <= medium" do
-      physical_road.update_attribute :slope, :medium
-      physical_road2.update_attribute :slope, :steep
-
-      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:slope => [:flat, :medium] })
-      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
-    end
-
-    it "should return physical roads which contains cant <=  medium" do
-      physical_road.update_attribute :cant, :medium
-      physical_road2.update_attribute :cant, :steep
-
-      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:cant => [:flat, :medium] })
-      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
-    end
-
-    it "should return physical roads which contains physical_road_type == path_link" do
-      physical_road.update_attribute :physical_road_type, :path_link
-      physical_road2.update_attribute :physical_road_type, :crossing
-
-      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:physical_road_type => :path_link})
-      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
-
-    end
-
-    it "should return physical roads which contains transport_mode == pedestrian" do
-      physical_road.update_attribute :transport_mode, :pedestrian
-      physical_road2.update_attribute :transport_mode, :bike
-      
-      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:transport_mode => [:pedestrian, nil]})
-      physical_road_filter.filter.should =~ [physical_road, physical_road3]            
-    end
-
-    it "should return physical roads which contains covering == asphalt_road or pavement" do
-      physical_road.update_attribute :covering, :asphalt_road
-      physical_road2.update_attribute :covering, :pavement
-     
-      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:covering => [:pavement, :asphalt_road, nil]})
-      physical_road_filter.filter.should =~ [physical_road, physical_road2, physical_road3]      
-    end
-  end
-
-end

data/spec/models/active_road/terra_import_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-describe ActiveRoad::TerraImport do
-
-  describe "test big xml file" do
-    let(:xml_file) { File.expand_path("../../../fixtures/terra.xml", __FILE__) }
-    
-    subject { ActiveRoad::TerraImport.new( xml_file ) } 
-    
-    before :each do 
-      subject.extract
-    end
-    
-    # it "should have import all logical roads" do   
-    #   ActiveRoad::LogicalRoad.all.size.should == 4
-    # end
-    
-    it "should have import all physical roads" do
-      ActiveRoad::PhysicalRoad.all.size.should == 78
-    end
-    
-    it "should have import all junctions" do
-      ActiveRoad::Junction.all.size.should == 70
-    end
-    
-    it "should have import all street number" do
-      ActiveRoad::StreetNumber.all.size.should == 20
-    end
-  end
-
-  describe "test minimal xml file" do
-    let(:xml_file) { File.expand_path("../../../fixtures/terra_minimal.xml", __FILE__) }
-    
-    subject { ActiveRoad::TerraImport.new( xml_file ) } 
-    
-    before :each do 
-      subject.extract
-    end
-
-    it "should have import one physical road" do
-      ActiveRoad::PhysicalRoad.all.size.should == 1
-      
-      physical_road = ActiveRoad::PhysicalRoad.first  
-    
-      physical_road.objectid.should == "ign-obj-205"
-    end
-    
-    it "should have import 2 junctions" do
-      ActiveRoad::Junction.all.size.should == 2
-
-      junction1 = ActiveRoad::Junction.first
-      junction2 = ActiveRoad::Junction.last
-
-      junction1.objectid.should == "ign-obj-55"
-      junction1.physical_roads.first.objectid.should == "ign-obj-205"
-      junction2.objectid.should == "ign-obj-56"
-      junction2.physical_roads.first.objectid.should == "ign-obj-205"
-    end    
-  end
-
-end
-
-describe ActiveRoad::TerraImport::TrajectoryNodeXml do
-  let(:trajectory_node_xml) { File.expand_path("../../../fixtures/trajectory_node.xml", __FILE__) }
-  let(:parser) { Saxerator.parser(File.new(trajectory_node_xml)) }
-  
-  let(:trajectory_node) { ActiveRoad::TerraImport::TrajectoryNodeXml.new(parser.for_tag(:TrajectoryNode).first) }
-
-  it "should have an object id" do
-    trajectory_node.objectid.should == "ign-obj-93"
-  end
-
-  it "should have tags" do
-    trajectory_node.tags.should == {}
-  end
-  
-  it "should have a geometry" do
-    trajectory_node.geometry.should_not be_nil
-  end
-  
-  # it "should have an height" do
-  #   trajectory_node.height.should == 5
-  # end
-
-end
-
-describe ActiveRoad::TerraImport::TrajectoryArcXml do
-  let(:trajectory_arc_xml) { File.expand_path("../../../fixtures/trajectory_arc.xml", __FILE__) }
-  let(:parser) { Saxerator.parser(File.new(trajectory_arc_xml)) }
-  
-  let(:trajectory_arc) { ActiveRoad::TerraImport::TrajectoryArcXml.new(parser.for_tag(:TrajectoryArc).first) }
-
-  it "should have an object id" do
-    trajectory_arc.objectid.should == "ign-obj-132"
-  end
-
-  it "should have tags" do
-    trajectory_arc.tags.should == {}
-  end
-  
-  it "should have a geometry" do
-    trajectory_arc.geometry.should_not be_nil
-  end
-
-  it "should have a minimum width" do
-    trajectory_arc.minimum_width.should == "wide"
-  end
-  
-  it "should have a length in meter" do
-    trajectory_arc.length.should == "62.59449394845691"
-  end
-  
-end

data/spec/support/georuby_ext.rb

@@ -1,15 +0,0 @@
-def geometry_from_text(text, srid = 4326)
-  GeoRuby::SimpleFeatures::Geometry.from_ewkt "SRID=#{srid};#{text}"
-end
-
-def point(x=0.0, y=0.0, srid = 4326)
-  GeoRuby::SimpleFeatures::Point.from_x_y x, y, srid
-end
-
-def line_string(*points)
-  if points.one? and String === points.first
-     geometry_from_text("LINESTRING(#{points.first})")
-  else
-    GeoRuby::SimpleFeatures::LineString.from_points(points, points.first.srid)
-  end
-end