polyseerio 0.0.1

data/lib/helper.rb

@@ -0,0 +1,153 @@
+require 'inflection'
+
+module Polyseerio
+  # General helper functions for SDK
+  module Helper
+    DEFAULT_REQUIRE_DIRECTORY_OPTIONS = {
+      exclude: ['index'].freeze
+    }.freeze
+
+    # Simple conversion to seconds from ms.
+    def self.ms_to_seconds(ms)
+      ms / 1000.0
+    end
+
+    # Given directory and module a map of module procs will be created.
+    # TODO: this is really a dir func map not a proc map
+    def self.dir_proc_map(dir, mod)
+      map = Polyseerio::Helper.dir_to_path_map dir
+
+      map.each { |(_, path)| require path }
+
+      map.each_with_object({}, &Helper.add_to_proc_map(mod))
+    end
+
+    # Adds a proc method to an accumulator by its name.
+    # TODO: this is really a dir func map not always a proc map.
+    def self.add_to_proc_map(*args)
+      proc do |mod, (name, _), acc|
+        if mod.respond_to? name
+          result = mod.send name
+
+          acc[name] = result unless result.nil?
+        end
+
+        acc
+      end.curry.call(*args)
+    end
+
+    # Convert resource string to resource type.
+    def self.resource_to_type(resource)
+      Inflection.singular(resource)
+    end
+
+    # A memoize function that has an optional cache key.
+    def self.memoize_function(func, get_key)
+      lambda do
+        results = {}
+
+        proc do |*args|
+          key = get_key.call(*args) # TODO: assert key is sym?
+
+          if results.key? key
+            results.fetch key
+          else
+            result = func.call(*args)
+
+            results[key] = result
+
+            result
+          end
+        end
+      end.call
+    end
+
+    # Simple identity function.
+    def self.identity(value)
+      proc { |x| x }.call(value)
+    end
+
+    # Maps filename to file path
+    def self.dir_to_path_map(directory, options = {})
+      directory = "#{directory}/*#{options[:extension]}"
+      options = defaults(options, DEFAULT_REQUIRE_DIRECTORY_OPTIONS)
+
+      paths = Dir[directory].select do |file|
+        name = File.basename(file, '.*')
+
+        !options[:exclude].include? name
+      end
+
+      paths.each_with_object({}) do |file, acc|
+        name = File.basename(file, '.*')
+
+        acc[name.to_sym] = file
+
+        acc
+      end
+    end
+
+    # Load an include an entire directory.
+    def self.require_directory(directory, options = {})
+      directory = "#{directory}/*#{options[:extension]}"
+      options = defaults(options, DEFAULT_REQUIRE_DIRECTORY_OPTIONS)
+
+      Dir[directory].select do |file|
+        pathname = Pathname.new(file)
+
+        !options[:exclude].include? pathname.basename
+      end
+    end
+
+    # Format a resouce payload for API consumption
+    def self.format_payload(payload)
+      { data: { attributes: payload.clone } }
+    end
+
+    # Attempt to geta token.
+    def self.resolve_token(options)
+      return options[:token] unless options[:token].nil?
+
+      if ENV.key? options[:token_env]
+        value = ENV.fetch(options[:token_env], nil)
+
+        return value unless value.nil?
+      end
+
+      nil
+    end
+
+    # Generates default options.
+    def self.defaults(options, *defaults)
+      result = {}
+
+      defaults.reverse_each do |opts|
+        result.merge!(opts)
+      end
+
+      result.merge!(options)
+    end
+
+    # Used to attach a method to an instance
+    def self.attach_to_instance!(*args)
+      lambda do |instance, (key, value)|
+        instance.instance_eval do
+          define_singleton_method(key, proc { value })
+        end
+      end.curry.call(*args)
+    end
+
+    # Rekey a hash using a remapping hash.
+    def self.rekey(hash, map)
+      hash.each_with_object({}) do |(key, value), acc|
+        if map.key? key
+          acc[map[key]] = value
+        else
+          acc[key] = value
+        end
+
+        acc
+      end
+    end
+  end
+end

data/lib/middleware.rb

