contr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83b6121c17aee582566059f1664b3d72a167d458f56f685e754b2baee68c35ee
+  data.tar.gz: 1daa46552ab5bfd252654e608608169d6cd5bad555c9dc3263377fdeb164c534
+SHA512:
+  metadata.gz: e8d219a62e8dfc86375875c450294cca263146d4d187bf910824d0b56fa3a15a6208d0719c388dd4f2f5d968f6a310f9f19b0bea24a70af8fb4869316bbe16b1
+  data.tar.gz: 21860bfa5ae3787cfd2ca35b4fe2c26fe5e25ba90e94866c7d56880bd3227cf8d3f7d31335d799fe922918a1f8ea0891669e88bf3b124375b7937e5a32dc1746

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+0.1.0
+----------
+
+- Initial release!

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Dmytro Horoshko
+
+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,447 @@
+# Contr
+
+Minimalistic contracts in plain Ruby.
+
+## Installation
+
+Install the gem and add to Gemfile:
+
+```sh
+bundle add contr
+```
+
+Or install it manually:
+
+```sh
+gem install contr
+```
+
+## Terminology
+
+Contract consists of rules of 2 types:
+
+- guarantees - the ones that *__should__* be valid
+- expectations - the ones that *__could__* be valid
+
+Contract is called *__matched__* when:
+- *__all__* guarantees are matched (if present)
+- *__at least one__* expectation is matched (if present)
+
+Rule is *__matched__* when it returns *__truthy__* value.\
+Rule is *__not matched__* when it returns *__falsey__* value (`nil`, `false`) or *__raises an error__*.
+
+Contract is triggered *__after__* operation under guard is succesfully executed.
+
+## Usage
+
+Example of basic contract:
+
+```ruby
+class PostRemovalContract < Contr::Act # or Contr::Base if you're a boring person
+  guarantee :verified_via_api do |user_id, post_id, _|
+    !API.post_exists?(user_id, post_id)
+  end
+
+  guarantee :verified_via_web do |*, post_url|
+    !Web.post_exists?(post_url)
+  end
+
+  expect :removed_from_user_feed do |user_id, post_id, _|
+    !Feed::User.post_exists?(user_id, post_id)
+  end
+
+  expect :removed_from_global_feed do |user_id, post_id, _|
+    !Feed::Global.post_exists?(user_id, post_id)
+  end
+end
+
+contract = PostRemovalContract.new
+```
+
+Contract check can be run in 2 modes: `sync` and `async`.
+
+### Sync
+
+In `sync` mode all rules are executed sequentially in the same thread with the operation.
+
+If contract is matched - operation result is returned.
+
+```ruby
+api_response = contract.check(user_id, post_id, post_url) { API.delete_post(*some_args) }
+# => {data: {deleted: true}}
+```
+
+If contract fails - the contract state is dumped via [Sampler](#Sampler), logged via [Logger](#Logger) and match error is raised:
+
+```ruby
+contract.check(*args) { operation }
+# if one of the guarantees failed
+# => Contr::Matcher::GuaranteesNotMatched: failed rules: [...], args: [...]
+
+# if all expectations failed
+# => Contr::Matcher::ExpectationsNotMatched: failed rules: [...], args: [...]
+```
+
+If operation raises an error it will be propagated right away, without triggering the contract itself:
+
+```ruby
+contract.check(*args) { raise StandardError, "some error" }
+# => StandardError: some error
+```
+
+### Async
+
+WIP
+
+## Sampler
+
+Default sampler creates marshalized dumps of contract state in specified folder with sampling period frequency:
+
+```ruby
+# state structure
+{
+  ts:            "2024-02-26T14:16:28.044Z",
+  contract_name: "PostRemovalContract",
+  failed_rules: [
+    {type: :expectation, name: :removed_from_user_feed, status: :unexpected_error, error: error_instance},
+    {type: :expectation, name: :removed_from_global_feed, status: :failed}
+  ],
+  ok_rules: [
+    {type: :guarantee, name: :verified_via_api, status: :ok},
+    {type: :guarantee, name: :verified_via_web, status: :ok}
+  ],
+  async:  false,
+  args:   [1, 2, "url"],
+  result: {data: {deleted: true}}
+}
+
+# default sampler can be reconfigured
+ConfigedSampler = Contr::Sampler::Default.new(
+  folder: "/tmp/contract_dumps",                       # default: "/tmp/contracts"
+  path_template: "%<contract_name>_%<period_id>i.bin", # default: "%<contract_name>s/%<period_id>i.dump"
+  period: 3600                                         # default: 600 (= 10 minutes)
+)
+
+class SomeContract < Contr::Act
+  sampler ConfigedSampler
+
+  # ...
+end
+
+# it will create dumps:
+#   /tmp/contract_dumps/SomeContract_474750.bin
+#   /tmp/contract_dumps/SomeContract_474751.bin
+#   /tmp/contract_dumps/SomeContract_474752.bin
+#   ...
+
+# NOTE: `period_id` is calculated as <unix_ts> / `period`
+```
+
+Sampler is enabled by default:
+
+```ruby
+class SomeContract < Contr::Act
+end
+
+SomeContract.new.sampler
+# => #<Contr::Sampler::Default:...>
+```
+
+It's possible to define custom sampler and use it instead:
+
+```ruby
+class CustomSampler < Contr::Sampler::Base
+  # optional
+  def initialize(*some_args)
+    # ...
+  end
+
+  # required
+  def sample!(state)
+    # ...
+  end
+end
+
+class SomeContract < Contr::Act
+  sampler CustomSampler.new(*some_args)
+
+  # ...
+end
+```
+
+As well as to disable sampler completely:
+
+```ruby
+class SomeContract < Contr::Act
+  sampler nil # or `false`
+end
+```
+
+Default sampler also provides a helper method to read created dumps:
+
+```ruby
+contract.sampler
+# => #<Contr::Sampler::Default:...>
+
+# using absolute path
+contract.sampler.read(path: "/tmp/contracts/SomeContract/474750.dump")
+# => {ts: "2024-02-26T14:16:28.044Z", contract_name: "SomeContract", failed_rules: [...], ...}
+
+# using `contract_name` + `period_id` args
+# it uses `folder` and `path_template` from sampler config
+contract.sampler.read(contract_name: "SomeContract", period_id: "474750")
+# => {ts: "2024-02-26T14:16:28.044Z", contract_name: "SomeContract", failed_rules: [...], ...}
+```
+
+## Logger
+
+Default logger logs contract state to specified stream in JSON format. State structure is the same as for sampler with a small addition of `tag` field.
+
+```ruby
+# state structure
+{
+  **sampler_state,
+  tag: "contract-failed"
+}
+
+# default logger can be reconfigured
+ConfigedLogger = Contr::Logger::Default.new(
+  stream: $stderr,     # default: $stdout
+  log_level: :warn,    # default: :debug
+  tag: "shit-happened" # default: "contract-failed"
+)
+
+class SomeContract < Contr::Act
+  logger ConfigedLogger
+
+  # ...
+end
+
+# it will print:
+# => W, [2024-02-27T14:36:53.607088 #58112]  WARN -- : {"ts":"...","contract_name":"...", ... "tag":"shit-happened"}
+```
+
+Logger is enabled by default:
+
+```ruby
+class SomeContract < Contr::Act
+end
+
+SomeContract.new.logger
+# => #<Contr::Logger::Default:...>
+```
+
+It's possible to define custom logger in the same manner as with sampler:
+
+```ruby
+class CustomLogger < Contr::Sampler::Base
+  # optional
+  def initialize(*some_args)
+    # ...
+  end
+
+  # required
+  def log(state)
+    # ...
+  end
+end
+
+class SomeContract < Contr::Act
+  logger CustomLogger.new(*some_args)
+
+  # ...
+end
+```
+
+As well as to disable logger completely:
+
+```ruby
+class SomeContract < Contr::Act
+  logger nil # or `false`
+end
+```
+
+## Configuration
+
+Contracts can be deeply inherited:
+
+```ruby
+class SomeContract < Contr::Act
+  guarantee :check_1 do
+    # ...
+  end
+
+  expect :check_2 do
+    # ...
+  end
+end
+# guarantees:  check_1
+# expecations: check_2
+# sampler:     Contr::Sampler::Default
+# logger:      Contr::Logger:Default
+
+class OtherContract < SomeContract
+  sampler CustomSampler.new
+
+  guarantee :check_3 do
+    # ...
+  end
+end
+# guarantees:  check_1, check_3
+# expecations: check_2
+# sampler:     CustomSampler
+# logger:      Contr::Logger:Default
+
+class AnotherContract < OtherContract
+  logger nil
+
+  expect :check_4 do
+    # ...
+  end
+end
+# guarantees:  check_1, check_3
+# expecations: check_2, check_4
+# sampler:     CustomSampler
+# logger:      nil
+```
+
+Contract can be configured using args passed to `.new` method:
+
+```ruby
+class SomeContract < Contr::Act
+end
+
+contract = SomeContract.new(sampler: CustomSampler.new, logger: CustomLogger.new)
+
+contract.sampler
+# => #<CustomSampler:...>
+
+contract.logger
+# => #<CustomLogger:...>
+```
+
+Rule block arguments are optional:
+
+```ruby
+class SomeContract < Contr::Act
+  guarantee :args_used do |arg_1, arg_2|
+    arg_1 # => 1
+    arg_2 # => 2
+  end
+
+  guarantee :args_not_used do
+    # ...
+  end
+end
+
+SomeContract.new.check(1, 2) { operation }
+```
+
+Each rule has access to contract variables:
+
+```ruby
+class SomeContract < Contr::Act
+  guarantee :check_1 do
+    @args         # => [1, [2, 3], {key: :value}]
+    @result       # => 2
+    @contract     # => #<SomeContract:...>
+    @guarantees   # => [{type: :guarantee, name: :check_1, block: #<Proc:...>}]
+    @expectations # => []
+    @sampler      # => #<Contr::Sampler::Default:...>
+    @logger       # => #<Contr::Logger::Default:...>
+  end
+end
+
+SomeContract.new.check(1, [2, 3], {key: :value}) { 1 + 1 }
+```
+
+Having access to `@result` can be really useful in contracts where operation produces a data that should be used inside the rules:
+
+```ruby
+class PostCreationContract < Contr::Act
+  guarantee :verified_via_api do |user_id|
+    post_id = @result["id"]
+    API.post_exists?(user_id, post_id)
+  end
+
+  # ...
+end
+
+contract = PostCreationContract.new
+
+contract.check(user_id) { API.create_post(*some_args) }
+# => {"id":1050118621198921700, "text":"Post text", ...}
+```
+
+Having access to `@guarantees` and `@expectations` makes possible building dynamic contracts (in case you really need it):
+
+```ruby
+class SomeContract < Contr::Act
+  guarantee :guarantee_1 do
+    # add new guarantee to the end of guarantees list
+    @guarantees << {
+      type: :guarantee,
+      name: :guarantee_2,
+      block: proc do
+        puts "guarantee 2"
+        true
+      end
+    }
+
+    puts "guarantee 1"
+    true
+  end
+
+  expect :expect_1 do
+    # add new expectation to the end of expectations list
+    @expectations << {
+      type: :expectation,
+      name: :expect_2,
+      block: proc do |*args|
+        puts "expect 2, args: #{args}"
+        true
+      end
+    }
+
+    puts "expect 1"
+    false
+  end
+end
+
+SomeContract.new.check(1, 2) { operation }
+
+# it will print:
+# => guarantee 1
+# => guarantee 2
+# => expect 1
+# => expect 2, args: [1, 2]
+```
+
+Other instance variables (e.g. `@args`, `@logger` etc.) can be modified on the fly too but make sure you really know what you do.
+
+## TODO
+
+- [x] Contract definition  
+- [x] Sampler  
+- [x] Logger  
+- [x] Sync matcher  
+- [ ] Async matcher  
+- [ ] Add `before` block for contract definition  
+
+## Development
+
+```sh
+bin/setup        # install deps
+bin/console      # interactive prompt to play around
+rake spec        # run tests
+rake rubocop     # lint code
+rake rubocop:md  # lint docs
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ocvit/contr.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/contr/base.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Contr
+  class Base
+    class << self
+      attr_reader :config, :guarantees, :expectations
+
+      def logger(logger)
+        set_config(:logger, logger)
+      end
+
+      def sampler(sampler)
+        set_config(:sampler, sampler)
+      end
+
+      def guarantee(name, &block)
+        add_guarantee(name, block)
+      end
+
+      def expect(name, &block)
+        add_expectation(name, block)
+      end
+
+      private
+
+      def set_config(key, value)
+        @config ||= {}
+        @config[key] = value
+      end
+
+      def add_guarantee(name, block)
+        @guarantees ||= []
+        @guarantees << {type: :guarantee, name: name, block: block}
+      end
+
+      def add_expectation(name, block)
+        @expectations ||= []
+        @expectations << {type: :expectation, name: name, block: block}
+      end
+    end
+
+    attr_reader :logger, :sampler
+
+    def initialize(instance_config = {})
+      @logger = choose_logger(instance_config)
+      @sampler = choose_sampler(instance_config)
+
+      validate_logger!
+      validate_sampler!
+    end
+
+    def check(*args)
+      result = yield
+      Matcher::Sync.new(self, args, result).match
+      result
+    end
+
+    def name
+      self.class.name
+    end
+
+    def guarantees
+      @guarantees ||= aggregate_rules(:guarantees)
+    end
+
+    def expectations
+      @expectations ||= aggregate_rules(:expectations)
+    end
+
+    private
+
+    def choose_logger(instance_config)
+      parent_config = find_parent_config(:logger)
+
+      case [instance_config, self.class.config, parent_config]
+      in [{logger: }, *]
+        logger
+      in [_, {logger: }, _]
+        logger
+      in [*, {logger: }]
+        logger
+      else
+        Logger::Default.new
+      end
+    end
+
+    def choose_sampler(instance_config)
+      parent_config = find_parent_config(:sampler)
+
+      case [instance_config, self.class.config, parent_config]
+      in [{sampler: }, *]
+        sampler
+      in [_, {sampler: }, _]
+        sampler
+      in [*, {sampler: }]
+        sampler
+      else
+        Sampler::Default.new
+      end
+    end
+
+    def find_parent_config(key)
+      parents = self.class.ancestors.take_while { |klass| klass != Contr::Base }.drop(1)
+      parents.detect { |klass| klass.config&.key?(key) }&.config
+    end
+
+    def aggregate_rules(rule_type)
+      contracts_chain = self.class.ancestors.take_while { |klass| klass != Contr::Base }.reverse
+      contracts_chain.flat_map(&rule_type).compact
+    end
+
+    def validate_logger!
+      return unless logger
+      return if logger.class.ancestors.include?(Logger::Base)
+
+      raise ArgumentError, "logger should be inherited from Contr::Logger::Base or be falsey, received: #{logger.inspect}"
+    end
+
+    def validate_sampler!
+      return unless sampler
+      return if sampler.class.ancestors.include?(Sampler::Base)
+
+      raise ArgumentError, "sampler should be inherited from Contr::Sampler::Base or be falsey, received: #{sampler.inspect}"
+    end
+  end
+
+  Act = Base
+end

data/lib/contr/logger/default.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "json"
+require "logger"
+
+module Contr
+  class Logger
+    class Default < Logger::Base
+      DEFAULT_STREAM    = $stdout
+      DEFAULT_LOG_LEVEL = :debug
+      DEFAULT_TAG       = "contract-failed"
+
+      attr_reader :stream, :stream_logger, :log_level, :tag
+
+      def initialize(stream: DEFAULT_STREAM, log_level: DEFAULT_LOG_LEVEL, tag: DEFAULT_TAG)
+        @stream = stream
+        @stream_logger = ::Logger.new(stream)
+        @log_level = log_level
+        @tag = tag
+      end
+
+      def log(state)
+        message = state.merge(tag: tag).to_json
+
+        stream_logger.send(log_level, message)
+      end
+    end
+  end
+end

data/lib/contr/logger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Contr
+  class Logger
+    class Base
+      def log(state)
+        raise NotImplementedError, "logger should implement `#log` method"
+      end
+    end
+  end
+end

data/lib/contr/matcher/sync.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Contr
+  class Matcher
+    class Sync < Matcher::Base
+      def initialize(*)
+        super
+
+        @async = false
+        @ok_rules = []
+        @failed_rules = []
+      end
+
+      def match
+        guarantees_matched?   || dump_state_and_raise(GuaranteesNotMatched)
+        expectations_matched? || dump_state_and_raise(ExpectationsNotMatched)
+      end
+
+      private
+
+      def guarantees_matched?
+        return true if @guarantees.empty?
+
+        @guarantees.all? { |rule| ok_rule?(rule) }
+      end
+
+      def expectations_matched?
+        return true if @expectations.empty?
+
+        @expectations.any? { |rule| ok_rule?(rule) }
+      end
+
+      def ok_rule?(rule)
+        match_result = match_rule(rule)
+        checked_rule = rule.slice(:type, :name).merge!(match_result)
+
+        if match_result[:status] == :ok
+          @ok_rules << checked_rule
+          true
+        else
+          @failed_rules << checked_rule
+          false
+        end
+      end
+
+      def dump_state_and_raise(error_class)
+        dump_state!
+
+        raise error_class.new(@failed_rules, @args)
+      end
+    end
+  end
+end

data/lib/contr/matcher.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "time"
+
+module Contr
+  class Matcher
+    class RulesNotMatched < StandardError
+      def initialize(failed_rules, args)
+        @failed_rules_minimized = failed_rules.map(&:values)
+        @args = args
+      end
+
+      def message
+        "failed rules: #{@failed_rules_minimized.inspect}, args: #{@args.inspect}"
+      end
+    end
+
+    class GuaranteesNotMatched < RulesNotMatched
+    end
+
+    class ExpectationsNotMatched < RulesNotMatched
+    end
+
+    class Base
+      def initialize(contract, args, result)
+        @contract = contract
+        @args     = args
+        @result   = result
+
+        # def_delegators would be slickier but it breaks consistency of
+        # variables names when used within the rules definitions
+        @guarantees   = @contract.guarantees
+        @expectations = @contract.expectations
+        @sampler      = @contract.sampler
+        @logger       = @contract.logger
+      end
+
+      def match
+        raise NotImplementedError, "matcher should implement `#match` method"
+      end
+
+      private
+
+      def match_rule(rule)
+        block = rule[:block]
+
+        block_result = instance_exec(*@args, &block)
+        block_result ? {status: :ok} : {status: :failed}
+      rescue => error
+        {status: :unexpected_error, error: error}
+      end
+
+      def dump_state!
+        state = compile_state
+
+        if @sampler
+          dump_info = @sampler.sample!(state)
+          state[:dump_info] = dump_info if dump_info
+        end
+
+        @logger&.log(state)
+      end
+
+      def compile_state
+        {
+          ts:            Time.now.utc.iso8601(3),
+          contract_name: @contract.name,
+          failed_rules:  @failed_rules,
+          ok_rules:      @ok_rules,
+          async:         @async,
+          args:          @args,
+          result:        @result
+        }
+      end
+    end
+  end
+end

data/lib/contr/sampler/default.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Contr
+  class Sampler
+    class Default < Sampler::Base
+      DEFAULT_FOLDER        = "/tmp/contracts"
+      DEFAULT_PATH_TEMPLATE = "%<contract_name>s/%<period_id>i.dump"
+      DEFAULT_PERIOD        = 10 * 60 # 10 minutes
+
+      attr_reader :folder, :path_template, :period
+
+      def initialize(folder: DEFAULT_FOLDER, path_template: DEFAULT_PATH_TEMPLATE, period: DEFAULT_PERIOD)
+        @folder = folder
+        @path_template = path_template
+        @period = period
+      end
+
+      def sample!(state)
+        path = dump_path(state[:contract_name])
+        return if dump_present?(path)
+
+        dump = Marshal.dump(state)
+
+        save_dump(dump, path)
+        create_dump_info(path)
+      end
+
+      def read(path: nil, contract_name: nil, period_id: nil)
+        path ||= dump_path(contract_name, period_id)
+
+        dump = File.read(path)
+        Marshal.load(dump)
+      end
+
+      private
+
+      def dump_path(contract_name, period_id = current_period_id)
+        raise ArgumentError, "`contract_name` should be defined" unless contract_name
+        raise ArgumentError, "`period_id` should be defined"     unless period_id
+
+        file_path = @path_template % {
+          contract_name: contract_name,
+          period_id:     period_id
+        }
+
+        File.join(@folder, file_path)
+      end
+
+      def save_dump(dump, path)
+        init_dump_folder!(path)
+        File.write(path, dump)
+      end
+
+      def create_dump_info(path)
+        {path: path}
+      end
+
+      def dump_present?(path)
+        File.exist?(path)
+      end
+
+      def current_period_id
+        Time.now.to_i / @period
+      end
+
+      def init_dump_folder!(path)
+        dump_folder = File.dirname(path)
+        FileUtils.mkdir_p(dump_folder)
+      end
+    end
+  end
+end

data/lib/contr/sampler.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Contr
+  class Sampler
+    class Base
+      def sample!(state)
+        raise NotImplementedError, "sampler should implement `#sample!` method"
+      end
+    end
+  end
+end

data/lib/contr/version.rb

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

data/lib/contr.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "contr/version"
+require_relative "contr/logger"
+require_relative "contr/logger/default"
+require_relative "contr/sampler"
+require_relative "contr/sampler/default"
+require_relative "contr/matcher"
+require_relative "contr/matcher/sync"
+require_relative "contr/base"
+
+module Contr
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: contr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmytro Horoshko
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-28 00:00:00.000000000 Z
+dependencies: []
+description: Minimalistic contracts in plain Ruby.
+email:
+- electric.molfar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/contr.rb
+- lib/contr/base.rb
+- lib/contr/logger.rb
+- lib/contr/logger/default.rb
+- lib/contr/matcher.rb
+- lib/contr/matcher/sync.rb
+- lib/contr/sampler.rb
+- lib/contr/sampler/default.rb
+- lib/contr/version.rb
+homepage: https://github.com/ocvit/contr
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/ocvit/contr/issues
+  changelog_uri: https://github.com/ocvit/contr/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/ocvit/contr
+  source_code_uri: https://github.com/ocvit/contr
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Minimalistic contracts in plain Ruby
+test_files: []