ninoxe 1.1.5 → 1.2.0

data/app/models/chouette/time_table.rb

@@ -2,13 +2,15 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
   # FIXME http://jira.codehaus.org/browse/JRUBY-6358
   self.primary_key = "id"
 
-  attr_accessible :objectid, :object_version, :creation_time, :creator_id, :version, :comment
-  attr_accessible :int_day_types,:monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday
-  attr_accessible :start_date, :end_date
-  attr_accessor :monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday
+  # attr_accessible :objectid, :object_version, :creation_time, :creator_id, :version, :comment
+  # attr_accessible :int_day_types,:monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday
+  # attr_accessible :start_date, :end_date
+  # attr_accessible :dates_attributes,:periods_attributes
+  # attr_accessible :tag_list, :tag_search
 
   acts_as_taggable
-  attr_accessible :tag_list, :tag_search
+  
+  attr_accessor :monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday  
   attr_accessor :tag_search
 
   def self.ransackable_attributes auth_object = nil
@@ -17,8 +19,8 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
 
   has_and_belongs_to_many :vehicle_journeys, :class_name => 'Chouette::VehicleJourney'
 
-  has_many :dates, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTableDate", :order => :date, :dependent => :destroy
-  has_many :periods, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTablePeriod", :order => :period_start, :dependent => :destroy
+  has_many :dates, -> {order(:date)}, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTableDate", :dependent => :destroy
+  has_many :periods, -> {order(:period_start)}, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTablePeriod", :dependent => :destroy
 
   after_save :save_shortcuts
 
@@ -28,7 +30,6 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
 
   accepts_nested_attributes_for :dates, :allow_destroy => :true
   accepts_nested_attributes_for :periods, :allow_destroy => :true
-  attr_accessible :dates_attributes,:periods_attributes
 
   validates_presence_of :comment
   validates_associated :dates
@@ -406,7 +407,7 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
       end
       self.dates = dates
     end
-    self.dates.sort! { |a,b| a.date <=> b.date}
+    self.dates.to_a.sort! { |a,b| a.date <=> b.date}
     self.save!
     end
   end
@@ -414,131 +415,33 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
   # remove dates form tt which aren't in another_tt
   def intersect!(another_tt)
     transaction do
-    common_day_types = self.int_day_types & another_tt.int_day_types & 508
-    # if both tt have periods with common day_types, intersect them
-    if !self.periods.empty? && !another_tt.periods.empty?
-      if common_day_types != 0
-        periods = []
-        days = []
-        valid_days = self.class.valid_days(common_day_types)
-        self.optimize_periods.each do |p1|
-          another_tt.optimize_periods.each do |p2|
-            if p1.overlap? p2
-              # create period for intersection
-              pi = Chouette::TimeTablePeriod.new(:period_start => [p1.period_start,p2.period_start].max,
-                                                 :period_end => [p1.period_end,p2.period_end].min)
-              if !self.effective_days_of_period(pi,valid_days).empty? && !another_tt.effective_days_of_period(pi,valid_days).empty?
-                if pi.period_start == pi.period_end
-                  days << pi.period_start
-                else
-                  periods << pi
-                end
-              end
-            end
-          end
-        end
-        # intersect dates
-        days |= another_tt.intersects(self.included_days) & self.intersects(another_tt.included_days)
-        excluded_days = self.excluded_days | another_tt.excluded_days
-        self.dates.clear
-        days.each {|day| self.dates << Chouette::TimeTableDate.new( :date =>day, :in_out => true)}
-        self.periods = periods
-        common_day_types = 0 if periods.empty?
-        self.int_day_types = common_day_types
-        days_of_periods = self.effective_days_of_periods
-        excluded_days.each do |day|
-          self.dates << Chouette::TimeTableDate.new( :date =>day, :in_out => false) if days_of_periods.include?(day)
-        end
-      end
-    else
+      
       # transform tt as effective dates and get common ones
       days = another_tt.intersects(self.effective_days) & self.intersects(another_tt.effective_days)
       self.dates.clear
       days.each {|d| self.dates << Chouette::TimeTableDate.new( :date =>d, :in_out => true)}
       self.periods.clear
       self.int_day_types = 0
