kodelyth-ecc 1.5.4 → 1.5.6

package/rules/elixir/hooks.md

@@ -0,0 +1,26 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Hooks
+
+> This file extends [common/hooks.md](../common/hooks.md) with Elixir specific content.
+
+## PostToolUse Hooks
+
+Configure in `~/.claude/settings.json`:
+
+- **mix format**: Auto-format `.ex` / `.exs` files after edit
+  ```bash
+  mix format <file>
+  ```
+- **Credo**: Run on edited files for style warnings
+  ```bash
+  mix credo <file>
+  ```
+
+## Warnings
+
+- Warn when `IO.inspect` is left in non-test `.ex` files (use `Logger` instead)
+- Warn when `dbg()` (Elixir 1.14+) is left in production code paths

package/rules/elixir/patterns.md

@@ -0,0 +1,67 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Patterns
+
+> This file extends [common/patterns.md](../common/patterns.md) with Elixir specific content.
+
+## with for Multi-Step Operations
+
+```elixir
+def create_user(params) do
+  with {:ok, validated} <- validate(params),
+       {:ok, user} <- Repo.insert(User.changeset(%User{}, validated)),
+       :ok <- send_welcome_email(user) do
+    {:ok, user}
+  end
+end
+```
+
+## GenServer Pattern
+
+```elixir
+defmodule MyApp.Cache do
+  use GenServer
+
+  def start_link(opts), do: GenServer.start_link(__MODULE__, %{}, opts)
+
+  def get(pid, key), do: GenServer.call(pid, {:get, key})
+  def put(pid, key, value), do: GenServer.cast(pid, {:put, key, value})
+
+  @impl true
+  def init(state), do: {:ok, state}
+
+  @impl true
+  def handle_call({:get, key}, _from, state), do: {:reply, Map.get(state, key), state}
+
+  @impl true
+  def handle_cast({:put, key, value}, state), do: {:noreply, Map.put(state, key, value)}
+end
+```
+
+## Context Modules (Phoenix)
+
+```elixir
+defmodule MyApp.Accounts do
+  alias MyApp.Accounts.User
+  alias MyApp.Repo
+
+  def get_user!(id), do: Repo.get!(User, id)
+
+  def create_user(attrs) do
+    %User{}
+    |> User.changeset(attrs)
+    |> Repo.insert()
+  end
+end
+```
+
+## Tagged Tuples for Errors
+
+Always return `{:ok, result}` or `{:error, reason}` — never bare values from functions that can fail.
+
+## Reference
+
+See skill: `phoenix-patterns` for Phoenix LiveView, contexts, and Ecto query patterns.

package/rules/elixir/security.md

@@ -0,0 +1,58 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+---
+# Elixir Security
+
+> This file extends [common/security.md](../common/security.md) with Elixir specific content.
+
+## Secret Management
+
+```elixir
+# config/runtime.exs — read from environment at runtime, never compile-time
+config :my_app, :stripe_key,
+  System.fetch_env!("STRIPE_SECRET_KEY")  # raises if missing
+```
+
+Never put secrets in `config/config.exs` or `config/dev.exs` committed to git.
+
+## SQL Injection
+
+Always use Ecto parameterized queries:
+
+```elixir
+# UNSAFE — never do this
+Repo.query("SELECT * FROM users WHERE email = '#{email}'")
+
+# SAFE
+from(u in User, where: u.email == ^email) |> Repo.one()
+```
+
+## Atom Exhaustion
+
+Never convert untrusted user input to atoms — the atom table is not garbage collected:
+
+```elixir
+# UNSAFE
+String.to_atom(user_input)
+
+# SAFE
+String.to_existing_atom(user_input)  # only if atom must already exist
+# or keep it as a string
+```
+
+## Security Scanning
+
+- **Sobelow** for Phoenix/Elixir static security analysis:
+  ```bash
+  mix sobelow --config
+  ```
+- **mix audit** for dependency vulnerability scanning:
+  ```bash
+  mix hex.audit
+  ```
+
+## Reference
+
+See skill: `security-review` for OWASP top 10 and authentication patterns.

