ninoxe 0.0.8

data/app/models/chouette/command.rb

@@ -0,0 +1,93 @@
+require 'tmpdir'
+
+#if RUBY_PLATFORM == "java"
+  # FIXME disable remove_entry_secure because incompatible with jruby ?! 
+  # See http://jira.codehaus.org/browse/JRUBY-4082
+  module FileUtils
+    def self.remove_entry_secure(*args)
+      self.remove_entry *args
+    end
+  end
+#end
+
+class Chouette::Command
+
+  include Chouette::CommandLineSupport
+
+  @@command = "chouette"
+  cattr_accessor :command
+
+  attr_accessor :database, :schema, :host, :user, :password
+
+  def initialize(options = {})
+    database_options_from_active_record.merge(options).each do |k,v|
+      send "#{k}=", v
+    end
+  end
+
+  def database_options_from_active_record
+    config = Chouette::ActiveRecord.connection_pool.spec.config
+    { 
+      :database => config[:database], 
+      :user => config[:username],
+      :password => config[:password],
+      :host => (config[:host] or "localhost")
+    }
+  end
+
+
+  def run!(options = {})
+    Dir.mktmpdir do |config_dir|
+      chouette_properties = File.join(config_dir, "chouette.properties")
+      open(chouette_properties, "w") do |f|
+        f.puts "database.name = #{database}"
+        f.puts "database.schema = #{schema}"
+        #f.puts "database.showsql = true"
+        f.puts "hibernate.username = #{user}"
+        f.puts "hibernate.password = #{password}"
+        f.puts "jdbc.url=jdbc:postgresql://#{host}:5432/#{database}"
+        f.puts "jdbc.username = #{user}"
+        f.puts "jdbc.password = #{password}"
+        f.puts "database.hbm2ddl.auto=update"
+      end
+
+      logger.debug "Chouette properties: #{File.readlines(chouette_properties).collect(&:strip).join(', ')}"
+
+      command_line = "#{command} -classpath #{config_dir} #{command_options(options)}"
+      logger.debug "Execute '#{command_line}'"
+
+      execute! command_line
+    end
+  end
+
+  class Option
+
+    attr_accessor :key, :value
+
+    def initialize(key, value)
+      @key, @value = key.to_s, value
+    end
+
+    def command_key
+      key.camelize(:lower) 
+    end
+
+    def to_s
+      unless value == true
+        "-#{command_key} #{value}"
+      else
+        "-#{command_key}"
+      end
+    end
+
+  end
+
+  def command_options(options)
+    options.collect do |key, value|
+      Option.new(key, value)
+    end.sort_by(&:key).join(' ')
+  end
+
+  
+
+end

data/app/models/chouette/command_line_support.rb

@@ -0,0 +1,35 @@
+module Chouette::CommandLineSupport
+
+  class ExecutionError < StandardError; end
+
+  def available_loggers
+    [].tap do |logger|
+      logger << Chouette::ActiveRecord.logger  
+      logger << Rails.logger if defined?(Rails)
+      logger << Logger.new($stdout)
+    end.compact
+  end
+
+  def logger
+    @logger ||= available_loggers.first
+  end
+
+  def max_output_length
+    2000
+  end
+
+  def execute!(command)
+    logger.debug "execute '#{command}'"
+
+    output = `#{command} 2>&1`
+    output = "[...] #{output[-max_output_length,max_output_length]}" if output.length > max_output_length
+    logger.info output unless output.empty?
+
+    if $? != 0
+      raise ExecutionError.new("Command failed: #{command} (error code #{$?})")
+    end
+
+    true
+  end
+
+end

data/app/models/chouette/company.rb

@@ -0,0 +1,19 @@
+class Chouette::Company < Chouette::TridentActiveRecord
+  has_many :lines
+  
+  validates_presence_of :registration_number
+  validates_uniqueness_of :registration_number
+  validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}
+
+  validates_presence_of :name
+
+  attr_accessible :objectid, :object_version, :creation_time, :creator_id, :name, :short_name
+  attr_accessible :organizational_unit, :operating_department_name, :code, :phone, :fax, :email, :registration_number
+ 
+  def self.nullable_attributes
+    [:organizational_unit, :operating_department_name, :code, :phone, :fax, :email]
+  end
+  
+
+end
+

data/app/models/chouette/connection_link.rb

