active_windows 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c506ec36f11ce9b82beab86a0f574479965825dfd347eca6f46274111db50f08
+  data.tar.gz: bd81dd06b95ed05826d6b56daa294ec6396d31e0f800e42a3c68783fed72ef59
+SHA512:
+  metadata.gz: 7dfc6256cdaf8c2770f0ab59763de4a81552fe7a283b3852fe9bcb6d6d12f427709e5bf9e8ae999bee456761647ba7100ed191b2e5da2e3a808511d12935168e
+  data.tar.gz: b19cc5ad7f5bb62752ec2c64060230cff28582317cee5e9c5a95b065f9c31ce613c8f15a07ef0294786664dfe553db971cd79ca731e413d611ee34057c4f6f97

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Andrei Andriichuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,309 @@
+# ActiveWindows
+
+A Ruby DSL for SQL window functions in ActiveRecord. Write expressive window function queries using a fluent, chainable interface instead of raw SQL.
+
+```ruby
+# Fluent API
+User.row_number.partition_by(:department).order(:salary).as(:rank)
+
+# Hash API
+User.window(row_number: { partition: :department, order: :salary, as: :rank })
+
+# Both produce:
+# SELECT "users".*, ROW_NUMBER() OVER (PARTITION BY "users"."department" ORDER BY "users"."salary") AS rank
+# FROM "users"
+```
+
+## Requirements
+
+- Ruby >= 3.3
+- Rails >= 8.0 (ActiveRecord >= 8.0)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "active_windows"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+ActiveWindows automatically integrates with ActiveRecord via a Rails Railtie. No additional configuration is needed.
+
+## Usage
+
+ActiveWindows provides two equivalent APIs: a **fluent API** with chainable methods and a **hash API** for inline definitions. Both support the same window functions and options.
+
+### Fluent API
+
+Every window function method returns a chainable object with `.partition_by()`, `.order()`, and `.as()`:
+
+```ruby
+User.row_number.partition_by(:department).order(:salary).as(:rank)
+```
+
+All three chain methods are optional. Order can be mixed freely:
+
+```ruby
+User.row_number.as(:rn).order(:created_at)
+User.dense_rank.order(:score).as(:position)
+```
+
+### Hash API
+
+Pass one or more window function definitions as a hash:
+
+```ruby
+User.window(
+  row_number: { partition: :department, order: :salary, as: :rank }
+)
+```
+
+Available options:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `:partition` | `Symbol`, `Array` | Column(s) for `PARTITION BY` |
+| `:order` | `Symbol`, `Array` | Column(s) for `ORDER BY` |
+| `:as` | `Symbol` | Alias for the result column |
+| `:frame` | `String` | Raw SQL frame clause (e.g. `"ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING"`) |
+| `:value` | `Symbol`, `String`, `Array` | Expression(s) passed as function arguments |
+
+### Chaining with ActiveRecord
+
+Window functions integrate naturally with standard ActiveRecord methods:
+
+```ruby
+User.where(active: true)
+    .row_number
+    .partition_by(:department)
+    .order(:salary)
+    .as(:rank)
+
+User.select(:name, :salary)
+    .window(row_number: { order: :salary, as: :rn })
+
+User.where(department: "Engineering")
+    .window(rank: { order: :salary, as: :salary_rank })
+    .limit(10)
+```
+
+When no `.select()` is specified, `*` is automatically included so all model columns are available alongside the window function result.
+
+### Accessing Window Function Results
+
+Window function values are accessible as attributes on the returned records:
+
+```ruby
+results = User.row_number.partition_by(:department).order(:salary).as(:rank)
+
+results.each do |user|
+  puts "#{user.name}: rank #{user.attributes['rank']}"
+end
+```
+
+## Window Functions Reference
+
+### Ranking Functions
+
+```ruby
+# ROW_NUMBER() - sequential integer within partition
+User.row_number.partition_by(:department).order(:salary).as(:rn)
+
+# RANK() - rank with gaps for ties
+User.rank.partition_by(:department).order(:salary).as(:salary_rank)
+
+# DENSE_RANK() - rank without gaps for ties
+User.dense_rank.partition_by(:department).order(:salary).as(:dense_salary_rank)
+
+# PERCENT_RANK() - relative rank as a fraction (0 to 1)
+User.percent_rank.order(:salary).as(:percentile)
+
+# CUME_DIST() - cumulative distribution (fraction of rows <= current row)
+User.cume_dist.order(:salary).as(:cumulative)
+
+# NTILE(n) - divide rows into n roughly equal buckets
+User.ntile(4).order(:salary).as(:quartile)
+```
+
+### Value Functions
+
+```ruby
+# LAG(column, offset, default) - value from a preceding row
+User.lag(:salary).order(:hire_date).as(:prev_salary)
+User.lag(:salary, 2).order(:hire_date).as(:two_back)         # custom offset
+User.lag(:salary, 1, 0).order(:hire_date).as(:prev_or_zero)  # with default
+
+# LEAD(column, offset, default) - value from a following row
+User.lead(:salary).order(:hire_date).as(:next_salary)
+User.lead(:salary, 2, 0).order(:hire_date).as(:two_ahead)
+
+# FIRST_VALUE(column) - first value in the window frame
+User.first_value(:name).partition_by(:department).order(:salary).as(:lowest_paid)
+
+# LAST_VALUE(column) - last value in the window frame
+User.last_value(:name).partition_by(:department).order(:salary).as(:highest_paid)
+
+# NTH_VALUE(column, n) - nth value in the window frame
+User.nth_value(:name, 2).partition_by(:department).order(:salary).as(:second_lowest)
+```
+
+### Aggregate Window Functions
+
+Prefixed with `window_` to avoid conflicts with ActiveRecord's built-in aggregate methods:
+
+```ruby
+# SUM(column) OVER(...)
+User.window_sum(:salary).partition_by(:department).as(:dept_total)
+
+# AVG(column) OVER(...)
+User.window_avg(:salary).partition_by(:department).as(:dept_avg)
+
+# COUNT(column) OVER(...)
+User.window_count(:id).partition_by(:department).as(:dept_size)
+User.window_count.partition_by(:department).as(:dept_size)  # COUNT(*)
+
+# MIN(column) OVER(...)
+User.window_min(:salary).partition_by(:department).as(:min_salary)
+
+# MAX(column) OVER(...)
+User.window_max(:salary).partition_by(:department).as(:max_salary)
+```
+
+### Window Frames
+
+Pass a raw SQL frame clause via the hash API:
+
+```ruby
+User.window(sum: {
+  value: :salary,
+  partition: :department,
+  order: :hire_date,
+  frame: "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW",
+  as: :running_total
+})
+```
+
+## Examples
+
+### Rank employees by salary within each department
+
+```ruby
+User.rank
+    .partition_by(:department)
+    .order(:salary)
+    .as(:salary_rank)
+```
+
+### Running total of salaries ordered by hire date
+
+```ruby
+User.window(sum: {
+  value: :salary,
+  order: :hire_date,
+  frame: "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW",
+  as: :running_total
+})
+```
+
+### Compare each salary to the department average
+
+```ruby
+users = User.window_avg(:salary).partition_by(:department).as(:dept_avg)
+
+users.each do |user|
+  diff = user.salary - user.attributes["dept_avg"].to_f
+  puts "#{user.name}: #{diff >= 0 ? '+' : ''}#{diff.round(0)} vs department average"
+end
+```
+
+### Find the previous and next hire in each department
+
+```ruby
+User.lag(:name)
+    .partition_by(:department)
+    .order(:hire_date)
+    .as(:previous_hire)
+```
+
+### Divide employees into salary quartiles
+
+```ruby
+User.ntile(4).order(:salary).as(:quartile)
+```
+
+### Rank users by total order amount (with joins)
+
+```ruby
+User.joins(:orders)
+    .group(:id)
+    .select("users.*, SUM(orders.amount) AS total_spent")
+    .window(rank: { order: "total_spent", as: :spending_rank })
+```
+
+### Window function on joined data
+
+```ruby
+# Rank orders by amount within each user
+Order.joins(:user)
+     .row_number
+     .partition_by("users.id")
+     .order(amount: :desc)
+     .as(:order_rank)
+
+# Number each user's orders chronologically
+Order.joins(:user)
+     .select("orders.*, users.name AS user_name")
+     .row_number
+     .partition_by(:user_id)
+     .order(:created_at)
+     .as(:order_number)
+```
+
+### Combine window functions with scoped queries
+
+```ruby
+# Running total of order amounts per user
+Order.joins(:user)
+     .where(users: { department: "Engineering" })
+     .window(sum: {
+       value: :amount,
+       partition: :user_id,
+       order: :created_at,
+       frame: "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW",
+       as: :running_total
+     })
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+Run tests against a specific database:
+
+```bash
+# SQLite (default)
+bundle exec rake test
+
+# PostgreSQL
+DB_ADAPTER=postgresql POSTGRES_DB=active_windows_test bundle exec rake test
+
+# MySQL
+DB_ADAPTER=mysql2 MYSQL_DB=active_windows_test bundle exec rake test
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/andreiandriichuk/active_windows.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end
+
+task default: :test