@@ -0,0 +1,51 @@
+require 'helper'
+require 'json'
+require 'response'
+require 'resource/helper'
+
+module Polyseerio
+  module Middleware
+    # Pre request middleware.
+    module Pre
+      # Requests arguments run through there.
+      def self.format_arguments
+        proc do |*args|
+          new_args = args
+
+          if new_args.size > 1
+            new_args[1] = Helper.format_payload new_args[1]
+            new_args[1] = new_args[1].to_json
+          end
+
+          new_args
+        end
+      end
+    end
+
+    # Post request middleware.
+    module Post
+      # Takes rest-client and response and converts it to internal response.
+      def self.to_response
+        proc do |response|
+          Response.new(response)
+        end
+      end
+
+      # Request results run through there.
+      def self.parse_response
+        proc do |response|
+          Resource::Helper.parse_response(response, 0) # TODO: need a cid
+        end
+      end
+    end
+
+    # Request rejection (error) middleware.
+    module Reject
+      def self.handle_rejection
+        proc do |error|
+          error
+        end
+      end
+    end
+  end
+end

data/lib/polyseerio.rb

@@ -0,0 +1,115 @@
+require 'resource/factory'
+require 'request'
+require 'middleware'
+require 'constant'
+require 'enum'
+require 'client'
+require 'url_builder'
+require 'rest-client'
+require 'helper'
+
+# Main Polyseerio module.
+module Polyseerio
+  # Default client options.
+  DEFAULT_CLIENT_OPTIONS = {
+    agent:       {},
+    deduce:      true,
+    env:         Constant::DEFAULT_ENV,
+    timeout:     Constant::DEFAULT_TIMEOUT,
+    environment: Constant::DEFAULT_ENVIRONMENT,
+    token:       nil,
+    token_env:   Constant::DEFAULT_TOKEN_ENV,
+    upsert_env:  true,
+    version:     Constant::DEFAULT_API_VERSION
+  }.freeze
+
+  # Required resources for constructing a client.
+  REQUIRED_RESOURCES = [
+    Enum::Resource::ALERT,
+    Enum::Resource::CHANNEL,
+    Enum::Resource::ENVIRONMENT,
+    Enum::Resource::EVENT,
+    Enum::Resource::EXPECTATION,
+    Enum::Resource::INSTANCE,
+    Enum::Resource::LOGIC_BLOCK,
+    Enum::Resource::MEMBER,
+    Enum::Resource::SETTING,
+    Enum::Resource::TASK
+  ].freeze
+
+  # Maps resources to paths within a Client
+  CLIENT_RESOURCE_PATHS = {
+    Enum::Resource::ALERT       => :Alert,
+    Enum::Resource::CHANNEL     => :Channel,
+    Enum::Resource::ENVIRONMENT => :Environment,
+    Enum::Resource::EVENT       => :Event,
+    Enum::Resource::EXPECTATION => :Expectation,
+    Enum::Resource::INSTANCE    => :Instance,
+    Enum::Resource::LOGIC_BLOCK => :LogicBlock,
+    Enum::Resource::MEMBER      => :Member,
+    Enum::Resource::SETTING     => :Settings,
+    Enum::Resource::TASK        => :Task
+  }.freeze
+
+  # Create a client and start it's agent.
+  def self.start(*args)
+    client = make(*args)
+
+    client.start_agent
+  end
+
+  @make_call_count = 0
+
+  # Create a client.
+  def self.make(options = {})
+    options = Helper.defaults(options, DEFAULT_CLIENT_OPTIONS)
+
+    cid = @make_call_count
+
+    token = Helper.resolve_token options
+
+    base_url = URL.get_base_url(
+      Constant::DEFAULT_API_BASE_URL,
+      Constant::DEFAULT_API_PROTOCOL,
+      options[:version]
+    )
+
+    if token.nil?
+      raise ArgumentError, 'Could not find an access token. None was passed' \
+        'and non could be found in the environment variable: ' \
+        "#{options[:token_env]}."
+    end
+
+    headers = {
+      Constant::ACCESS_TOKEN_HEADER => token,
+      :content_type => 'application/json'
+    }
+
+    rest_resource = RestClient::Resource.new(
+      base_url,
+      headers: headers,
+      timeout: Helper.ms_to_seconds(options[:timeout])
+    )
+
+    # Create a request instance that uses middleware.
+    request = Request.new(
+      rest_resource,
+      pre: [Middleware::Pre.format_arguments],
+      post: [Middleware::Post.to_response, Middleware::Post.parse_response]
+    )
+
+    resources = REQUIRED_RESOURCES.each_with_object({}) do |resource, acc|
+      acc[resource] = Resource::Factory.make(resource, request, cid, options)
+
+      acc
+    end
+
+    resources = Helper.rekey(resources, CLIENT_RESOURCE_PATHS)
+
+    client = Client.new(cid, request: request, resources: resources)
+
+    @make_call_count += 1
+
+    client
+  end
+end

