influx 0.1.0.alpha → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4b53c95048c7332be3eed378213fe0952d7815ec5f3780e18ceaeac0328cc83
-  data.tar.gz: 0ac5483c268718a4267227a6a18636e6ce68fb9c5c63076a47f174e8a0ded456
+  metadata.gz: 0d2c6ec69b8f21ac0b2fab377c7215598ac2cd8ecd20f443b971e5909fa014aa
+  data.tar.gz: 120f06af14b691787c7b25e6ed40fc287d8e0d7a7e0f03ea3d97348f4e76a8b2
 SHA512:
-  metadata.gz: 01c4f79cf46720f791139bf14507c8ead9e4e7a8560ad8ca03886188552e219a15a968646671a6eaa8d084893a2c16d11e75b188ce9bf74292913ee7985263b7
-  data.tar.gz: f10c0ebf7fd02de18f1e120ade62e4c0a5d7fe02607123e28aaa2379a38cdc10c79347ddda3f505f679382a925286f689db201c54aec88e2543148081efabd33
+  metadata.gz: 6e1df569de6d83a399004cb32597a00e51fd454d07a929f47a62b439867b63da2cf6e81c1830bd8b9d279f0ea8be439de962580533501119d2c03867a90d50ce
+  data.tar.gz: 002a155c47b90be78d75ecbeee8ee980559c6088992023e3ba079556a068dba18978ed838ffe0b0d53dadb34cd894e217c50704932817573381ebff89dad8a24

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -1,13 +1,177 @@
+# require: rubocop-graphql
+
+# Allow longer lines and methods
+Layout/LineLength:
+  Max: 500
+
+Metrics/MethodLength:
+  Max: 30
+
+# Tests are declarative, no block length test
+Metrics/BlockLength:
+  IgnoredMethods: ["describe", "context", "namespace"]
+  
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0.2
+  # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
+  # to ignore them, so only the ones explicitly set in this file are enabled.
+  DisabledByDefault: true
+
+# Prefer &&/|| over and/or.
+Style/AndOr:
+  Enabled: true
+
+# Align `when` with `case`.
+Layout/CaseIndentation:
+  Enabled: true
+
+# Align comments with method definitions.
+Layout/CommentIndentation:
+  Enabled: true
+
+Layout/ElseAlignment:
+  Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Layout/EndAlignment:
+  Enabled: true
+  EnforcedStyleAlignWith: variable
+  AutoCorrect: true
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+# In a regular class definition, no empty lines around the body.
+Layout/EmptyLinesAroundClassBody:
+  Enabled: true
+
+# In a regular method definition, no empty lines around the body.
+Layout/EmptyLinesAroundMethodBody:
+  Enabled: true
+
+# In a regular module definition, no empty lines around the body.
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: true
+
+Layout/FirstArgumentIndentation:
+  Enabled: true
+
+# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
+Style/HashSyntax:
+  Enabled: true
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+Layout/IndentationConsistency:
+  Enabled: true
+  EnforcedStyle: indented_internal_methods
+
+# Two spaces, no tabs (for indentation).
+Layout/IndentationWidth:
+  Enabled: true
+
+Layout/LeadingCommentSpace:
+  Enabled: true
+
+Layout/SpaceAfterColon:
+  Enabled: true
+
+Layout/SpaceAfterComma:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+Layout/SpaceAroundOperators:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+  Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: true
+
+Style/DefWithParentheses:
+  Enabled: true
+
+# Defining a method with parameters needs parentheses.
+Style/MethodDefParentheses:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+  Exclude:
+    - "actionview/test/**/*.builder"
+    - "actionview/test/**/*.ruby"
+    - "actionpack/test/**/*.builder"
+    - "actionpack/test/**/*.ruby"
+    - "activestorage/db/migrate/**/*.rb"
+    - "db/migrate/**/*.rb"
+    - "db/*.rb"
+
+# Use `foo {}` not `foo{}`.
+Layout/SpaceBeforeBlockBraces:
+  Enabled: true
 
