zenaton 0.1.0

data/lib/zenaton/services/http.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'zenaton/exceptions'
+
+module Zenaton
+  # Collection of utility classes for the Zenaton library
+  module Services
+    # Wrapper class around HTTParty that:
+    # - handles http calls
+    # - sets appropriate headers for each request type
+    # - translates exceptions into Zenaton specific ones
+    class Http
+      # Makes a GET request and sets the correct headers
+      #
+      # @param url [String] the url for the request
+      # @return [Hash] the parsed json response
+      def get(url)
+        request(:get, url, default_options)
+      end
+
+      # Makes a POST request with some data and sets the correct headers
+      #
+      # @param url [String] the url for the request
+      # @param body [Hash] the payload to send with the request
+      # @return [Hash] the parsed json response
+      def post(url, body)
+        request(:post, url, post_options(body))
+      end
+
+      # Makes a PUT request with some data and sets the correct headers
+      #
+      # @param url [String] the url for the request
+      # @param body [Hash] the payload to send with the request
+      # @return [Hash] the parsed json response
+      def put(url, body)
+        request(:put, url, put_options(body))
+      end
+
+      private
+
+      def request(verb, url, options)
+        make_request(verb, url, options)
+      rescue SocketError, HTTParty::Error => error
+        raise Zenaton::ConnectionError, error
+      end
+
+      def make_request(verb, url, options)
+        response = HTTParty.send(verb, url, options)
+        raise Zenaton::InternalError, format_error(response) if errors? response
+        JSON.parse(response.body)
+      end
+
+      def errors?(response)
+        response.code >= 400
+      end
+
+      def format_error(response)
+        "#{response.code}: #{response.message}"
+      end
+
+      def default_options
+        {
+          headers: { 'Accept' => 'application/json' }
+        }
+      end
+
+      def post_options(body)
+        {
+          body: body.to_json,
+          headers: {
+            'Accept' => 'application/json',
+            'Content-Type' => 'application/json'
+          }
+        }
+      end
+      alias put_options post_options
+    end
+  end
+end

data/lib/zenaton/services/properties.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Zenaton
+  module Services
+    # Wrapper class to read instance variables from an object and
+    # to create new objects with a given set of instance variables.
+    class Properties
+      # Handle (de)serializaton separately for these classes.
+      SPECIAL_CASES = [Time, Date, DateTime].freeze
+
+      # Returns an allocated instance of the given class name
+      # @param class_name [String] the name of the class to allocate
+      # @return [Object]
+      def blank_instance(class_name)
+        klass = Object.const_get(class_name)
+        if klass < Singleton
+          klass.instance
+        else
+          klass.allocate
+        end
+      end
+
+      # Returns a hash with the instance variables of a given object
+      # @param object [Object] the object to be read
+      # @return [Hash]
+      def from(object)
+        return from_complex_type(object) if special_case?(object)
+        object.instance_variables.map do |ivar|
+          value = object.instance_variable_get(ivar)
+          [ivar, value]
+        end.to_h
+      end
+
+      # Returns the given object with the properties as instance variables
+      # @param object [Object] the object to write the variables to
+      # @param properties [Hash] the properties to be written
+      # @return [Object]
+      def set(object, properties)
+        return set_complex_type(object, properties) if special_case?(object)
+        properties.each do |ivar, value|
+          object.instance_variable_set(ivar, value)
+        end
+        object
+      end
+
+      # Given a class name and a set of properties, return a new instance of the
+      # class with the given properties as instance variables
+      # @param class_name [String] name of the class to instantiate
+      # @param properties [Hash] the properties to be written
+      # @param super_class [Class] the optional class the object should inherit
+      # @return [Object]
+      def object_from(class_name, properties, super_class = nil)
+        blank_instance(class_name).tap do |object|
+          check_class(object, super_class)
+          set(object, properties)
+        end
+      end
+
+      private
+
+      def check_class(object, super_class)
+        msg = "Error - #{object.class} should be an instance of #{super_class}"
+        raise ArgumentError, msg unless valid_object(object, super_class)
+      end
+
+      def valid_object(object, super_class)
+        super_class.nil? || object.is_a?(super_class)
+      end
+
+      def from_complex_type(object)
+        case object.class.name
+        when 'Time'
+          from_time(object)
+        when 'Date'
+          from_date(object)
+        when 'DateTime'
+          from_date_time(object)
+        end
+      end
+
+      def from_time(object)
+        nanoseconds = [object.tv_usec * 1_000]
+        object.respond_to?(:tv_nsec) && nanoseconds << object.tv_nsec
+        { 's' => object.tv_sec, 'n' => nanoseconds.max }
+      end
+
+      def from_date(object)
+        { 'y' => object.year, 'm' => object.month,
+          'd' => object.day, 'sg' => object.start }
+      end
+
+      def from_date_time(object)
+        {
+          'y' => object.year, 'm' => object.month, 'd' => object.day,
+          'H' => object.hour, 'M' => object.minute, 'S' => object.sec,
+          'of' => object.offset.to_s, 'sg' => object.start
+        }
+      end
+
+      def set_complex_type(object, props)
+        case object.class.name
+        when 'Time'
+          return_time(object, props)
+        when 'Date'
+          return_date(props)
+        when 'DateTime'
+          return_date_time(props)
+        end
+      end
+
+      def return_time(object, props)
+        if object.respond_to?(:tv_usec)
+          Time.at(props['s'], Rational(props['n'], 1000))
+        else
+          Time.at(props['s'], props['n'] / 1000)
+        end
+      end
+
+      def return_date(props)
+        Date.civil(*props.values_at('y', 'm', 'd', 'sg'))
+      end
+
+      def return_date_time(props)
+        args = props.values_at('y', 'm', 'd', 'H', 'M', 'S')
+        of_a, of_b = props['of'].split('/')
+        args << if of_b && of_b != 0
+                  Rational(of_a.to_i, of_b.to_i)
+                else
+                  of_a
+                end
+        args << props['sg']
+        DateTime.civil(*args) # rubocop:disable Style/DateTime
+      end
+
+      def special_case?(object)
+        SPECIAL_CASES.include?(object.class)
+      end
+    end
+  end
+end

