liveqa 1.4.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d6664a0eec986c9adae1bacead1983dc3d739162
+  data.tar.gz: 7036cb5e2e9b76d770b9ac7a9a9a5902b09aa33c
+SHA512:
+  metadata.gz: b83f428273d7e13842210e74ae6676368f57da02a758ad6ef7d905bd391eb110556af77e3b9a59d36490702a5fd03f7f8212d477b1a63b5240223fe59bb5a140
+  data.tar.gz: 4b4424ca15f6043a65fcf1651eb66f9a06b409692a31ba14e284bcff9810635c42234b31eecd40074bf4ca0c8c6e5343a2884448ab2b9ba6122e0c043efac02c

data/.gitignore

@@ -0,0 +1,4 @@
+doc
+*.gem
+Gemfile.lock
+todo.md

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rubocop.yml

@@ -0,0 +1,40 @@
+Metrics/AbcSize:
+  Max: 24
+Metrics/LineLength:
+  Max: 120
+Metrics/ClassLength:
+  CountComments: false
+  Max: 120
+Metrics/MethodLength:
+  CountComments: false
+  Max: 20
+Metrics/CyclomaticComplexity:
+  Max: 7
+
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/MethodMissing:
+  Enabled: false
+
+Documentation:
+  Enabled: false
+
+Bundler/DuplicatedGem:
+  Enabled: false
+
+AllCops:
+  TargetRubyVersion: 2.3
+  Exclude:
+    - 'spec/**/*'
+  Exclude:
+    - bin/**/*
+    - vendor/**/*
+    - tmp/**/*
+    - spec/**/*

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/.travis.yml

@@ -0,0 +1,10 @@
+cache: bundler
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+script:
+  - bundle exec rspec spec
+  - bundle exec rubocop .

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.0.1
+
+- Production ready

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+if RUBY_VERSION > '2.1.0' && RUBY_VERSION < '2.2.2'
+  gem 'sidekiq', '>= 2.13.0', '< 5.0'
+else
+  gem 'sidekiq', '>= 2.13.0'
+end
+
+gem 'rack'
+gem 'rails'
+
+gemspec

data/README.md