package/rules/elixir/testing.md

@@ -0,0 +1,64 @@
+---
+paths:
+  - "**/*.ex"
+  - "**/*.exs"
+  - "**/test/**"
+---
+# Elixir Testing
+
+> This file extends [common/testing.md](../common/testing.md) with Elixir specific content.
+
+## Framework
+
+Use **ExUnit** (built-in). Use **Mox** for behaviour-based mocking.
+
+## Structure
+
+```elixir
+defmodule MyApp.AccountsTest do
+  use MyApp.DataCase
+
+  alias MyApp.Accounts
+
+  describe "create_user/1" do
+    test "creates a user with valid attrs" do
+      attrs = %{name: "Alice", email: "alice@example.com"}
+      assert {:ok, user} = Accounts.create_user(attrs)
+      assert user.email == "alice@example.com"
+    end
+
+    test "returns error with invalid attrs" do
+      assert {:error, changeset} = Accounts.create_user(%{})
+      assert "can't be blank" in errors_on(changeset).email
+    end
+  end
+end
+```
+
+## Coverage
+
+```bash
+mix test --cover
+```
+
+Use **excoveralls** for detailed coverage reports:
+
+```bash
+mix coveralls
+mix coveralls.html
+```
+
+## Async Tests
+
+Mark tests as `async: true` when they don't share state:
+
+```elixir
+defmodule MyApp.PureTest do
+  use ExUnit.Case, async: true
+  ...
+end
+```
+
+## Reference
+
+See skill: `elixir-testing` for ExUnit async patterns, Mox setup, and property-based testing with StreamData.

package/rules/ruby/coding-style.md

@@ -0,0 +1,41 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+  - "**/Gemfile"
+  - "**/Rakefile"
+---
+# Ruby Coding Style
+
+> This file extends [common/coding-style.md](../common/coding-style.md) with Ruby specific content.
+
+## Standards
+
+- Follow the **Ruby Style Guide** (rubocop default)
+- Use **frozen_string_literal: true** at the top of every file
+- Prefer `do...end` for multi-line blocks, `{ }` for single-line
+
+## Immutability
+
+```ruby
+# frozen_string_literal: true
+
+User = Data.define(:name, :email)  # Ruby 3.2+ immutable value object
+```
+
+## Formatting
+
+- **RuboCop** for linting and style enforcement
+- **StandardRB** as a zero-config RuboCop config alternative
+- Line length: 120 characters max
+
+## Naming
+
+- `snake_case` for methods and variables
+- `CamelCase` for classes and modules
+- `SCREAMING_SNAKE_CASE` for constants
+- Predicate methods end with `?`, destructive methods end with `!`
+
+## Reference
+
+See skill: `ruby-patterns` for comprehensive Ruby idioms, Rails patterns, and concurrency.

package/rules/ruby/hooks.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+---
+# Ruby Hooks
+
+> This file extends [common/hooks.md](../common/hooks.md) with Ruby specific content.
+
+## PostToolUse Hooks
+
+Configure in `~/.claude/settings.json`:
+
+- **RuboCop**: Auto-lint `.rb` files after edit
+  ```bash
+  rubocop --autocorrect <file>
+  ```
+- **Syntax check**: Run `ruby -c <file>` after editing
+
+## Warnings
+
+- Warn about `puts` / `p` statements in non-test `.rb` files (use `Rails.logger` or a logger instead)
+- Warn when `binding.pry` or `byebug` is left in edited files

package/rules/ruby/patterns.md

