tapioca_dsl_compiler_store_model 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8599b4a2721338d14a30ce4662dfe880eec4b11b2cee175b4fb23f59e7057c13
+  data.tar.gz: e8076445bf9f432bfe2b6fc667235037c9af89b5d2f9ea64979526190fe03835
+SHA512:
+  metadata.gz: f4f26d03579f5c9a75a6c6816562e756391bf6b99b50fb3a086e6a1dbd1e36095daa26477ed266a473802f06360704ba5c28c303a7f1817981d0ad4afd7d1445
+  data.tar.gz: 1306687309250806d06ef63b9b9cac7e705e96fe97a4abc53670f98b0e5aa1075c805c9c99f423e00093fcf000881c202bfb2a4d00c7fd091f33a271c820ff81

data/README.md

@@ -0,0 +1,151 @@
+# Tapioca DSL Compiler for StoreModel
+
+A [Tapioca](https://github.com/Shopify/tapioca) DSL compiler that generates RBI files for [StoreModel](https://github.com/DmitryTsepelev/store_model) attributes in ActiveRecord models.
+
+StoreModel adds JSON-backed attributes to ActiveRecord models, and this gem provides Sorbet type signatures for the methods that StoreModel dynamically generates.
+
+## Features
+
+- **Automatic RBI Generation**: Generates Sorbet RBI files for StoreModel attributes
+- **Comprehensive Type Coverage**: Supports both single and array StoreModel types
+- **Build Methods**: Generates signatures for `build_*` methods created by StoreModel
+- **Tapioca Integration**: Follows Tapioca's standard compiler patterns and is automatically discovered
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tapioca_dsl_compiler_store_model'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install tapioca_dsl_compiler_store_model
+```
+
+## Usage
+
+Once installed, Tapioca will automatically discover and use the `Tapioca::Dsl::Compilers::StoreModel` compiler when generating RBI files for ActiveRecord models that use StoreModel attributes.
+
+### Example
+
+Given the following StoreModel setup:
+
+```ruby
+# app/models/user_settings.rb
+class UserSettings
+  include StoreModel::Model
+
+  attribute :theme, :string
+  attribute :notifications, :boolean
+  attribute :language, :string
+end
+
+# app/models/preference.rb
+class Preference
+  include StoreModel::Model
+
+  attribute :key, :string
+  attribute :value, :string
+end
+
+# app/models/user.rb
+class User < ActiveRecord::Base
+  attribute :settings, UserSettings.to_type
+  attribute :preferences, Preference.to_array_type
+end
+```
+
+Running `bundle exec tapioca dsl` will generate the following RBI file:
+
+```ruby
+# sorbet/rbi/dsl/user.rbi
+# typed: strong
+
+class User
+  sig { returns(T.nilable(UserSettings)) }
+  def settings; end
+
+  sig { params(value: T.nilable(T.any(UserSettings, T::Hash[T.untyped, T.untyped]))).returns(T.nilable(UserSettings)) }
+  def settings=(value); end
+
+  sig { params(attributes: T::Hash[T.untyped, T.untyped]).returns(UserSettings) }
+  def build_settings(attributes: {}); end
+
+  sig { returns(T::Array[Preference]) }
+  def preferences; end
+
+  sig { params(value: T.nilable(T.any(T::Array[Preference], T::Array[T::Hash[T.untyped, T.untyped]]))).returns(T::Array[Preference]) }
+  def preferences=(value); end
+end
+```
+
+### Supported StoreModel Types
+
+This compiler supports all StoreModel attribute types:
+
+- **Single Models**: `Model.to_type` - generates getter, setter, and builder methods
+- **Array Models**: `Model.to_array_type` - generates getter and setter methods for arrays
+- **Nested Models**: StoreModel classes that contain other StoreModel attributes
+
+### Generated Methods
+
+For each StoreModel attribute, the compiler generates type signatures for:
+
+1. **Getter method**: Returns the StoreModel instance or array
+2. **Setter method**: Accepts StoreModel instance(s) or Hash(es)
+3. **Builder method** (single types only): Creates a new instance with given attributes
+
+## Limitations
+
+Currently, this compiler has the following limitations:
+
+- **Enum Support**: Does not generate RBI signatures for enum methods (e.g., predicate methods like `active?`, bang methods like `status_active!`)
+- **Nested Attributes**: Does not support `accepts_nested_attributes_for` generated methods
+- **Custom Types**: Only supports `StoreModel::Types::One` and `StoreModel::Types::Many`, custom types are not detected
+- **Validation Methods**: Does not generate signatures for StoreModel validation methods
+
+These features may be added in future versions.
+
+## Requirements
+
+- Ruby 2.7+
+- [Tapioca](https://github.com/Shopify/tapioca) 0.10+
+- [StoreModel](https://github.com/DmitryTsepelev/store_model) 1.0+
+- ActiveRecord 6.0+
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+$ bundle install
+```
+
+To run the test suite:
+
+```bash
+$ bundle exec rspec
+```
+
+To run the linter:
+
+```bash
+$ bundle exec rubocop
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/speria-jp/tapioca_dsl_compiler_store_model.
+
+## 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,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[rubocop spec]

data/lib/tapioca/dsl/compilers/store_model.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+# Tapioca DSL Compiler for StoreModel
+module Tapioca
+  module Dsl
+    module Compilers
+      class StoreModel < Tapioca::Dsl::Compiler
+        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def self.gather_constants
+          return [] unless defined?(::StoreModel)
+
+          ::ActiveRecord::Base.descendants.select do |klass|
+            next false unless klass.respond_to?(:attribute_types)
+
+            # Skip classes that can't load their schema or attributes
+            begin
+              attribute_types = klass.attribute_types
+            rescue ActiveRecord::TableNotSpecified, StandardError
+              next false
+            end
+
+            # Check if any attribute types are StoreModel types
+            attribute_types.values.any? { |type| store_model_type?(type) }
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |klass|
+            create_store_model_methods(klass)
+          end
+        end
+
+        sig { params(type: T.untyped).returns(T::Boolean) }
+        def self.store_model_type?(type)
+          return true if type.is_a?(::StoreModel::Types::One)
+          return true if type.is_a?(::StoreModel::Types::Many)
+          return true if store_model_class_type?(type)
+          return true if store_model_one_of_type?(type)
+
+          false
+        end
+
+        sig { params(type: T.untyped).returns(T::Boolean) }
+        def self.store_model_class_type?(type)
+          return false unless type.respond_to?(:model_klass)
+
+          model_klass = type.model_klass
+          return false if model_klass.nil?
+
+          model_klass.include?(::StoreModel::Model)
+        end
+
+        sig { params(type: T.untyped).returns(T::Boolean) }
+        def self.store_model_one_of_type?(type)
+          # Check for StoreModel.one_of types (polymorphic types)
+          return true if type.is_a?(::StoreModel::Types::OnePolymorphic)
+          return true if type.is_a?(::StoreModel::Types::ManyPolymorphic)
+
+          false
+        end
+
+        private
+
+        sig { params(mod: T.untyped).void }
+        def create_store_model_methods(mod)
+          constant.attribute_types.each do |attribute_name, type|
+            next unless self.class.store_model_type?(type)
+
+            create_attribute_methods(mod, attribute_name, type)
+          end
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String, type: T.untyped).void }
+        def create_attribute_methods(mod, attribute_name, type)
+          case type
+          when ::StoreModel::Types::One
+            create_single_store_model_methods(mod, attribute_name, type.model_klass)
+          when ::StoreModel::Types::Many
+            create_many_store_model_methods(mod, attribute_name, type.model_klass)
+          else
+            if self.class.store_model_one_of_type?(type)
+              create_one_of_store_model_methods(mod, attribute_name, type)
+            else
+              create_fallback_store_model_methods(mod, attribute_name, type)
+            end
+          end
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String, type: T.untyped).void }
+        def create_fallback_store_model_methods(mod, attribute_name, type)
+          return unless type.respond_to?(:model_klass)
+          return unless type.model_klass&.include?(::StoreModel::Model)
+
+          if array_type?(type)
+            create_many_store_model_methods(mod, attribute_name, type.model_klass)
+          else
+            create_single_store_model_methods(mod, attribute_name, type.model_klass)
+          end
+        end
+
+        sig { params(type: T.untyped).returns(T::Boolean) }
+        def array_type?(type)
+          type_name = type.class.name
+          type_name&.include?("Many") || type_name&.include?("Array")
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String, type: T.untyped).void }
+        def create_one_of_store_model_methods(mod, attribute_name, type)
+          # OneOf types have dynamic model selection, so we use more generic types
+          if array_type?(type)
+            create_one_of_array_methods(mod, attribute_name)
+          else
+            create_one_of_single_methods(mod, attribute_name)
+          end
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String).void }
+        def create_one_of_single_methods(mod, attribute_name)
+          # OneOf types are dynamically resolved, so we use generic StoreModel::Model types
+          mod.create_method(
+            attribute_name,
+            return_type: "T.nilable(StoreModel::Model)"
+          )
+
+          mod.create_method(
+            "#{attribute_name}=",
+            parameters: [create_param("value",
+                                      type: "T.nilable(T.any(StoreModel::Model, T::Hash[T.untyped, T.untyped]))")],
+            return_type: "T.nilable(StoreModel::Model)"
+          )
+
+          mod.create_method(
+            "build_#{attribute_name}",
+            parameters: [create_kw_opt_param("attributes", type: "T::Hash[T.untyped, T.untyped]", default: "{}")],
+            return_type: "StoreModel::Model"
+          )
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String).void }
+        def create_one_of_array_methods(mod, attribute_name)
+          # OneOf array types are dynamically resolved
+          mod.create_method(
+            attribute_name,
+            return_type: "T::Array[StoreModel::Model]"
+          )
+
+          mod.create_method(
+            "#{attribute_name}=",
+            parameters: [create_param("value",
+                                      type: "T.nilable(T.any(T::Array[StoreModel::Model], " \
+                                            "T::Array[T::Hash[T.untyped, T.untyped]]))")],
+            return_type: "T::Array[StoreModel::Model]"
+          )
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String, model_klass: T.untyped).void }
+        def create_single_store_model_methods(mod, attribute_name, model_klass)
+          return_type = model_klass.name
+
+          mod.create_method(
+            attribute_name,
+            return_type: "T.nilable(#{return_type})"
+          )
+
+          mod.create_method(
+            "#{attribute_name}=",
+            parameters: [create_param("value",
+                                      type: "T.nilable(T.any(#{return_type}, T::Hash[T.untyped, T.untyped]))")],
+            return_type: "T.nilable(#{return_type})"
+          )
+
+          mod.create_method(
+            "build_#{attribute_name}",
+            parameters: [create_kw_opt_param("attributes", type: "T::Hash[T.untyped, T.untyped]", default: "{}")],
+            return_type: return_type
+          )
+        end
+
+        sig { params(mod: T.untyped, attribute_name: String, model_klass: T.untyped).void }
+        def create_many_store_model_methods(mod, attribute_name, model_klass)
+          return_type = model_klass.name
+          array_type = "T::Array[#{return_type}]"
+
+          mod.create_method(
+            attribute_name,
+            return_type: array_type
+          )
+
+          mod.create_method(
+            "#{attribute_name}=",
+            parameters: [create_param("value",
+                                      type: "T.nilable(T.any(#{array_type}, " \
+                                            "T::Array[T::Hash[T.untyped, T.untyped]]))")],
+            return_type: array_type
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tapioca_dsl_compiler_store_model/version.rb

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

data/lib/tapioca_dsl_compiler_store_model.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "tapioca_dsl_compiler_store_model/version"
+
+# Conditionally load required dependencies
+begin
+  require "tapioca/dsl"
+  require "store_model"
+rescue LoadError
+  # Do nothing if dependencies are not available
+end
+
+# Only load implementation when both Tapioca::Dsl::Compiler and StoreModel are available
+require_relative "tapioca/dsl/compilers/store_model" if defined?(Tapioca::Dsl::Compiler) && defined?(StoreModel)

data/tapioca_dsl_compiler_store_model.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/tapioca_dsl_compiler_store_model/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "tapioca_dsl_compiler_store_model"
+  spec.version = TapiocaDslCompilerStoreModel::VERSION
+  spec.authors = ["speria-jp"]
+
+  spec.summary = "Tapioca DSL compiler for StoreModel"
+  spec.description = "Provides Tapioca DSL compiler for generating RBI files for StoreModel gem"
+  spec.homepage = "https://github.com/speria-jp/tapioca_dsl_compiler_store_model"
+  spec.email = ["daichi.sakai@speria.jp"]
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?("test/", "spec/", "features/") ||
+        f.start_with?(".github/") ||
+        f == ".gitignore" ||
+        f == ".rspec" ||
+        f == ".rubocop.yml" ||
+        f == "Gemfile" ||
+        f == "Gemfile.lock" ||
+        f == "CLAUDE.md"
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "store_model", ">= 1.0.0"
+  spec.add_dependency "tapioca", ">= 0.11.0"
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: tapioca_dsl_compiler_store_model
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- speria-jp
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: store_model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+description: Provides Tapioca DSL compiler for generating RBI files for StoreModel
+  gem
+email:
+- daichi.sakai@speria.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/tapioca/dsl/compilers/store_model.rb
+- lib/tapioca_dsl_compiler_store_model.rb
+- lib/tapioca_dsl_compiler_store_model/version.rb
+- tapioca_dsl_compiler_store_model.gemspec
+homepage: https://github.com/speria-jp/tapioca_dsl_compiler_store_model
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/speria-jp/tapioca_dsl_compiler_store_model
+  source_code_uri: https://github.com/speria-jp/tapioca_dsl_compiler_store_model
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Tapioca DSL compiler for StoreModel
+test_files: []