+# Use `foo { bar }` not `foo {bar}`.
+Layout/SpaceInsideBlockBraces:
+  Enabled: true
+
+# Use `{ a: 1 }` not `{a:1}`.
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: true
+
+Layout/SpaceInsideParens:
+  Enabled: true
+
+# Check quotes usage according to lint rule below.
 Style/StringLiterals:
   Enabled: true
-  EnforcedStyle: double_quotes
+  EnforcedStyle: single_quotes
 
-Style/StringLiteralsInInterpolation:
+# Detect hard tabs, no hard tabs.
+Layout/IndentationStyle:
   Enabled: true
-  EnforcedStyle: double_quotes
 
-Layout/LineLength:
-  Max: 120
+# Blank lines should not have any spaces.
+Layout/TrailingEmptyLines:
+  Enabled: true
+
+# No trailing whitespace.
+Layout/TrailingWhitespace:
+  Enabled: true
+
+# Use quotes for string literals when they are enough.
+Style/RedundantPercentQ:
+  Enabled: true
+
+# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+Lint/RequireParentheses:
+  Enabled: true
+
+Lint/RedundantStringCoercion:
+  Enabled: true
+
+# Supports --auto-correct
+Style/RedundantSelf:
+  Description: Don't use self where it's not needed.
+  StyleGuide: https://github.com/rubocop-hq/ruby-style-guide#no-self-unless-required
+  Enabled: true
+
+Style/RedundantReturn:
+  Enabled: true
+  AllowMultipleReturnValues: true
+
+Style/Semicolon:
+  Enabled: true
+  AllowAsExpressionSeparator: true
+
+# Prefer Foo.method over Foo::method
+Style/ColonMethodCall:
+  Enabled: true
+ 

data/Gemfile

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in influx.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
+gem 'rake', '~> 13.0'
 
-gem "rubocop", "~> 1.21"
+gem 'rspec', '~> 3'
+
+gem 'rubocop', '~> 1'
+
+gem 'simplecov', require: false, group: :test

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    influx (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    parallel (1.22.0)
+    parser (3.1.1.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.2.1)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.2)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rubocop (1.26.1)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.16.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.16.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  influx!
+  rake (~> 13.0)
+  rspec (~> 3)
+  rubocop (~> 1)
+  simplecov
+
+BUNDLED WITH
+   2.3.9

data/README.md