@@ -0,0 +1,43 @@
+class Chouette::ConnectionLink < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  attr_accessor :connection_link_type
+
+  attr_accessible :connection_link_type,:departure_id, :arrival_id, :objectid, :object_version, :creation_time, :creator_id, :name, :comment
+  attr_accessible :link_distance, :link_type, :default_duration, :frequent_traveller_duration, :occasional_traveller_duration
+  attr_accessible :mobility_restricted_traveller_duration, :mobility_restricted_suitability, :stairs_availability, :lift_availability, :int_user_needs
+
+  belongs_to :departure, :class_name => 'Chouette::StopArea'
+  belongs_to :arrival, :class_name => 'Chouette::StopArea'
+
+  validates_presence_of :name
+  validates_presence_of :link_type
+
+  def connection_link_type
+    link_type && Chouette::ConnectionLinkType.new( link_type.underscore)
+  end
+
+  def connection_link_type=(connection_link_type)
+    self.link_type = (connection_link_type ? connection_link_type.camelcase : nil)
+  end
+
+  @@connection_link_types = nil
+  def self.connection_link_types
+    @@connection_link_types ||= Chouette::ConnectionLinkType.all
+  end
+
+  def possible_areas
+    Chouette::StopArea.where("area_type != 'ITL'")
+  end
+
+  def stop_areas
+    Chouette::StopArea.where(:id => [self.departure_id,self.arrival_id])
+  end
+
+  def geometry
+    GeoRuby::SimpleFeatures::LineString.from_points( [ departure.geometry, arrival.geometry], 4326) if departure.geometry and arrival.geometry
+  end
+
+end
+

data/app/models/chouette/connection_link_type.rb

@@ -0,0 +1,51 @@
+class Chouette::ConnectionLinkType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["underground", 0],
+    ["mixed", 1],
+    ["overground", 2]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
+

data/app/models/chouette/direction.rb

