emery 0.0.2 → 0.0.8

data/test/type_test.rb

@@ -1,220 +1,218 @@
 require "test/unit/runner/junitxml"
 require "date"
 
-require 'emery/type'
+require 'emery'
 
-module Emery
-  class TypeEquality < Test::Unit::TestCase
-    def test_plain_equals
-      assert_true Integer == Integer
-    end
+class TypeEquality < Test::Unit::TestCase
+  def test_plain_equals
+    assert_true Integer == Integer
+  end
 
-    def test_plain_not_equals
-      assert_false Integer == String
-    end
+  def test_plain_not_equals
+    assert_false Integer == String
+  end
 
-    def test_uuid_equals
-      assert_true UUID == UUID
-    end
+  def test_uuid_equals
+    assert_true UUID == UUID
+  end
 
-    def test_boolean_equals
-      assert_true Boolean == Boolean
-    end
+  def test_boolean_equals
+    assert_true Boolean == Boolean
+  end
 
-    def test_untyped_equals
-      assert_true Untyped == Untyped
-    end
+  def test_untyped_equals
+    assert_true Untyped == Untyped
+  end
 
-    def test_nilable_equals
-      assert_true T.nilable(Integer) == T.nilable(Integer)
-    end
+  def test_nilable_equals
+    assert_true T.nilable(Integer) == T.nilable(Integer)
+  end
 
-    def test_nilable_not_equals
-      assert_false T.nilable(Integer) == T.nilable(String)
-    end
+  def test_nilable_not_equals
+    assert_false T.nilable(Integer) == T.nilable(String)
+  end
 
-    def test_array_equals
-      assert_true T.array(Integer) == T.array(Integer)
-    end
+  def test_array_equals
+    assert_true T.array(Integer) == T.array(Integer)
+  end
 
-    def test_array_not_equals
-      assert_false T.array(Integer) == Integer
-    end
+  def test_array_not_equals
+    assert_false T.array(Integer) == Integer
+  end
 
-    def test_array_other_item_type
-      assert_false T.array(Integer) == T.array(String)
-    end
+  def test_array_other_item_type
+    assert_false T.array(Integer) == T.array(String)
+  end
 
-    def test_hash_equals
-      assert_true T.hash(String, Integer) == T.hash(String, Integer)
-    end
+  def test_hash_equals
+    assert_true T.hash(String, Integer) == T.hash(String, Integer)
+  end
 
-    def test_hash_not_equals
-      assert_false T.hash(String, Integer) == String
-    end
+  def test_hash_not_equals
+    assert_false T.hash(String, Integer) == String
+  end
 
-    def test_hash_other_value_type
-      assert_false T.hash(String, Integer) == T.hash(String, String)
-    end
+  def test_hash_other_value_type
+    assert_false T.hash(String, Integer) == T.hash(String, String)
+  end
 
-    def test_any_equals
-      assert_true T.any(String, Integer) == T.any(String, Integer)
-    end
+  def test_any_equals
+    assert_true T.any(String, Integer) == T.any(String, Integer)
+  end
 
-    def test_any_equals_other_order
-      assert_true T.any(String, Integer) == T.any(Integer, String)
-    end
+  def test_any_equals_other_order
+    assert_true T.any(String, Integer) == T.any(Integer, String)
+  end
 
-    def test_any_of_other_type
-      assert_false T.any(String, Integer) == T.any(Integer, Float)
-    end
+  def test_any_of_other_type
+    assert_false T.any(String, Integer) == T.any(Integer, Float)
   end
+end
 
-  class TypeToString < Test::Unit::TestCase
-    def test_nilable
-      assert_equal "Nilable[Integer]", T.nilable(Integer).to_s
-    end
+class TypeToString < Test::Unit::TestCase
+  def test_nilable
+    assert_equal "Nilable[Integer]", T.nilable(Integer).to_s
+  end
 
-    def test_array
-      assert_equal "Array[Integer]", T.array(Integer).to_s
-    end
+  def test_array
+    assert_equal "Array[Integer]", T.array(Integer).to_s
+  end
 
-    def test_hash
-      assert_equal "Hash[String, Integer]", T.hash(String, Integer).to_s
-    end
+  def test_hash
+    assert_equal "Hash[String, Integer]", T.hash(String, Integer).to_s
+  end
 