@@ -0,0 +1,71 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+---
+# Ruby Patterns
+
+> This file extends [common/patterns.md](../common/patterns.md) with Ruby specific content.
+
+## Service Objects
+
+```ruby
+# frozen_string_literal: true
+
+class CreateUserService
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    user = User.new(@params)
+    user.save!
+    user
+  end
+end
+
+# Usage
+result = CreateUserService.new(params).call
+```
+
+## Value Objects
+
+```ruby
+# frozen_string_literal: true
+
+Address = Data.define(:street, :city, :country)
+
+address = Address.new(street: "123 Main St", city: "London", country: "UK")
+```
+
+## Query Objects
+
+```ruby
+# frozen_string_literal: true
+
+class ActiveUsersQuery
+  def initialize(relation = User.all)
+    @relation = relation
+  end
+
+  def call
+    @relation.where(status: :active).order(created_at: :desc)
+  end
+end
+```
+
+## Modules for Composition
+
+Prefer composition over inheritance for shared behavior:
+
+```ruby
+module Auditable
+  def self.included(base)
+    base.before_action :track_activity
+  end
+end
+```
+
+## Reference
+
+See skill: `rails-patterns` for Rails-specific patterns including concerns, callbacks, and ActiveRecord best practices.

package/rules/ruby/security.md

@@ -0,0 +1,56 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*.rake"
+---
+# Ruby Security
+
+> This file extends [common/security.md](../common/security.md) with Ruby specific content.
+
+## Secret Management
+
+```ruby
+# Never hardcode secrets
+api_key = ENV.fetch("STRIPE_SECRET_KEY")  # raises KeyError if missing, not nil
+
+# Rails credentials (encrypted)
+Rails.application.credentials.stripe[:secret_key]
+```
+
+## SQL Injection
+
+Always use parameterized queries — never string interpolation:
+
+```ruby
+# UNSAFE
+User.where("email = '#{params[:email]}'")
+
+# SAFE
+User.where(email: params[:email])
+User.where("email = ?", params[:email])
+```
+
+## Mass Assignment
+
+Use strong parameters in Rails controllers:
+
+```ruby
+def user_params
+  params.require(:user).permit(:name, :email)
+end
+```
+
+## Security Scanning
+
+- **Brakeman** for static security analysis of Rails apps:
+  ```bash
+  brakeman -q
+  ```
+- **bundler-audit** for dependency CVE scanning:
+  ```bash
+  bundle audit check --update
+  ```
+
+## Reference
+
+See skill: `security-review` for OWASP top 10 and auth patterns.

package/rules/ruby/testing.md

@@ -0,0 +1,65 @@
+---
+paths:
+  - "**/*.rb"
+  - "**/*_spec.rb"
+  - "**/spec/**"
+---
+# Ruby Testing
+
+> This file extends [common/testing.md](../common/testing.md) with Ruby specific content.
+
+## Framework
+
+Use **RSpec** as the testing framework. Use **FactoryBot** for fixtures.
+
+## Structure
+
+```ruby
+# frozen_string_literal: true
+
+RSpec.describe CreateUserService do
+  subject(:service) { described_class.new(params) }
+
+  let(:params) { { name: "Alice", email: "alice@example.com" } }
+
+  describe "#call" do
+    context "with valid params" do
+      it "creates a user" do
+        expect { service.call }.to change(User, :count).by(1)
+      end
+    end
+
+    context "with invalid params" do
+      let(:params) { { name: "", email: "bad" } }
+
+      it "raises an error" do
+        expect { service.call }.to raise_error(ActiveRecord::RecordInvalid)
+      end
+    end
+  end
+end
+```
+
+## Coverage
+
+```bash
+COVERAGE=true bundle exec rspec
+```
+
+Use **SimpleCov** for coverage reporting. Target 90%+ for new code.
+
+## Factories
+
+```ruby
+FactoryBot.define do
+  factory :user do
+    sequence(:email) { |n| "user#{n}@example.com" }
+    name { Faker::Name.name }
+    status { :active }
+  end
+end
+```
+
+## Reference
+
+See skill: `ruby-testing` for detailed RSpec patterns, shared examples, and Rails request specs.