-    end
-    self.dates.sort! { |a,b| a.date <=> b.date}
-    self.save!
+      self.dates.to_a.sort! { |a,b| a.date <=> b.date}
+      self.save!
     end
   end
 
 
   def disjoin!(another_tt)
     transaction do
-    common_day_types = self.int_day_types & another_tt.int_day_types & 508
-    # if both tt have periods with common day_types, reduce first ones to exclude second
-    if !self.periods.blank? && !another_tt.periods.blank?
-      if common_day_types != 0
-        periods = []
-        days = []
-        valid_days = self.class.valid_days(self.int_day_types)
-        remain_days = self.class.valid_days(self.int_day_types & ~another_tt.int_day_types)
-        self.optimize_periods.each do |p1|
-          deleted = false
-          another_tt.optimize_periods.each do |p2|
-            if  p2.contains? p1
-              # p1 is removed, keep remaining dates as included
-              days |= self.effective_days_of_period(p1,remain_days)
-              deleted = true
-              break
-            elsif  p1.contains? p2
-              # p1 is broken in 2; keep remaining dates covered by p2 as included days
-              days |= self.effective_days_of_period(p2,remain_days)
-              if  p1.period_start != p2.period_start
-                pi = Chouette::TimeTablePeriod.new(:period_start => p1.period_start,
-                                                   :period_end => p2.period_start - 1)
-                if !self.effective_days_of_period(pi,valid_days).empty?
-                  if pi.period_start == pi.period_end
-                    days << pi.period_start
-                  else
-                    periods << pi
-                  end
-                end
-              end
-              if p1.period_end != p2.period_end
-                 p1.period_start = p2.period_end + 1
-              else
-                 deleted = true
-                 break
-              end
-            elsif  p1.overlap? p2
-              if p2.period_start <= p1.period_start
-                p2.period_start = p1.period_start
-                p1.period_start = p2.period_end + 1
-              else
-                p2.period_end = p1.period_end
-                p1.period_end = p2.period_start - 1
-              end
-              days |= self.effective_days_of_period(p2,remain_days)
-            end
-          end
-          unless deleted || self.effective_days_of_period(p1,valid_days).blank?
-            if p1.period_start != p1.period_end
-              periods << p1
-            else
-              days << p1.period_start
-            end
-          end
-        end
-        # rebuild periods and dates
-        self.periods = periods
-        self.int_day_types = 0 if periods.blank?
-        days.each { |d| self.dates |= [Chouette::TimeTableDate.new( :date =>d, :in_out => true)] }
-      end
-    else
-      # otherwise remove or exclude dates and delete empty periods
-      # first remove peculiar dates
-      days = self.intersects(another_tt.effective_days)
-      self.dates -= self.dates.select{|date| days.include?(date.date)}
-      # then add excluded dates
-      self.intersects(another_tt.effective_days).each do |d|
-        self.dates |= [Chouette::TimeTableDate.new( :date =>d, :in_out => false)]
-      end
-    end
-    self.dates.sort! { |a,b| a.date <=> b.date}
-    self.periods.sort! { |a,b| a.period_start <=> b.period_start}
-    self.save!
+      # remove days from another calendar
+      days_to_exclude = self.intersects(another_tt.effective_days)
+      days = self.effective_days - days_to_exclude
+      self.dates.clear
+      self.periods.clear
+      self.int_day_types = 0
+
+      days.each {|d| self.dates << Chouette::TimeTableDate.new( :date =>d, :in_out => true)}
+
+      self.dates.to_a.sort! { |a,b| a.date <=> b.date}
+      self.periods.to_a.sort! { |a,b| a.period_start <=> b.period_start}
+      self.save!
     end
   end
 

data/app/models/chouette/time_table_date.rb

@@ -6,7 +6,7 @@ class Chouette::TimeTableDate < Chouette::ActiveRecord
   validates_presence_of :date
   validates_uniqueness_of :date, :scope => :time_table_id
 
-  attr_accessible :date, :position, :time_table_id, :time_table, :in_out
+  # attr_accessible :date, :position, :time_table_id, :time_table, :in_out
 
   def self.model_name
     ActiveModel::Name.new Chouette::TimeTableDate, Chouette, "TimeTableDate"

data/app/models/chouette/time_table_period.rb

@@ -3,7 +3,7 @@ class Chouette::TimeTablePeriod < Chouette::ActiveRecord
   belongs_to :time_table, inverse_of: :periods
   acts_as_list :scope => 'time_table_id = #{time_table_id}',:top_of_list => 0
 
