emery 0.0.4 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f274712dc6632b3ab10cc2f51259f9b1b8c4ed411c2480a2c29f3ad1024d1366
-  data.tar.gz: 24c03d4e4af1c063fffcab685c5c4d2e1b68723fdd2d087f0d27e7d265cb2422
+  metadata.gz: 252b3f770bfc4f85ebe27dd9a36c2b9ab899351f40fbab5f2637339d6e7bf1dd
+  data.tar.gz: 17bbf5caecc70c8fbbdb0217c2396fc7bf655d332379c4595f58f9f677e1d0ab
 SHA512:
-  metadata.gz: 66e3dc27fcf2eb03f85dbae15d04b91758f624e4dd6aea7cd0ce4b074d128ab43dbec522b4b4b251119debcc6425152cc595caa9425074ba474cb5ddc2e66c7c
-  data.tar.gz: 5f7bc33da37df73954e251fdf55297d3855e857c06f71d32cef87f0dc855388f04a83ddae5941d72c443bf15e006d31c217952d308ad18cbd165bb845a8e19be
+  metadata.gz: 632c08064d1f980d094cca2e7209589e4f529308e7396f818e7c0fbddb43a13e130c72c7d2f83dda9f9500e22082294d9842d871ec9c8c1dc3ead0e50ea8a92d
+  data.tar.gz: b38c1c785b049dd0e46e47521078792c15dbd515f33693bb564b8e973a11662877c07fee47cd2924d5da7e390eacaf8b9d628b7f9cb153c63c6458d023bdf4c7

data/lib/emery.rb

@@ -1,4 +1,3 @@
-require 'emery/tod'
 require 'emery/type'
 require 'emery/jsoner'
 require 'emery/enum'

data/lib/emery/dataclass.rb

@@ -39,6 +39,10 @@ module DataClass
     return self.class.new(new_params)
   end
 
+  def to_json
+    return Jsoner.serialize(self.class, self)
+  end
+
   def self.included(base)
     base.extend ClassMethods
   end

data/lib/emery/jsoner.rb

@@ -1,8 +1,6 @@
 require "json"
 require "date"
 
-require "emery/type"
-
 class JsonerError < StandardError
 end
 
@@ -72,7 +70,7 @@ module Jsoner
       types.each do |type|
         begin
           return Jsoner.deserialize(type, json_value)
-        rescue TypeError
+        rescue JsonerError
         end
       end
       raise JsonerError.new("Value '#{json_value.inspect.to_s}' can not be deserialized as any of #{@types.map { |t| t.to_s}.join(', ')}")
@@ -217,4 +215,4 @@ module Jsoner
       raise JsonerError.new(error.message)
     end
   end
-end
+end

data/test/jsoner_test.rb

@@ -33,10 +33,16 @@ class PlainTypesDeserialization < Test::Unit::TestCase
     end
   end
 
-  def test_deserialize_boolean
+  def test_deserialize_true
     data = Jsoner.from_json(Boolean, 'true')
     T.check(Boolean, data)
-    assert_equal true, data, "Boolean should be parsable from JSON"
+    assert_equal true, data, "Boolean true should be parsable from JSON"
+  end
+
+  def test_deserialize_false
+    data = Jsoner.from_json(Boolean, 'false')
+    T.check(Boolean, data)
+    assert_equal false, data, "Boolean false should be parsable from JSON"
   end
 
   def test_deserialize_boolean_fail

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emery
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.18
 platform: ruby
 authors:
 - Vladimir Sapronov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-11 00:00:00.000000000 Z
+date: 2021-06-09 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:
@@ -60,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Type safety library

data/lib/emery/tod.rb

@@ -1,260 +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
-
-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

data/test/tod_test.rb

@@ -1,36 +0,0 @@
-require "test/unit/runner/junitxml"
-
-require 'emery'
-
-class TypeCheckTimeOfDay < Test::Unit::TestCase
-  def test_success
-    assert_equal TimeOfDay.parse("10:40:50"), T.check(TimeOfDay, TimeOfDay.parse("10:40:50"))
-  end
-
-  def test_fail
-    assert_raise TypeError do
-      T.check(DateTime, TimeOfDay.parse("10:40:50"))
-    end
-  end
-end
-
-class TimeOfDayDeserialization < Test::Unit::TestCase
-  def test_deserialize
-    data = Jsoner.from_json(TimeOfDay, '"10:40:50"')
-    T.check(TimeOfDay, data)
-    assert_equal TimeOfDay.parse("10:40:50"), data
-  end
-
-  def test_deserialize_fail
-    assert_raise JsonerError do
-      Jsoner.from_json(TimeOfDay, '"abc"')
-    end
-  end
-end
-
-class TimeOfDaySerialization < Test::Unit::TestCase
-  def test_serialize
-    json_str = Jsoner.to_json(TimeOfDay, TimeOfDay.parse("10:40:50"))
-    assert_equal '"10:40:50"', json_str
-  end
-end