emery 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8dc449ad3ba135140479a6711b016e63bfc30f9fd6dcf6dba8ff78ee71208a6a
+  data.tar.gz: 9c2f86bde90521cfa5adb78eda8ceef5504c2fbcf44de558cf2450c550cea96e
+SHA512:
+  metadata.gz: e9695fe9eeed44ad9d3bc33e1dc92ae4de5a31e024c7fa9ba1fa34dbd3df554cf5cd73e9634dbaec1246ca80b8ac536fd1020b129ef26d9973512c34ca77b920
+  data.tar.gz: 8f7b8961c1c39cf2a354163725bd1fc761e620627ebbb73cb1dd91c7d5746bdc6fd937ccc17fa2bf70ef7af826dd0eb60f09102a4b27ab7f6cf1343633686ecf

data/lib/emery.rb

@@ -0,0 +1,6 @@
+require 'emery/tod'
+require 'emery/type'
+require 'emery/jsoner'
+require 'emery/enum'
+require 'emery/dataclass'
+require 'emery/client'

data/lib/emery/dataclass.rb

@@ -0,0 +1,86 @@
+module Emery
+  module DataClass
+    def initialize(params)
+      self.class.json_attributes.each do |attr, attr_type|
+        attr_value = params[attr]
+        self.instance_variable_set("@#{attr}", T.check_var(attr, attr_type, attr_value))
+      end
+    end
+
+    def ==(other)
+      begin
+        T.check(self.class, other)
+        self.class.json_attributes.keys.each do |attr|
+          if self.instance_variable_get("@#{attr}") != other.instance_variable_get("@#{attr}")
+            return false
+          end
+        end
+        return true
+      rescue
+        return false
+      end
+    end
+
+    def copy(params)
+      params.each do |attr, attr_value|
+        if !self.class.json_attributes.key?(attr)
+          raise TypeError.new("Non existing attribute #{attr}")
+        end
+      end
+      new_params =
+        self.class.json_attributes.map do |attr, attr_type|
+          attr_value =
+            if params.key?(attr)
+              params[attr]
+            else
+              self.instance_variable_get("@#{attr}")
+            end
+          [attr, attr_value]
+        end.to_h
+      return self.class.new(new_params)
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def json_attributes
+        @json_attributes
+      end
+
+      def val(name, type)
+        if @json_attributes == nil
+          @json_attributes = {}
+        end
+        @json_attributes[name] = type
+        attr_reader name
+      end
+
+      def var(name, type)
+        if @json_attributes == nil
+          @json_attributes = {}
+        end
+        @json_attributes[name] = type
+        attr_accessor name
+      end
+
+      def jsoner_deserialize(json_value)
+        T.check(T.hash(String, NilableUntyped), json_value)
+        parameters = @json_attributes.map do |attr, attr_type|
+          attr_value = json_value[attr.to_s]
+          [attr, Jsoner.deserialize(attr_type, attr_value)]
+        end
+        return self.new parameters.to_h
+      end
+
+      def jsoner_serialize(value)
+        T.check(self, value)
+        attrs = @json_attributes.map do |attr, attr_type|
+          [attr, Jsoner.serialize(attr_type, value.send(attr))]
+        end
+        return attrs.to_h
+      end
+    end
+  end
+end

data/lib/emery/enum.rb

@@ -0,0 +1,101 @@
+module Emery
+  module Enum
+    attr_reader :key, :value
+
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+
+    def self.included(base)
+      base.extend Enumerable
+      base.extend ClassMethods
+
+      base.private_class_method(:new)
+    end
+
+    module ClassMethods
+      def check(value)
+        T.check_not_nil(self, value)
+        if !value?(value)
+          raise TypeError.new("Value '#{value.inspect.to_s}' is not a member of enum #{self}")
+        end
+      end
+
+      def jsoner_deserialize(json_value)
+        T.check(self, json_value)
+      end
+
+      def jsoner_serialize(value)
+        T.check(self, value)
+      end
+
+      def define(key, value)
+        @_enum_hash ||= {}
+        @_enums_by_value ||= {}
+
+        if @_enum_hash.key?(key) then
+          raise TypeError.new("Duplicate key: #{key}")
+        end
+
+        if @_enums_by_value.key?(value) then
+          raise TypeError.new("Duplicate value: #{value}")
+        end
+
+        new_instance = new(key, value)
+        @_enum_hash[key] = new_instance
+        @_enums_by_value[value] = new_instance
+
+        if key.to_s == key.to_s.upcase
+          const_set key, value
+        else
+          define_singleton_method(key) { value }
+        end
+      end
+
+      def each(&block)
+        @_enum_hash.each(&block)
+      end
+
+      def parse(k)
+        k = k.to_s.upcase
+        each do |key, enum|
+          return enum.value if key.to_s.upcase == k
+        end
+        nil
+      end
+
+      def key?(k)
+        @_enum_hash.key?(k)
+      end
+
+      def value(k)
+        enum = @_enum_hash[k]
+        enum.value if enum
+      end
+
+      def value?(v)
+        @_enums_by_value.key?(v)
+      end
+
+      def key(v)
+        enum = @_enums_by_value[v]
+        enum.key if enum
+      end
+
+      def keys
+        @_enum_hash.values.map(&:key)
+      end
+
+      def values
+        @_enum_hash.values.map(&:value)
+      end
+
+      def to_h
+        Hash[@_enum_hash.map do |key, enum|
+          [key, enum.value]
+        end]
+      end
+    end
+  end
+end

data/lib/emery/jsoner.rb

