omnievent 0.1.0.pre1

data/lib/omnievent/event_hash.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module OmniEvent
+  # The EventHash is a normalized schema returned by all OmniEvent strategies.
+  class EventHash < OmniEvent::KeyStore
+    def self.subkey_class
+      Hashie::Mash
+    end
+
+    # Tells you if this is considered to be a valid EventHash.
+    def valid?
+      provider? &&
+        data? &&
+        data.valid? &&
+        (!metadata || metadata.valid?) &&
+        (!associated_data || associated_data.valid?)
+    end
+
+    def regular_writer(key, value)
+      value = DataHash.new(value) if key.to_s == "data" && value.is_a?(::Hash) && !value.is_a?(DataHash)
+      value = MetadataHash.new(value) if key.to_s == "metadata" && value.is_a?(::Hash) && !value.is_a?(MetadataHash)
+      if key.to_s == "associated_data" && value.is_a?(::Hash) && !value.is_a?(AssociatedDataHash)
+        value = AssociatedDataHash.new(value)
+      end
+      super
+    end
+
+    # Base for data hashes
+    class EventHashBase < OmniEvent::KeyStore
+      def permitted?(keys, attribute = nil, sub_attribute = nil)
+        permitted = self.class.permitted_attributes
+        permitted = permitted[attribute] if attribute
+        permitted = permitted[sub_attribute] if sub_attribute
+        permitted = permitted.is_a?(Hash) ? permitted.keys.map(&:to_s) : permitted
+        (keys - permitted).empty?
+      end
+
+      # Tells you if this is considered to be a valid hash.
+      def valid?
+        if self.class.respond_to?(:required_attributes) && !self.class.required_attributes.all? do |attribute|
+             value = send(attribute)
+             !value.nil? && !value.empty?
+           end
+          # All required attributes have values
+          return false
+        end
+
+        # All attributes are permitted
+        return false unless permitted?(keys)
+
+        # All attribute values are valid
+        self.class.permitted_attributes.all? do |attribute|
+          value = send(attribute.to_s)
+          return true if value.to_s.empty? || send("#{attribute}_valid?")
+
+          invalid << attribute
+          false
+        end
+      end
+
+      def invalid
+        @invalid ||= []
+      end
+    end
+
+    # The event data.
+    class DataHash < EventHashBase
+      def self.subkey_class
+        Hashie::Mash
+      end
+
+      def self.permitted_attributes
+        %w[
+          start_time
+          end_time
+          name
+          description
+          url
+        ]
+      end
+
+      def self.required_attributes
+        %w[
+          start_time
+          name
+        ]
+      end
+
+      def start_time_valid?
+        OmniEvent::Utils.valid_time?(start_time)
+      end
+
+      def end_time_valid?
+        OmniEvent::Utils.valid_time?(end_time)
+      end
+
+      def name_valid?
+        OmniEvent::Utils.valid_type?(name, :string)
+      end
+
+      def description_valid?
+        OmniEvent::Utils.valid_type?(name, :string)
+      end
+
+      def url_valid?
+        OmniEvent::Utils.valid_url?(url)
+      end
+    end
+
+    # The event metadata.
+    class MetadataHash < EventHashBase
+      def self.subkey_class
+        Hashie::Mash
+      end
+
+      # The permitted MetadataHash attributes.
+      def self.permitted_attributes
+        %w[
+          uid
+          created_at
+          updated_at
+          language
+          status
+          taxonomies
+        ]
+      end
+
+      def self.permitted_statuses
+        %w[
+          draft
+          published
+          cancelled
+        ]
+      end
+
+      def uid_valid?
+        OmniEvent::Utils.valid_uid?(uid)
+      end
+
+      def created_at_valid?
+        OmniEvent::Utils.valid_time?(created_at)
+      end
+
+      def updated_at_valid?
+        OmniEvent::Utils.valid_time?(updated_at)
+      end
+
+      def language_valid?
+        OmniEvent::Utils.valid_language_code?(language)
+      end
+
+      def status_valid?
+        self.class.permitted_statuses.include?(status)
+      end
+
+      def taxonomies_valid?
+        OmniEvent::Utils.all_valid_type?(taxonomies, :string)
+      end
+    end
+
+    # The event's associated data.
+    class AssociatedDataHash < EventHashBase
+      def self.subkey_class
+        Hashie::Mash
+      end
+
+      # The permitted MetadataHash attributes.
+      def self.permitted_attributes
+        {
+          location: %w[uid name address city postal_code country latitude longitude url],
+          virtual_location: { "uid": "", "entry_points": %w[uri type code label] },
+          organizer: %w[uid name email uris],
+          registrations: %w[uid name email status]
+        }
+      end
+
+      def self.permitted_entry_point_attributes
+        %w[
+          uri
+          type
+          code
+          label
+        ]
+      end
+
+      def location_valid?
+        return true unless location
+        return false unless location.is_a?(Hash)
+        return false unless permitted?(location.keys, :location)
+
+        location.all? do |key, value|
+          case key
+          when "uid"
+            OmniEvent::Utils.valid_uid?(value)
+          when "name", "address", "city", "postal_code"
+            OmniEvent::Utils.valid_type?(value, :string)
+          when "country"
+            OmniEvent::Utils.valid_country_code?(value)
+          when "latitude", "longitude"
+            OmniEvent::Utils.valid_coordinate?(value, key.to_sym)
+          when "url"
+            OmniEvent::Utils.valid_url?(value)
+          else
+            false
+          end
+        end
+      end
+
+      def virtual_location_valid?
+        return true unless virtual_location
+        return false unless virtual_location.is_a?(Hash)
+        return true unless virtual_location["entry_points"]
+
+        return false if virtual_location["uid"] && !OmniEvent::Utils.valid_uid?(virtual_location["uid"])
+
+        virtual_location["entry_points"].all? do |entry_point|
+          return false unless entry_point.is_a?(Hash)
+          return false unless entry_point["uri"] && entry_point["type"]
+          return false unless permitted?(entry_point.keys, :virtual_location, :entry_points)
+          return false unless case entry_point["type"]
+                              when "video"
+                                OmniEvent::Utils.valid_url?(entry_point["uri"])
+                              when "phone", "sip"
+                                OmniEvent::Utils.valid_type?(entry_point["uri"], :string)
+                              else
+                                false
+                              end
+
+          OmniEvent::Utils.valid_type?(entry_point["label"], :string) &&
+            OmniEvent::Utils.valid_type?(entry_point["code"], :string)
+        end
+      end
+
+      def organizer_valid?
+        return true unless organizer
+        return false unless organizer.is_a?(Hash)
+        return false unless permitted?(organizer.keys, :organizer)
+
+        organizer.all? do |key, value|
+          case key
+          when "uid"
+            OmniEvent::Utils.valid_uid?(value)
+          when "name"
+            OmniEvent::Utils.valid_type?(value, :string)
+          when "email"
+            OmniEvent::Utils.valid_email?(value)
+          when "uris"
+            OmniEvent::Utils.all_valid_type?(value, :string)
+          else
+            false
+          end
+        end
+      end
+
+      def self.permitted_registration_statuses
+        %w[
+          confirmed
+          declined
+          tentative
+        ]
+      end
+
+      def registrations_valid?
+        return true unless registrations
+        return false unless registrations.is_a?(Array)
+
+        registrations.all? do |registration|
+          return false unless registration.is_a?(Hash)
+          return false unless registration["email"] && registration["status"]
+          return false unless permitted?(registration.keys, :registrations)
+
+          registration.all? do |key, value|
+            case key
+            when "uid"
+              OmniEvent::Utils.valid_uid?(value)
+            when "name"
+              OmniEvent::Utils.valid_type?(value, :string)
+            when "email"
+              OmniEvent::Utils.valid_email?(value)
+            when "status"
+              self.class.permitted_registration_statuses.include?(value)
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnievent/key_store.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "hashie/mash"
+
+module OmniEvent
+  # Generic helper hash that allows method access on deeply nested keys.
+  class KeyStore < ::Hashie::Mash
+    # Disables warnings on Hashie 3.5.0+ for overwritten keys
+    def self.override_logging
+      require "hashie/version"
+      return unless Gem::Version.new(Hashie::VERSION) >= Gem::Version.new("3.5.0")
+
+      if respond_to?(:disable_warnings)
+        disable_warnings
+      else
+        define_method(:log_built_in_message) { |*| }
+        private :log_built_in_message
+      end
+    end
+
+    # Disable on loading of the class
+    override_logging
+  end
+end