@@ -0,0 +1,40 @@
+# LiveQA
+
+[![Build Status](https://travis-ci.org/arkes/liveqa-ruby.svg?branch=master)](https://travis-ci.org/arkes/liveqa-ruby)
+
+LiveQA ruby integration for [LiveQA](https://www.liveqa.io)
+
+## Installation
+
+```sh 
+gem install liveqa
+```
+
+For Rails in your Gemfile
+
+```ruby
+gem 'liveqa'
+```
+
+## Configuration
+
+```ruby
+LiveQA.configure do |config|
+  config.api_key = 'your-api-key'
+end
+```
+
+## Usage
+
+```ruby
+LiveQA.track('my event', { 
+    user_id: 42,
+    properties: {
+        order_id: 84 
+    }
+});
+```
+
+## Issues
+
+If you have any issue you can report them on github, or contact support@liveqa.io

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/liveqa/api_operation/save.rb

@@ -0,0 +1,57 @@
+module LiveQA
+  class APIOperation
+    ##
+    # == Save (create or update) a resource for the API
+    #
+    module Save
+      module ClassMethods
+        ##
+        # Create an API Resource and validate the params for the API.
+        #
+        # @param [Hash] params for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [LiveQA::Object] response from the API
+        def create(params = {}, options = {})
+          response = request(:post, resource_path, params, options)
+          initialize_from(response)
+        end
+
+        ##
+        # Update an API Resource and validate params for the API
+        #
+        # @param [String] id for the request
+        # @param [Hash] params for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [LiveQA::Object] response from the API
+        def update(id, params = {}, options = {})
+          response = request(:put, "#{resource_path}/#{id}", params, options)
+          initialize_from(response)
+        end
+
+      end
+
+      ##
+      # Create or Update an API Resource
+      #
+      # @param [Hash] params for the request
+      # @param [Hash] Additional options for the request
+      #
+      # @return [LiveQA::Object] response from the API
+      def save(params = {}, options = {})
+        path   = singleton_methods.include?(:id) ? "#{resource_path}/#{id}" : resource_path
+        method = singleton_methods.include?(:id) ? :put : :post
+
+        response = request(method, path, to_hash.merge(params), options)
+        update_from(response)
+      end
+      alias update save
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/liveqa/api_resource.rb

@@ -0,0 +1,123 @@
+module LiveQA
+  ##
+  # == LiveQA \API \Resource
+  #
+  # Define the API requests methods
+  class APIResource < LiveQAObject
+    ##
+    # @return [String] resource name
+    def resource_name
+      self.class.resource_name
+    end
+
+    ##
+    # @return [String] resource path
+    def resource_path(path = nil)
+      self.class.resource_path(path)
+    end
+
+    ##
+    # Send a request to the API
+    #
+    # @param [Symbol] method for the request
+    # @param [String] endpoint for the request
+    # @param [Hash] options
+    # @param [Hash] Payload
+    #
+    # @return [Hash] response
+    # @raise [LiveQA::RequestError] if the request is invalid
+    def request(method, resource_path, payload = {}, options = {})
+      self.class.request(method, resource_path, payload, options)
+    end
+
+    class << self
+
+      ##
+      # @return [String] resource path
+      def resource_path(path = nil)
+        "/api/#{configurations.api_version}/#{path || @resource_name || CGI.escape(resource_name)}"
+      end
+
+      ##
+      # @return [String] resource name
+      def resource_name
+        Util.underscore("#{class_name}s")
+      end
+
+      ##
+      # @return [String] the class name
+      def class_name
+        name.split('::')[-1]
+      end
+
+      ##
+      # Send a request to the API
+      #
+      # @param [Symbol] method for the request
+      # @param [String] endpoint for the request
+      # @param [Hash] options
+      # @param [Hash] Payload
+      #
+      # @return [Hash] response
+      # @raise [LiveQA::RequestError] if the request is invalid
+      def request(method, path, payload = {}, options = {})
+        payload    = Util.deep_obfuscate_value(payload, configurations.obfuscated_fields)
+        url_params = Util.encode_parameters(payload) if method == :get
+        uri        = build_endpoint_url(path, url_params)
+
+        request_options = Util.compact(
+          method:  method,
+          url:     uri.to_s,
+          payload: payload.to_json,
+          proxy:   configurations.proxy_url,
+          use_ssl: configurations.http_secure
+        ).merge(headers).merge(options)
+
+        Request.execute(request_options)
+      rescue LiveQA::RequestError => error
+        return error.http_body if error.http_status == 422
+        raise
+      end
+
+      private
+
+      def build_endpoint_url(path, params = nil)
+        host, port = configurations.api_host.split(':')
+        port       = port.to_i if port
+
+        url_params = Util.compact(
+          host:  host,
+          path:  path,
+          port:  port,
+          query: params
+        )
+
+        return URI::HTTPS.build(url_params) if configurations.http_secure
+        URI::HTTP.build(url_params)
+      end
+
+      def ssl_options
+        return {} unless configurations.http_secure
+        {
+          ca_file:     File.expand_path(File.dirname(__FILE__) + '/../../vendor/cacert.pem'),
+          verify_mode: OpenSSL::SSL::VERIFY_PEER
+        }
+      end
+
+      def headers
+        {
+          headers: {
+            accept:       'application/json',
+            content_type: 'application/json',
+            x_request_key: configurations.api_key
+          }
+        }
+      end
+
+      def configurations
+        LiveQA.configurations
+      end
+
+    end
+  end
+end

data/lib/liveqa/async_handlers/base.rb

@@ -0,0 +1,17 @@
+module LiveQA
+  module AsyncHandlers
+    class Base
+
+      def enqueue(*)
+        raise LiveQA::MissingImplementation, 'Method \'enqueue\' need to be implemented in a subclass'
+      end
+
+      def execute(args)
+        klass_name, method, payload, request_options = args
+
+        Object.const_get(klass_name).send(method.to_sym, payload, request_options)
+      end
+
+    end
+  end
+end

data/lib/liveqa/async_handlers/sidekiq.rb

@@ -0,0 +1,33 @@
+require 'sidekiq'
+
+module LiveQA
+  module AsyncHandlers
+    class Sidekiq < Base
+      include ::Sidekiq::Worker
+
+      OPTIONS = {
+        'queue' => 'liveqa',
+        'class' => self
+      }.freeze
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = OPTIONS.merge(
+          Util.deep_stringify_key(options)
+        )
+      end
+
+      def enqueue(*args)
+        ::Sidekiq::Client.push(
+          options.merge('args' => args)
+        )
+      end
+
+      def perform(*args)
+        execute(args)
+      end
+
+    end
+  end
+end

data/lib/liveqa/config.rb

@@ -0,0 +1,116 @@
+module LiveQA
+  ##
+  # == LiveQA \Config
+  #
+  # Represent the LiveQA configuration for the API
+  class Config
+
+    ASYNC_HANDLERS = {
+      sidekiq: {
+        class:   'LiveQA::AsyncHandlers::Sidekiq',
+        require: 'liveqa/async_handlers/sidekiq'
+      }
+    }.freeze
+
+    DEFAULT_OBFUSCATED_FIELDS = %w[
+      password
+      password_confirmation
+      secret
+      secret_token
+      authenticity_token
+      token
+      api_key
+      access_token
+      credit_card_number
+      cvv
+      ccv
+    ].freeze
+
+    ##
+    # @return [String] API key
+    attr_accessor :api_key
+
+    ##
+    # @return [String] API host
+    attr_accessor :api_host
+
+    ##
+    # @return [String] API version
+    attr_accessor :api_version
+
+    ##
+    # @return [String] proxy url
+    attr_accessor :proxy_url
+
+    ##
+    # @return [Boolean] http secure
+    attr_accessor :http_secure
+
+    ##
+    # @return [Boolean] service is enable
+    attr_accessor :enabled
+
+    ##
+    # @return [Array[String]] fields to obfuscate
+    attr_accessor :obfuscated_fields
+
+    ##
+    # @return [Null|Symbol|Proc] asynchronous handler
+    attr_accessor :async_handler
+
+    ##
+    # @return [Hash] options for asynchronous handler
+    attr_accessor :async_options
+
+    ##
+    # @param [Hash{Symbol=>Object}]
+    # Initialize and validate the configuration
+    def initialize(options = {})
+      self.api_key           = options[:api_key]
+      self.api_host          = options[:api_host] || 'api.liveqa.io'
+      self.api_version       = options[:api_version] || 'v1'
+      self.proxy_url         = options[:proxy_url]
+      self.http_secure       = options[:http_secure] || true
+      self.enabled           = options[:enabled] || true
+      self.obfuscated_fields = options[:obfuscated_fields] || []
+      self.async_handler     = options[:async_handler]
+      self.async_options     = options[:async_options] || {}
+    end
+
+    ##
+    # validate the configuration
+    # Raise when configuration are not valid
+    # @return [Boolean] true
+    def valid!
+      format!
+
+      %i[api_key api_host api_version].each do |field|
+        validate_presence(field)
+      end
+
+      true
+    end
+
+    private
+
+    ##
+    # Format configuration fields
+    #
+    # * Set obfuscated_fields to string
+    # * Change to the class for async handler
+    #
+    def format!
+      self.obfuscated_fields = (obfuscated_fields.map(&:to_s) + DEFAULT_OBFUSCATED_FIELDS).uniq
+
+      return unless ASYNC_HANDLERS[async_handler]
+
+      require ASYNC_HANDLERS[async_handler][:require]
+      self.async_handler = Object.const_get(ASYNC_HANDLERS[async_handler][:class]).new(async_options)
+    end
+
+    def validate_presence(field)
+      raise LiveQA::ConfigurationError, "#{field} can't be blank" if send(field).nil? || send(field).empty?
+    end
+
+  end
+end

data/lib/liveqa/errors.rb

@@ -0,0 +1,41 @@
+module LiveQA
+
+  ##
+  # Configuration Error
+  class ConfigurationError < StandardError; end
+
+  ##
+  # Missing Implementation Error
+  class MissingImplementation < StandardError; end
+
+  ##
+  # Request to API Error
+  class RequestError < StandardError; end
+
+  ##
+  # Method unknown for the request
+  class UnknownRequestMethod < StandardError; end
+
+  ##
+  # Request to API Error
+  class RequestError < StandardError
+
+    attr_reader :http_body
+    attr_reader :http_status
+    attr_reader :http_status_type
+    attr_reader :http_message
+
+    def initialize(response, message: nil)
+      @http_status      = response.code.to_i
+      @http_status_type = response.code_type
+      @http_body        = response.body
+      @http_message     = message || response.message
+    end
+
+    def to_s
+      "Status #{http_status}: #{http_message}"
+    end
+
+  end
+
+end

data/lib/liveqa/event.rb

@@ -0,0 +1,22 @@
+module LiveQA
+  ##
+  # == LiveQA \Event
+  #
+  # @example: Usage
+  #
+  #   request = LiveQA::Event.create('Event Name') #=> #<LiveQA::Response...>
+  #
+  class Event < APIResource
+    include LiveQA::APIOperation::Save
+
+    class << self
+
+      def build_payload(payload)
+        Message
+          .to_h
+          .merge(payload)
+      end
+
+    end
+  end
+end

data/lib/liveqa/library_name.rb

@@ -0,0 +1,3 @@
+module LiveQA # :nodoc:
+  LIBRARY_NAME = 'liveqa'.freeze
+end

data/lib/liveqa/liveqa_object.rb

@@ -0,0 +1,139 @@
+module LiveQA
+  ##
+  # == LiveQA \Object
+  #
+  # Define the API objects
+  class LiveQAObject
+    ##
+    # @return [Hash] JSON parsed response
+    attr_reader :raw
+
+    ##
+    # @return [Hash] JSON parsed response
+    attr_reader :data
+
+    attr_reader :accepted
+    alias accepted? accepted
+
+    attr_reader :errors
+
+    class << self
+
+      ##
+      # Initialize from the API response
+      #
+      # @return [LiveQA::LiveQAObject]
+      def initialize_from(_response = '')
+        object = new
+
+        object.successful = true
+
+        object
+      end
+
+    end
+
+    ##
+    # Initialize and create accessor for values
+    #
+    # @params [Hash] values
+    def initialize(values = {})
+      @data   = []
+      @values = {}
+
+      update_attributes(values)
+    end
+
+    ##
+    # get attribute value
+    def [](key)
+      @values[key.to_sym]
+    end
+
+    ##
+    # set attribute value
+    def []=(key, value)
+      send(:"#{key}=", value)
+    end
+
+    ##
+    # @return [Array] all the keys
+    def keys
+      @values.keys
+    end
+
+    ##
+    # @return [Hash] values to hash
+    def to_hash
+      @values
+    end
+
+    ##
+    # @return [JSON] values to JSON
+    def to_json
+      JSON.generate(@values)
+    end
+
+    ##
+    # Update the attribute and add accessor for new attributes
+    #
+    # @param [Hash] values
+    def update_attributes(attributes)
+      attributes.each do |(key, value)|
+        add_accessor(key, value)
+      end
+    end
+
+    ##
+    # Add data for sub-object
+    #
+    # @param [Object] data
+    def add_data(data)
+      @data << data
+    end
+
+    protected
+
+    def inspect
+      id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ''
+      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+    end
+
+    def method_missing(name, *args)
+      super unless name.to_s.end_with?('=')
+
+      attribute = name.to_s[0...-1].to_sym
+      value     = args.first
+
+      add_accessor(attribute, value)
+    end
+
+    private
+
+    def add_accessors(keys, payload = raw)
+      keys.each do |key|
+        add_accessor(key, payload[key])
+      end
+    end
+
+    def add_accessor(name, value)
+      @values[name] = value
+
+      define_singleton_method(name) { @values[name] }
+      define_singleton_method(:"#{name}=") do |v|
+        @values[name] = v
+      end
+
+      define_singleton_method(:"#{name}?") { value } if [FalseClass, TrueClass].include?(value.class)
+    end
+
+    def remove_accessor(name)
+      @values.delete(name)
+
+      singleton_class.class_eval { remove_method name.to_sym } if singleton_methods.include?(name.to_sym)
+      singleton_class.class_eval { remove_method "#{name}=".to_sym } if singleton_methods.include?("#{name}=".to_sym)
+      singleton_class.class_eval { remove_method "#{name}?".to_sym } if singleton_methods.include?("#{name}?".to_sym)
+    end
+
+  end
+end