@@ -0,0 +1,188 @@
+require "json"
+require "date"
+
+require "emery/type"
+
+module Emery
+  class JsonerError < StandardError
+  end
+
+  module Jsoner
+    T::StringFormatted.class_eval do
+      def jsoner_deserialize(json_value)
+        T.check(self, json_value)
+      end
+      def jsoner_serialize(value)
+        T.check(self, value)
+      end
+    end
+
+    T::ArrayType.class_eval do
+      def jsoner_deserialize(json_value)
+        T.check_not_nil(self, json_value)
+        if !json_value.is_a?(Array)
+          raise JsonerError.new("JSON value type #{json_value.class} is not Array")
+        end
+        json_value.map { |item_json_value| Jsoner.deserialize(self.item_type, item_json_value) }
+      end
+      def jsoner_serialize(value)
+        if !value.is_a?(Array)
+          raise JsonerError.new("Value type #{json_value.class} is not Array")
+        end
+        value.map { |item| Jsoner.serialize(self.item_type, item) }
+      end
+    end
+
+    T::HashType.class_eval do
+      def jsoner_deserialize(json_value)
+        T.check_not_nil(self, json_value)
+        if self.key_type != String
+          raise JsonerError.new("Hash key type #{self.key_type} is not supported for JSON (de)serialization - key should be String")
+        end
+        if !json_value.is_a?(Hash)
+          raise JsonerError.new("JSON value type #{json_value.class} is not Hash")
+        end
+        json_value.map do |key, value|
+          [T.check(self.key_type, key), Jsoner.deserialize(self.value_type, value)]
+        end.to_h
+      end
+      def jsoner_serialize(value)
+        if self.key_type != String
+          raise JsonerError.new("Hash key type #{self.key_type} is not supported for JSON (de)serialization - key should be String")
+        end
+        if !value.is_a?(Hash)
+          raise JsonerError.new("Value type #{value.class} is not Hash")
+        end
+        value.map do |key, value|
+          [T.check(self.key_type, key), Jsoner.serialize(self.value_type, value)]
+        end.to_h
+      end
+    end
+
+    T::AnyType.class_eval do
+      def jsoner_deserialize(json_value)
+        types.each do |type|
+          begin
+            return Jsoner.deserialize(type, json_value)
+          rescue TypeError
+          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(', ')}")
+      end
+      def jsoner_serialize(value)
+        T.check(self, value)
+        type = types.find {|t| T.instance_of?(t, value) }
+        Jsoner.serialize(type, value)
+      end
+    end
+
+    T::Nilable.class_eval do
+      def jsoner_deserialize(json_value)
+        if json_value != nil
+          Jsoner.deserialize(self.type, json_value)
+        else
+          nil
+        end
+      end
+      def jsoner_serialize(value)
+        if value != nil
+          Jsoner.serialize(self.type, value)
+        else
+          nil
+        end
+      end
+    end
+
+    module FloatSerializer
+      def self.jsoner_deserialize(json_value)
+        T.check(T.any(Float, Integer), json_value)
+        json_value.to_f
+      end
+      def self.jsoner_serialize(value)
+        T.check(Float, value)
+      end
+    end
+
+    module DateTimeSerializer
+      def self.jsoner_deserialize(json_value)
+        T.check(String, json_value)
+        begin
+          DateTime.strptime(json_value, '%Y-%m-%dT%H:%M:%S')
+        rescue
+          raise JsonerError.new("Failed to parse DateTime from '#{json_value.inspect.to_s}' format %Y-%m-%dT%H:%M:%S is required")
+        end
+      end
+      def self.jsoner_serialize(value)
+        T.check(DateTime, value)
+        value.strftime('%Y-%m-%dT%H:%M:%S')
+      end
+    end
+
+    module DateSerializer
+      def self.jsoner_deserialize(json_value)
+        T.check(String, json_value)
+        begin
+          Date.strptime(json_value, '%Y-%m-%d')
+        rescue
+          raise JsonerError.new("Failed to parse Date from '#{json_value.inspect.to_s}' format %Y-%m-%d is required")
+        end
+      end
+      def self.jsoner_serialize(value)
+        T.check(Date, value)
+        value.strftime('%Y-%m-%d')
+      end
+    end
+
+    @@serializers = {
+        Float => FloatSerializer,
+        Date => DateSerializer,
+        DateTime => DateTimeSerializer
+    }
+    def self.add_serializer(type, serializer)
+      @@serializers[type] = serializer
+    end
+
+    def Jsoner.from_json(type, json)
+      data = JSON.parse(json)
+      return deserialize(type, data)
+    end
+
+    def Jsoner.deserialize(type, json_value)
+      begin
+        if type.methods.include? :jsoner_deserialize
+          return type.jsoner_deserialize(json_value)
+        elsif @@serializers.include? type
+          return @@serializers[type].jsoner_deserialize(json_value)
+        else
+          if ![String, Float, Integer, TrueClass, FalseClass, NilClass].include? type
+            raise JsonerError.new("Type #{type} is not supported in Jsoner deserialization")
+          end
+          return T.check(type, json_value)
+        end
+      rescue StandardError => error
+        raise JsonerError.new(error.message)
+      end
+    end
+
+    def Jsoner.to_json(type, value)
+      JSON.dump(serialize(type, value))
+    end
+
+    def Jsoner.serialize(type, value)
+      begin
+        if type.methods.include? :jsoner_serialize
+          return type.jsoner_serialize(value)
+        elsif @@serializers.include? type
+          return @@serializers[type].jsoner_serialize(value)
+        else
+          if ![String, Float, Integer, TrueClass, FalseClass, NilClass].include? type
+            raise JsonerError.new("Type #{type} is not supported in Jsoner serialization")
+          end
+          return T.check(type, value)
+        end
+      rescue StandardError => error
+        raise JsonerError.new(error.message)
+      end
+    end
+  end
+end

data/lib/emery/tod.rb

@@ -0,0 +1,262 @@
+=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