-    def test_any
-      assert_equal "Any[String, Integer]", T.any(String, Integer).to_s
-    end
+  def test_any
+    assert_equal "Any[String, Integer]", T.any(String, Integer).to_s
+  end
 
-    def test_union
-      assert_equal "Union[str: String, int: Integer]", T.union(str: String, int: Integer).to_s
-    end
+  def test_union
+    assert_equal "Union[str: String, int: Integer]", T.union(str: String, int: Integer).to_s
   end
+end
 
-  class TypeCheck < Test::Unit::TestCase
-    def test_nil
-      assert_equal nil, T.check(NilClass, nil)
-    end
+class TypeCheck < Test::Unit::TestCase
+  def test_nil
+    assert_equal nil, T.check(NilClass, nil)
+  end
 
-    def test_nil_string
-      assert_raise TypeError do
-        T.check(String, nil)
-      end
+  def test_nil_string
+    assert_raise TypeError do
+      T.check(String, nil)
     end
+  end
 
-    def test_types_mismatch
-      assert_raise TypeError do
-        T.check(String, 123)
-      end
+  def test_types_mismatch
+    assert_raise TypeError do
+      T.check(String, 123)
     end
+  end
 
-    def test_string
-      assert_equal "the string", T.check(String, "the string"), "Plain String type should allow String value"
-    end
+  def test_string
+    assert_equal "the string", T.check(String, "the string"), "Plain String type should allow String value"
+  end
 
-    def test_string_nil
-      err = assert_raise TypeError do
-        T.check(String, nil)
-      end
-      assert_match "Type String does not allow nil value", err.message
+  def test_string_nil
+    err = assert_raise TypeError do
+      T.check(String, nil)
     end
+    assert_match "Type String does not allow nil value", err.message
+  end
 
-    def test_boolean
-      assert_equal true, T.check(Boolean, true), "Artificial Boolean type should allow true value"
-    end
+  def test_boolean
+    assert_equal true, T.check(Boolean, true), "Artificial Boolean type should allow true value"
+  end
 
-    def test_date
-      assert_equal Date.new(2020, 5, 24), T.check(Date, Date.new(2020, 5, 24)), "Date type should pass validation"
-    end
+  def test_date
+    assert_equal Date.new(2020, 5, 24), T.check(Date, Date.new(2020, 5, 24)), "Date type should pass validation"
+  end
 
-    def test_datetime
-      assert_equal DateTime.new(2020, 5, 24, 14, 30, 30), T.check(Date, DateTime.new(2020, 5, 24, 14, 30, 30)), "DateTime type should pass validation"
-    end
+  def test_datetime
+    assert_equal DateTime.new(2020, 5, 24, 14, 30, 30), T.check(Date, DateTime.new(2020, 5, 24, 14, 30, 30)), "DateTime type should pass validation"
+  end
 
-    def test_time
-      assert_equal Time.new(2007,11,5,13,45,0, "-05:00"), T.check(Time, Time.new(2007, 11, 5, 13, 45, 0, "-05:00")), "Time type should pass validation"
-    end
+  def test_time
+    assert_equal Time.new(2007,11,5,13,45,0, "-05:00"), T.check(Time, Time.new(2007, 11, 5, 13, 45, 0, "-05:00")), "Time type should pass validation"
+  end
 
-    def test_uuid
-      assert_equal "123e4567-e89b-12d3-a456-426655440000", T.check(UUID, "123e4567-e89b-12d3-a456-426655440000"), "UUID type should pass validation on correctly formatted string"
-    end
+  def test_uuid
+    assert_equal "123e4567-e89b-12d3-a456-426655440000", T.check(UUID, "123e4567-e89b-12d3-a456-426655440000"), "UUID type should pass validation on correctly formatted string"
+  end
 
-    def test_uuid_fail
-      assert_raise TypeError do
-        T.check(UUID, "really not the uuid")
-      end
+  def test_uuid_fail
+    assert_raise TypeError do
+      T.check(UUID, "really not the uuid")
     end
+  end
 
-    def test_untyped_success
-      assert_equal "bla", T.check(Untyped, "bla"), "Untyped should accept strings"
-    end
+  def test_untyped_success
+    assert_equal "bla", T.check(Untyped, "bla"), "Untyped should accept strings"
+  end
 
-    def test_untyped_nil
-      assert_raise TypeError do
-        T.check(Untyped, nil)
-      end
+  def test_untyped_nil
+    assert_raise TypeError do
+      T.check(Untyped, nil)
     end