data/lib/zenaton/services/serializer.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/properties'
+
+module Zenaton
+  module Services
+    # Encoding and decoding ruby objects into Zenaton's json format
+    class Serializer
+      # this string prefixs ids that are used to identify objects
+      ID_PREFIX = '@zenaton#'
+
+      KEY_OBJECT = 'o' # JSON key for objects
+      KEY_OBJECT_NAME = 'n' # JSON key for class name
+      KEY_OBJECT_PROPERTIES = 'p' # JSON key for object ivars
+      KEY_ARRAY = 'a' # JSON key for array and hashes
+      KEY_DATA = 'd' # JSON key for json compatibles types
+      KEY_STORE = 's' # JSON key for deserialized complex object
+
+      def initialize
+        @properties = Properties.new
+      end
+
+      # rubocop:disable Metrics/MethodLength
+
+      # Encodes a given ruby object to Zenaton's json format
+      def encode(data)
+        @encoded = []
+        @decoded = []
+        value = {}
+        raise ArgumentError, 'Procs cannot be serialized' if data.is_a?(Proc)
+        if data.is_a?(Array)
+          value[KEY_ARRAY] = encode_array(data)
+        elsif data.is_a?(Hash)
+          value[KEY_ARRAY] = encode_hash(data)
+        elsif basic_type?(data)
+          value[KEY_DATA] = data
+        else
+          value[KEY_OBJECT] = encode_object(data)
+        end
+        value[KEY_STORE] = @encoded
+        value.to_json
+      end
+
+      # Decodes Zenaton's format in a valid Ruby object
+      def decode(json_string)
+        parsed_json = JSON.parse(json_string)
+        @decoded = []
+        @encoded = parsed_json.delete(KEY_STORE)
+        case parsed_json.keys.first
+        when KEY_DATA
+          return parsed_json[KEY_DATA]
+        when KEY_ARRAY
+          return decode_enumerable(parsed_json[KEY_ARRAY])
+        when KEY_OBJECT
+          id = parsed_json[KEY_OBJECT][ID_PREFIX.length..-1].to_i
+          return decode_object(id, @encoded[id])
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def array_type?(data)
+        data.is_a?(Array) || data.is_a?(Hash)
+      end
+
+      def basic_type?(data)
+        data.is_a?(String) \
+          || data.is_a?(Integer) \
+          || data.is_a?(Float) \
+          || data == true \
+          || data == false \
+          || data.nil?
+      end
+
+      def encode_array(array)
+        array.map { |elem| encode_value(elem) }
+      end
+
+      def encode_hash(hash)
+        hash.transform_values { |value| encode_value(value) }
+      end
+
+      def encode_value(value)
+        raise ArgumentError, 'Procs cannot be serialized' if value.is_a?(Proc)
+        if value.is_a?(Array)
+          encode_array(value)
+        elsif value.is_a?(Hash)
+          encode_hash(value)
+        elsif basic_type?(value)
+          value
+        else
+          encode_object(value)
+        end
+      end
+
+      def encode_object(object)
+        id = @decoded.index(object)
+        unless id
+          id = @decoded.length
+          @decoded[id] = object
+          @encoded[id] = {
+            KEY_OBJECT_NAME => object.class.name,
+            KEY_OBJECT_PROPERTIES => encode_hash(@properties.from(object))
+          }
+        end
+        "#{ID_PREFIX}#{id}"
+      end
+
+      def object_id?(string)
+        string.is_a?(String) \
+          && string.start_with?(ID_PREFIX) \
+          && string[ID_PREFIX.length..-1].to_i <= @encoded.length
+      end
+
+      def decode_enumerable(enumerable)
+        return decode_array(enumerable) if enumerable.is_a?(Array)
+        return decode_hash(enumerable) if enumerable.is_a?(Hash)
+        raise ArgumentError, 'Unknown type'
+      end
+
+      def decode_array(array)
+        array.map { |elem| decode_element(elem) }
+      end
+
+      def decode_hash(hash)
+        hash.transform_values { |value| decode_element(value) }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def decode_element(value)
+        if object_id?(value)
+          id = value[ID_PREFIX.length..-1].to_i
+          encoded = @encoded[id]
+          decode_object(id, encoded) if encoded.is_a?(Hash)
+        elsif value.is_a?(Array)
+          decode_array(value)
+        elsif value.is_a?(Hash)
+          decode_hash(value)
+        else
+          value
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def decode_object(id, encoded_object)
+        decoded = @decoded[id]
+        return decoded if decoded
+        object = @properties.blank_instance(encoded_object[KEY_OBJECT_NAME])
+        @decoded[id] = object
+        properties = decode_hash(encoded_object[KEY_OBJECT_PROPERTIES])
+        @properties.set(object, properties)
+      end
+    end
+  end
+end