@@ -0,0 +1,60 @@
+class Chouette::Direction < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    to_s
+  end
+
+  @@definitions = [
+    ["straight_forward", 0],
+    ["backward", 1],
+    ["clock_wise", 2],
+    ["counter_clock_wise", 3],
+    ["north", 4],
+    ["north_west", 5],
+    ["west", 6],
+    ["south_west", 7],
+    ["south", 8],
+    ["south_east", 9],
+    ["east", 10],
+    ["north_east", 11]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
+

data/app/models/chouette/exporter.rb

@@ -0,0 +1,32 @@
+class Chouette::Exporter
+
+  attr_reader :schema
+
+  def initialize(schema)
+    @schema = schema
+  end
+
+  def chouette_command
+    @chouette_command ||= Chouette::Command.new(:schema => schema)
+  end
+
+  def export(file, options = {})
+    options = {
+      :format => :neptune
+    }.merge(options)
+
+    command_options = {
+      :c => "export", 
+      :o => "line", 
+      :format => options.delete(:format).to_s.upcase, 
+      :output_file => File.expand_path(file), 
+      :optimize_memory => true
+    }.merge(options)
+
+    logger.info "Export #{file} in schema #{schema}"
+    chouette_command.run! command_options
+  end
+
+  include Chouette::CommandLineSupport
+
+end

data/app/models/chouette/file_validator.rb

@@ -0,0 +1,47 @@
+class Chouette::FileValidator
+
+  attr_reader :schema, :database, :user, :password, :host
+
+  def initialize(schema)
+    @schema = schema
+
+    Chouette::ActiveRecord.connection_pool.spec.config.tap do |config|
+      @database = config[:database]
+      @user = config[:username]
+      @password = config[:password]
+      @host = (config[:host] or "localhost")
+    end
+  end
+
+  def self.chouette_command=(command)
+    Chouette::Command.command = command
+  end
+
+  class << self
+    deprecate :chouette_command= => "Use Chouette::Command.command ="
+  end
+
+  def chouette_command
+    @chouette_command ||= Chouette::Command.new(:schema => schema)
+  end
+
+  def validate(file, options = {})
+    options = {
+      :format => :neptune
+    }.merge(options)
+
+    command_options = {
+      :c => "validate", 
+      :o => "line", 
+      :input_file => File.expand_path(file), 
+      :optimize_memory => true
+    }.merge(options)
+
+    logger.info "Validate #{file}"
+    chouette_command.run! command_options
+  end
+
+
+  include Chouette::CommandLineSupport
+
+end

data/app/models/chouette/group_of_line.rb

@@ -0,0 +1,30 @@
+class Chouette::GroupOfLine < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+  
+  has_and_belongs_to_many :lines, :class_name => 'Chouette::Line', :order => 'lines.name'
+
+  validates_presence_of :name
+
+  attr_accessible :objectid, :object_version, :creation_time, :creator_id, :name, :comment, :lines  
+  attr_accessible :line_tokens
+  attr_reader :line_tokens
+  
+  def self.nullable_attributes
+    [:comment]
+  end
+  
+  def commercial_stop_areas
+    Chouette::StopArea.joins(:children => [:stop_points => [:route => [:line => :group_of_lines] ] ]).where(:group_of_lines => {:id => self.id}).uniq
+  end
+
+  def stop_areas
+    Chouette::StopArea.joins(:stop_points => [:route => [:line => :group_of_lines] ]).where(:group_of_lines => {:id => self.id})
+  end
+  
+  def line_tokens=(ids)
+    self.line_ids = ids.split(",")
+  end
+
+end
+

data/app/models/chouette/journey_pattern.rb

@@ -0,0 +1,63 @@
+class Chouette::JourneyPattern < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  belongs_to :route
+  has_many :vehicle_journeys, :dependent => :destroy
+  has_many :vehicle_journey_at_stops, :through => :vehicle_journeys
+  has_and_belongs_to_many :stop_points, :class_name => 'Chouette::StopPoint', :order => 'stop_points.position', :before_add => :vjas_add, :before_remove => :vjas_remove, :after_add => :shortcuts_update_for_add, :after_remove => :shortcuts_update_for_remove
+
+  attr_accessible :route_id, :objectid, :object_version, :creation_time, :creator_id, :name, :comment, :registration_number, :published_name, :departure_stop_point_id, :arrival_stop_point_id, :stop_point_ids, :stop_points
+  
+  # TODO: this a workarround
+  # otherwise, we loose the first stop_point 
+  # when creating a new journey_pattern
+  def special_update
+    bck_sp = self.stop_points.map {|s| s}
+    self.update_attributes :stop_points => []
+    self.update_attributes :stop_points => bck_sp
+  end
+
+  def departure_stop_point
+    return unless departure_stop_point_id
+    Chouette::StopPoint.find( departure_stop_point_id)
+  end
+  def arrival_stop_point
+    return unless arrival_stop_point_id
+    Chouette::StopPoint.find( arrival_stop_point_id)
+  end
+
+  def shortcuts_update_for_add( stop_point)
+    stop_points << stop_point unless stop_points.include?( stop_point)
+
+    ordered_stop_points = stop_points
+    ordered_stop_points = ordered_stop_points.sort { |a,b| a.position <=> b.position} unless ordered_stop_points.empty?
+
+    self.update_attributes!( :departure_stop_point_id => (ordered_stop_points.first && ordered_stop_points.first.id),
+                             :arrival_stop_point_id => (ordered_stop_points.last && ordered_stop_points.last.id))
+  end
+  def shortcuts_update_for_remove( stop_point)
+    stop_points.delete( stop_point) if stop_points.include?( stop_point)
+    
+    ordered_stop_points = stop_points
+    ordered_stop_points = ordered_stop_points.sort { |a,b| a.position <=> b.position} unless ordered_stop_points.empty?
+
+    self.update_attributes!( :departure_stop_point_id => (ordered_stop_points.first && ordered_stop_points.first.id),
+                             :arrival_stop_point_id => (ordered_stop_points.last && ordered_stop_points.last.id))
+  end
+  def vjas_add( stop_point)
+    return if new_record? 
+
+    vehicle_journeys.each do |vj|
+      vjas = vj.vehicle_journey_at_stops.create :stop_point_id => stop_point.id 
+    end
+  end
+  def vjas_remove( stop_point)
+    return if new_record?
+
+    vehicle_journey_at_stops.where( :stop_point_id => stop_point.id).each do |vjas|
+      vjas.destroy
+    end
+  end
+end
+

data/app/models/chouette/line.rb

@@ -0,0 +1,65 @@
+class Chouette::Line < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  attr_accessor :transport_mode
+  attr_accessible :transport_mode, :network_id, :company_id, :objectid, :object_version
+  attr_accessible :creation_time, :creator_id, :name, :number, :published_name, :transport_mode_name
+  attr_accessible :registration_number, :comment, :mobility_restricted_suitability, :int_user_needs
+
+  belongs_to :company
+  belongs_to :network
+  has_many :routes, :dependent => :destroy
+  has_many :journey_patterns, :through => :routes
+
+  has_and_belongs_to_many :group_of_lines, :class_name => 'Chouette::GroupOfLine', :order => 'group_of_lines.name'
+  attr_accessible :group_of_lines, :group_of_line_ids, :group_of_line_tokens
+  attr_reader :group_of_line_tokens
+
+  validates_presence_of :network
+  validates_presence_of :company
+
+  validates_presence_of :registration_number
+  validates_uniqueness_of :registration_number
+  validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}
+
+  validates_presence_of :name
+  
+  def self.nullable_attributes
+    [:published_name, :number, :comment]
+  end
+
+  def transport_mode
+    # return nil if transport_mode_name is nil
+    transport_mode_name && Chouette::TransportMode.new( transport_mode_name.underscore)
+  end
+
+  def transport_mode=(transport_mode)
+    self.transport_mode_name = (transport_mode ? transport_mode.camelcase : nil)
+  end
+
+  @@transport_modes = nil
+  def self.transport_modes
+    @@transport_modes ||= Chouette::TransportMode.all.select do |transport_mode|
+      transport_mode.to_i > 0
+    end
+  end
+
+  def commercial_stop_areas
+    Chouette::StopArea.joins(:children => [:stop_points => [:route => :line] ]).where(:lines => {:id => self.id}).uniq
+  end
+
+  def stop_areas
+    Chouette::StopArea.joins(:stop_points => [:route => :line]).where(:lines => {:id => self.id})
+  end
+
+  def stop_areas_last_parents
+    Chouette::StopArea.joins(:stop_points => [:route => :line]).where(:lines => {:id => self.id}).collect(&:root).flatten.uniq
+  end
+
+  def group_of_line_tokens=(ids)
+    self.group_of_line_ids = ids.split(",")
+  end
+
+
+end

data/app/models/chouette/link_orientation_type.rb

@@ -0,0 +1,49 @@
+class Chouette::LinkOrientationType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["access_point_to_stop_area", 0],
+    ["stop_area_to_access_point", 1]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end