-  attr_accessible :period_start, :period_end, :position,:time_table_id,:time_table
+  #attr_accessible :period_start, :period_end, :position,:time_table_id,:time_table
   
   validates_presence_of :period_start
   validates_presence_of :period_end

data/app/models/chouette/vehicle_journey.rb

@@ -1,101 +1,106 @@
-class Chouette::VehicleJourney < Chouette::TridentActiveRecord
-  #
-  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
-  self.primary_key = "id"
-
-  attr_accessor :transport_mode_name
-  attr_accessible :route_id, :journey_pattern_id, :time_slot_id, :company_id, :objectid, :object_version, :creation_time, :creator_id, :comment, :status_value
-  attr_accessible :route, :transport_mode,:transport_mode_name, :published_journey_name, :published_journey_identifier, :facility, :vehicle_type_identifier, :number
-  attr_accessible :vehicle_journey_at_stops_attributes, :time_table_tokens, :time_tables, :mobility_restricted_suitability, :flexible_service
-  attr_reader :time_table_tokens
-
-  def self.nullable_attributes
-    [:transport_mode, :published_journey_name, :vehicle_type_identifier, :published_journey_identifier, :comment, :status_value]
-  end
+module Chouette
+  class VehicleJourney < TridentActiveRecord
+    #
+    # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+    self.primary_key = "id"
+
+    # attr_accessible :route_id, :journey_pattern_id, :time_slot_id, :company_id, :objectid, :object_version, :creation_time, :creator_id, :comment, :status_value
+    #  attr_accessible :route, :transport_mode,:transport_mode_name, :published_journey_name, :published_journey_identifier, :facility, :vehicle_type_identifier, :number
+    #  attr_accessible :vehicle_journey_at_stops_attributes, :time_table_tokens, :time_tables, :mobility_restricted_suitability, :flexible_service
+
+    attr_accessor :transport_mode_name
+    attr_reader :time_table_tokens
 
-  belongs_to :company
-  belongs_to :route
-  belongs_to :journey_pattern
+    def self.nullable_attributes
+      [:transport_mode, :published_journey_name, :vehicle_type_identifier, :published_journey_identifier, :comment, :status_value]
+    end
 
-  has_and_belongs_to_many :footnotes, :class_name => 'Chouette::Footnote'
-  attr_accessible :footnote_ids
+    belongs_to :company
+    belongs_to :route
+    belongs_to :journey_pattern
 
-  validates_presence_of :route
-  validates_presence_of :journey_pattern
+    has_and_belongs_to_many :footnotes, :class_name => 'Chouette::Footnote'
+    # attr_accessible :footnote_ids
 
-  has_many :vehicle_journey_at_stops, :dependent => :destroy, :include => :stop_point, :order => "stop_points.position"
-  accepts_nested_attributes_for :vehicle_journey_at_stops, :allow_destroy => true
+    validates_presence_of :route
+    validates_presence_of :journey_pattern
 
-  has_and_belongs_to_many :time_tables, :class_name => 'Chouette::TimeTable'
-  has_many :stop_points, :through => :vehicle_journey_at_stops, :order => 'stop_points.position'
+    has_many :vehicle_journey_at_stops, -> { includes(:stop_point).order("stop_points.position") }, :dependent => :destroy
+    has_and_belongs_to_many :time_tables, :class_name => 'Chouette::TimeTable', :foreign_key => "vehicle_journey_id", :association_foreign_key => "time_table_id"
+    has_many :stop_points, -> { order("stop_points.position") }, :through => :vehicle_journey_at_stops
 
-  validate :increasing_times
-  validates_presence_of :number
+    validate :increasing_times
+    validates_presence_of :number
 
-  before_validation :set_default_values
-  def set_default_values
-    if number.nil?
-      self.number = 0
+    before_validation :set_default_values
+    def set_default_values
+      if number.nil?
+        self.number = 0
+      end
     end
-  end
 