data/lib/zenaton/tasks/wait.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'zenaton/exceptions'
+require 'zenaton/interfaces/task'
+require 'zenaton/interfaces/event'
+require 'zenaton/traits/with_timestamp'
+require 'zenaton/traits/zenatonable'
+
+module Zenaton
+  # Subclasses of Zenaton::Interfaces::Task
+  module Tasks
+    # Class for creating waiting tasks
+    class Wait < Interfaces::Task
+      attr_reader :event
+
+      include Traits::WithTimestamp
+      include Traits::Zenatonable
+
+      # Creates a new wait task and validates the event given
+      # @param event [Class, String]
+      def initialize(event = nil)
+        raise ExternalError, error unless valid_param(event)
+        @event = event
+      end
+
+      # NOOP: No waiting when executing locally
+      def handle; end
+
+      private
+
+      def error
+        # rubocop:disable Metrics/LineLength
+        "#{self.class}: Invalid parameter - argument must be a Zenaton::Interfaces::Event subclass"
+        # rubocop:enable Metrics/LineLength
+      end
+
+      def valid_param(event)
+        event.nil? || event.is_a?(String) || event_class?(event)
+      end
+
+      def event_class?(event)
+        event.class == Class && event < Zenaton::Interfaces::Event
+      end
+    end
+  end
+end

data/lib/zenaton/traits/with_duration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module Zenaton
+  module Traits
+    # Module to calculate duration between events
+    module WithDuration
+      # @return [Integer, NilClass] Duration in seconds
+      def _get_duration
+        return unless @buffer
+        now, now_dup = _init_now_then
+        @buffer.each do |time_unit, time_value|
+          now_dup = _apply_duration(time_unit, time_value, now_dup)
+        end
+        diff_in_seconds(now, now_dup)
+      end
+
+      %i[seconds minutes hours days weeks months years].each do |method_name|
+        define_method method_name do |value = 1|
+          _push(method_name, value)
+          self
+        end
+      end
+
+      private
+
+      def _init_now_then
+        Time.zone = self.class.class_variable_get(:@@_timezone) || 'UTC'
+        now = Time.zone.now
+        Time.zone = nil # Resets time zone
+        [now, now.dup]
+      end
+
+      def _push(method_name, value)
+        @buffer ||= {}
+        @buffer[method_name] = value
+      end
+
+      def _apply_duration(time_unit, time_value, time)
+        time + time_value.send(time_unit)
+      end
+
+      def diff_in_seconds(before, after)
+        (after - before).to_i
+      end
+    end
+  end
+end