+  end
 
-    def test_nilable_nil
-      assert_equal nil, T.check(T.nilable(String), nil), "Nilable type should allow nil value"
-    end
+  def test_nilable_nil
+    assert_equal nil, T.check(T.nilable(String), nil), "Nilable type should allow nil value"
+  end
 
-    def test_nilable
-      assert_equal "the string", T.check(T.nilable(String), "the string"), "Nilable String type should allow String value"
-    end
+  def test_nilable
+    assert_equal "the string", T.check(T.nilable(String), "the string"), "Nilable String type should allow String value"
   end
+end
 
-  class TypeCheckArray < Test::Unit::TestCase
-    def test_array_string
-      assert_equal ["the string"], T.check(T.array(String), ["the string"]), "Array of String should allow String value"
-    end
+class TypeCheckArray < Test::Unit::TestCase
+  def test_array_string
+    assert_equal ["the string"], T.check(T.array(String), ["the string"]), "Array of String should allow String value"
+  end
 
-    def test_array_fail
-      assert_raise TypeError do
-        T.check(T.array(String), "the string")
-      end
+  def test_array_fail
+    ex = assert_raise TypeError do
+      T.check(T.array(String), "the string")
     end
+    puts ex
+  end
 
-    def test_array_wrong_item_type
-      assert_raise TypeError do
-        T.check(T.array(String), ["the string", 123])
-      end
+  def test_array_wrong_item_type
+    assert_raise TypeError do
+      T.check(T.array(String), ["the string", 123])
     end
   end
+end
 
-  class TypeCheckHash < Test::Unit::TestCase
-    def test_hash_string_to_string
-      assert_equal({"key" => "the value"}, T.check(T.hash(String, String), {"key" => "the value"}), "Hash of String -> String should allow String -> String value")
-    end
+class TypeCheckHash < Test::Unit::TestCase
+  def test_hash_string_to_string
+    assert_equal({"key" => "the value"}, T.check(T.hash(String, String), {"key" => "the value"}), "Hash of String -> String should allow String -> String value")
+  end
 
-    def test_hash_string_to_untyped
-      assert_equal({"key" => "the value"}, T.check(T.hash(String, Untyped), {"key" => "the value"}), "Hash of String -> Untyped should allow String -> String value")
-    end
+  def test_hash_string_to_untyped
+    assert_equal({"key" => "the value"}, T.check(T.hash(String, Untyped), {"key" => "the value"}), "Hash of String -> Untyped should allow String -> String value")
   end
+end
 
-  class TypeCheckAny < Test::Unit::TestCase
-    def test_success
-      assert_equal(123, T.check(T.any(String, Integer), 123), "Any of String, Integer should allow Integer value")
-    end
+class TypeCheckAny < Test::Unit::TestCase
+  def test_success
+    assert_equal(123, T.check(T.any(String, Integer), 123), "Any of String, Integer should allow Integer value")
+  end
 
-    def test_fail
-      assert_raise TypeError do
-        T.check(T.any(String, Integer), true)
-      end
+  def test_fail
+    assert_raise TypeError do
+      T.check(T.any(String, Integer), true)
     end
   end
+end
 
-  class TypeCheckUnion < Test::Unit::TestCase
-    def test_success
-      assert_equal(123, T.check(T.union(str: String, int: Integer), 123))
-    end
+class TypeCheckUnion < Test::Unit::TestCase
+  def test_success
+    assert_equal(123, T.check(T.union(str: String, int: Integer), 123))
+  end
 
-    def test_fail
-      assert_raise TypeError do
-        T.check(T.union(str: String, int: Integer), true)
-      end
+  def test_fail
+    assert_raise TypeError do
+      T.check(T.union(str: String, int: Integer), true)
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emery
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.8
 platform: ruby
 authors:
 - Vladimir Sapronov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2021-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -34,12 +34,10 @@ files:
 - lib/emery/dataclass.rb
 - lib/emery/enum.rb
 - lib/emery/jsoner.rb
-- lib/emery/tod.rb
 - lib/emery/type.rb
 - test/dataclass_test.rb
 - test/enum_test.rb
 - test/jsoner_test.rb
-- test/tod_test.rb
 - test/type_test.rb
 homepage: https://github.com/vsapronov/emery
 licenses:

data/lib/emery/tod.rb