-  def transport_mode_name
-    # return nil if transport_mode is nil
-    transport_mode && Chouette::TransportMode.new( transport_mode.underscore)
-  end
+    scope :without_any_time_table, -> { joins('LEFT JOIN "time_tables_vehicle_journeys" ON "time_tables_vehicle_journeys"."vehicle_journey_id" = "vehicle_journeys"."id" LEFT JOIN "time_tables" ON "time_tables"."id" = "time_tables_vehicle_journeys"."time_table_id"').where(:time_tables => { :id => nil}) }
+    scope :without_any_passing_time, -> { joins('LEFT JOIN "vehicle_journey_at_stops" ON "vehicle_journey_at_stops"."vehicle_journey_id" = "vehicle_journeys"."id"').where(vehicle_journey_at_stops: { id: nil }) }
 
-  def transport_mode_name=(transport_mode_name)
-    self.transport_mode = (transport_mode_name ? transport_mode_name.camelcase : nil)
-  end
+    accepts_nested_attributes_for :vehicle_journey_at_stops, :allow_destroy => true
 
-  @@transport_mode_names = nil
-  def self.transport_mode_names
-    @@transport_mode_names ||= Chouette::TransportMode.all.select do |transport_mode_name|
-      transport_mode_name.to_i > 0
+    def transport_mode_name
+      # return nil if transport_mode is nil
+      transport_mode && Chouette::TransportMode.new( transport_mode.underscore)
     end
-  end
-
 
-  def increasing_times
-    previous = nil
-    vehicle_journey_at_stops.select{|vjas| vjas.departure_time && vjas.arrival_time}.each do |vjas|
-      errors.add( :vehicle_journey_at_stops, 'time gap overflow') unless vjas.increasing_times_validate( previous)
-      previous = vjas
+    def transport_mode_name=(transport_mode_name)
+      self.transport_mode = (transport_mode_name ? transport_mode_name.camelcase : nil)
     end
-  end
 
-  def missing_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
-    selected_journey_pattern.stop_points - self.stop_points
-  end
-  def extra_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
-    self.stop_points - selected_journey_pattern.stop_points
-  end
-  def extra_vjas_in_relation_to_a_journey_pattern(selected_journey_pattern)
-    extra_stops = self.extra_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
-    self.vehicle_journey_at_stops.select { |vjas| extra_stops.include?( vjas.stop_point)}
-  end
-  def time_table_tokens=(ids)
-    self.time_table_ids = ids.split(",")
-  end
-  def bounding_dates
-    dates = []
+    @@transport_mode_names = nil
+    def self.transport_mode_names
+      @@transport_mode_names ||= Chouette::TransportMode.all.select do |transport_mode_name|
+        transport_mode_name.to_i > 0
+      end
+    end
 
-    time_tables.each do |tm|
-      dates << tm.start_date if tm.start_date
-      dates << tm.end_date if tm.end_date
+    def increasing_times
+      previous = nil
+      vehicle_journey_at_stops.select{|vjas| vjas.departure_time && vjas.arrival_time}.each do |vjas|
+        errors.add( :vehicle_journey_at_stops, 'time gap overflow') unless vjas.increasing_times_validate( previous)
+        previous = vjas
+      end
     end
 
-    dates.empty? ? [] : [dates.min, dates.max]
-  end
+    def missing_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      selected_journey_pattern.stop_points - self.stop_points
+    end
+    def extra_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      self.stop_points - selected_journey_pattern.stop_points
+    end
+    def extra_vjas_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      extra_stops = self.extra_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      self.vehicle_journey_at_stops.select { |vjas| extra_stops.include?( vjas.stop_point)}
+    end
+    def time_table_tokens=(ids)
+      self.time_table_ids = ids.split(",")
+    end
+    def bounding_dates
+      dates = []
 
-  def update_journey_pattern( selected_journey_pattern)
-    return unless selected_journey_pattern.route_id==self.route_id
+      time_tables.each do |tm|
+        dates << tm.start_date if tm.start_date
+        dates << tm.end_date if tm.end_date
+      end
 
-    missing_stops_in_relation_to_a_journey_pattern(selected_journey_pattern).each do |sp|
-      self.vehicle_journey_at_stops.build( :stop_point => sp)
+      dates.empty? ? [] : [dates.min, dates.max]
     end
