nano-smart-lib 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ec09cb5c3f58464babe2db65f3da483fd886681ff9833e77e4bf99e19af42b0
+  data.tar.gz: 8a1ab3d749cb4de6baa8326682e2518eda99e02844d3b870316366b8f2d040e1
+SHA512:
+  metadata.gz: 5d225b4f0c52899e1e628dfe9a7b725ee0b9c7f51337e189ab7f25706205f883215cd4d82c53cff27deafb70d12f0ec24a3d9419f9a9bc1324cc549754198d9b
+  data.tar.gz: faa662213b9fe69b4853a0d276695a48d7260ed1ec382fdba551e9fea98341aae98f5d7bd74455d450a568278b705500124882cc120ec4bb4910993361c096fa

data/nano-smart-lib.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "nano-smart-lib"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on timecop"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/nano-smart-lib" }
+end

data/timecop-0.9.11/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2019 — Travis Jeffery, John Trupiano
+
+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/timecop-0.9.11/README.markdown

@@ -0,0 +1,162 @@
+# timecop
+
+[![Gem Version](https://badge.fury.io/rb/timecop.svg)](https://rubygems.org/gems/timecop)
+[![Build Status](https://github.com/travisjeffery/timecop/workflows/CI/badge.svg)](https://github.com/travisjeffery/timecop/actions?query=workflow%3ACI)
+
+## DESCRIPTION
+
+A gem providing "time travel" and "time freezing" capabilities, making it dead simple to test time-dependent code. It provides a unified method to mock `Time.now`, `Date.today`, `DateTime.now`, and `Process.clock_gettime` in a single call.
+
+## INSTALL
+
+`bundle add timecop`
+
+## FEATURES
+
+- Freeze time to a specific point.
+- Travel back to a specific point in time, but allow time to continue moving forward from there.
+- Scale time by a given scaling factor that will cause time to move at an accelerated pace.
+- No dependencies, can be used with _any_ ruby project
+- Timecop api allows arguments to be passed into `#freeze` and `#travel` as one of the following:
+  - Time instance
+  - DateTime instance
+  - Date instance
+  - individual arguments (year, month, day, hour, minute, second)
+  - a single integer argument that is interpreted as an offset in seconds from `Time.now`
+- Nested calls to `Timecop#travel` and `Timecop#freeze` are supported -- each block will maintain its interpretation of now.
+- Works with regular Ruby projects, and Ruby on Rails projects
+
+## USAGE
+
+Run a time-sensitive test
+
+```ruby
+joe = User.find(1)
+joe.purchase_home()
+assert !joe.mortgage_due?
+# move ahead a month and assert that the mortgage is due
+Timecop.freeze(Date.today + 30) do
+  assert joe.mortgage_due?
+end
+```
+
+You can mock the time for a set of tests easily via setup/teardown methods
+
+```ruby
+describe "some set of tests to mock" do
+  before do
+    Timecop.freeze(Time.local(1990))
+  end
+
+  after do
+    Timecop.return
+  end
+
+  it "should do blah blah blah" do
+  end
+end
+```
+
+Set the time for the test environment of a rails app -- this is particularly
+helpful if your whole application is time-sensitive.  It allows you to build
+your test data at a single point in time, and to move in/out of that time as
+appropriate (within your tests)
+
+in `config/environments/test.rb`
+
+```ruby
+config.after_initialize do
+  # Set Time.now to September 1, 2008 10:05:00 AM (at this instant), but allow it to move forward
+  t = Time.local(2008, 9, 1, 10, 5, 0)
+  Timecop.travel(t)
+end
+```
+
+### The difference between Timecop.freeze and Timecop.travel
+
+`freeze` is used to statically mock the concept of now. As your program executes,
+`Time.now` will not change unless you make subsequent calls into the Timecop API.
+`travel`, on the other hand, computes an offset between what we currently think
+`Time.now` is (recall that we support nested traveling) and the time passed in.
+It uses this offset to simulate the passage of time.  To demonstrate, consider
+the following code snippets:
+
+```ruby
+new_time = Time.local(2008, 9, 1, 12, 0, 0)
+Timecop.freeze(new_time)
+sleep(10)
+new_time == Time.now # ==> true
+
+Timecop.return # "turn off" Timecop
+Timecop.travel(new_time)
+sleep(10)
+new_time == Time.now # ==> false
+```
+
+### Timecop.scale
+
+Let's say you want to test a "live" integration wherein entire days could pass by
+in minutes while you're able to simulate "real" activity. For example, one such use case
+is being able to test reports and invoices that run in 30 day cycles in very little time, while also
+being able to simulate activity via subsequent calls to your application.
+
+```ruby
+# seconds will now seem like hours
+Timecop.scale(3600)
+Time.now
+# => 2012-09-20 21:23:25 -0500
+# seconds later, hours have passed and it's gone from 9pm at night to 6am in the morning
+Time.now
+# => 2012-09-21 06:22:59 -0500
+```
+
+See [#42](https://github.com/travisjeffery/timecop/pull/42) for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
+
+### Timecop.safe_mode
+
+Safe mode forces you to use Timecop with the block syntax since it always puts time back the way it was. If you are running in safe mode and use Timecop without the block syntax `Timecop::SafeModeException` will be raised to tell the user they are not being safe.
+
+``` ruby
+# turn on safe mode
+Timecop.safe_mode = true
+
+# check if you are in safe mode
+Timecop.safe_mode?
+# => true
+
+# using method without block
+Timecop.freeze
+# => Timecop::SafeModeException: Safe mode is enabled, only calls passing a block are allowed.
+```
+
+### Configuring Mocking Process.clock_gettime
+
+By default Timecop does not mock Process.clock_gettime. You must enable it like this:
+
+``` ruby
+# turn on
+Timecop.mock_process_clock = true
+```
+
+### Rails v Ruby Date/Time libraries
+
+Sometimes [Rails Date/Time methods don't play nicely with Ruby Date/Time methods.](https://rails.lighthouseapp.com/projects/8994/tickets/6410-dateyesterday-datetoday)
+
+Be careful mixing Ruby `Date.today` with Rails `Date.tomorrow` / `Date.yesterday` as things might break.
+
+## Contribute
+
+timecop is maintained by [travisjeffery](http://github.com/travisjeffery), and
+was created by [jtrupiano](https://github.com/jtrupiano).
+
+Here's the most direct way to get your work merged into the project.
+
+- Fork the project
+- Clone down your fork
+- Create a feature branch
+- Hack away and add tests, not necessarily in that order
+- Make sure everything still passes by running tests
+- If necessary, rebase your commits into logical chunks without errors
+- Push the branch up to your fork
+- Send a pull request for your branch
+

data/timecop-0.9.11/Rakefile

@@ -0,0 +1,34 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rdoc/task'
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.title = "timecop #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('History.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :test do
+  failed = Dir["test/*_test.rb"].map do |test|
+    command = "ruby #{test}"
+    puts
+    puts command
+    command unless system(command)
+  end.compact
+  if failed.any?
+    abort "#{failed.count} Tests failed\n#{failed.join("\n")}"
+  end
+end
+
+desc 'Default: run tests'
+task :default => [:test]

data/timecop-0.9.11/lib/timecop/time_extensions.rb

@@ -0,0 +1,235 @@
+require 'time'
+require 'date'
+
+class Time #:nodoc:
+  class << self
+    def mock_time
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.time(self)
+    end
+
+    alias_method :now_without_mock_time, :now
+
+    def now_with_mock_time
+      mock_time || now_without_mock_time
+    end
+
+    alias_method :now, :now_with_mock_time
+
+    alias_method :new_without_mock_time, :new
+
+    def new_with_mock_time(*args, **kwargs)
+      if args.empty? && kwargs.empty?
+        now
+      elsif kwargs.any?
+        new_without_mock_time(*args, **kwargs)
+      else
+        new_without_mock_time(*args)
+      end
+    end
+
+    alias_method :new, :new_with_mock_time
+  end
+end
+
+class Date #:nodoc:
+  class << self
+    def mock_date
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date(self)
+    end
+
+    alias_method :today_without_mock_date, :today
+
+    def today_with_mock_date
+      mock_date || today_without_mock_date
+    end
+
+    alias_method :today, :today_with_mock_date
+
+    alias_method :strptime_without_mock_date, :strptime
+
+    def strptime_with_mock_date(str = '-4712-01-01', fmt = '%F', start = Date::ITALY)
+      #If date is not valid the following line raises
+      Date.strptime_without_mock_date(str, fmt, start)
+
+      d = Date._strptime(str, fmt)
+      now = Time.now.to_date
+
+      # If "current" time falls near a year boundary, with a year-ambiguous str, we need to explicitly handle it
+      cwday = d[:cwday] && (now + (d[:cwday] - now.wday))
+      wday = d[:wday] && (now + (d[:wday] - now.wday))
+
+      year = d[:year] || d[:cwyear] || (cwday || wday || now).year
+      mon = d[:mon] || now.mon
+      if d.keys == [:year]
+        Date.new(year, 1, 1, start)
+      elsif d[:mday]
+        Date.new(year, mon, d[:mday], start)
+      elsif d[:yday]
+        Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
+      elsif d[:cwyear] || d[:cweek] || d[:wnum0] || d[:wnum1] || d[:wday] || d[:cwday]
+        # When only a day (wday/cwday) is present, derive the week from the resolved date; otherwise fall back to now's week
+        week = d[:cweek] || d[:wnum1] || d[:wnum0] || (cwday || wday || now).strftime('%W').to_i
+        if d[:wnum0] #Week of year where week starts on sunday
+          if d[:cwday] #monday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday]}", '%Y %U %u', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday] || 0}", '%Y %U %w', start)
+          end
+        else #Week of year where week starts on monday
+          if d[:wday] #sunday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday]}", '%Y %W %w', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday] || 1}", '%Y %W %u', start)
+          end
+        end
+      elsif d[:seconds]
+        Time.at(d[:seconds]).to_date
+      else
+        Date.new(year, mon, 1, start)
+      end
+    end
+
+    alias_method :strptime, :strptime_with_mock_date
+
+    def parse_with_mock_date(*args)
+      parsed_date = parse_without_mock_date(*args)
+      return parsed_date unless mocked_time_stack_item
+      date_hash = Date._parse(*args)
+
+      case
+      when date_hash[:year] && date_hash[:mon]
+        parsed_date
+      when date_hash[:mon] && date_hash[:mday]
+        Date.new(mocked_time_stack_item.year, date_hash[:mon], date_hash[:mday])
+      when date_hash[:mday]
+        Date.new(mocked_time_stack_item.year, mocked_time_stack_item.month, date_hash[:mday])
+      when date_hash[:wday]
+        closest_wday(date_hash[:wday])
+      else
+        parsed_date + mocked_time_stack_item.travel_offset_days
+      end
+    end
+
+    alias_method :parse_without_mock_date, :parse
+    alias_method :parse, :parse_with_mock_date
+
+    def mocked_time_stack_item
+      Timecop.top_stack_item
+    end
+
+    def closest_wday(wday)
+      today = Date.today
+      result = today - today.wday
+      result += 1 until wday == result.wday
+      result
+    end
+  end
+end
+
+class DateTime #:nodoc:
+  class << self
+    def mock_time
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
+    end
+
+    def now_with_mock_time
+      mock_time || now_without_mock_time
+    end
+
+    alias_method :now_without_mock_time, :now
+
+    alias_method :now, :now_with_mock_time
+
+    def parse_with_mock_date(*args)
+      parsed_date = parse_without_mock_date(*args)
+      return parsed_date unless mocked_time_stack_item
+      date_hash = DateTime._parse(*args)
+
+      case
+      when date_hash[:year] && date_hash[:mon]
+        parsed_date
+      when date_hash[:mon] && date_hash[:mday]
+        DateTime.new(mocked_time_stack_item.year, date_hash[:mon], date_hash[:mday])
+      when date_hash[:mday]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, date_hash[:mday])
+      when date_hash[:wday] && date_hash[:hour] && date_hash[:min]
+        closest_date = Date.closest_wday(date_hash[:wday]).to_datetime
+
+        DateTime.new(
+          closest_date.year, closest_date.month, closest_date.day,
+          date_hash[:hour], date_hash[:min]
+        )
+      when date_hash[:wday]
+        Date.closest_wday(date_hash[:wday]).to_datetime
+      when date_hash[:hour] && date_hash[:min] && date_hash[:sec]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], date_hash[:sec])
+      when date_hash[:hour] && date_hash[:min]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], 0)
+      else
+        parsed_date + mocked_time_stack_item.travel_offset_days
+      end
+    end
+
+    alias_method :parse_without_mock_date, :parse
+    alias_method :parse, :parse_with_mock_date
+
+    def mocked_time_stack_item
+      Timecop.top_stack_item
+    end
+  end
+end
+
+module Process #:nodoc:
+  class << self
+    alias_method :clock_gettime_without_mock, :clock_gettime
+
+    def clock_gettime_mock_time(clock_id, unit = :float_second)
+      mock_time = case clock_id
+                  when Process::CLOCK_MONOTONIC
+                    mock_time_monotonic
+                  when Process::CLOCK_REALTIME
+                    mock_time_realtime
+                  end
+
+      return clock_gettime_without_mock(clock_id, unit) unless Timecop.mock_process_clock? && mock_time
+
+      divisor = case unit
+                when :float_second
+                  1_000_000_000.0
+                when :second
+                  1_000_000_000
+                when :float_millisecond
+                  1_000_000.0
+                when :millisecond
+                  1_000_000
+                when :float_microsecond
+                  1000.0
+                when :microsecond
+                  1000
+                when :nanosecond
+                  1
+                end
+
+      (mock_time / divisor)
+    end
+
+    alias_method :clock_gettime, :clock_gettime_mock_time
+
+    private
+
+    def mock_time_monotonic
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.monotonic
+    end
+
+    def mock_time_realtime
+      mocked_time_stack_item = Timecop.top_stack_item
+
+      return nil if mocked_time_stack_item.nil?
+
+      t = mocked_time_stack_item.time
+      t.to_i * 1_000_000_000 + t.nsec
+    end
+  end
+end

data/timecop-0.9.11/lib/timecop/time_stack_item.rb

@@ -0,0 +1,169 @@
+class Timecop
+  # A data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
+  # movements on a simple stack.
+  class TimeStackItem #:nodoc:
+    attr_reader :mock_type
+
+    def initialize(mock_type, *args)
+      raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel, :scale].include?(mock_type)
+      @travel_offset  = @scaling_factor = nil
+      @scaling_factor = args.shift if mock_type == :scale
+      @mock_type      = mock_type
+      @monotonic      = parse_monotonic_time(*args)
+      @time           = parse_time(*args)
+      @time_was       = Time.now_without_mock_time
+      @travel_offset  = compute_travel_offset
+    end
+
+    def year
+      time.year
+    end
+
+    def month
+      time.month
+    end
+
+    def day
+      time.day
+    end
+
+    def hour
+      time.hour
+    end
+
+    def min
+      time.min
+    end
+
+    def sec
+      time.sec
+    end
+
+    def utc_offset
+      time.utc_offset
+    end
+
+    def travel_offset
+      @travel_offset unless mock_type == :freeze
+    end
+
+    def travel_offset_days
+      (@travel_offset / 60 / 60 / 24).round
+    end
+
+    def scaling_factor
+      @scaling_factor
+    end
+
+    def monotonic
+      if travel_offset.nil?
+        @monotonic
+      elsif scaling_factor.nil?
+        current_monotonic + travel_offset * (10 ** 9)
+      else
+        (@monotonic + (current_monotonic - @monotonic) * scaling_factor).to_i
+      end
+    end
+
+    def current_monotonic
+      Process.clock_gettime_without_mock(Process::CLOCK_MONOTONIC, :nanosecond)
+    end
+
+    def current_monotonic_with_mock
+      Process.clock_gettime_mock_time(Process::CLOCK_MONOTONIC, :nanosecond)
+    end
+
+    def time(time_klass = Time) #:nodoc:
+      if @time.respond_to?(:in_time_zone)
+        time = time_klass.at(@time.dup.localtime)
+      else
+        time = time_klass.at(@time)
+      end
+
+      if travel_offset.nil?
+        time
+      elsif scaling_factor.nil?
+        time_klass.at(Time.now_without_mock_time + travel_offset)
+      else
+        time_klass.at(scaled_time)
+      end
+    end
+
+    def scaled_time
+      (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+    end
+
+    def date(date_klass = Date)
+      date_klass.jd(time.__send__(:to_date).jd)
+    end
+
+    def datetime(datetime_klass = DateTime)
+      if Float.method_defined?(:to_r)
+        fractions_of_a_second = time.to_f % 1
+        datetime_klass.new(year, month, day, hour, min, (fractions_of_a_second + sec), utc_offset_to_rational(utc_offset))
+      else
+        datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(utc_offset))
+      end
+    end
+
+    private
+
+    def rational_to_utc_offset(rational)
+      ((24.0 / rational.denominator) * rational.numerator) * (60 * 60)
+    end
+
+    def utc_offset_to_rational(utc_offset)
+      Rational(utc_offset, 24 * 60 * 60)
+    end
+
+    def parse_monotonic_time(*args)
+      arg = args.shift
+      offset_in_nanoseconds = if args.empty? && (arg.kind_of?(Integer) || arg.kind_of?(Float))
+        arg * 1_000_000_000
+      else
+        0
+      end
+      current_monotonic_with_mock + offset_in_nanoseconds
+    end
+
+    def parse_time(*args)
+      arg = args.shift
+      if arg.is_a?(Time)
+        arg
+      elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
+        time_klass.at(arg.to_time.to_f).getlocal
+      elsif Object.const_defined?(:Date) && arg.is_a?(Date)
+        time_klass.local(arg.year, arg.month, arg.day, 0, 0, 0)
+      elsif args.empty? && (arg.kind_of?(Integer) || arg.kind_of?(Float))
+        time_klass.now + arg
+      elsif arg.nil?
+        time_klass.now
+      else
+        if arg.is_a?(String) && Time.respond_to?(:parse)
+          time_klass.parse(arg)
+        else
+          # we'll just assume it's a list of y/m/d/h/m/s
+          year   = arg        || 2000
+          month  = args.shift || 1
+          day    = args.shift || 1
+          hour   = args.shift || 0
+          minute = args.shift || 0
+          second = args.shift || 0
+          time_klass.local(year, month, day, hour, minute, second)
+        end
+      end
+    end
+
+    def compute_travel_offset
+      time - Time.now_without_mock_time
+    end
+
+    def times_are_equal_within_epsilon t1, t2, epsilon_in_seconds
+      (t1 - t2).abs < epsilon_in_seconds
+    end
+
+    def time_klass
+      Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
+    end
+  end
+end

data/timecop-0.9.11/lib/timecop/timecop.rb

@@ -0,0 +1,264 @@
+require 'singleton'
+require File.join(File.dirname(__FILE__), "time_stack_item")
+
+# Timecop
+# * Wrapper class for manipulating the extensions to the Time, Date, and DateTime objects
+# * Allows us to "freeze" time in our Ruby applications.
+# * Optionally allows time travel to simulate a running clock, such time is not technically frozen.
+#
+# This is very useful when your app's functionality is dependent on time (e.g.
+# anything that might expire).  This will allow us to alter the return value of
+# Date.today, Time.now, and DateTime.now, such that our application code _never_ has to change.
+class Timecop
+  include Singleton
+
+  class << self
+    private :instance
+
+    # Allows you to run a block of code and "fake" a time throughout the execution of that block.
+    # This is particularly useful for writing test methods where the passage of time is critical to the business
+    # logic being tested.  For example:
+    #
+    #   joe = User.find(1)
+    #   joe.purchase_home()
+    #   assert !joe.mortgage_due?
+    #   Timecop.freeze(2008, 10, 5) do
+    #     assert joe.mortgage_due?
+    #   end
+    #
+    # freeze and travel will respond to several different arguments:
+    # 1. Timecop.freeze(time_inst)
+    # 2. Timecop.freeze(datetime_inst)
+    # 3. Timecop.freeze(date_inst)
+    # 4. Timecop.freeze(offset_in_seconds)
+    # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
+    # 6. Timecop.freeze() # Defaults to Time.now
+    #
+    # When a block is also passed, Time.now, DateTime.now and Date.today are all reset to their
+    # previous values after the block has finished executing.  This allows us to nest multiple
+    # calls to Timecop.travel and have each block maintain it's concept of "now."
+    #
+    # The Process.clock_gettime call mocks both CLOCK::MONOTIC and CLOCK::REALTIME
+    #
+    # CLOCK::MONOTONIC works slightly differently than other clocks. This clock cannot move to a
+    # particular date/time. So the only option that changes this clock is #4 which will move the
+    # clock the requested offset. Otherwise the clock is frozen to the current tick.
+    #
+    # * Note: Timecop.freeze will actually freeze time.  This can cause unanticipated problems if
+    #   benchmark or other timing calls are executed, which implicitly expect Time to actually move
+    #   forward.
+    #
+    # * Rails Users: Be especially careful when setting this in your development environment in a
+    #   rails project.  Generators will load your environment, including the migration generator,
+    #   which will lead to files being generated with the timestamp set by the Timecop.freeze call
+    #   in your dev environment
+    #
+    # Returns the value of the block if one is given, or the mocked time.
+    def freeze(*args, &block)
+      send_travel(:freeze, *args, &block)
+    end
+
+    # Allows you to run a block of code and "fake" a time throughout the execution of that block.
+    # See Timecop#freeze for a sample of how to use (same exact usage syntax)
+    #
+    # * Note: Timecop.travel will not freeze time (as opposed to Timecop.freeze).  This is a particularly
+    #   good candidate for use in environment files in rails projects.
+    #
+    # Returns the value of the block if one is given, or the mocked time.
+    def travel(*args, &block)
+      send_travel(:travel, *args, &block)
+    end
+
+    # Allows you to run a block of code and "scale" a time throughout the execution of that block.
+    # The first argument is a scaling factor, for example:
+    #   Timecop.scale(2) do
+    #     ... time will 'go' twice as fast here
+    #   end
+    # See Timecop#freeze for exact usage of the other arguments
+    #
+    # Returns the value of the block if one is given, or the mocked time.
+    def scale(*args, &block)
+      send_travel(:scale, *args, &block)
+    end
+
+    def baseline
+      instance.baseline
+    end
+
+    def baseline=(baseline)
+      instance.baseline = baseline
+    end
+
+    # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists) permamently when
+    # no block argument is given, or temporarily reverts back to the system's time temporarily for
+    # the given block.
+    def return(&block)
+      if block_given?
+        instance.return(&block)
+      else
+        instance.unmock!
+        nil
+      end
+    end
+    alias :unfreeze :return
+
+    def return_to_baseline
+      instance.return_to_baseline
+      Time.now
+    end
+
+    def top_stack_item #:nodoc:
+      instance.stack.last
+    end
+
+    def safe_mode=(safe)
+      @safe_mode = safe
+    end
+
+    def safe_mode?
+      @safe_mode ||= false
+    end
+
+    def thread_safe=(t)
+      instance.thread_safe = t
+    end
+
+    def thread_safe
+      instance.thread_safe
+    end
+
+    # Returns whether or not Timecop is currently frozen
+    def frozen?
+      !instance.stack.empty? && instance.stack.last.mock_type == :freeze
+    end
+
+    # Returns whether or not Timecop is currently travelled
+    def travelled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :travel
+    end
+
+    # Returns whether or not Timecop is currently scaled
+    def scaled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :scale
+    end
+
+    def mock_process_clock=(mock)
+      @mock_process_clock = mock
+    end
+
+    def mock_process_clock?
+      @mock_process_clock ||= false
+    end
+
+    private
+    def send_travel(mock_type, *args, &block)
+      val = instance.travel(mock_type, *args, &block)
+      block_given? ? val : Time.now
+    end
+  end
+
+  def baseline=(b)
+    set_baseline(b)
+    stack << TimeStackItem.new(:travel, b)
+  end
+
+  def baseline
+    if @thread_safe
+      Thread.current[:timecop_baseline]
+    else
+      @baseline
+    end
+  end
+
+  def set_baseline(b)
+    if @thread_safe
+      Thread.current[:timecop_baseline] = b
+    else
+      @baseline = b
+    end
+  end
+
+  def stack
+    if @thread_safe
+      Thread.current[:timecop_stack] ||= []
+      Thread.current[:timecop_stack]
+    else
+      @stack
+    end
+  end
+
+  def set_stack(s)
+    if @thread_safe
+      Thread.current[:timecop_stack] = s
+    else
+      @stack = s
+    end
+  end
+
+  def initialize #:nodoc:
+    @stack = []
+    @safe = nil
+    @thread_safe = false
+  end
+
+  def thread_safe=(t)
+    initialize
+    @thread_safe = t
+  end
+
+  def thread_safe
+    @thread_safe
+  end
+
+  def travel(mock_type, *args, &block) #:nodoc:
+    raise SafeModeException if Timecop.safe_mode? && !block_given? && !@safe
+
+    stack_item = TimeStackItem.new(mock_type, *args)
+
+    stack_backup = stack.dup
+    stack << stack_item
+
+    if block_given?
+      safe_backup = @safe
+      @safe = true
+      begin
+        yield stack_item.time
+      ensure
+        stack.replace stack_backup
+        @safe = safe_backup
+      end
+    end
+  end
+
+  def return(&block)
+    current_stack = stack
+    current_baseline = baseline
+    unmock!
+    yield
+  ensure
+    set_stack current_stack
+    set_baseline current_baseline
+  end
+
+  def unmock! #:nodoc:
+    set_baseline nil
+    set_stack []
+  end
+
+  def return_to_baseline
+    if baseline
+      set_stack [stack.shift]
+    else
+      unmock!
+    end
+  end
+
+  class SafeModeException < StandardError
+    def initialize
+      super "Safe mode is enabled, only calls passing a block are allowed."
+    end
+  end
+end
+
+# This must be done after TimeCop is available
+require File.join(File.dirname(__FILE__), "time_extensions")

data/timecop-0.9.11/lib/timecop/version.rb

@@ -0,0 +1,3 @@
+class Timecop
+  VERSION = "0.9.11"
+end

data/timecop-0.9.11/lib/timecop.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "timecop", "timecop")
+require File.join(File.dirname(__FILE__), "timecop", "version")

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: nano-smart-lib
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on timecop
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- nano-smart-lib.gemspec
+- timecop-0.9.11/LICENSE
+- timecop-0.9.11/README.markdown
+- timecop-0.9.11/Rakefile
+- timecop-0.9.11/lib/timecop.rb
+- timecop-0.9.11/lib/timecop/time_extensions.rb
+- timecop-0.9.11/lib/timecop/time_stack_item.rb
+- timecop-0.9.11/lib/timecop/timecop.rb
+- timecop-0.9.11/lib/timecop/version.rb
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Andrey78/nano-smart-lib
+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: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []