oriole 0.1.0.alpha.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3980000fdb8c01321628cf597f3c15ae043f53c962a8cb28cd36f510a2257fe8
+  data.tar.gz: 9ab73fd8f5f0c7b7c970bcc7eca1c35a117f278280bd3334741a47a49615608c
+SHA512:
+  metadata.gz: 8d73c9afdf4b033b19ab48010815fdb0a83ff5e30182851d299fd739a22d0a2bcdc185f8960e6a06cba25f28ceef99e2b045b43b2fe7ea7e02d657823d93b519
+  data.tar.gz: b89be1561d1398fbc2de5487a828141e0600b7b0274678b9f98a6daa57f54992e8aa587d8b0dffd42c2194ded90fe200dd4dd575208d1eed352f45519e91a60e

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/.rubocop.yml

@@ -0,0 +1,32 @@
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+require:
+- rubocop-rake
+- rubocop-minitest
+- rubocop-sorbet
+
+AllCops:
+  TargetRubyVersion: 3.2
+  SuggestExtensions: false
+  NewCops: enable
+
+Sorbet/ValidSigil:
+  MinimumStrictness: true
+  Enabled: true
+  Exclude:
+    - "bench/**/*.rb"
+    - "rakelib/**/*.rake"
+
+Sorbet/FalseSigil:
+  Enabled: false
+
+Sorbet/StrictSigil:
+  Enabled: true
+  Exclude:
+    - "test/**/*.rb"
+    - "bench/**/*.rb"
+    - "rakelib/**/*.rake"
+
+Sorbet/ConstantsFromStrings:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

data/Gemfile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in oriole.gemspec
+gemspec
+
+group :development do
+  gem "rubocop", "~> 1.21", require: false
+  gem "rubocop-minitest", "~> 0.27.0", require: false
+  gem "rubocop-rake", "~> 0.6.0", require: false
+  gem "rubocop-shopify", "~> 2.12", require: false
+  gem "rubocop-sorbet", "~> 0.6.11", require: false
+  gem "ruby-lsp", "~> 0.4.0", require: false
+  gem "sorbet", "~> 0.5"
+  gem "tapioca", require: false
+  gem "bluejay", "~> 0.1.0.alpha.2"
+end

data/Gemfile.lock

@@ -0,0 +1,121 @@
+PATH
+  remote: .
+  specs:
+    oriole (0.1.0.alpha.0)
+      sorbet-runtime (~> 0.5)
+      tinygql (~> 0.1.4)
+      zeitwerk (~> 2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    base64 (0.1.1)
+    bluejay (0.1.0.alpha.2-arm64-darwin)
+      sorbet-runtime
+    bluejay (0.1.0.alpha.2-x86_64-darwin)
+      sorbet-runtime
+    diff-lcs (1.5.0)
+    erubi (1.12.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    minitest (5.19.0)
+    netrc (0.11.0)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    prettier_print (1.2.1)
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rbi (0.0.17)
+      ast
+      parser (>= 3.0.0)
+      sorbet-runtime (>= 0.5.9204)
+      unparser (>= 0.5.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rubocop (1.56.1)
+      base64 (~> 0.1.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-minitest (0.27.0)
+      rubocop (>= 0.90, < 2.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-shopify (2.14.0)
+      rubocop (~> 1.51)
+    rubocop-sorbet (0.6.11)
+      rubocop (>= 0.90.0)
+    ruby-lsp (0.4.5)
+      language_server-protocol (~> 3.17.0)
+      sorbet-runtime
+      syntax_tree (>= 6.1.1, < 7)
+    ruby-progressbar (1.13.0)
+    sorbet (0.5.10987)
+      sorbet-static (= 0.5.10987)
+    sorbet-runtime (0.5.10987)
+    sorbet-static (0.5.10987-universal-darwin-22)
+    sorbet-static-and-runtime (0.5.10987)
+      sorbet (= 0.5.10987)
+      sorbet-runtime (= 0.5.10987)
+    spoom (1.2.3)
+      erubi (>= 1.10.0)
+      sorbet-static-and-runtime (>= 0.5.10187)
+      syntax_tree (>= 6.1.1)
+      thor (>= 0.19.2)
+    syntax_tree (6.1.1)
+      prettier_print (>= 1.2.0)
+    tapioca (0.11.8)
+      bundler (>= 2.2.25)
+      netrc (>= 0.11.0)
+      parallel (>= 1.21.0)
+      rbi (~> 0.0.0, >= 0.0.16)
+      sorbet-static-and-runtime (>= 0.5.10187)
+      spoom (~> 1.2.0, >= 1.2.0)
+      thor (>= 1.2.0)
+      yard-sorbet
+    thor (1.2.2)
+    tinygql (0.1.4)
+    unicode-display_width (2.4.2)
+    unparser (0.6.8)
+      diff-lcs (~> 1.3)
+      parser (>= 3.2.0)
+    yard (0.9.34)
+    yard-sorbet (0.8.1)
+      sorbet-runtime (>= 0.5)
+      yard (>= 0.9)
+    zeitwerk (2.6.11)
+
+PLATFORMS
+  arm64-darwin-22
+  x86_64-darwin-22
+
+DEPENDENCIES
+  bluejay (~> 0.1.0.alpha.2)
+  bundler (~> 2.4.10)
+  minitest (~> 5.0)
+  oriole!
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+  rubocop-minitest (~> 0.27.0)
+  rubocop-rake (~> 0.6.0)
+  rubocop-shopify (~> 2.12)
+  rubocop-sorbet (~> 0.6.11)
+  ruby-lsp (~> 0.4.0)
+  sorbet (~> 0.5)
+  tapioca
+
+BUNDLED WITH
+   2.4.10

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Adam Petro
+
+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,84 @@
+# `oriole`
+
+> **Warning**
+> This is very scrappy and incomplete
+
+## Benchmark
+
+<!---benchmark result start-->
+<details>
+  <summary>Parse + Execute (Ruby 3.2, YJIT enabled)</summary>
+
+  ```
+  Profiling IPS:
+  Warming up --------------------------------------
+     oriole_visibility   362.000  i/100ms
+  oriole_no_visibility   488.000  i/100ms
+               bluejay     1.766k i/100ms
+  Calculating -------------------------------------
+     oriole_visibility      3.682k (± 2.3%) i/s -     18.462k in   5.017324s
+  oriole_no_visibility      4.992k (± 1.3%) i/s -     25.376k in   5.083988s
+               bluejay     18.240k (± 3.1%) i/s -     91.832k in   5.039693s
+
+  Comparison:
+               bluejay:    18239.9 i/s
+  oriole_no_visibility:     4992.3 i/s - 3.65x  slower
+     oriole_visibility:     3681.7 i/s - 4.95x  slower
+
+  Profiling Ruby memory allocations:
+  Calculating -------------------------------------
+     oriole_visibility    22.648k memsize (   120.000  retained)
+                         264.000  objects (     2.000  retained)
+                          15.000  strings (     0.000  retained)
+  oriole_no_visibility    12.656k memsize (     4.000k retained)
+                         166.000  objects (    56.000  retained)
+                          14.000  strings (    12.000  retained)
+               bluejay     5.256k memsize (     5.056k retained)
+                          40.000  objects (    35.000  retained)
+                           0.000  strings (     0.000  retained)
+
+  Comparison:
+               bluejay:       5256 allocated
+  oriole_no_visibility:      12656 allocated - 2.41x more
+     oriole_visibility:      22648 allocated - 4.31x more
+  ```
+</details>
+
+<details>
+  <summary>Parse + Execute (Ruby 3.2, YJIT disabled)</summary>
+
+  ```
+  Profiling IPS:
+  Warming up --------------------------------------
+     oriole_visibility   234.000  i/100ms
+  oriole_no_visibility   323.000  i/100ms
+               bluejay     1.804k i/100ms
+  Calculating -------------------------------------
+     oriole_visibility      2.403k (± 3.3%) i/s -     12.168k in   5.069266s
+  oriole_no_visibility      3.274k (± 1.9%) i/s -     16.473k in   5.033067s
+               bluejay     18.418k (± 2.1%) i/s -     93.808k in   5.095735s
+
+  Comparison:
+               bluejay:    18417.7 i/s
+  oriole_no_visibility:     3274.2 i/s - 5.63x  slower
+     oriole_visibility:     2403.1 i/s - 7.66x  slower
+
+  Profiling Ruby memory allocations:
+  Calculating -------------------------------------
+     oriole_visibility    22.648k memsize (     7.680k retained)
+                         264.000  objects (   104.000  retained)
+                          15.000  strings (    12.000  retained)
+  oriole_no_visibility    12.656k memsize (     4.960k retained)
+                         166.000  objects (    63.000  retained)
+                          14.000  strings (    12.000  retained)
+               bluejay     5.256k memsize (     5.056k retained)
+                          40.000  objects (    35.000  retained)
+                           0.000  strings (     0.000  retained)
+
+  Comparison:
+               bluejay:       5256 allocated
+  oriole_no_visibility:      12656 allocated - 2.41x more
+     oriole_visibility:      22648 allocated - 4.31x more
+  ```
+</details>
+<!---benchmark result end-->

data/Rakefile

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

data/bench/bench.rb

@@ -0,0 +1,35 @@
+# typed: false
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "benchmark/memory"
+require "sorbet-runtime"
+
+T::Configuration.default_checked_level = :never
+
+require "oriole"
+
+module Bench
+  extend(self)
+
+  def ips(&blk)
+    Benchmark.ips do |x|
+      blk.call(x)
+
+      x.config(time: 0, warmup: 0) if ENV["CI"]
+    end
+  end
+
+  def memory(&blk)
+    Benchmark.memory do |x|
+      blk.call(x)
+    end
+  end
+
+  def all(&blk)
+    puts "Profiling IPS:"
+    ips(&blk)
+    puts "Profiling Ruby memory allocations:"
+    memory(&blk)
+  end
+end

data/bench/execute.rb

@@ -0,0 +1,66 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require_relative "bench"
+require_relative "schemas/bluejay"
+require_relative "schemas/oriole"
+require_relative "schemas/models"
+
+Bench.all do |x|
+  root_value = Schemas::Models::QueryRoot.new(teams: Schemas::Models::Team.all)
+  schema_root_value = Schemas::Models::SchemaRoot.new(query: root_value)
+  query = <<~GQL
+    {
+      teams {
+        __typename
+        name
+        city
+        players {
+          __typename
+          firstName
+          lastName
+          age
+          draftPosition { __typename round selection year }
+        }
+      }
+    }
+  GQL
+
+  oriole_visibility_test_run = Schemas::Oriole::Schema.execute(query:, root_value:, context: nil)
+  oriole_no_visibility_test_run = Oriole::Execution::Engine.execute(
+    schema_definition: Schemas::Oriole::Schema,
+    query:,
+    context: nil,
+    operation_name: nil,
+    root_value:,
+  )
+  bluejay_test_run = Schemas::Bluejay::Schema.execute(query:, operation_name: nil, initial_value: schema_root_value)
+
+  unless bluejay_test_run.errors.empty?
+    raise "errors returned"
+  end
+
+  unless oriole_visibility_test_run == bluejay_test_run.value && oriole_no_visibility_test_run == bluejay_test_run.value
+    raise "results not equal"
+  end
+
+  x.report(:oriole_visibility) do
+    Schemas::Oriole::Schema.execute(query:, root_value:, context: nil)
+  end
+
+  x.report(:oriole_no_visibility) do
+    Oriole::Execution::Engine.execute(
+      schema_definition: Schemas::Oriole::Schema,
+      query:,
+      context: nil,
+      operation_name: nil,
+      root_value:,
+    )
+  end
+
+  x.report(:bluejay) do
+    Schemas::Bluejay::Schema.execute(query:, operation_name: nil, initial_value: schema_root_value)
+  end
+
+  x.compare!
+end

data/bench/schemas/bluejay.rb

@@ -0,0 +1,149 @@
+# typed: false
+# frozen_string_literal: true
+
+require "bluejay"
+
+module Schemas
+  module Bluejay
+    class DraftPosition < ::Bluejay::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::FieldDefinition]) }
+        def field_definitions
+          [
+            ::Bluejay::FieldDefinition.new(name: "round", type: ot!(::Bluejay::Scalar::Int)),
+            ::Bluejay::FieldDefinition.new(name: "selection", type: ot!(::Bluejay::Scalar::Int)),
+            ::Bluejay::FieldDefinition.new(name: "year", type: ot!(::Bluejay::Scalar::Int)),
+          ]
+        end
+      end
+    end
+
+    class Player < ::Bluejay::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::FieldDefinition]) }
+        def field_definitions
+          [
+            ::Bluejay::FieldDefinition.new(name: "firstName", type: ot!(::Bluejay::Scalar::String)),
+            ::Bluejay::FieldDefinition.new(name: "lastName", type: ot!(::Bluejay::Scalar::String)),
+            ::Bluejay::FieldDefinition.new(name: "age", type: ot!(::Bluejay::Scalar::Int)),
+            ::Bluejay::FieldDefinition.new(name: "draftPosition", type: ot(DraftPosition)),
+          ]
+        end
+      end
+    end
+
+    class Team < ::Bluejay::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::FieldDefinition]) }
+        def field_definitions
+          [
+            ::Bluejay::FieldDefinition.new(name: "name", type: ot!(::Bluejay::Scalar::String)),
+            ::Bluejay::FieldDefinition.new(name: "city", type: ot!(::Bluejay::Scalar::String)),
+            ::Bluejay::FieldDefinition.new(name: "players", type: lot!(ot!(Player))),
+          ]
+        end
+      end
+    end
+
+    class QueryRoot < ::Bluejay::QueryRoot
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::FieldDefinition]) }
+        def field_definitions
+          [
+            ::Bluejay::FieldDefinition.new(name: "teams", type: lot!(ot!(Team))),
+          ]
+        end
+      end
+    end
+
+    class DraftPositionInput < ::Bluejay::InputObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::InputValueDefinition]) }
+        def input_field_definitions
+          [
+            ::Bluejay::InputValueDefinition.new(name: "round", type: it!(::Bluejay::Scalar::Int)),
+            ::Bluejay::InputValueDefinition.new(name: "selection", type: it!(::Bluejay::Scalar::Int)),
+            ::Bluejay::InputValueDefinition.new(name: "year", type: it!(::Bluejay::Scalar::Int)),
+          ]
+        end
+      end
+    end
+
+    class PlayerInput < ::Bluejay::InputObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::InputValueDefinition]) }
+        def input_field_definitions
+          [
+            ::Bluejay::InputValueDefinition.new(name: "firstName", type: it!(::Bluejay::Scalar::String)),
+            ::Bluejay::InputValueDefinition.new(name: "lastName", type: it!(::Bluejay::Scalar::String)),
+            ::Bluejay::InputValueDefinition.new(name: "age", type: it!(::Bluejay::Scalar::Int)),
+            ::Bluejay::InputValueDefinition.new(name: "draftPosition", type: it(DraftPositionInput)),
+          ]
+        end
+      end
+    end
+
+    class PlayersCreate < ::Bluejay::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::FieldDefinition]) }
+        def field_definitions
+          [
+            ::Bluejay::FieldDefinition.new(name: "count", type: ot!(::Bluejay::Scalar::Int)),
+          ]
+        end
+      end
+    end
+
+    class MutationRoot < ::Bluejay::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Bluejay::FieldDefinition]) }
+        def field_definitions
+          [
+            ::Bluejay::FieldDefinition.new(
+              name: "playersCreate",
+              argument_definitions: [
+                ::Bluejay::InputValueDefinition.new(
+                  name: "players",
+                  type: lit!(it!(PlayerInput)),
+                ),
+              ],
+              type: ot!(PlayersCreate),
+            ),
+          ]
+        end
+      end
+    end
+
+    class Schema < ::Bluejay::Schema
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T.class_of(::Bluejay::QueryRoot)) }
+        def query
+          QueryRoot
+        end
+
+        sig { override.returns(T.nilable(T.class_of(::Bluejay::ObjectType))) }
+        def mutation
+          MutationRoot
+        end
+      end
+    end
+  end
+end