@@ -1,262 +0,0 @@
-=begin
-
-source: https://github.com/jackc/tod
-
-Copyright (c) 2010-2015 Jack Christensen
-
-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.
-
-=end
-
-module Emery
-  class TimeOfDay
-    include Comparable
-
-    def self.jsoner_deserialize(json_value)
-      TimeOfDay.parse(T.check(String, json_value))
-    end
-    def self.jsoner_serialize(value)
-      T.check(TimeOfDay, value).to_s
-    end
-
-    attr_reader :hour, :minute, :second, :second_of_day
-    alias_method :min, :minute
-    alias_method :sec, :second
-    alias_method :to_i, :second_of_day
-
-    PARSE_24H_REGEX = /
-      \A
-      ([01]?\d|2[0-4])
-      :?
-      ([0-5]\d)?
-      :?
-      ([0-5]\d)?
-      \z
-    /x
-
-    PARSE_12H_REGEX = /
-      \A
-      (0?\d|1[0-2])
-      :?
-      ([0-5]\d)?
-      :?
-      ([0-5]\d)?
-      \s*
-      ([ap])
-      \.?
-      \s*
-      m?
-      \.?
-      \z
-    /x
-
-    WORDS = {
-        "noon" => "12pm".freeze,
-        "midnight" => "12am".freeze
-    }
-
-    NUM_SECONDS_IN_DAY = 86400
-    NUM_SECONDS_IN_HOUR = 3600
-    NUM_SECONDS_IN_MINUTE = 60
-
-    FORMATS = {
-        short: "%-l:%M %P".freeze,
-        medium: "%-l:%M:%S %P".freeze,
-        time: "%H:%M".freeze
-    }
-
-    def initialize(h, m=0, s=0)
-      @hour = Integer(h)
-      @minute = Integer(m)
-      @second = Integer(s)
-
-      raise ArgumentError, "hour must be between 0 and 24" unless (0..24).include?(@hour)
-      if @hour == 24 && (@minute != 0 || @second != 0)
-        raise ArgumentError, "hour can only be 24 when minute and second are 0"
-      end
-      raise ArgumentError, "minute must be between 0 and 59" unless (0..59).include?(@minute)
-      raise ArgumentError, "second must be between 0 and 59" unless (0..59).include?(@second)
-
-      @second_of_day = @hour * 60 * 60 + @minute * 60 + @second
-
-      freeze # TimeOfDay instances are value objects
-    end
-
-    def <=>(other)
-      return unless other.respond_to?(:second_of_day)
-      @second_of_day <=> other.second_of_day
-    end
-
-    # Rounding to the given nearest number of seconds
-    def round(round_sec = 1)
-      down = self - (self.to_i % round_sec)
-      up = down + round_sec
-
-      difference_down = self - down
-      difference_up = up - self
-
-      if (difference_down < difference_up)
-        return down
-      else
-        return up
-      end
-    end
-
-    # Formats identically to Time#strftime
-    def strftime(format_string)
-      # Special case 2400 because strftime will load TimeOfDay into Time which
-      # will convert 24 to 0
-      format_string = format_string.gsub(/%H|%k/, '24') if @hour == 24
-      Time.local(2000,1,1, @hour, @minute, @second).strftime(format_string)
-    end
-
-    def to_formatted_s(format = :default)
-      if formatter = FORMATS[format]
-        if formatter.respond_to?(:call)
-          formatter.call(self).to_s
-        else
-          strftime(formatter)
-        end
-      else
-        strftime "%H:%M:%S"
-      end
-    end
-    alias_method :to_s, :to_formatted_s
-
-    def value_for_database
-      to_s
-    end
-
-    # Return a new TimeOfDay num_seconds greater than self. It will wrap around
-    # at midnight.
-    def +(num_seconds)
-      TimeOfDay.from_second_of_day @second_of_day + num_seconds
-    end
-
-    # Return a new TimeOfDay num_seconds less than self. It will wrap around
-    # at midnight.
-    def -(other)
-      if other.instance_of?(TimeOfDay)
-        TimeOfDay.from_second_of_day @second_of_day - other.second_of_day
-      else
-        TimeOfDay.from_second_of_day @second_of_day - other
-      end
-    end
-
-    # Returns a Time instance on date using self as the time of day
-    # Optional time_zone will build time in that zone
-    def on(date, time_zone=Tod::TimeOfDay.time_zone)
-      time_zone.local date.year, date.month, date.day, @hour, @minute, @second
-    end
-
-    # Build a new TimeOfDay instance from second_of_day
-    #
-    #   TimeOfDay.from_second_of_day(3600) == TimeOfDay.new(1)   # => true
-    def self.from_second_of_day(second_of_day)
-      second_of_day = Integer(second_of_day)
-      return new 24 if second_of_day == NUM_SECONDS_IN_DAY
-      remaining_seconds = second_of_day % NUM_SECONDS_IN_DAY
-      hour = remaining_seconds / NUM_SECONDS_IN_HOUR
-      remaining_seconds -= hour * NUM_SECONDS_IN_HOUR
-      minute = remaining_seconds / NUM_SECONDS_IN_MINUTE
-      remaining_seconds -= minute * NUM_SECONDS_IN_MINUTE
-      new hour, minute, remaining_seconds
-    end
-    class << self
-      alias :from_i :from_second_of_day
-    end
-
-    # Build a TimeOfDay instance from string
-    #
-    # Strings only need to contain an hour. Minutes, seconds, AM or PM, and colons
-    # are all optional.
-    #   TimeOfDay.parse "8"                            # => 08:00:00
-    #   TimeOfDay.parse "8am"                          # => 08:00:00
-    #   TimeOfDay.parse "8pm"                          # => 20:00:00
-    #   TimeOfDay.parse "8p"                           # => 20:00:00
-    #   TimeOfDay.parse "9:30"                         # => 09:30:00
-    #   TimeOfDay.parse "15:30"                        # => 15:30:00
-    #   TimeOfDay.parse "3:30pm"                       # => 15:30:00
-    #   TimeOfDay.parse "1230"                         # => 12:30:00
-    #   TimeOfDay.parse "3:25:58"                      # => 03:25:58
-    #   TimeOfDay.parse "515p"                         # => 17:15:00
-    #   TimeOfDay.parse "151253"                       # => 15:12:53
-    # You can give a block, that is called with the input if the string is not parsable.
-    # If no block is given an ArgumentError is raised if try_parse returns nil.
-    def self.parse(tod_string)
-      try_parse(tod_string) || (block_given? ? yield(tod_string) : raise(ArgumentError, "Invalid time of day string"))
-    end
-
-    # Same as parse(), but return nil if not parsable (instead of raising an error)
-    #   TimeOfDay.try_parse "8am"                      # => 08:00:00
-    #   TimeOfDay.try_parse ""                         # => nil
-    #   TimeOfDay.try_parse "abc"                      # => nil
-    def self.try_parse(tod_string)
-      tod_string = tod_string.to_s
-      tod_string = tod_string.strip
-      tod_string = tod_string.downcase
-      tod_string = WORDS[tod_string] || tod_string
-      if PARSE_24H_REGEX =~ tod_string || PARSE_12H_REGEX =~ tod_string
-        hour, minute, second, a_or_p = $1.to_i, $2.to_i, $3.to_i, $4
-        if hour == 12 && a_or_p == "a"
-          hour = 0
-        elsif hour < 12 && a_or_p == "p"
-          hour += 12
-        end
-
-        new hour, minute, second
-      else
-        nil
-      end
-    end
-
-    # Determine if a string is parsable into a TimeOfDay instance
-    #   TimeOfDay.parsable? "8am"                      # => true
-    #   TimeOfDay.parsable? "abc"                      # => false
-    def self.parsable?(tod_string)
-      !!try_parse(tod_string)
-    end
-
-    # If ActiveSupport TimeZone is available and set use current time zone else return Time
-    def self.time_zone
-      (Time.respond_to?(:zone) && Time.zone) || Time
-    end
-
-    def self.dump(time_of_day)
-      time_of_day =
-          if time_of_day.is_a? Hash
-            # rails multiparam attribute
-            # get hour, minute and second and construct new TimeOfDay object
-            ::Tod::TimeOfDay.new(time_of_day[4], time_of_day[5], time_of_day[6])
-          else
-            # return nil, if input is not parsable
-            Tod::TimeOfDay(time_of_day){}
-          end
-      time_of_day.to_s if time_of_day
-    end
-
-    def self.load(time)
-      if time && !time.to_s.empty?
-        return ::Tod::TimeOfDay.new(24) if time.respond_to?(:day) && time.day == 2 && time.hour == 0 && time.min == 0 && time.sec == 0
-        ::Tod::TimeOfDay(time)
-      end
-    end
-  end
-end