-    extra_vjas_in_relation_to_a_journey_pattern(selected_journey_pattern).each do |vjas|
-      vjas._destroy = true
+
+    def update_journey_pattern( selected_journey_pattern)
+      return unless selected_journey_pattern.route_id==self.route_id
+
+      missing_stops_in_relation_to_a_journey_pattern(selected_journey_pattern).each do |sp|
+        self.vehicle_journey_at_stops.build( :stop_point => sp)
+      end
+      extra_vjas_in_relation_to_a_journey_pattern(selected_journey_pattern).each do |vjas|
+        vjas._destroy = true
+      end
     end
   end
 end

data/app/models/chouette/vehicle_journey_at_stop.rb

@@ -10,7 +10,7 @@ module Chouette
     belongs_to :vehicle_journey
 
     attr_accessor :_destroy
-    attr_accessible :vehicle_journey_id, :stop_point_id, :connecting_service_id, :boarding_alighting_possibility, :arrival_time, :departure_time, :waiting_time, :elapse_duration, :headway_frequency, :_destroy, :stop_point, :for_boarding, :for_alighting
+    # attr_accessible :vehicle_journey_id, :stop_point_id, :connecting_service_id, :boarding_alighting_possibility, :arrival_time, :departure_time, :waiting_time, :elapse_duration, :headway_frequency, :_destroy, :stop_point, :for_boarding, :for_alighting
 
     validate :arrival_must_be_before_departure
     def arrival_must_be_before_departure

data/config/database.yml

@@ -1,11 +1,19 @@
-development:
+default: &default
   adapter: postgresql
-  database: ninoxe_dev
+  encoding: unicode
+  pool: 5
   port: 5432
-  username: <%= ENV['USER'] %>
-  
+  host: localhost
+  username: chouette
+  password: chouette
+
+development:
+  <<: *default
+  database: ninoxe_dev
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
 test:
-  adapter: postgresql
-  database: ninoxe_test
-  port: 5432  
-  username: <%= ENV['USER'] %>
+  <<: *default
+  database: ninoxe_test

data/config/database.yml.travis

@@ -1,9 +1,18 @@
-development:
+default: &default
   adapter: postgresql
-  database: ninoxe_dev
+  encoding: unicode
+  pool: 5
+  port: 5432
+  host: localhost
   username: postgres
-  
+
+development:
+  <<: *default
+  database: ninoxe_dev
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
 test:
-  adapter: postgresql
-  database: ninoxe_test
-  username: postgres
+  <<: *default
+  database: ninoxe_test

data/db/migrate/20150526075108_add_foreign_key_to_routes.rb

@@ -0,0 +1,28 @@
+class AddForeignKeyToRoutes < ActiveRecord::Migration
+require "forwardable"
+  def up
+	 Chouette::Route.all.map do |route|
+		if route.opposite_route_id.present? &&  !Chouette::Route.exists?(route.opposite_route_id) 
+		     route.update_attributes :opposite_route_id => nil
+		end
+	 end
+    change_table :routes do |t|
+      if  @connection.foreign_keys(:routes).any? 
+        @connection.foreign_keys(:routes).map do |f|
+          name = f.options[:name]
+          if (name == "route_opposite_route_fkey" )
+            remove_foreign_key :routes, :name => name
+          end
+        end
+      end
+		t.foreign_key :routes, :dependent => :nullify, :column => 'opposite_route_id', :name => 'route_opposite_route_fkey'
+    end
+     
+  end
+
+  def down
+    change_table :routes do |t|
+      t.remove_foreign_key :name => :route_opposite_route_fkey
+    end
+  end
+end

data/lib/ninoxe/engine.rb

@@ -11,5 +11,9 @@ module Ninoxe
 
       ::Chouette::ActiveRecord.logger = Rails.logger
     end
+
+    initializer "ninoxe.factories", :after => "factory_girl.set_factory_paths" do
+      FactoryGirl.definition_file_paths << File.expand_path('../../../spec/factories', __FILE__) if defined?(FactoryGirl)
+    end
   end
 end

data/lib/ninoxe/version.rb

@@ -1,3 +1,3 @@
 module Ninoxe
-  VERSION = "1.1.5"
+  VERSION = "1.2.0"
 end

data/lib/ninoxe.rb

@@ -6,5 +6,8 @@ require "acts_as_tree"
 require "acts-as-taggable-on"
 require "enumerize"
 
+# Hack to delete to use bundler https://github.com/guard/guard-rspec/issues/258
+require "thor"
+
 module Ninoxe
 end