rubocop-boochtek 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b02de4ada297f8524fa07a7104ba7ba709df9bdf01293b644ee407b6a8459dd
-  data.tar.gz: 79828971327eb8186d681f022f40028e0118c97bd81e287ea04c105276ebbbdf
+  metadata.gz: 3db02cc1d2130d7a3e39ddf0ab20bebceba68a3b59d292db8993c630d6d6727d
+  data.tar.gz: 9b7e264f064f8060b5de691c575e474fe422a44ba320040ead510dba586c403f
 SHA512:
-  metadata.gz: b5189e192ba4e1cb7a33e4b1356de89fb468399d73983ea3573bab18d369434804426a74b2f6a01939838a11c543ebc03f4b0b5fc661af84f39695c50e2075de
-  data.tar.gz: '08cc3863e0eb14aad60668b1d66d570e396f9d9d59e9f5eaea2e375c93030a3a62cecc711a03af319b7a1172cdb1a32040254b4b5dfbe1f7e8838aeee761b59c'
+  metadata.gz: '09cbd0212c65603d868df7bcde0fb7bb20b08c2bd8cca67c263a9fb5a58aca5a2dfe88f394afae2bf4aa6b7bd24efe5832270bd7dde5b159b334118102deb926'
+  data.tar.gz: 54b39ca84f94c52cf0b617269ba6d073450a8863ef8ddcd52bcb63ae075ee483fea9e41efd795746cd461c798f53b51c7d1887188cdb1abb0d497f3979104539

data/.rubocop.yml

@@ -1,8 +1,118 @@
 ---
-# Use our own configuration for this gem.
-inherit_from:
-  - config/default.yml
+plugins:
+  - rubocop-boochtek
 
+# Ignore some files. NOTE: Exclude does not add to any existing Exclude directives.
 AllCops:
-  TargetRubyVersion: 3.1
-  NewCops: enable
+  Exclude:
+    - "church*.rb"
+    - "vendor/**/*"
+    - "**/*.stone"
+  NewCops: disable
+
+# Allow longer lines.
+Layout/LineLength:
+  Max: 160
+
+# Use `{}` for blocks that return a value; otherwise use `do` and `end`.
+# We make a few exceptions, mostly for RSpec. And for grammar and transform rules.
+Style/BlockDelimiters:
+  EnforcedStyle: semantic
+  FunctionalMethods:
+    - expect
+  AllowedMethods:
+    - let
+    - let!
+    - subject
+    - rule
+    - rule!
+    - terminal
+    - terminal!
+
+# Allow non-ASCII identifiers, and in comments.
+Naming/AsciiIdentifiers:
+  Enabled: false
+
+# Some of our classes are going to be long.
+Metrics/ClassLength:
+  Max: 250
+  Exclude:
+    - lib/stone/transform.rb
+    - lib/stone/ast/property_access.rb
+
+# Sometimes we need to pass a block down recursively, so allow expressing that.
+Performance/RedundantBlockCall:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    - lib/stone/type/*
+
+# Not sure why `∧` and `∨` are problematic, even after allowing non-ASCII identifiers.
+# Also allow `builtin_ClassName` methods.
+Naming/MethodName:
+  Exclude:
+    - lib/extensions/boolean.rb
+    - lib/stone/top.rb
+  AllowedPatterns:
+    - as_String
+
+# Allow numbered variables in record field comparisons (field1_0, field2_0).
+Naming/VariableNumber:
+  Exclude:
+    - lib/stone/ast/function_call.rb
+
+# I don't believe `module_function` should be outdented like `private`, but there's no way to turn it off for just `module_function`.
+Layout/AccessModifierIndentation:
+  EnforcedStyle: outdent
+  Exclude:
+    - lib/stone/top.rb
+
+# Allow `expr = expr + x` in this particular file, to parallel `expr = x + expr` that's right next to it.
+Style/SelfAssignment:
+  Exclude:
+    - lib/stone/ast/binary_operation.rb
+
+# The `grammar` and `transforms` methods are DSLs; don't worry about their size/complexity.
+Metrics/AbcSize:
+  AllowedMethods:
+    - grammar
+    - transforms
+Metrics/MethodLength:
+  AllowedMethods:
+    - grammar
+    - transforms
+Metrics/PerceivedComplexity:
+  AllowedMethods:
+    - grammar
+    - transforms
+Metrics/CyclomaticComplexity:
+  AllowedMethods:
+    - grammar
+    - transforms
+
+Style/PercentLiteralDelimiters:
+  Exclude:
+    - "lib/stone/ast/binary_operation.rb"
+
+# Be a bit more lenient with RSpec: don't require filename to match class; allow more than 1 expectation per example.
+RSpec/SpecFilePathFormat:
+  Enabled: false
+RSpec/DescribedClass:
+  Enabled: false
+RSpec/DescribeClass:
+  Enabled: false
+
+# RuboCop doesn't like the way we use the `parse_as` custom matcher.
+RSpec/ExpectActual:
+  Exclude:
+    - "spec/unit/parser/**/**.rb"
+
+# I like to put 2 spaces before inline comments.
+Layout/ExtraSpacing:
+  Enabled: false
+
+# Allow use of a single `module_function` instead of prepending it to every method.
+# Unfortunately, we can't turn this off only for `module_function`.
+Style/AccessModifierDeclarations:
+  Enabled: false

