ignore_nsec 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be45015634ef3b453c087b0a42506df7beb18179
+  data.tar.gz: 165ec182423b7905a9ba0f056b828215e8574d42
+SHA512:
+  metadata.gz: a09d81851252ed2577484a5f6c1d2b95375b4b1df1f839aaab22fce65af3e939de92182c59a8f203c5b97fad0c23c4656bd30b1ba918eb54eaebb479d6a58ac6
+  data.tar.gz: e9be5bafa488788bef891dc02f4f4a1d913735fbdd71999e7e86166626667bd5b903587b7d571942583c83d5d854695966ca18399d985c9e19820ce60667a52f

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 FineLine Prototyping, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+## Ignore Nsec
+
+Have ever run into a strange problem in Ruby where two Time instances that looked the same were different? You may have run into the nanosecond precision problem.
+
+The ignore_nsec gem takes care of that. With the gem, nanoseconds are still available via the `nsec` and other methods, but the `<=>` method on Time instances will ignore nanoseconds, which resolves problems caused by some operating systems providing nanosecond precision that is more precise than what the database accepts, so when you compare a time before persisting, then retrieve the record and compare times, the times will be different. For example, let's setup two times with different nanoseconds:
+
+```ruby
+# note: We are manually setting Time nsec here, so it isn't checking that
+# your OS is returning nsec in the current time, nor is it checking your
+# database stores or does not store nsec with (date)time.
+#
+a = Time.at(421.158888888)
+b = Time.at(421.15888888)
+a == b # => false
+```
+
+While using this gem, Time instances will return `to_i <=> other.to_i` if the object that a Time is being compared to looks like a Time (i.e. responds to `nsec`). Using the same example:
+
+```ruby
+a == b # => true
+```
+
+### Checking nsec
+
+Run Time.now a few times in `irb` and see if it always seems to return the last three as '0' or if it has 6 or fewer significant digits (non-zero digits to the right of the decimal point). In OS X 10.9, I see that it does not support nanosecond precision in Time (by default, at least), e.g.:
+
+```ruby
+Time.now # => 220359000
+```
+
+In my Linux VM, it does use nsec precision, e.g.:
+
+```ruby
+Time.now # => 543686757
+```
+
+### Setup
+
+In your Gemfile:
+
+    gem 'ignore_nsec'
+
+Then run:
+
+    bundle install
+
+### Performance
+
+In testing, the revised `<=>` method only for the Time object seemed to be about 10x slower (0.00001029 sec vs. 0.00000105 sec). This is probably not a problem for small numbers of calls, but would become a concern if you were doing anything that required a lot of date comparisons, such as sorting millions of records in Ruby by time (vs. sorting in the database via query, which hopefully you would be able to do instead).
+
+### License
+
+Copyright (c) 2014 FineLine Prototyping, Inc., released under the [MIT license][lic].
+
+[lic]: http://github.com/garysweaver/ignore_nsec/blob/master/LICENSE

data/lib/ignore_nsec.rb

@@ -0,0 +1,9 @@
+require 'ignore_nsec/version'
+
+class Time
+  alias_method '___<=>'.to_sym, :<=>
+
+  def <=>(other)
+    other.respond_to?(:nsec) ? to_i <=> other.to_i : send('___<=>'.to_sym, other)
+  end
+end

data/lib/ignore_nsec/version.rb

@@ -0,0 +1,3 @@
+module IgnoreNsec
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: ignore_nsec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gary S. Weaver
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-14 00:00:00.000000000 Z
+dependencies: []
+description: Some versions of OS's and databases only support microsecond precision.
+  Using this gem makes Ruby ignore nanoseconds in Time comparisons to hopefully help
+  avoid the time != time problem.
+email:
+- garysweaver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ignore_nsec.rb
+- lib/ignore_nsec/version.rb
+homepage: https://github.com/garysweaver/ignore_nsec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ignore nanosecond precision in Time comparisons.
+test_files: []