@@ -1,8 +1,42 @@
-# Influx
+## <img src="https://user-images.githubusercontent.com/50866745/168482997-7ed6ae74-aac9-4aee-bf03-fef5e01d683a.png" width="48" align="left"> Ruby InfluxDB Flux  <!-- omit in toc -->
+[![CircleCI](https://circleci.com/gh/LapoElisacci/influx/tree/main.svg?style=svg)](https://circleci.com/gh/LapoElisacci/influx/tree/main)
+![](https://img.shields.io/static/v1?label=Coverage&message=99.54%&color=brightgreen)
+![](https://img.shields.io/static/v1?label=Latest&message=0.1.0.alpha&color=blue)
+![](https://ruby-gem-downloads-badge.herokuapp.com/influx?type=total&color=blue)
+![StandWithUkraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/StandWithUkraine.svg)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/influx`. To experiment with that code, run `bin/console` for an interactive prompt.
+Write InfluxDB Flux queries in an ORM fashion with Ruby.
 
-TODO: Delete this and the text above, and describe your gem
+## Table of contents
+
+- [Table of contents](#table-of-contents)
+- [Installation](#installation)
+- [Utilities](#utilities)
+  - [Now](#now)
+- [Flux points](#flux-points)
+- [Flux queries](#flux-queries)
+  - [From](#from)
+  - [Range](#range)
+- [Query data with Flux](#query-data-with-flux)
+  - [From](#from-1)
+  - [Range](#range-1)
+  - [Query fields and tags](#query-fields-and-tags)
+  - [Group](#group)
+  - [Sort and limit](#sort-and-limit)
+  - [Window & aggregate](#window--aggregate)
+  - [Increase](#increase)
+  - [Moving Average](#moving-average)
+  - [Rate](#rate)
+  - [Histograms](#histograms)
+  - [Fill](#fill)
+  - [Median](#median)
+  - [Percentile & quantile](#percentile--quantile)
+  - [Join (TBD)](#join-tbd)
+  - [Cumulative sum](#cumulative-sum)
+  - [First & last](#first--last)
+- [Contributing](#contributing)
+- [License](#license)
+- [Code of Conduct](#code-of-conduct)
 
 ## Installation
 
@@ -14,15 +48,290 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install influx
 
-## Usage
+## Utilities
+
+Here are some utility methods provided by the gem.
+
+### Now
+
+The gem provides a method to return the Clock timestamp in nanoseconds.
+
+```Ruby
+Influx.now # Default precision is Nanoseconds
+```
+
+You can also pass other precisions if needed:
+
+```Ruby
+Influx.now(:second)
+Influx.now(:millisecond)
+Influx.now(:microsecond)
+Influx.now(:nanosecond)
+```
+
+---
+
+## Flux points
+
+```Ruby
+Influx::Point.new(
+  'h2o', # measurement
+  tags: { location: 'west' },
+  fields: { value: 33 },
+  time: Influx.now # The default value is Influx.now, you can also use Time or Integer
+).to_flux # h2o,location=west value=33 1652720908000000
+```
+
+## Flux queries
+
+The gem acts as an ORM therefore you can chain methods to build your `Flux` query string.
+
+You can always call the `to_flux` method to see a preview or your query:
+
+```Ruby
+flux_query = Influx.from(bucket: 'my-bucket').range(start: '-1d')
+flux_query.to_flux # from(bucket: "my-bucket") |> range(start: -1d)
+```
+
+### From
+
+The `from` method is the starting point of all queries, it allows you to specify the InfluxDB bucket.
+
+```Ruby
+Influx.from(bucket: 'my-bucket')
+```
+> ⚠️ This is mandatory to perform any query.
+
+### Range
+
+The `range` method allows you to specify the time-range you want to query.
+
+```Ruby
+Influx.from(bucket: 'my-bucket').range(start: '-1d', stop: 'now()')
+```
+
+It supports the `Flux` sytanx as well as `Time`.
+
+```Ruby
+Influx.from(bucket: 'my-bucket').range(start: Time.new.yesterday, stop: Time.new)
+```
+
+> ⚠️ This is mandatory to perform any query.
+
+---
+
+## Query data with Flux
+
+The following guides are based on top of the original InfluxData Flux Documentation, available [here](https://docs.influxdata.com/influxdb/cloud/query-data/flux/).
+
+**Example data variable**
+Many of the examples provided in the following guides use a **data** variable, which represents a basic query that filters data by measurement and field. **data** is defined as:
+
+```Ruby
+data = Influx.from(bucket: 'my-bucket').range(start: '-1d', stop: 'now()')
+
+# from(bucket: "my-bucket")
+#   |> range(start: -1d, stop: now())
+```
+
+### From
+
+The `from` method allows you to specify the InfluxDB bucket. Every query starts with the `from` method.
+
+```Ruby
+Influx.from(bucket: 'my-bucket')
+
+# from(bucket: "my-bucket")
+```
+
+### Range
+
+The `range` method allows you to bind your query to a time range, it supports native Flux syntax as well as the Ruby `Time` class and `Integer`.
+
+```Ruby
+Influx.from(bucket: 'my-bucket').range(start: '-1d', stop: 'now()')
+
+# from(bucket: "my-bucket")
+#   |> range(start: -1d, stop: now())
+```
+```Ruby
+Influx.from(bucket: 'my-bucket').range(start: Time.new(2018, 1, 1, 0, 0, 0, '+00:00').utc, stop: 1514768400)
+
+# from(bucket: "my-bucket")
+#   |> range(start: 2018-01-01T00:00:00Z, stop: 2018-01-01T01:00:00Z)
+```
+
+---
+
+### Query fields and tags
+
+Use `filter()` to query data based on fields, tags, or any other column value.
+
+```Ruby
+data.filter("_measurement": "example-measurement", tag: "example-tag")
+
+# data
+#   |> filter(fn: (r) => r._measurement == "example-measurement" and r.tag == "example-tag")
+```
+
+### Group
+
+Use `group()` to group data with common values in specific columns.
+
+```Ruby
+data.group(columns: ["host"], mode: "by")
+
+# data
+#   |> group(columns: ["host"], mode: "by")
+```
+
+### Sort and limit
+
+Use `sort()` to order records within each table by specific columns and `limit()` to limit the number of records in output tables to a fixed number, `n`.
+
+```Ruby
+data.sort(columns: ["host", "_value"]).limit(4)
+
+# data
+#   |> sort(columns: ["host","_value"])
+#   |> limit(n: 4)
+```
+
+### Window & aggregate
+
+```Ruby
+data.aggregate_window(every: "20m", fn: "mean")
+
+# data
+#   |> aggregateWindow(every: 20m, fn: mean)
+```
+
+### Increase
+
+Use `increase()` to track increases across multiple columns in a table. 
+
+```Ruby
+data.increase
+
+# data
+#   |> increase()
+```
+
+### Moving Average
+
+Use `moving_average()` or `timed_moving_average()` to return the moving average of data.
+
+```Ruby
+data.moving_average(5)
+
+# data
+#   |> movingAverage(n: 5)
+```
+```Ruby
+data.timed_moving_average(every: "2m", period: "4m")
+
+# data
+#   |> timedMovingAverage(every: 2m, period: 4m)
+```
+
+### Rate
+
+Use `derivative()` to calculate the rate of change between subsequent values.
+
+```Ruby
+data.derivative(unit: "1m", non_negative: true)
+
+# data
+#   |> derivative(unit: 1m, nonNegative: true)
+```
+
+### Histograms
+
+Use `histogram()` to create cumulative histograms with Flux.
+
+```Ruby
+data.histogram(column: "_value", upper_bound_column: "le", count_column: "_value", bins: [100.0, 200.0, 300.0, 400.0])
+
+# data
+#   |> histogram(
+#     column: "_value",
+#     upperBoundColumn: "le",
+#     countColumn: "_value",
+#     bins: [100.0,200.0,300.0,400.0]
+#   )
+```
+### Fill
+
+Use `fill()` function to replace null values.
+
+```Ruby
+data.fill(use_previous: true)
+
+# data
+#   |> fill(usePrevious: true)
+```
+```Ruby
+data.fill(value: 0.0)
+# data
+#   |> fill(value: 0.0)
+```
+
+### Median
+
+Use `median()` to return a value representing the 0.5 quantile (50th percentile) or median of input data.
+
+```Ruby
+data.median
+
+# data
+#   |> median()
+```
+
+### Percentile & quantile
+
+Use the `quantile()` function to return all values within the `q` quantile or percentile of input data.
+
+```Ruby
+data.quantile(q: 0.99, method: "estimate_tdigest")
+
+# data
+#   |> quantile(q: 0.99, method: "estimate_tdigest")
+```
+
+
+### Join (TBD)
+
+TBD
+
+### Cumulative sum
+
+Use the `cumulativeSum()` function to calculate a running total of values.
+
+```Ruby
+data.cumulative_sum
+
+# data
+#   |> cumulativeSum()
+```
+
+### First & last
+
+Use `first()` or `last()`  to return the first or last point in an input table.
 
-TODO: Write usage instructions here
+```Ruby
+data.first
 
-## Development
+# data
+#   |> first()
+```
+```Ruby
+data.last
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+# data
+#   |> last()
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+---
 
 ## Contributing
 

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rubocop/rake_task"
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/lib/influx/flux/aggregate_window.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# |> aggregateWindow(every: 20m, fn: mean)
+
+module Influx
+  module Flux
+    class AggregateWindow
+      def initialize(every:, fn:)
+        @every = every
+        @fn = fn
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> aggregateWindow(every: #{@every}, fn: #{@fn})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/cumulative_sum.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# |> cumulativeSum()
+
+module Influx
+  module Flux
+    class CumulativeSum
+      def self.to_flux
+        <<~FLUX.chomp
+          |> cumulativeSum()
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/derivative.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# |> derivative(unit: 1m, nonNegative: true)
+
+module Influx
+  module Flux
+    class Derivative
+      def initialize(unit:, non_negative:)
+        @unit = unit
+        @non_negative = non_negative
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> derivative(unit: #{@unit}, nonNegative: #{@non_negative})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/fill.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# |> fill(usePrevious: true)
+# |> fill(value: 0.0)
+
+module Influx
+  module Flux
+    class Fill
+      def initialize(use_previous: false, value: nil)
+        @use_previous = use_previous
+        @value = value
+      end
+
+      def to_flux
+        if @use_previous
+          <<~FLUX.chomp
+            |> fill(usePrevious: #{@use_previous})
+          FLUX
+        else
+          <<~FLUX.chomp
+            |> fill(value: #{@value})
+          FLUX
+        end
+      end
+    end
+  end
+end

data/lib/influx/flux/filter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# |> filter(fn: (r) => r._measurement == "example-measurement" and r._field == "example-field")
+
+module Influx
+  module Flux
+    class Filter
+      def initialize(**params)
+        @params = params
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> filter(fn: (r) => #{@params.map { |k, v| "r.#{k} == #{v.to_json}" }.join(' and ')})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/first.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# |> first()
+
+module Influx
+  module Flux
+    class First
+      def self.to_flux
+        <<~FLUX.chomp
+          |> first()
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/from.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Influx
+  module Flux
+    class From
+      attr_accessor :bucket
+
+      def initialize(bucket:)
+        @bucket = bucket
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          from(bucket: "#{@bucket}")
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/group.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# |> group(columns: ["host"], mode: "by")
+
+module Influx
+  module Flux
+    class Group
+      def initialize(columns: [], mode:)
+        raise Influx::Error.new('Columns value has to be Array of Strings!') unless columns.is_a?(Array) && columns.all? { |c| c.is_a?(String) }
+
+        @columns = columns
+        @mode = mode
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> group(columns: #{@columns.to_json}, mode: "#{@mode}")
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/histogram.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# |> histogram(
+#   column: "_value",
+#   upperBoundColumn: "le",
+#   countColumn: "_value",
+#   bins: [100.0, 200.0, 300.0, 400.0],
+# )
+
+module Influx
+  module Flux
+    class Histogram
+      def initialize(column:, upper_bound_column:, count_column:, bins: [])
+        @column = column
+        @upper_bound_column = upper_bound_column
+        @count_column = count_column
+        @bins = bins
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> histogram(column: "#{@column}", upperBoundColumn: "#{@upper_bound_column}", countColumn: "#{@count_column}", bins: #{@bins.to_json})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/increase.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# |> increase()
+
+module Influx
+  module Flux
+    class Increase
+      def self.to_flux
+        <<~FLUX.chomp
+          |> increase()
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/last.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# |> last()
+
+module Influx
+  module Flux
+    class Last
+      def self.to_flux
+        <<~FLUX.chomp
+          |> last()
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/limit.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# |> limit(n: 4)
+
+module Influx
+  module Flux
+    class Limit
+      def initialize(n:)
+        raise Influx::Error.new('Limit value has to be Integer!') unless n.is_a?(Integer)
+
+        @n = n
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> limit(n: #{@n})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/median.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# |> median()
+
+module Influx
+  module Flux
+    class Median
+      def self.to_flux
+        <<~FLUX.chomp
+          |> median()
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/moving_average.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# |> movingAverage(n: 5)
+
+module Influx
+  module Flux
+    class MovingAverage
+      def initialize(n:)
+        raise Influx::Error.new('N value has to be Integer!') unless n.is_a?(Integer)
+
+        @n = n
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> movingAverage(n: #{@n})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/quantile.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# |> quantile(q: 0.99, method: "estimate_tdigest")
+
+module Influx
+  module Flux
+    class Quantile
+      def initialize(q:, method:)
+        @q = q
+        @method = method
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> quantile(q: #{@q}, method: "#{@method}")
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/range.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# |> range(start: -1h)
+
+module Influx
+  module Flux
+    class Range
+      attr_accessor :start, :stop
+
+      def initialize(start: nil, stop: nil)
+        @start = cast_value(start)
+        @stop = cast_value(stop)
+      end
+
+      def to_flux
+        params = []
+
+        params << "start: #{@start}" if @start
+        params << "stop: #{@stop}" if @stop
+
+        <<~FLUX.chomp
+          |> range(#{params.join(', ')})
+        FLUX
+      end
+
+      private
+
+        def cast_value(time)
+          return if time.nil?
+
+          case time.class.to_s
+          when 'Time'
+            time.iso8601
+          when 'String'
+            time
+          when 'Integer'
+            Time.at(time).iso8601
+          else
+            raise ArgumentError, 'Invalid time format, expected Time, String or Integer'
+          end
+        end
+    end
+  end
+end

data/lib/influx/flux/sort.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# |> sort(columns: ["host", "_value"])
+
+module Influx
+  module Flux
+    class Sort
+      def initialize(columns:)
+        raise Influx::Error.new('Columns value has to be Array of Strings!') unless columns.is_a?(Array) && columns.all? { |c| c.is_a?(String) }
+
+        @columns = columns
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> sort(columns: #{@columns.to_json})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/flux/timed_moving_average.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# |> timedMovingAverage(every: 2m, period: 4m)
+
+module Influx
+  module Flux
+    class TimedMovingAverage
+      def initialize(every:, period:)
+        @every = every
+        @period = period
+      end
+
+      def to_flux
+        <<~FLUX.chomp
+          |> timedMovingAverage(every: #{@every}, period: #{@period})
+        FLUX
+      end
+    end
+  end
+end

data/lib/influx/point.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Influx
+  class Point
+    def initialize(measurement, tags: {}, fields: {}, time: Influx.now)
+      @measurement = measurement
+      @tags = tags
+      @fields = fields
+      @time = time.to_i
+    end
+
+    def to_flux
+      "#{@measurement},#{hash_to_flux(@tags)} #{hash_to_flux(@fields)} #{@time}"
+    end
+
+    private
+
+      def hash_to_flux(hash)
+        hash.map { |key, value| "#{key}=#{value}" }.join(',')
+      end
+  end
+end

data/lib/influx/query.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Influx
+  class Query
+    def initialize(bucket:)
+      @from = Influx::Flux::From.new(bucket: bucket)
+      @statements = []
+    end
+
+    def aggregate_window(every:, fn:)
+      @statements << Influx::Flux::AggregateWindow.new(every: every, fn: fn)
+      self
+    end
+
+    def cumulative_sum
+      @statements << Influx::Flux::CumulativeSum
+      self
+    end
+
+    def derivative(unit:, non_negative: true)
+      @statements << Influx::Flux::Derivative.new(unit: unit, non_negative: non_negative)
+      self
+    end
+
+    def fill(use_previous: false, value: nil)
+      @statements << Influx::Flux::Fill.new(use_previous: use_previous, value: value)
+      self
+    end
+
+    def filter(**params)
+      @statements << Influx::Flux::Filter.new(**params)
+      self
+    end
+
+    def first
+      @statements << Influx::Flux::First
+      self
+    end
+
+    def group(columns: [], mode:)
+      @statements << Influx::Flux::Group.new(columns: columns, mode: mode)
+      self
+    end
+
+    def histogram(column:, upper_bound_column:, count_column:, bins: [])
+      @statements << Influx::Flux::Histogram.new(column: column, upper_bound_column: upper_bound_column, count_column: count_column, bins: bins)
+      self
+    end
+
+    def increase
+      @statements << Influx::Flux::Increase
+      self
+    end
+
+    def last
+      @statements << Influx::Flux::Last
+      self
+    end
+
+    def limit(n)
+      @statements << Influx::Flux::Limit.new(n: n)
+      self
+    end
+
+    def median
+      @statements << Influx::Flux::Median
+      self
+    end
+
+    def moving_average(n)
+      @statements << Influx::Flux::MovingAverage.new(n: n)
+      self
+    end
+
+    def quantile(q:, method:)
+      @statements << Influx::Flux::Quantile.new(q: q, method: method)
+      self
+    end
+
+    def range(start: nil, stop: nil)
+      @statements << Influx::Flux::Range.new(start: start, stop: stop)
+      self
+    end
+
+    def sort(columns:)
+      @statements << Influx::Flux::Sort.new(columns: columns)
+      self
+    end
+
+    def timed_moving_average(every:, period:)
+      @statements << Influx::Flux::TimedMovingAverage.new(every: every, period: period)
+      self
+    end
+
+    def to_flux
+      "#{@from.to_flux} #{@statements.map(&:to_flux).join(' ')}"
+    end
+  end
+end

data/lib/influx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Influx
-  VERSION = "0.1.0.alpha"
+  VERSION = '0.1.0'
 end

data/lib/influx.rb

@@ -1,8 +1,40 @@
 # frozen_string_literal: true
 
-require_relative "influx/version"
+require 'json'
+
+require_relative 'influx/point'
+require_relative 'influx/query'
+require_relative 'influx/version'
+
+require_relative 'influx/flux/aggregate_window'
+require_relative 'influx/flux/cumulative_sum'
+require_relative 'influx/flux/derivative'
+require_relative 'influx/flux/fill'
+require_relative 'influx/flux/filter'
+require_relative 'influx/flux/first'
+require_relative 'influx/flux/from'
+require_relative 'influx/flux/group'
+require_relative 'influx/flux/histogram'
+require_relative 'influx/flux/increase'
+require_relative 'influx/flux/last'
+require_relative 'influx/flux/limit'
+require_relative 'influx/flux/median'
+require_relative 'influx/flux/moving_average'
+require_relative 'influx/flux/quantile'
+require_relative 'influx/flux/range'
+require_relative 'influx/flux/sort'
+require_relative 'influx/flux/timed_moving_average'
 
 module Influx
   class Error < StandardError; end
-  # Your code goes here...
+
+  class << self
+    def from(bucket:)
+      Influx::Query.new(bucket: bucket)
+    end
+
+    def now(precision = :nanosecond)
+      Process.clock_gettime(Process::CLOCK_REALTIME, precision)
+    end
+  end
 end

metadata

@@ -1,30 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: influx
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha
+  version: 0.1.0
 platform: ruby
 authors:
 - Lapo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-05-17 00:00:00.000000000 Z
 dependencies: []
-description: InfluxDB Flux ORM for Ruby
+description: InfluxDB Flux queries builder for Ruby
 email:
 - lapoelisacci@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/influx.rb
+- lib/influx/flux/aggregate_window.rb
+- lib/influx/flux/cumulative_sum.rb
+- lib/influx/flux/derivative.rb
+- lib/influx/flux/fill.rb
+- lib/influx/flux/filter.rb
+- lib/influx/flux/first.rb
+- lib/influx/flux/from.rb
+- lib/influx/flux/group.rb
+- lib/influx/flux/histogram.rb
+- lib/influx/flux/increase.rb
+- lib/influx/flux/last.rb
+- lib/influx/flux/limit.rb
+- lib/influx/flux/median.rb
+- lib/influx/flux/moving_average.rb
+- lib/influx/flux/quantile.rb
+- lib/influx/flux/range.rb
+- lib/influx/flux/sort.rb
+- lib/influx/flux/timed_moving_average.rb
+- lib/influx/point.rb
+- lib/influx/query.rb
 - lib/influx/version.rb
 - sig/influx.rbs
 homepage: https://github.com/LapoElisacci/influx
@@ -45,12 +67,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.9
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
-summary: InfluxDB Flux ORM for Ruby
+summary: InfluxDB Flux queries builder for Ruby
 test_files: []