data/LICENSE.md

@@ -1,6 +1,6 @@
-MIT License
+# MIT License
 
-Copyright (c) 2024 Craig Buchek / BoochTek, LLC
+Copyright (c) 2018-2025 Craig Buchek
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,130 +1,77 @@
-# RuboCop BoochTek
+# The Stone Programming Language
 
-BoochTek's shared RuboCop configuration for Ruby projects.
+Stone is a multi-paradigm programming language. It combines the ideas of object-oriented,
+functional, and actor-based languages. It is a typed language, with immutability by default.
 
-## Installation
+This is a *very* new language, but I've been thinking about the design of the language for
+quite some time. The design documents can be found in [/docs/design](docs/design/README.md).
 
-Add to your `Gemfile`:
+## Goals
 
-```ruby
-group :development, :test do
-  gem "rubocop-boochtek", github: "boochtek/rubocop-boochtek"
-end
-```
+I have several goals that I keep in mind when designing and implementing Stone. My top-level goals are:
 
-Or install directly:
+- Have fun learning and creating
+- See if I can make something useful
+- Correctness
 
-```bash
-gem install rubocop-boochtek
-```
+For more details, see the [Goals](docs/design/Goals.md) in the design documents.
 
-## Usage
+## Specifications
 
-Create a `.rubocop.yml` in your project root:
+The language is described in Markdown, with code blocks showing example code.
+The code blocks also show the expected result of evaluating the code.
+This is also used as the language specification —
+all the example code is checked to ensure that it evaluates to the expected result.
+These can be found in [docs/specs](docs/specs/README.md).
 
-```yaml
-plugins:
-  - rubocop-boochtek
-```
+## Building
 
-That's it! The gem automatically loads `rubocop-rspec` and `rubocop-performance`.
+We're using standard `make` to build the system.
 
-### Overriding Settings
+Currently, we're using Ruby for all pieces of Stone, so you won't need to actually run a build step to get a `stone` binary.
 
-Override any settings in your project's `.rubocop.yml`:
+You can verify that the specs are all passing:
 
-```yaml
-plugins:
-  - rubocop-boochtek
+~~~ shell
+make verify-specs
+~~~
 
-Layout/LineLength:
-  Max: 160
+## Running
 
-AllCops:
-  NewCops: enable
-```
+Binaries are located in the bin directory:
 
-## Key Style Decisions
+- `stone`
+    - `stone parse` - Output parse tree
+    - `stone ast` - Output AST (abstract syntax tree)
+    - `stone mlir` - Output MLIR (multi-level intermediate representation)
+    - `stone llir` - Output LLIR (low-level intermediate representation)
+    - `stone compile` - Compile to an executable
+    - `stone run` - Compile to an executable and run it
+    - `stone eval` - Output the result of each top-level expression (non-interactive REPL)
+    - `stone verify` - Verify that results of top-level expressions match expectations in comments
+    - `stone repl` - Accept interactive manual input, and show the result of each top-level expression (default if no arguments are given)
+    - `stone specs` - Run tests/specs
+    - `stone build` - Compile an entire project
+    - `stone lint` - Check Stone code for issues
+    - `stone format` - Format Stone code
+    - `stone lsp` - Start the Language Server Protocol service
+    - `stone publish` - Publish to package repository
+    - `stone deps` - Manage project dependencies (package manager)
 
-### `private def` (Inline Access Modifiers)
+Note that most of these commands are still under development — or development has not even started on them yet.
 
-We prefer `private def` over a separate `private` section:
+## Changelog
 