data/lib/omnievent/strategies/developer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+
+module OmniEvent
+  module Strategies
+    # The Developer strategy can be used for testing purposes.
+    #
+    # ## Usage
+    #
+    # All you need to do is add it in like any other strategy:
+    #
+    # @example Basic Usage
+    #
+    #   OmniEvent::Builder.new do
+    #     provider :developer
+    #   end
+    #
+    class Developer
+      include OmniEvent::Strategy
+
+      option :name, "developer"
+
+      def self.raw_data
+        fixture = File.join(File.expand_path("../../..", __dir__), "spec", "fixtures", "list_events.json")
+        @raw_data ||= JSON.parse(File.open(fixture).read).to_h
+      end
+
+      def raw_events
+        self.class.raw_data["events"]
+      end
+
+      def event_hash(raw_event)
+        event = OmniEvent::EventHash.new(
+          provider: name,
+          data: raw_event.slice(*OmniEvent::EventHash::DataHash.permitted_attributes),
+          metadata: raw_event.slice(*OmniEvent::EventHash::MetadataHash.permitted_attributes),
+          associated_data: {
+            location: map_location(raw_event["location"]),
+            virtual_location: raw_event["virtual_location"]
+          }
+        )
+
+        event.data.start_time = format_time(event.data.start_time)
+        event.data.end_time = format_time(event.data.end_time)
+        event.metadata.created_at = format_time(event.metadata.created_at)
+        event.metadata.updated_at = format_time(event.metadata.updated_at)
+        event.metadata.uid = raw_event["id"]
+
+        event
+      end
+
+      def authorized?
+        true
+      end
+
+      protected
+
+      def location_key_map
+        {
+          countryCode: "country",
+          latitude: "latitude",
+          longitude: "longitude",
+          address1: "address",
+          address2: "address",
+          address3: "address",
+          city: "city",
+          postalCode: "postal_code"
+        }
+      end
+
+      def map_location(raw_location)
+        raw_location.each_with_object({}) do |(raw_key, raw_value), result|
+          next unless location_key_map[raw_key.to_sym]
+
+          key = location_key_map[raw_key.to_sym]
+          value = result[key]
+          if value && key == "address"
+            value += " #{raw_value}"
+          else
+            value = raw_value
+          end
+          result[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/omnievent/strategy.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module OmniEvent
+  # The Strategy is the base unit of OmniEvent's ability to handle
+  # multiple event providers. It's substantially based on OmniAuth::Strategy.
+  module Strategy
+    class NotImplementedError < NotImplementedError; end
+    class Options < OmniEvent::KeyStore; end
+
+    def self.included(base)
+      OmniEvent.strategies << base
+      base.extend ClassMethods
+      base.class_eval do
+        option :uid_delimiter, "-"
+      end
+    end
+
+    # Class methods for Strategy
+    module ClassMethods
+      # Default options for all strategies which can be overriden at the class-level
+      # for each strategy.
+      def default_options
+        @default_options ||= begin
+          d_opts = OmniEvent::Strategy::Options.new
+          d_opts.merge!(superclass.default_options) if superclass.respond_to?(:default_options)
+          d_opts
+        end
+      end
+
+      # This allows for more declarative subclassing of strategies by allowing
+      # default options to be set using a simple configure call.
+      #
+      # @param options [Hash] If supplied, these will be the default options
+      #    (deep-merged into the superclass's default options).
+      # @yield [Options] The options Mash that allows you to set your defaults as you'd like.
+      #
+      # @example Using a yield to configure the default options.
+      #
+      #   class MyStrategy
+      #     include OmniEvent::Strategy
+      #
+      #     configure do |c|
+      #       c.foo = 'bar'
+      #     end
+      #   end
+      #
+      # @example Using a hash to configure the default options.
+      #
+      #   class MyStrategy
+      #     include OmniEvent::Strategy
+      #     configure foo: 'bar'
+      #   end
+      def configure(options = nil)
+        if block_given?
+          yield default_options
+        else
+          default_options.deep_merge!(options)
+        end
+      end
+
+      # Directly declare a default option for your class. This is a useful from
+      # a documentation perspective as it provides a simple line-by-line analysis
+      # of the kinds of options your strategy provides by default.
+      #
+      # @param name [Symbol] The key of the default option in your configuration hash.
+      # @param value [Object] The value your object defaults to. Nil if not provided.
+      #
+      # @example
+      #
+      #   class MyStrategy
+      #     include OmniEvent::Strategy
+      #
+      #     option :foo, 'bar'
+      #     option
+      #   end
+      def option(name, value = nil)
+        default_options[name] = value
+      end
+
+      # Sets (and retrieves) option key names for initializer arguments to be
+      # recorded as. This takes care of 90% of the use cases for overriding
+      # the initializer in OmniEvent Strategies.
+      def args(args = nil)
+        if args
+          @args = Array(args)
+          return
+        end
+        existing = superclass.respond_to?(:args) ? superclass.args : []
+        (instance_variable_defined?(:@args) && @args) || existing
+      end
+    end
+
+    attr_reader :options
+
+    # Initializes the strategy. An `options` hash is automatically
+    # created from the last argument if it is a hash.
+    #
+    # @overload new(options = {})
+    #   If nothing but a hash is supplied, initialized with the supplied options
+    #   overriding the strategy's default options via a deep merge.
+    # @overload new(*args, options = {})
+    #   If the strategy has supplied custom arguments that it accepts, they may
+    #   will be passed through and set to the appropriate values.
+    #
+    # @yield [Options] Yields options to block for further configuration.
+    def initialize(*args, &block) # rubocop:disable Lint/UnusedMethodArgument
+      @options = self.class.default_options.dup
+
+      options.deep_merge!(args.pop) if args.last.is_a?(Hash)
+      options[:name] ||= self.class.to_s.split("::").last.downcase
+
+      self.class.args.each do |arg|
+        break if args.empty?
+
+        options[arg] = args.shift
+      end
+
+      # Make sure that all of the args have been dealt with, otherwise error out.
+
+      yield options if block_given?
+
+      validate_options
+    end
+
+    def validate_options
+      # rubocop:disable Style/GuardClause
+      if options[:from_time] && !options[:from_time].respond_to?(:strftime)
+        raise ArgumentError, "from_time must be a valid ruby time object"
+      end
+      if options[:to_time] && !options[:to_time].respond_to?(:strftime)
+        raise ArgumentError, "to_time must be a valid ruby time object"
+      end
+      # rubocop:enable Style/GuardClause
+    end
+
+    def request(method, opts)
+      options.deep_merge!(opts)
+
+      authorize
+      return unless authorized?
+
+      send(method)
+    end
+
+    def authorize; end
+
+    def authorized?
+      raise NotImplementedError
+    end
+
+    def raw_events
+      raise NotImplementedError
+    end
+
+    def event_hash
+      raise NotImplementedError
+    end
+
+    def list_events
+      raw_events.each_with_object([]) do |raw_event, result|
+        event = event_hash(raw_event)
+
+        next unless event.valid?
+        next if options.from_time && Time.parse(event.data.start_time).utc < options.from_time.utc
+        next if options.to_time && Time.parse(event.data.start_time).utc > options.to_time.utc
+
+        result << event
+      end
+    end
+
+    # Direct access to the OmniEvent logger, automatically prefixed
+    # with this strategy's name.
+    #
+    # @example
+    #   log :warn, 'This is a warning.'
+    def log(level, message)
+      OmniEvent.logger.send(level, "(#{name}) #{message}")
+    end
+
+    def name
+      options[:name]
+    end
+
+    def format_time(time)
+      return nil if time.nil? || !time.respond_to?(:to_s)
+
+      OmniEvent::Utils.convert_time_to_iso8601(time.to_s)
+    end
+  end
+end

data/lib/omnievent/utils.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "uri"
+require "tzinfo"
+require "iso-639"
+require "time"
+
+module OmniEvent
+  # Utility methods
+  module Utils
+    module_function
+
+    def camelize(word, first_letter_in_uppercase = true)
+      return OmniEvent.config.camelizations[word.to_s] if OmniEvent.config.camelizations[word.to_s]
+
+      if first_letter_in_uppercase
+        word.to_s.gsub(%r{/(.?)}) do
+          "::#{Regexp.last_match[1].upcase}"
+        end.gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
+      else
+        camelize(word).tap { |w| w[0] = w[0].downcase }
+      end
+    end
+
+    def valid_time?(value)
+      !!Time.iso8601(value)
+    rescue ArgumentError
+      false
+    end
+
+    def valid_language_code?(value)
+      !!ISO_639.find_by_code(value)
+    end
+
+    def valid_country_code?(value)
+      !!TZInfo::Country.all_codes.include?(value)
+    end
+
+    def valid_coordinate?(value, type)
+      case type
+      when :latitude
+        /^-?([1-8]?\d(?:\.\d{1,})?|90(?:\.0{1,6})?)$/ =~ value
+      when :longitude
+        /^-?((?:1[0-7]|[1-9])?\d(?:\.\d{1,})?|180(?:\.0{1,})?)$/ =~ value
+      else
+        false
+      end
+    end
+
+    def valid_email?(value)
+      URI::MailTo::EMAIL_REGEXP =~ value
+    end
+
+    def valid_url?(value)
+      (URI.parse value).is_a? URI::HTTP
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def valid_type?(value, type)
+      case type
+      when :boolean
+        [true, false].include? value
+      when :string
+        value.is_a?(String)
+      when :array
+        value.is_a?(Array)
+      else
+        false
+      end
+    end
+
+    def valid_uid?(value)
+      value.is_a?(String)
+    end
+
+    def all_valid_type?(array, type)
+      valid_type?(array, :array) && array.all? { |t| valid_type?(t, type) }
+    end
+
+    def convert_time_to_iso8601(value)
+      Time.parse(value).iso8601
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/omnievent/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OmniEvent
+  VERSION = "0.1.0.pre1"
+end