data/docs/REVIEW_AND_PLAN.md

@@ -0,0 +1,47 @@
+# ActiveWindows — Review & Improvement Plan
+
+## Overall Assessment
+
+The gem provides a fluent DSL for SQL window functions in ActiveRecord. Core functionality is implemented and tested, with 16 window functions available via both fluent and hash APIs. 53 tests passing with 242 assertions.
+
+---
+
+## Completed
+
+- ~~**WindowChain disconnected from window()**~~ — Fixed. WindowChain holds a relation reference and delegates query methods through `to_relation`.
+- ~~**Relation state not preserved through cloning**~~ — Fixed. Uses ActiveRecord's `select()` infrastructure instead of custom `@window_values`, so state survives `spawn`/`clone`/chaining.
+- ~~**Window frame hardcoded**~~ — Fixed. `apply_window_frame` now passes user-provided string to Arel.
+- ~~**SQL injection via Arel.sql()**~~ — Mitigated. Column references now use `klass.arel_table[column]` instead of raw `Arel.sql()`.
+- ~~**Broken test suite**~~ — Fixed. Placeholder test removed, 53 real tests passing.
+- ~~**Bundler constraint**~~ — Fixed. Changed `~> 2.0` to `>= 2.0`.
+- ~~**Standalone arel gem conflict**~~ — Fixed. Removed incompatible `arel >= 9.0` dependency (ActiveRecord 8 bundles its own).
+- ~~**sqlite3 version**~~ — Fixed. Updated to `>= 2.1` for ActiveRecord 8 compatibility.
+- ~~**Only row_number supported**~~ — Fixed. Added 15 more window functions: `rank`, `dense_rank`, `percent_rank`, `cume_dist`, `ntile`, `lag`, `lead`, `first_value`, `last_value`, `nth_value`, `window_sum`, `window_avg`, `window_count`, `window_min`, `window_max`.
+- ~~**Empty partition/order arrays**~~ — Fixed. Guarded with early return.
+- ~~**No real tests**~~ — Fixed. 53 Minitest tests with SQL verification and query execution against SQLite.
+- ~~**Gemspec TODO placeholders**~~ — Fixed. Summary, description, homepage, source/changelog URIs all filled in.
+- ~~**README boilerplate**~~ — Fixed. Full documentation with usage examples, API reference, and generated SQL.
+- ~~**CI only Ruby 3.3.5**~~ — Fixed. Matrix now tests Ruby 3.3, 3.4, and 4.0.
+- ~~**RSpec dependency**~~ — Removed. Tests rewritten to Minitest.
+- ~~**RuboCop dependency**~~ — Removed.
+- ~~**LICENSE**~~ — Cleaned up. Full name, no year, `.txt` extension removed.
+- ~~**Boilerplate files**~~ — Removed. `CHANGELOG.md`, `CODE_OF_CONDUCT.md`, `bin/console`, `bin/setup`, `sig/active_windows.rbs`.
+- ~~**Ordering direction**~~ — Fixed. Supports `order(salary: :desc)`, `order({ col: :asc }, { col: :desc })`, and hash API `order: { salary: :desc }`.
+- ~~**Gemfile/gemspec duplication**~~ — Fixed. Dev gems (`minitest`, `rake`) defined only in Gemfile under `test, development` group. No more bundler override warnings.
+- ~~**Cross-platform lockfile**~~ — Fixed. Added `aarch64-linux`, `arm-linux`, `arm64-darwin`, `x86_64-darwin`, `x86_64-linux` platforms.
+- ~~**Multiple window functions in one call**~~ — Tested. Single `window()` with multiple keys and chaining separate `window()` calls both work.
+- ~~**Edge case tests**~~ — Added. Empty result sets, single-row partitions, NULL values in partition/order/value columns, chaining with `.joins()`, `.includes()`, `.where()` + `.joins()`. 67 tests, 328 assertions.
+
+---
+
+## Remaining Work
+
+### Low Priority
+
+1. **RBS type signatures** — Add method signatures for `QueryMethods` and `WindowChain`.
+
+2. **GitHub Actions for gem publishing** — No automated release workflow.
+
+3. **PostgreSQL test coverage** — SQLite has limited window function support. Testing against PostgreSQL would catch more issues.
+
+4. **Input validation on function arguments** — `lag`, `lead`, `ntile`, `nth_value` accept arbitrary values without type checking (e.g., `ntile("abc")` won't raise until query execution).

data/lib/active_windows/active_record_extensions.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module ActiveWindows
+  class WindowChain
+    attr_reader :function, :alias_name, :partition_columns, :order_columns, :function_args
+
+    def initialize(function, relation, function_args: [])
+      @function = function
+      @relation = relation
+      @function_args = function_args
+      @alias_name = nil
+      @partition_columns = []
+      @order_columns = []
+    end
+
+    def as(name)
+      @alias_name = name
+      self
+    end
+
+    def partition_by(*columns)
+      @partition_columns = columns.flatten
+      self
+    end
+
+    def order(*columns)
+      @order_columns = columns.flatten
+      self
+    end
+
+    def to_window_hash
+      options = {}
+      options[:partition] = @partition_columns unless @partition_columns.empty?
+      options[:order] = @order_columns unless @order_columns.empty?
+      options[:as] = @alias_name if @alias_name
+      options[:value] = @function_args unless @function_args.empty?
+      { @function => options }
+    end
+
+    # Materialize the chain into a relation with the window applied
+    def to_relation
+      @relation.window(to_window_hash)
+    end
+
+    # Delegate common relation/query methods so the chain is transparent
+    delegate :to_sql, :to_a, :to_ary, :load, :loaded?, :each, :map, :first, :last, :count,
+             :where, :select, :joins, :group, :having, :limit, :offset, :reorder, :pluck,
+             :find_each, :find_in_batches, :inspect, :exists?, :any?, :none?, :empty?,
+             to: :to_relation
+  end
+
+  module QueryMethods
+    VALID_WINDOW_OPTIONS = %i[value partition order frame as].freeze
+
+    # Non-mutating: returns a new relation with window function projections
+    def window(*args)
+      raise ArgumentError, "wrong number of arguments (given 0, expected 1+)" if args.empty?
+
+      processed = process_window_args(args)
+      arel_nodes = processed.map { |name, options| build_window_function(name, options || {}) }
+
+      result = spawn
+      # Ensure we keep all columns alongside the window function columns
+      result = result.select(klass.arel_table[Arel.star]) if result.select_values.empty?
+      result.select(*arel_nodes)
+    end
+
+    # Ranking window functions
+    def row_number
+      WindowChain.new(:row_number, spawn)
+    end
+
+    def rank
+      WindowChain.new(:rank, spawn)
+    end
+
+    def dense_rank
+      WindowChain.new(:dense_rank, spawn)
+    end
+
+    def percent_rank
+      WindowChain.new(:percent_rank, spawn)
+    end
+
+    def cume_dist
+      WindowChain.new(:cume_dist, spawn)
+    end
+
+    def ntile(num_buckets)
+      WindowChain.new(:ntile, spawn, function_args: [num_buckets.to_s])
+    end
+
+    # Value window functions
+    def lag(column, offset = 1, default = nil)
+      args = [column.to_s, offset.to_s]
+      args << default.to_s unless default.nil?
+      WindowChain.new(:lag, spawn, function_args: args)
+    end
+
+    def lead(column, offset = 1, default = nil)
+      args = [column.to_s, offset.to_s]
+      args << default.to_s unless default.nil?
+      WindowChain.new(:lead, spawn, function_args: args)
+    end
+
+    def first_value(column)
+      WindowChain.new(:first_value, spawn, function_args: [column.to_s])
+    end
+
+    def last_value(column)
+      WindowChain.new(:last_value, spawn, function_args: [column.to_s])
+    end
+
+    def nth_value(column, n)
+      WindowChain.new(:nth_value, spawn, function_args: [column.to_s, n.to_s])
+    end
+
+    # Aggregate window functions
+    def window_sum(column)
+      WindowChain.new(:sum, spawn, function_args: [column.to_s])
+    end
+
+    def window_avg(column)
+      WindowChain.new(:avg, spawn, function_args: [column.to_s])
+    end
+
+    def window_count(column = "*")
+      WindowChain.new(:count, spawn, function_args: [column.to_s])
+    end
+
+    def window_min(column)
+      WindowChain.new(:min, spawn, function_args: [column.to_s])
+    end
+
+    def window_max(column)
+      WindowChain.new(:max, spawn, function_args: [column.to_s])
+    end
+
+    private
+
+    def build_window_function(name, options)
+      window = Arel::Nodes::Window.new
+
+      apply_window_partition(window, options[:partition])
+      apply_window_order(window, options[:order])
+      apply_window_frame(window, options[:frame]) if options[:frame]
+
+      expressions = extract_window_value(options[:value])
+
+      Arel::Nodes::NamedFunction.new(
+        name.to_s.upcase,
+        expressions
+      ).over(window).as((options[:as] || name).to_s)
+    end
+
+    def apply_window_partition(window, partition)
+      return unless partition
+
+      columns = Array(partition)
+      return if columns.empty?
+
+      window.partition(columns.map { |p| arel_column(p) })
+    end
+
+    def apply_window_order(window, order)
+      return unless order
+
+      # When order is a Hash like { salary: :desc }, pass it directly to arel_order
+      if order.is_a?(Hash)
+        window.order(*arel_order(order))
+        return
+      end
+
+      columns = Array(order)
+      return if columns.empty?
+
+      window.order(*columns.flat_map { |o| arel_order(o) })
+    end
+
+    def apply_window_frame(window, frame)
+      return unless frame.is_a?(String)
+
+      window.frame(Arel.sql(frame))
+    end
+
+    def extract_window_value(value)
+      case value
+      when Symbol, String
+        [Arel::Nodes::SqlLiteral.new(value.to_s)]
+      when nil
+        []
+      when Array
+        value.map { |v| Arel::Nodes::SqlLiteral.new(v.to_s) }
+      else
+        raise ArgumentError, "Invalid argument for window value: #{value.class}"
+      end
+    end
+
+    def arel_column(name)
+      if name.is_a?(Arel::Nodes::Node) || name.is_a?(Arel::Nodes::SqlLiteral)
+        name
+      else
+        klass.arel_table[name.to_sym]
+      end
+    end
+
+    def arel_order(expr)
+      case expr
+      when Arel::Nodes::Node, Arel::Nodes::SqlLiteral
+        [expr]
+      when Hash
+        expr.map do |col, dir|
+          node = arel_column(col)
+          dir.to_s.downcase == "desc" ? node.desc : node.asc
+        end
+      else
+        [arel_column(expr)]
+      end
+    end
+
+    def process_window_args(args)
+      args.flat_map do |element|
+        case element
+        when Hash
+          element.each_value do |v|
+            next unless v.is_a?(Hash)
+
+            unsupported = v.keys - VALID_WINDOW_OPTIONS
+            raise ArgumentError, "Unsupported window options: #{unsupported.join(', ')}" unless unsupported.empty?
+          end
+          element.map { |k, v| [k, v] }
+        when WindowChain
+          [element.to_window_hash.first]
+        else
+          raise ArgumentError, "Expected Hash or WindowChain, got #{element.class}"
+        end
+      end
+    end
+  end
+end

data/lib/active_windows/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ActiveWindows
+  class Railtie < Rails::Railtie
+    initializer "active_windows.active_record" do
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Relation.include(ActiveWindows::QueryMethods)
+        ActiveRecord::Querying.delegate(*ActiveWindows::QUERY_METHODS, to: :all)
+      end
+    end
+  end
+end

data/lib/active_windows/version.rb

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

data/lib/active_windows.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_windows/version"
+require "active_windows/active_record_extensions"
+require "active_windows/railtie" if defined?(Rails::Railtie)
+
+module ActiveWindows
+  class Error < StandardError; end
+
+  QUERY_METHODS = %i[
+    window row_number rank dense_rank percent_rank cume_dist ntile
+    lag lead first_value last_value nth_value
+    window_sum window_avg window_count window_min window_max
+  ].freeze
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: active_windows
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrei Andriichuk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Expressive, chainable DSL for SQL window functions (ROW_NUMBER, RANK,
+  LAG, LEAD, SUM, etc.) that integrates naturally with ActiveRecord query methods.
+email:
+- andreiandriichuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- docs/REVIEW_AND_PLAN.md
+- lib/active_windows.rb
+- lib/active_windows/active_record_extensions.rb
+- lib/active_windows/railtie.rb
+- lib/active_windows/version.rb
+homepage: https://github.com/andreiandriichuk/active_windows
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/andreiandriichuk/active_windows
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A Ruby DSL for SQL window functions in ActiveRecord
+test_files: []