-```ruby
-# Good
-private def my_method
-  # ...
-end
+See the [CHANGELOG](CHANGELOG.md) file for information about what changes have been made in each release.
 
-# Avoided
-private
-
-def my_method
-  # ...
-end
-```
-
-This makes it easier to see at a glance which methods are private, and makes moving methods around simpler.
-
-### Semantic Block Delimiters
-
-Use `{}` for blocks that return a value; use `do`/`end` otherwise:
-
-```ruby
-# Good - returns a value
-names = users.map { |u| u.name }
-
-# Good - side effects only
-users.each do |user|
-  send_email(user)
-end
-```
-
-### Double Quotes
-
-We use double quotes by default for strings, as they require fewer changes when you later need interpolation.
-
-### Other Notable Preferences
-
-- Line length: 120 characters
-- No frozen string literal comments required
-- No documentation required for classes/modules
-- `fail` for raising exceptions, `raise` for re-raising
-- `%x[]` for shell commands (not backticks)
-- Unicode allowed in comments and identifiers
-
-## Adding Custom Cops
-
-Create cops in `lib/rubocop/cop/boochtek/`:
-
-```ruby
-# lib/rubocop/cop/boochtek/my_custom_cop.rb
-module RuboCop
-  module Cop
-    module Boochtek
-      class MyCustomCop < Base
-        MSG = "Custom message here"
-
-        def on_send(node)
-          # ...
-        end
-      end
-    end
-  end
-end
-```
-
-Custom cops are auto-loaded when the gem is required.
+## License
 
-## Development
+Stone is released under the MIT license. See the [LICENSE](/LICENSE.txt) file for details.
 
-```bash
-git clone https://github.com/boochtek/rubocop-boochtek
-cd rubocop-boochtek
-bundle install
-bundle exec rake
-```
+## Thanks
 
-## License
+Thanks to some advice from my friends in the STL Polyglots group in selecting the name.
+Especially Deech.
 
-MIT License. See [LICENSE](LICENSE) for details.
+Thanks to Claude, ChatGPT, and GitHub Copilot for lots of good advice.
+And lots of frustration!

data/lib/disable_ssl_verify.rb

@@ -0,0 +1,5 @@
+# Temporary workaround for SSL certificate verification issues
+# Used by Makefile when downloading remote RuboCop configs.
+require "openssl"
+OpenSSL::SSL.__send__(:remove_const, :VERIFY_PEER)
+OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE

data/lib/extensions/argf.rb

@@ -0,0 +1,8 @@
+# Iterate through ARGF input files. Can still use ARGF.filename and ARGF.lineno.
+def ARGF.each_file
+  until ARGF.closed?
+    yield ARGF.file
+    ARGF.skip
+    return if ARGV.empty? # Ensure we stop if we were reading from STDIN.
+  end
+end

data/lib/extensions/boolean.rb

@@ -0,0 +1,48 @@
+class TrueClass
+
+  include Comparable
+
+  def ∧(other)
+    !!other
+  end
+
+  def ∨(_other)
+    true
+  end
+
+  def <=>(other)
+    return 1 if other.instance_of?(FalseClass)
+    return 0 if other.instance_of?(TrueClass)
+    fail ArgumentError, "comparison of Boolean with #{other.class} failed"
+  end
+
+  def ==(other)
+    other.instance_of?(TrueClass)
+  end
+
+end
+
+
+class FalseClass
+
+  include Comparable
+
+  def ∧(_other)
+    false
+  end
+
+  def ∨(other)
+    !!other
+  end
+
+  def <=>(other)
+    return -1 if other.instance_of?(TrueClass)
+    return 0 if other.instance_of?(FalseClass)
+    fail ArgumentError, "comparison of Boolean with #{other.class} failed"
+  end
+
+  def ==(other)
+    other.instance_of?(FalseClass)
+  end
+
+end

data/lib/extensions/class.rb

@@ -0,0 +1,10 @@
+class Class
+
+  def descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+
+  def subclass(&)
+    Class.new(self, &)
+  end
+end

data/lib/extensions/enumerable.rb

@@ -0,0 +1,42 @@
+# TODO: Get these added to the `pretty_ruby` gem, and use that. (Note that it uses refinements, not monkey-patching.)
+
+module Enumerable
+
+  # Allow Scheme-style `rest`.
+  def rest(count = 1)
+    drop(count)
+  end
+
+  # Allow Scheme-style `tail`.
+  # FIXME: Shouldn't this be the same as `rest`?
+  def tail
+    return self if empty?
+    last(size - 1)
+  end
+
+  # Returns `true` iff all the elements are equal. Returns `false` if there are no elements.
+  def same?
+    uniq.size == 1
+  end
+
+  # Like `first` or `last`, but *requires* that there be exactly one element.
+  def only
+    fail IndexError, "expected to have exactly 1 element" unless size == 1
+    first
+  end
+
+  # Allow Rails-style `second`.
+  def second
+    drop(1).first
+  end
+
+  # Prefer 1-based indexing to get the `nth` element.
+  def nth(n) # rubocop:disable Naming/MethodParameterName
+    drop(n - 1).first
+  end
+
+  def map_dig(*)
+    map{ |a| a.dig(*) }
+  end
+
+end

data/lib/extensions/integer.rb

@@ -0,0 +1,7 @@
+class Integer
+
+  def sign
+    ["-", "", "+"][(self <=> 0) + 1]
+  end
+
+end

data/lib/extensions/llvm_module.rb

