- 'lib/rich_text.rb'
- 'test/helpers/application_helper_test.rb'
-# Offense count: 90
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: strict, flexible
-Rails/TimeZone:
- Enabled: false
-
# Offense count: 6
# Cop supports --auto-correct.
Rake/Desc:
times = time.split(",")
raise OSM::APIBadUserInput, "bad time range" if times.size != 2
- from, to = times.collect { |t| Time.parse(t) }
+ from, to = times.collect { |t| Time.parse(t).utc }
changesets.where("closed_at >= ? and created_at <= ?", from, to)
else
# if there is no comma, assume its a lower limit on time
- changesets.where("closed_at >= ?", Time.parse(time))
+ changesets.where("closed_at >= ?", Time.parse(time).utc)
end
# stupid Time seems to throw both of these for bad parsing, so
# we have to catch both and ensure the correct code path is taken.
changesets
else
changesets.where("closed_at >= ? and num_changes <= ?",
- Time.now.getutc, Changeset::MAX_ELEMENTS)
+ Time.now.utc, Changeset::MAX_ELEMENTS)
end
end
changesets
else
changesets.where("closed_at < ? or num_changes > ?",
- Time.now.getutc, Changeset::MAX_ELEMENTS)
+ Time.now.utc, Changeset::MAX_ELEMENTS)
end
end
# Add any date filter
if params[:from]
begin
- from = Time.parse(params[:from])
+ from = Time.parse(params[:from]).utc
rescue ArgumentError
raise OSM::APIBadUserInput, "Date #{params[:from]} is in a wrong format"
end
begin
to = if params[:to]
- Time.parse(params[:to])
+ Time.parse(params[:to]).utc
else
- Time.now
+ Time.now.utc
end
rescue ArgumentError
raise OSM::APIBadUserInput, "Date #{params[:to]} is in a wrong format"
elsif closed_since.positive?
notes.where(:status => "open")
.or(notes.where(:status => "closed")
- .where(notes.arel_table[:closed_at].gt(Time.now - closed_since.days)))
+ .where(notes.arel_table[:closed_at].gt(Time.now.utc - closed_since.days)))
else
notes.where(:status => "open")
end
:visibility => visibility,
:inserted => false,
:user => current_user,
- :timestamp => Time.now.getutc,
+ :timestamp => Time.now.utc,
:file => file
)
friendship.befriendee = @new_friend
if current_user.is_friends_with?(@new_friend)
flash[:warning] = t "friendships.make_friend.already_a_friend", :name => @new_friend.display_name
- elsif current_user.friendships.where("created_at >= ?", Time.now.getutc - 1.hour).count >= current_user.max_friends_per_hour
+ elsif current_user.friendships.where("created_at >= ?", Time.now.utc - 1.hour).count >= current_user.max_friends_per_hour
flash.now[:error] = t "friendships.make_friend.limit_exceeded"
elsif friendship.save
flash[:notice] = t "friendships.make_friend.success", :name => @new_friend.display_name
@message = Message.new(message_params)
@message.recipient = @user
@message.sender = current_user
- @message.sent_on = Time.now.getutc
+ @message.sent_on = Time.now.utc
- if current_user.sent_messages.where("sent_on >= ?", Time.now.getutc - 1.hour).count >= current_user.max_messages_per_hour
+ if current_user.sent_messages.where("sent_on >= ?", Time.now.utc - 1.hour).count >= current_user.max_messages_per_hour
flash.now[:error] = t ".limit_exceeded"
render :action => "new"
elsif @message.save
:description => params[:trace][:description],
:visibility => params[:trace][:visibility],
:inserted => false, :user => current_user,
- :timestamp => Time.now.getutc)
+ :timestamp => Time.now.utc)
@trace.valid?
@trace.errors.add(:gpx_file, "can't be blank")
:visibility => visibility,
:inserted => false,
:user => current_user,
- :timestamp => Time.now.getutc,
+ :timestamp => Time.now.utc,
:file => file
)
end
def edit
- params[:user_block_period] = ((@user_block.ends_at - Time.now.getutc) / 1.hour).ceil.to_s
+ params[:user_block_period] = ((@user_block.ends_at - Time.now.utc) / 1.hour).ceil.to_s
end
def create
:user => @user,
:creator => current_user,
:reason => params[:user_block][:reason],
- :ends_at => Time.now.getutc + @block_period.hours,
+ :ends_at => Time.now.utc + @block_period.hours,
:needs_view => params[:user_block][:needs_view]
)
flash[:error] = t(".only_creator_can_edit")
redirect_to :action => "edit"
elsif @user_block.update(
- :ends_at => Time.now.getutc + @block_period.hours,
+ :ends_at => Time.now.utc + @block_period.hours,
:reason => params[:user_block][:reason],
:needs_view => params[:user_block][:needs_view]
)
elsif current_user
unless current_user.terms_agreed?
current_user.consider_pd = params[:user][:consider_pd]
- current_user.tou_agreed = Time.now.getutc
- current_user.terms_agreed = Time.now.getutc
+ current_user.tou_agreed = Time.now.utc
+ current_user.terms_agreed = Time.now.utc
current_user.terms_seen = true
flash[:notice] = t "users.new.terms accepted" if current_user.save
current_user.description = "" if current_user.description.nil?
current_user.creation_ip = request.remote_ip
current_user.languages = http_accept_language.user_preferred_languages
- current_user.terms_agreed = Time.now.getutc
- current_user.tou_agreed = Time.now.getutc
+ current_user.terms_agreed = Time.now.utc
+ current_user.tou_agreed = Time.now.utc
current_user.terms_seen = true
if current_user.auth_uid.blank?
end
def changeset_details(changeset)
- if changeset.closed_at > Time.now
+ if changeset.closed_at > Time.now.utc
action = :created
time = time_ago_in_words(changeset.created_at, :scope => :"datetime.distance_in_words_ago")
title = l(changeset.created_at)
if block.active?
# if the block hasn't expired yet show the date, if the user just needs to login show that
if block.needs_view?
- if block.ends_at > Time.now.getutc
+ if block.ends_at > Time.now.utc
t("user_blocks.helper.time_future_and_until_login_html", :time => friendly_date(block.ends_at))
else
t("user_blocks.helper.until_login")
protected
def set_authorized_at
- self.authorized_at = Time.now
+ self.authorized_at = Time.now.utc
end
end
# note that this may not be a hard limit - due to timing changes and
# concurrency it is possible that some changesets may be slightly
# longer than strictly allowed or have slightly more changes in them.
- ((closed_at > Time.now.getutc) && (num_changes <= MAX_ELEMENTS))
+ ((closed_at > Time.now.utc) && (num_changes <= MAX_ELEMENTS))
end
def set_closed_time_now
- self.closed_at = Time.now.getutc if is_open?
+ self.closed_at = Time.now.utc if is_open?
end
def self.from_xml(xml, create: false)
def self.from_xml_node(pt, create: false)
cs = Changeset.new
if create
- cs.created_at = Time.now.getutc
+ cs.created_at = Time.now.utc
# initial close time is 1h ahead, but will be increased on each
# modification.
cs.closed_at = cs.created_at + IDLE_TIMEOUT
self.closed_at = if (closed_at - created_at) > (MAX_TIME_OPEN - IDLE_TIMEOUT)
created_at + MAX_TIME_OPEN
else
- Time.now.getutc + IDLE_TIMEOUT
+ Time.now.utc + IDLE_TIMEOUT
end
end
end
event :resolve do
transitions :from => :open, :to => :resolved
after do
- self.resolved_at = Time.now.getutc
+ self.resolved_at = Time.now.utc
end
end
private
def save_with_history!
- t = Time.now.getutc
+ t = Time.now.utc
self.version += 1
self.timestamp = t
# Close a note
def close
self.status = "closed"
- self.closed_at = Time.now.getutc
+ self.closed_at = Time.now.utc
save
end
def generate_keys
self.token = OAuth::Helper.generate_key(20)[0, 20]
self.expires_at = 10.minutes.from_now
- self.authorized_at = Time.now
+ self.authorized_at = Time.now.utc
end
end
end
def invalidate!
- update(:invalidated_at => Time.now)
+ update(:invalidated_at => Time.now.utc)
end
def authorized?
private
def save_with_history!
- t = Time.now.getutc
+ t = Time.now.utc
self.version += 1
self.timestamp = t
return false if authorized?
self.user = user
- self.authorized_at = Time.now
+ self.authorized_at = Time.now.utc
self.verifier = OAuth::Helper.generate_key(20)[0, 20] unless oauth10?
save
end
##
# scope to match active blocks
def self.active
- where("needs_view or ends_at > ?", Time.now.getutc)
+ where("needs_view or ends_at > ?", Time.now.utc)
end
##
# returns true if the block is currently active (i.e: the user can't
# use the API).
def active?
- needs_view || ends_at > Time.now.getutc
+ needs_view || ends_at > Time.now.utc
end
##
# is the user object who is revoking the ban.
def revoke!(revoker)
update(
- :ends_at => Time.now.getutc,
+ :ends_at => Time.now.utc,
:revoker_id => revoker.id,
:needs_view => false
)
after_initialize :set_defaults
def expired?
- expiry < Time.now
+ expiry < Time.now.utc
end
private
private
def save_with_history!
- t = Time.now.getutc
+ t = Time.now.utc
self.version += 1
self.timestamp = t
elsif reader.name == "ele" && point
point.altitude = reader.read_string.to_f
elsif reader.name == "time" && point
- point.timestamp = Time.parse(reader.read_string)
+ point.timestamp = Time.parse(reader.read_string).utc
end
when XML::Reader::TYPE_END_ELEMENT
if reader.name == "trkpt" && point && point.valid?
require File.join(File.dirname(__FILE__), "..", "config", "environment")
-start_time = Time.now
+start_time = Time.now.utc
puts "<html>"
puts "<head>"
puts "<p><em>Exception: #{e}</em><br />#{e.backtrace.join('<br />')}</p>"
end
-puts "<p>Report took #{Time.new - start_time} seconds to run</p>"
+puts "<p>Report took #{Time.now.utc - start_time} seconds to run</p>"
puts "</body>"
puts "</html>"
addresses = User.count(
:conditions => {
:status => %w[suspended deleted],
- :creation_time => Time.now - 28.days..Time.now
+ :creation_time => Time.now.utc - 28.days..Time.now.utc
},
:group => :creation_ip
)
assert_response :forbidden
# Try again, after agreement with the terms
- user.terms_agreed = Time.now
+ user.terms_agreed = Time.now.utc
user.save!
assert_difference "ChangesetComment.count", 1 do
assert_response :forbidden
# Try again, after agreement with the terms
- user.terms_agreed = Time.now
+ user.terms_agreed = Time.now.utc
user.save!
assert_difference "ChangesetComment.count", 1 do
# test that it really is closed now
cs = Changeset.find(changeset.id)
assert_not(cs.is_open?,
- "changeset should be closed now (#{cs.closed_at} > #{Time.now.getutc}.")
+ "changeset should be closed now (#{cs.closed_at} > #{Time.now.utc}.")
end
##
end
assert_response :gone
- closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
+ closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now.utc)
assert_no_difference "NoteComment.count" do
post comment_note_path(:id => closed_note_with_comment, :text => "This is an additional comment"), :headers => auth_header
post close_note_path(:id => hidden_note_with_comment), :headers => auth_header
assert_response :gone
- closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
+ closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now.utc)
post close_note_path(:id => closed_note_with_comment), :headers => auth_header
assert_response :conflict
end
def test_reopen_success
- closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
+ closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now.utc)
user = create(:user)
post reopen_note_path(:id => closed_note_with_comment, :text => "This is a reopen comment", :format => "json")
end
def test_index_closed
- create(:note_with_comments, :status => "closed", :closed_at => Time.now - 5.days)
- create(:note_with_comments, :status => "closed", :closed_at => Time.now - 100.days)
+ create(:note_with_comments, :status => "closed", :closed_at => Time.now.utc - 5.days)
+ create(:note_with_comments, :status => "closed", :closed_at => Time.now.utc - 100.days)
create(:note_with_comments, :status => "hidden")
create(:note_with_comments)
def test_read_closed_note
user = create(:user)
- closed_note = create(:note_with_comments, :status => "closed", :closed_at => Time.now, :comments_count => 2) do |note|
+ closed_note = create(:note_with_comments, :status => "closed", :closed_at => Time.now.utc, :comments_count => 2) do |note|
create(:note_comment, :event => "closed", :note => note, :author => user)
end
m = Message.last
assert_equal user.id, m.from_user_id
assert_equal recipient_user.id, m.to_user_id
- assert_in_delta Time.now, m.sent_on, 2
+ assert_in_delta Time.now.utc, m.sent_on, 2
assert_equal "Test Message", m.title
assert_equal "Test message body", m.body
assert_equal "markdown", m.body_format
assert_redirected_to user_block_path(:id => id)
assert_equal "Created a block on user #{target_user.display_name}.", flash[:notice]
b = UserBlock.find(id)
- assert_in_delta Time.now, b.created_at, 1
- assert_in_delta Time.now, b.updated_at, 1
- assert_in_delta Time.now + 12.hours, b.ends_at, 1
+ assert_in_delta Time.now.utc, b.created_at, 1
+ assert_in_delta Time.now.utc, b.updated_at, 1
+ assert_in_delta Time.now.utc + 12.hours, b.ends_at, 1
assert_not b.needs_view
assert_equal "Vandalism", b.reason
assert_equal "markdown", b.reason_format
assert_redirected_to user_block_path(active_block)
assert_equal "Block updated.", flash[:notice]
b = UserBlock.find(active_block.id)
- assert_in_delta Time.now, b.updated_at, 1
+ assert_in_delta Time.now.utc, b.updated_at, 1
assert b.needs_view
assert_equal "Vandalism", b.reason
assert_response :success
assert_template "revoke"
b = UserBlock.find(active_block.id)
- assert b.ends_at - Time.now > 100
+ assert b.ends_at - Time.now.utc > 100
# Check that revoking a block works using POST
post revoke_user_block_path(:id => active_block, :confirm => true)
assert_redirected_to user_block_path(active_block)
b = UserBlock.find(active_block.id)
- assert_in_delta Time.now, b.ends_at, 1
+ assert_in_delta Time.now.utc, b.ends_at, 1
# We should get an error if the block doesn't exist
get revoke_user_block_path(:id => 99999)
factory :message do
sequence(:title) { |n| "Message #{n}" }
sequence(:body) { |n| "Body text for message #{n}" }
- sent_on { Time.now }
+ sent_on { Time.now.utc }
association :sender, :factory => :user
association :recipient, :factory => :user
changeset
visible { true }
- timestamp { Time.now }
+ timestamp { Time.now.utc }
version { 1 }
trait :deleted do
association :current_node, :factory => :node
visible { true }
- timestamp { Time.now }
+ timestamp { Time.now.utc }
version { 1 }
end
end
FactoryBot.define do
factory :old_relation do
- timestamp { Time.now }
+ timestamp { Time.now.utc }
visible { true }
version { 1 }
FactoryBot.define do
factory :old_way do
- timestamp { Time.now }
+ timestamp { Time.now.utc }
visible { true }
version { 1 }
FactoryBot.define do
factory :relation do
- timestamp { Time.now }
+ timestamp { Time.now.utc }
visible { true }
version { 1 }
latitude { 1 * GeoRecord::SCALE }
longitude { 1 * GeoRecord::SCALE }
# tile { QuadTile.tile_for_point(1,1) }
- timestamp { Time.now }
+ timestamp { Time.now.utc }
trace
end
user
- timestamp { Time.now }
+ timestamp { Time.now.utc }
inserted { true }
size { 10 }
end
terms_seen { true }
- terms_agreed { Time.now.getutc }
+ terms_agreed { Time.now.utc }
data_public { true }
trait :with_home_location do
FactoryBot.define do
factory :user_block do
sequence(:reason) { |n| "User Block #{n}" }
- ends_at { Time.now + 1.day }
+ ends_at { Time.now.utc + 1.day }
user
association :creator, :factory => :moderator_user
end
trait :expired do
- ends_at { Time.now - 1.day }
+ ends_at { Time.now.utc - 1.day }
end
trait :revoked do
FactoryBot.define do
factory :way do
- timestamp { Time.now }
+ timestamp { Time.now.utc }
visible { true }
version { 1 }
end
def test_friendly_date
- date = friendly_date(Time.new(2014, 3, 5, 18, 58, 23))
+ date = friendly_date(Time.new(2014, 3, 5, 18, 58, 23).utc)
assert_match %r{^<span title=" *5 March 2014 at 18:58">.*</span>$}, date
- date = friendly_date(Time.now - 1.hour)
+ date = friendly_date(Time.now.utc - 1.hour)
assert_match %r{^<span title=".*">about 1 hour</span>$}, date
- date = friendly_date(Time.now - 2.days)
+ date = friendly_date(Time.now.utc - 2.days)
assert_match %r{^<span title=".*">2 days</span>$}, date
- date = friendly_date(Time.now - 3.weeks)
+ date = friendly_date(Time.now.utc - 3.weeks)
assert_match %r{^<span title=".*">21 days</span>$}, date
- date = friendly_date(Time.now - 4.months)
+ date = friendly_date(Time.now.utc - 4.months)
assert_match %r{^<span title=".*">4 months</span>$}, date
end
include ApplicationHelper
def test_block_status
- block = create(:user_block, :needs_view, :ends_at => Time.now.getutc)
+ block = create(:user_block, :needs_view, :ends_at => Time.now.utc)
assert_equal "Active until the user logs in.", block_status(block)
- block = create(:user_block, :needs_view, :ends_at => Time.now.getutc + 1.hour)
+ block = create(:user_block, :needs_view, :ends_at => Time.now.utc + 1.hour)
assert_match %r{^Ends in <span title=".*">about 1 hour</span> and after the user has logged in\.$}, block_status(block)
- block = create(:user_block, :ends_at => Time.now.getutc + 1.hour)
+ block = create(:user_block, :ends_at => Time.now.utc + 1.hour)
assert_match %r{^Ends in <span title=".*">about 1 hour</span>\.$}, block_status(block)
end
:user_id => blocked_user.id,
:creator_id => create(:moderator_user).id,
:reason => "testing",
- :ends_at => Time.now.getutc + 5.minutes
+ :ends_at => Time.now.utc + 5.minutes
)
get "/api/#{Settings.api_version}/user/details", :headers => basic_authorization_header(blocked_user.display_name, "test")
assert_response :forbidden
:user_id => blocked_user.id,
:creator_id => moderator.id,
:reason => "testing",
- :ends_at => Time.now.getutc + 5.minutes
+ :ends_at => Time.now.utc + 5.minutes
)
get "/api/#{Settings.api_version}/user/details", :headers => basic_authorization_header(blocked_user.display_name, "test")
assert_response :forbidden
from "from@example.com"
to "to@example.com"
subject "Test message"
- date Time.now
+ date Time.now.utc
content_type "text/plain; charset=utf-8"
body "This is a test & a message"
end
from "from@example.com"
to "to@example.com"
subject "Test message"
- date Time.now
+ date Time.now.utc
content_type "text/html; charset=utf-8"
body "<p>This is a <b>test</b> & a message</p>"
end
from "from@example.com"
to "to@example.com"
subject "Test message"
- date Time.now
+ date Time.now.utc
text_part do
content_type "text/plain; charset=utf-8"
from "from@example.com"
to "to@example.com"
subject "Test message"
- date Time.now
+ date Time.now.utc
html_part do
content_type "text/html; charset=utf-8"
from "from@example.com"
to "to@example.com"
subject "[OpenStreetMap] Test message"
- date Time.now
+ date Time.now.utc
content_type "text/plain; charset=utf-8"
body "This is a test & a message"
end
end
def test_reopen
- note = create(:note, :status => "closed", :closed_at => Time.now)
+ note = create(:note, :status => "closed", :closed_at => Time.now.utc)
assert_equal "closed", note.status
assert_not_nil note.closed_at
note.reopen
end
def test_closed?
- assert create(:note, :status => "closed", :closed_at => Time.now).closed?
+ assert create(:note, :status => "closed", :closed_at => Time.now.utc).closed?
assert_not create(:note, :status => "open", :closed_at => nil).closed?
end
projects / rails.git / commitdiff