data/lib/request.rb

@@ -0,0 +1,84 @@
+require 'helper'
+require 'concurrent'
+
+module Polyseerio
+  # HTTP request wrapper that can use attached middleware.
+  class Request
+    module Middleware
+      PRE    = :pre
+      POST   = :post
+      REJECT = :reject
+    end
+
+    INITIALIZE_DEFAULTS = {
+      Middleware::PRE    => [],
+      Middleware::POST   => [],
+      Middleware::REJECT => []
+    }.freeze
+
+    def initialize(resource, options = {})
+      # need to ensure taht pre, post, reject are all arrays otherwise raise
+      options = Helper.defaults(options, INITIALIZE_DEFAULTS)
+
+      @resource = resource
+
+      @pre_request    = options[Middleware::PRE]
+      @post_request   = options[Middleware::POST]
+      @reject_request = options[Middleware::REJECT]
+    end
+
+    # Perform a GET request.
+    def get(*args)
+      execute(:get, *args)
+    end
+
+    # Perform a POST request.
+    def post(*args)
+      execute(:post, *args)
+    end
+
+    # Perform a PUT request.
+    def put(*args)
+      execute(:put, *args)
+    end
+
+    # Perform a DELETE request.
+    def delete(*args)
+      execute(:delete, *args)
+    end
+
+    private
+
+    # Execute a request using pre, post, and reject middleware.
+    #
+    # method - The HTTP method.
+    # ...    - Arguments to forward to execute.
+    #
+    # Returns a promise.
+    def execute(method, *args)
+      new_args = args
+
+      @pre_request.each do |middleware|
+        new_args = middleware.call(*new_args)
+      end
+
+      path = new_args.empty? ? '' : new_args.shift
+
+      req = proc do ||
+        @resource[path].send(method, *new_args)
+      end
+
+      post = proc do |result|
+        @post_request.each do |middleware|
+          result = middleware.call(result)
+        end
+
+        result
+      end
+
+      Concurrent::Promise.new(&req).on_success(&post)
+    end
+
+    attr_accessor :resource, :pre_request, :post_request, :reject_request
+  end
+end

data/lib/resource/base.rb

@@ -0,0 +1,73 @@
+require 'sdk/helper'
+
+module Polyseerio
+  module Resource
+    # Base class for any resource.
+    class Base
+      attr_accessor :eid
+      attr_writer :eid
+
+      def initialize(attributes = {})
+        @eid = if attributes.include? :eid
+                 attributes[:eid]
+               else
+                 Polyseerio::SDK::Helper.resolve_eid(copts)
+               end
+        @attributes = attributes
+      end
+
+      # Set a property hash on the instance.
+      def override_properties(properties)
+        properties.each_with_object(self) do |(key, value), this|
+          this.send(:"#{key}=", value)
+        end
+      end
+
+      # Returns a copy of class attributes.
+      def properties
+        attributes.clone
+      end
+
+      # Returns the type of the class.
+      def type
+        self.class.type
+      end
+
+      # Returns the client options this class was constructed with.
+      def copts
+        self.class.copts
+      end
+
+      # Returns the client's request object.
+      def request
+        self.class.request
+      end
+
+      # True if the resource is new (not yet saved).
+      def new?
+        id.nil?
+      end
+
+      def method_missing(name, *args) # rubocop:disable all
+        # Setter.
+        if name =~ /^(\w+)=$/
+          name = :"#{$1}" # rubocop:disable all
+
+          @attributes[:"#{$1}"] = args[0] # rubocop:disable all
+        end
+
+        # Getter.
+        @attributes.fetch(name, nil)
+      end
+
+      def respond_to_missing?(_method_name)
+        true
+      end
+
+      private
+
+      attr_accessor :attributes
+      attr_writer :attributes
+    end
+  end
+end