@@ -0,0 +1,101 @@
+require "llvm/core"
+
+
+# Extensions to LLVM::Module to support Stone-specific features
+#
+# NOTE: Many of these registries are now duplicated in Stone::Scope for lexical scoping:
+# - string_constants: types also stored via scope.declare_type(name, type: Stone::Type::String)
+# - record_instances: types also stored via scope.declare_type(name, type: record_type)
+# - function_aliases: values also stored via scope.define(name, value: function)
+#
+# The module registries remain necessary for:
+# - Computed properties (Int@abs) which are global, not lexically scoped
+# - Type inference via the `type` method (which doesn't have access to scope)
+# - Property access lookups that need the actual AST node (not just the type)
+#
+# Future work: migrate fully to scope by updating `type` method signatures to accept scope.
+module Stone
+  module LLVMModuleExtensions
+
+    # Get the function aliases hash, creating it if it doesn't exist
+    def function_aliases
+      @function_aliases ||= {}
+    end
+
+    # Register a function alias (e.g., for lambdas assigned to constants)
+    def register_function_alias(name, function)
+      function_aliases[name] = function
+    end
+
+    # Look up a function by name, checking aliases if not found in the module's function table
+    def lookup_function(name)
+      functions[name] || function_aliases[name]
+    end
+
+    # Get the current lambda parameter storage context
+    def lambda_param_storage
+      @lambda_param_storage
+    end
+
+    # Set the lambda parameter storage context (used during lambda compilation)
+    def lambda_param_storage=(storage)
+      @lambda_param_storage = storage
+    end
+
+    # Track which constants are strings (for type checking during returns)
+    def string_constants
+      @string_constants ||= {}
+    end
+
+    def register_string_constant(name, string_literal)
+      string_constants[name] = string_literal
+    end
+
+    def string_constant?(name)
+      string_constants.key?(name)
+    end
+
+    # TODO: Type system refactor needed.
+    # This ad-hoc tracking of record types and instances should be replaced
+    # with a proper Type class hierarchy where:
+    # - All types (Bool, Int, String, Records) are Type instances
+    # - Types are global constants accessible at runtime
+    # - Types have vtables for properties and polymorphic operations
+    # - typeof() can get the type of any value
+    # - User-defined types work the same as built-in types
+
+    # Track record type definitions
+    def record_types
+      @record_types ||= {}
+    end
+
+    def register_record_type(name, record_definition)
+      record_types[name] = record_definition
+    end
+
+    def record_type?(name)
+      record_types.key?(name)
+    end
+
+    # Track which variables hold record instances (maps variable name -> record type name)
+    def record_instances
+      @record_instances ||= {}
+    end
+
+    def register_record_instance(variable_name, record_type_name)
+      record_instances[variable_name] = record_type_name
+    end
+
+    def record_instance?(variable_name)
+      record_instances.key?(variable_name)
+    end
+
+    def record_instance_type(variable_name)
+      record_instances[variable_name]
+    end
+
+  end
+end
+
+# Extend LLVM::Module with our extensions
+LLVM::Module.include(Stone::LLVMModuleExtensions)

data/lib/extensions/module.rb

@@ -0,0 +1,34 @@
+class Module
+
+  # Document methods that MUST be overridden by child classes.
+  def abstract(method_name)
+    define_method(method_name) do
+      fail NotImplementedError
+    end
+  end
+
+  # Document methods that CAN or SHOULD be overridden by child classes.
+  def overridable(method_name)
+    method_name
+  end
+
+  # Document methods that are overriding a parent class.
+  def override(method_name)
+    method_name
+  end
+
+  # Delegate a set of methods to another object.
+  # This is meant to be a simpler version of Rails' ActiveSupport implementation.
+  def delegate(*methods, to: nil)
+    fail ArgumentError, "Must specify target of `delegate` using `to` keyword argument." if to.nil?
+    to = to.to_sym
+    to = "self.#{to}" unless to.start_with?("@")
+    methods.each do |method|
+      define_method(method) do |*args|
+        receiver = instance_eval(to)
+        receiver.__send__(method, *args)
+      end
+    end
+  end
+
+end

data/lib/extensions/string.rb

@@ -0,0 +1,29 @@
+# TODO: Get these added to the `pretty_ruby` gem, and use that. (Note that it uses refinements, not monkey-patching.)
+
+class String
+
+  # Allow Scheme-style `first`.
+  def first(count = 1)
+    self[0..(count - 1)]
+  end
+
+  # Allow Scheme-style `rest`.
+  def rest(count = 1)
+    drop(count)
+  end
+
+  def drop(count = 1)
+    self.chars.drop(count).join
+  end
+
+  # Allow Scheme-style `tail`.
+  def tail
+    return self if size.zero?
+    last(size - 1)
+  end
+
+  def last(count = 1)
+    self.chars.last(count).join
+  end
+
+end