keen-csv 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9fe8e0dce221ce5b5e2f0b915e85bd2e8084b36
+  data.tar.gz: 1ab02862ac7b47d6fffb82c8b22633e09dc50fe5
+SHA512:
+  metadata.gz: e2df446da5ab8e23eb305d2555487a37cd131dbef5650cff34d1ad1234fa91c501ef3505ea4502f220ca5ece89dde98ccdf561f925b21b9a55c7216bac441c45
+  data.tar.gz: 9b009e1685d3d5f4c99daedef05991d406cbd1e32aaf4ad1c7cb8e22558bde26354c31a645481c6344b032aa963f07c53ca87f67bf944505bd5f4905759bd845

data/lib/keen/query_wrapper.rb

@@ -0,0 +1,31 @@
+require('keen')
+
+# Monkeypatch the Keen gem to wrap :query and steal the :csv option
+module Keen
+  class << self
+
+    def query_wrapper(*args)
+      # let's optimize for lowest-possible overhead in case 'csv' output isn't requested
+      if args[-1][:csv]
+        # CSV ouput was requested.
+        # First, remove the :csv option to keep from messing up the Keen gem
+        options = args[-1].delete(:csv)
+        # and perform the query
+        response = naked_query(*args)
+
+        # and now for the main event . . . generating the CSV output
+        keenCSV = Keen::CSV.new(response, options)
+        return keenCSV.csvString
+      else
+        # not CSV; just pass through to the naked query
+        return naked_query(*args)
+      end
+    end
+
+    # Wrap :query with :query_wrapper via aliases
+    alias :naked_query :query
+    alias :query :query_wrapper
+
+  end
+
+end

data/lib/keen-csv.rb

@@ -0,0 +1,135 @@
+require_relative('keen/query_wrapper')
+
+class Keen::CSV
+  @@defaultOptions = {
+    delimiter:        ',',
+    delimiterSub:     '.',
+    nestedDelimiter:  '.',
+    filteredColumns:  nil,
+  }
+
+  def initialize(response, options = {})
+    @rawResponse = response
+    @options = options.is_a?(Hash) ? @@defaultOptions.merge(options) : @@defaultOptions
+  end
+
+  # ---------------------------------------------------------------------------
+  # generateResultColumns
+  # Transforms the Keen result columnar Map, keyed by header
+  # ---------------------------------------------------------------------------
+  def generateResultColumns
+    resultColumns = {
+      columns: {},
+      maxRowIndex: 0 # We're going to count the rows, for future use
+    }
+
+    # Using a lambda to add the right columns into resultColumns, and keep track
+    # of maxRowIndex
+    setColumnValue = lambda do |column, rowIndex, value|
+      unless self.columnIsFiltered?(column)
+        resultColumns[:columns][column] ||= []
+        resultColumns[:columns][column][rowIndex] = value
+      end
+
+      # Gotta keep track of how many rows we're working with.
+      resultColumns[:maxRowIndex] = rowIndex if rowIndex > resultColumns[:maxRowIndex]
+    end
+
+    # Exit early if this is a simple math operation
+    if @rawResponse.is_a? Numeric
+      resultColumns[:columns]['result'] = [@rawResponse]
+      resultColumns[:maxRowIndex] = 1
+      return resultColumns
+    end
+
+    rowIndex = 0
+    @rawResponse.each do |object|
+      if object["value"].is_a? Array
+        # This result is grouped! We're gonna have to create alot more columns and rows
+        object["value"].each do |group|
+
+          # iterate over each value grouping, and store the values
+          self.flatten(group).each do |column, value|
+            setColumnValue.call(column, rowIndex, value)
+          end
+          if object["timeframe"]
+            self.flatten({"timeframe" => object["timeframe"]}).each do |column, value|
+              setColumnValue.call(column, rowIndex, value)
+            end
+          end
+          rowIndex += 1
+
+        end
+      else
+        # Not grouped: This either an Extraction or a math operation on an interval.
+        self.flatten(object).each do |column, value|
+          setColumnValue.call(column, rowIndex, value)
+        end
+        rowIndex += 1
+
+      end
+    end
+
+    resultColumns
+  end
+
+  # ---------------------------------------------------------------------------
+  # columnIsFiltered?
+  # Takes a column header, and determines whether that column should be
+  # filtered out
+  # ---------------------------------------------------------------------------
+  def columnIsFiltered?(header)
+    return @options[:filteredColumns] &&
+           @options[:filteredColumns].is_a?(Array) &&
+           @options[:filteredColumns].include?(header)
+  end
+
+  # ---------------------------------------------------------------------------
+  # csvString
+  # Generates and returns a CSV for this Keen response
+  # ---------------------------------------------------------------------------
+  def csvString
+    resultColumns = self.generateResultColumns
+    headers = resultColumns[:columns].keys
+    # Start off instantiating the csv string with the header values
+    csvString = headers.map{|s| self.filterValue(s)}.join(@options[:delimiter])
+
+    # Now iterate over each row, sticking its value under each header
+    (0..resultColumns[:maxRowIndex]).each do |rowIndex|
+      csvString << "\r\n"
+      csvString << headers.map{ |header|
+        self.filterValue(resultColumns[:columns][header][rowIndex])
+      }.join(@options[:delimiter])
+    end
+    return csvString
+  end
+
+  # ---------------------------------------------------------------------------
+  # filterValue
+  # Takes a scalar value, and returns a CSV-compatible one
+  # ---------------------------------------------------------------------------
+  def filterValue(value)
+    if value == nil
+      return ''
+    else
+      return value.to_s.gsub(/#{Regexp.escape(@options[:delimiter])}/, @options[:delimiterSub])
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # flatten
+  # Converts any nested dictionaries into a flattened/delimited one.
+  # ---------------------------------------------------------------------------
+  def flatten(object, flattened = {}, prefix = "")
+    object.each do |key, value|
+      if value.is_a?(Hash) || value.is_a?(Array)
+        # recurse!
+        flatten(value, flattened, prefix + key + @options[:nestedDelimiter])
+      else
+        flattened[prefix + key] = value
+      end
+    end
+
+    return flattened
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: keen-csv
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Jevon Wild
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: keen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Builds a CSV string from a Keen IO response
+email: jevon@keenio
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/keen-csv.rb
+- lib/keen/query_wrapper.rb
+homepage: https://keen.io/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: CSV output for Keen IO
+test_files: []