circuit_switch 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4cdb8d820d7ecce566ca391ad90990a2df09007d23ab3c223dbac66a3fcaa93
-  data.tar.gz: adb2a3ab38f303dd610f10a964014cbe75f0c752f5f6cd24ebf3c03319329c96
+  metadata.gz: 6a00a04ad121a8f40a84f78a55e769aaa8f3fc185ac58fab51ddff11a0678e28
+  data.tar.gz: '06189169b6959b97e8a33617f2d9e054f9acf3d55bce2833b39a5f6567a061c6'
 SHA512:
-  metadata.gz: 25f3265010930a67234ab82ad2aac34915460c12fd2f85789961c93f32e459ef8af0516bac47160b390564056aad9d51f3d75dbf36103294eae72962944f3b77
-  data.tar.gz: bd0195acf137e1aba67081a1c0bef74a58cb8594cc4e2960eb899c88c5dfad84f0759761fce7aaab45a4b0ea860fc86057dbbda6c6490b03f5581f5a28219284
+  metadata.gz: b63203a04cb3a37e4c6ac265eb8283fdde5b5cb5990c4234bb57876d72c5c26e48ade13907373046dc9f4b8f943f8c6a34e8c6957bceae9ba3857ca087c9c033
+  data.tar.gz: ff59240799e6841334eaffcaa76706cd78268804f8dc263da2c57dfd2bdc480264768ba614fb4102186fa483750ff36eb7c2c0bcc87eb6836f70c0025bcd0361

data/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0, head, truffleruby]
+        exclude:
+          - os: windows-latest
+            ruby: head
+          - os: windows-latest
+            ruby: truffleruby
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Run the default task
+      run: |
+        bundle exec rake

data/CHANGELOG.md

@@ -1,6 +1,56 @@
+## 0.3.0
+
+### Breaking Changes
+
+* Modify `key` to unique by default.
+To migrate, run next.
+
+```
+rails generate circuit_switch:migration circuit_switch make_key_unique
+rails db:migrate
+```
+
+### Changes
+
+* Fix to save switch when block for `CircuitSwitch.run` raises error.
+
+## 0.2.2
+
+### New features
+
+* Add `key_column_name` to configuration for aliasing `circuit_switches.key`.
+
+### Changes
+
+* Declare dependent on ActiveSupport instead of implicitly dependent.
+
+## 0.2.1
+
+### New features
+
+* Add `initially_closed` option to `run` and `open?`.
+* Add `key` argument for easy handling for human more than caller.  
+To migrate, run next.
+
+```
+rails generate circuit_switch:migration circuit_switch add_key
+rails db:migrate
+```
+
+### Changes
+
+* Modify log level from warn to info when default value for `close_if_reach_limit` is used.
+* Suppress warning that ivar is not initialized.
+
+## 0.2.0
+
+### Breaking Changes
+
+* Modify default value of `CircuitSwitch.run` argument `close_if_reach_limit` from true to false.
+
 ## 0.1.2
 
-* Modify `CircuitSwitch.open?` recieves same arguments as `CircuitSwtich.run`
+* Modify `CircuitSwitch.open?` receives same arguments as `CircuitSwitch.run`
 
 ## 0.1.1
 

data/README.md

@@ -37,7 +37,7 @@ rails generate circuit_switch:install
 ```
 
 Generate a migration for ActiveRecord.  
-This table saves circuit caller, called count, limit count and so on.
+This table saves named key, circuit caller, called count, limit count and so on.
 
 ```
 rails generate circuit_switch:migration circuit_switch
@@ -57,14 +57,18 @@ end
 ```
 
 `run` calls received proc, and when conditions are met, closes it's circuit.  
-To switch circuit opening and closing, some conditions can be set. By default, the circuit is closed when reached the specified count. The default count is 10. To change this default value, modify `circuit_switches.run_limit_count` default value in the migration file.  
+To switch circuit opening and closing, some conditions can be set. By default, the circuit is always opened.  
+You can also set `limit_count` to close circuit when reached the specified count. Default limit_count is 10. To change this default value, modify `circuit_switches.run_limit_count` default value in the migration file.  
 `run` receives optional arguments.
 
+- `key`: [String] Named key to find switch instead of caller  
+  If no key passed, use caller.
 - `if`: [Boolean, Proc] Call proc when `if` is truthy (default: true)
 - `close_if`: [Boolean, Proc] Call proc when `close_if` is falsy (default: false)
-- `close_if_reach_limit`: [Boolean] Stop calling proc when run count reaches limit (default: true)
+- `close_if_reach_limit`: [Boolean] Stop calling proc when run count reaches limit (default: false)
 - `limit_count`: [Integer] Limit count. Use `run_limit_count` default value if it's nil (default: nil)  
   Can't be set 0 when `close_if_reach_limit` is true
+- `initially_closed`: [Boolean] Create switch with terminated mode (default: false)
 
 To close the circuit at specific date or when called 1000 times, code goes like:
 
@@ -83,7 +87,7 @@ unless circuit_open
 end
 ```
 
-`CircuitSwitch.run.run?` has syntax sugar. `open` doesn't receive proc.
+`CircuitSwitch.run.run?` has syntax sugar. `open?` doesn't receive proc.
 
 ```ruby
 if CircuitSwitch.open?
@@ -105,6 +109,8 @@ CircuitSwitch.report(if: some_condition)
 Same as `run`, some conditions can be set. By default, reporting is stopped when reached the specified count. The default count is 10. To change this default value, modify `circuit_switches.report_limit_count` default value in the migration file.  
 `report` receives optional arguments.
 
+- `key`: [String] Named key to find switch instead of caller  
+  If no key passed, use caller.
 - `if`: [Boolean, Proc] Report when `if` is truthy (default: true)
 - `stop_report_if`: [Boolean, Proc] Report when `close_if` is falsy (default: false)
 - `stop_report_if_reach_limit`: [Boolean] Stop reporting when reported count reaches limit (default: true)
@@ -128,12 +134,31 @@ called_path: /app/services/greetings_service:21 block in validate
 /app/controllers/greetings_controller.rb:93 create
 ```
 
+## Test
+
+To test, FactoryBot will look like this;
+
+```ruby
+FactoryBot.define do
+  factory :circuit_switch, class: 'CircuitSwitch::CircuitSwitch' do
+    sequence(:key) { |n| "/path/to/file:#{n}" }
+    sequence(:caller) { |n| "/path/to/file:#{n}" }
+    due_date { Date.tomorrow }
+
+    trait :initially_closed do
+      run_is_terminated { true }
+    end
+  end
+end
+```
+
 ## Task
 
-When find a problem and you want to terminate running or reporting right now, execute a task with it's caller.
+When find a problem and you want to terminate running or reporting right now, execute a task with it's caller.  
+You can specify either key or caller.
 
 ```
-rake circuit_switch:terminate_to_run[/app/services/greetings_service:21 block in validate]
+rake circuit_switch:terminate_to_run[your_key]
 rake circuit_switch:terminate_to_report[/app/services/greetings_service:21 block in validate]
 ```
 

data/Rakefile

@@ -1,2 +1,10 @@
 require "bundler/gem_tasks"
-task :default => :spec
+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/circuit_switch.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activejob'
   spec.add_dependency 'activerecord'
+  spec.add_dependency 'activesupport'
   spec.add_development_dependency 'byebug'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'test-unit'

data/lib/circuit_switch/builder.rb

@@ -0,0 +1,66 @@
+require_relative 'core'
+
+module CircuitSwitch
+  class Builder < Core
+    def initialize
+      super
+      @run = false
+      @reported = false
+    end
+
+    def assign_runner(
+      key: nil,
+      if: true,
+      close_if: false,
+      close_if_reach_limit: nil,
+      limit_count: nil,
+      initially_closed: false
+    )
+      @key = key
+      @run_if = binding.local_variable_get(:if)
+      @close_if = close_if
+      @close_if_reach_limit = close_if_reach_limit
+      @run_limit_count = limit_count
+      @initially_closed = initially_closed
+    end
+
+    def assign_reporter(
+      key: nil,
+      if: true,
+      stop_report_if: false,
+      stop_report_if_reach_limit: true,
+      limit_count: nil
+    )
+      @key = key
+      @report_if = binding.local_variable_get(:if)
+      @stop_report_if = stop_report_if
+      @stop_report_if_reach_limit = stop_report_if_reach_limit
+      @report_limit_count = limit_count
+    end
+
+    def run(key: nil, if: nil, close_if: nil, close_if_reach_limit: nil, limit_count: nil, initially_closed: nil, &block)
+      arguments = {
+        key: key,
+        if: binding.local_variable_get(:if),
+        close_if: close_if,
+        close_if_reach_limit: close_if_reach_limit,
+        limit_count: limit_count,
+        initially_closed: initially_closed,
+      }.select { |_, v| v }
+      assign_runner(**arguments)
+      execute_run(&block)
+    end
+
+    def report(key: nil, if: nil, stop_report_if: nil, stop_report_if_reach_limit: nil, limit_count: nil)
+      arguments = {
+        key: key,
+        if: binding.local_variable_get(:if),
+        stop_report_if: stop_report_if,
+        stop_report_if_reach_limit: stop_report_if_reach_limit,
+        limit_count: limit_count
+      }.select { |_, v| v }
+      assign_reporter(**arguments)
+      execute_report
+    end
+  end
+end

data/lib/circuit_switch/configuration.rb

@@ -25,6 +25,10 @@ module CircuitSwitch
       report_if.respond_to?(:call) ? report_if.call : !!report_if
     end
 
+    def key_column_name=(key)
+      ::CircuitSwitch::CircuitSwitch.alias_attribute :key, key
+    end
+
     def due_date
       @due_date ||= Date.today + 10
     end

data/lib/circuit_switch/core.rb

@@ -1,50 +1,56 @@
+require_relative 'notification'
+require_relative 'workers/reporter'
+require_relative 'workers/run_count_updater'
+
 module CircuitSwitch
   class Core
     delegate :config, to: ::CircuitSwitch
+    attr_reader :key, :run_if, :close_if, :close_if_reach_limit, :run_limit_count, :initially_closed,
+      :report_if, :stop_report_if, :stop_report_if_reach_limit, :report_limit_count
 
-    def run(
-      if: true,
-      close_if: false,
-      close_if_reach_limit: true,
-      limit_count: nil,
-      &block
-    )
-      if close_if_reach_limit && limit_count == 0
+    def execute_run(&block)
+      if close_if_reach_limit && run_limit_count == 0
         raise CircuitSwitchError.new('Can\'t set limit_count to 0 when close_if_reach_limit is true')
       end
-      return self if evaluate(close_if) || !evaluate(binding.local_variable_get(:if))
-      return self if close_if_reach_limit && switch.reached_run_limit?(limit_count)
+      if close_if_reach_limit.nil?
+        Logger.new($stdout).info('Default value for close_if_reach_limit is modified from true to false at ver 0.2.0.')
+        @close_if_reach_limit = false
+      end
+
+      return self if evaluate(close_if) || !evaluate(run_if)
+      return self if close_if_reach_limit && switch.reached_run_limit?(run_limit_count)
       return self if switch.run_is_terminated?
 
-      yield
+      unless switch.new_record? && initially_closed
+        yield
+        @run = true
+      end
+      self
+    ensure
       RunCountUpdater.perform_later(
-        limit_count: limit_count,
+        key: key,
+        limit_count: run_limit_count,
         called_path: called_path,
-        reported: reported?
+        reported: reported?,
+        initially_closed: initially_closed
       )
-      @run = true
-      self
     end
 
-    def report(
-      if: true,
-      stop_report_if: false,
-      stop_report_if_reach_limit: true,
-      limit_count: nil
-    )
+    def execute_report
       if config.reporter.nil?
         raise CircuitSwitchError.new('Set config.reporter.')
       end
-      if stop_report_if_reach_limit && limit_count == 0
+      if stop_report_if_reach_limit && report_limit_count == 0
         raise CircuitSwitchError.new('Can\'t set limit_count to 0 when stop_report_if_reach_limit is true')
       end
       return self unless config.enable_report?
-      return self if evaluate(stop_report_if) || !evaluate(binding.local_variable_get(:if))
+      return self if evaluate(stop_report_if) || !evaluate(report_if)
       return self if switch.report_is_terminated?
-      return self if stop_report_if_reach_limit && switch.reached_report_limit?(limit_count)
+      return self if stop_report_if_reach_limit && switch.reached_report_limit?(report_limit_count)
 
       Reporter.perform_later(
-        limit_count: limit_count,
+        key: key,
+        limit_count: report_limit_count,
         called_path: called_path,
         run: run?
       )
@@ -54,24 +60,30 @@ module CircuitSwitch
 
     # @return [Boolean]
     def run?
-      !!@run
+      @run
     end
 
     # @return [Boolean]
     def reported?
-      !!@reported
+      @reported
     end
 
     private
 
     def switch
-      @switch ||= CircuitSwitch.find_or_initialize_by(caller: called_path)
+      return @switch if defined? @switch
+
+      if key
+        @switch = CircuitSwitch.find_or_initialize_by(key: key)
+      else
+        @switch = CircuitSwitch.find_or_initialize_by(caller: called_path)
+      end
     end
 
     def called_path
       @called_path ||= caller
-        .reject { |path| path.match?(/(#{config.silent_paths.join('|')})/) }
-        .detect { |path| path.match?(/(#{config.report_paths.join('|')})/) }
+        .reject { |path| /(#{config.silent_paths.join('|')})/.match?(path) }
+        .detect { |path| /(#{config.report_paths.join('|')})/.match?(path) }
         &.sub(/(#{config.strip_paths.join('|')})/, '')
         &.gsub(/[`']/, '') ||
         "/somewhere/in/library:in #{Date.today}"

data/lib/circuit_switch/notification.rb

@@ -1,4 +1,4 @@
-require 'circuit_switch/stacktrace_modifier'
+require_relative 'stacktrace_modifier'
 
 module CircuitSwitch
   class CircuitSwitchError < RuntimeError

data/lib/circuit_switch/orm/active_record/circuit_switch.rb

@@ -1,5 +1,13 @@
+require 'active_record'
+
 module CircuitSwitch
   class CircuitSwitch < ::ActiveRecord::Base
+    validates :key, uniqueness: true
+
+    after_initialize do |switch|
+      switch.key ||= switch.caller
+    end
+
     def assign(run_limit_count: nil, report_limit_count: nil)
       self.run_limit_count = run_limit_count if run_limit_count
       self.report_limit_count = report_limit_count if report_limit_count
@@ -22,16 +30,17 @@ module CircuitSwitch
       end
     end
 
-    def increment_run_count
+    def increment_run_count!
       with_writable { update!(run_count: run_count + 1) }
     end
 
-    def increment_report_count
+    def increment_report_count!
       with_writable { update!(report_count: report_count + 1) }
     end
 
     def message
-      "Watching process is called for #{report_count}th. Report until for #{report_limit_count}th."
+      process = key == caller ? 'Watching process' : "Process for '#{key}'"
+      "#{process} is called for #{report_count}th. Report until for #{report_limit_count}th."
     end
 
     private

data/lib/circuit_switch/stacktrace_modifier.rb

@@ -1,4 +1,4 @@
-require 'circuit_switch/configuration.rb'
+require 'active_support/core_ext/module/delegation'
 
 module CircuitSwitch
   class StacktraceModifier
@@ -7,7 +7,7 @@ module CircuitSwitch
 
       def call(backtrace:)
         backtrace
-          .select { |path| path.match?(/(#{config.allowed_backtrace_paths.join('|')})/) }
+          .select { |path| /(#{config.allowed_backtrace_paths.join('|')})/.match?(path) }
           .map { |path| path.sub(/(#{config.strip_paths.join('|')})/, '') }
           .join("\n")
       end

data/lib/circuit_switch/tasks/circuit_switch.rake

@@ -1,40 +1,40 @@
 namespace :circuit_switch do
   desc 'Update run_is_terminated to true to close circuit'
-  task :terminate_to_run, ['caller'] => :environment do |_, arg|
-    called_path = arg[:caller]
-    puts "Start to update run_is_terminated of circuit_switch for '#{called_path}' to true."
+  task :terminate_to_run, ['key_or_caller'] => :environment do |_, arg|
+    key_or_caller = arg[:key_or_caller]
+    puts "Start to update run_is_terminated of circuit_switch for '#{key_or_caller}' to true."
     sleep(3)
 
-    switch = CircuitSwitch::CircuitSwitch.find_by!(caller: called_path)
+    switch = CircuitSwitch::CircuitSwitch.find_by(key: key_or_caller) || CircuitSwitch::CircuitSwitch.find_by!(caller: key_or_caller)
     puts "circuit_switch is found. id: #{switch.id}."
 
     switch.update(run_is_terminated: true)
-    puts "Updated run_is_terminated of circuit_switch for '#{called_path}' to true."
+    puts "Updated run_is_terminated of circuit_switch for '#{key_or_caller}' to true."
   end
 
   desc 'Update report_is_terminated to true to stop reporting'
-  task :terminate_to_report, ['caller'] => :environment do |_, arg|
-    called_path = arg[:caller]
-    puts "Start to update report_is_terminated of circuit_switch for '#{called_path}' to true."
+  task :terminate_to_report, ['key_or_caller'] => :environment do |_, arg|
+    key_or_caller = arg[:key_or_caller]
+    puts "Start to update report_is_terminated of circuit_switch for '#{key_or_caller}' to true."
     sleep(3)
 
-    switch = CircuitSwitch::CircuitSwitch.find_by!(caller: called_path)
+    switch = CircuitSwitch::CircuitSwitch.find_by(key: key_or_caller) || CircuitSwitch::CircuitSwitch.find_by!(caller: key_or_caller)
     puts "circuit_switch is found. id: #{switch.id}."
 
     switch.update(report_is_terminated: true)
-    puts "Updated report_is_terminated of circuit_switch for '#{called_path}' to true."
+    puts "Updated report_is_terminated of circuit_switch for '#{key_or_caller}' to true."
   end
 
   desc 'Delete switch'
-  task :delete_switch, ['caller'] => :environment do |_, arg|
-    called_path = arg[:caller]
-    puts "Start to delete circuit_switch for '#{called_path}'."
+  task :delete_switch, ['key_or_caller'] => :environment do |_, arg|
+    key_or_caller = arg[:key_or_caller]
+    puts "Start to delete circuit_switch for '#{key_or_caller}'."
     sleep(3)
 
-    switch = CircuitSwitch::CircuitSwitch.find_by!(caller: called_path)
+    switch = CircuitSwitch::CircuitSwitch.find_by(key: key_or_caller) || CircuitSwitch::CircuitSwitch.find_by!(caller: key_or_caller)
     puts "circuit_switch is found. id: #{switch.id}."
 
     switch.destroy!
-    puts "Successfully deleted circuit_switch for '#{called_path}'."
+    puts "Successfully deleted circuit_switch for '#{key_or_caller}'."
   end
 end

data/lib/circuit_switch/version.rb

@@ -1,3 +1,3 @@
 module CircuitSwitch
-  VERSION = '0.1.2'
+  VERSION = '0.3.0'
 end

data/lib/circuit_switch/workers/due_date_notifier.rb

@@ -10,7 +10,7 @@ module CircuitSwitch
       circuit_switches = CircuitSwitch.where('due_date <= ?', Date.today).order(id: :asc)
       if circuit_switches.present?
         message = "Due date has come! Let's consider about removing switches and cleaning up code! :)\n" +
-          circuit_switches.map { |switch|  "id: #{switch.id}, caller: '#{switch.caller}' , created_at: #{switch.created_at}" }.join("\n")
+          circuit_switches.map { |switch|  "id: #{switch.id}, key: '#{switch.key}', caller: '#{switch.caller}', created_at: #{switch.created_at}" }.join("\n")
         config.due_date_notifier.call(message)
       else
         switches_count = CircuitSwitch.all.size

data/lib/circuit_switch/workers/reporter.rb

@@ -1,21 +1,34 @@
+require 'active_job'
+require 'active_support/core_ext/module/delegation'
+
 module CircuitSwitch
   class Reporter < ::ActiveJob::Base
     delegate :config, to: ::CircuitSwitch
 
-    def perform(limit_count:, called_path:, run:)
-      circuit_switch =
-      if run
-        # Wait for RunCountUpdater saves circuit_switch
-        sleep(3)
-        CircuitSwitch.find_by!(caller: called_path)
-      else
-        CircuitSwitch.find_or_initialize_by(caller: called_path)
+    def perform(key:, limit_count:, called_path:, run:)
+      # Wait for RunCountUpdater saves circuit_switch
+      sleep(3) if run
+
+      first_raise = true
+      begin
+        circuit_switch = key ? CircuitSwitch.find_by(key: key) : CircuitSwitch.find_by(caller: called_path)
+        if run && circuit_switch.nil?
+          raise ActiveRecord::RecordNotFound.new('Couldn\'t find CircuitSwitch::CircuitSwitch')
+        end
+
+        circuit_switch ||= CircuitSwitch.new(key: key, caller: called_path)
+        circuit_switch.due_date ||= config.due_date
+        circuit_switch.assign(report_limit_count: limit_count).increment_report_count!
+        raise CalledNotification.new(circuit_switch.message)
+      rescue ActiveRecord::RecordInvalid => e
+        raise e unless first_raise
+
+        first_raise = false
+        sleep(2)
+        retry
+      rescue CalledNotification => notification
+        config.reporter.call(notification.to_message(called_path: called_path))
       end
-      circuit_switch.due_date ||= config.due_date
-      circuit_switch.assign(report_limit_count: limit_count).increment_report_count
-      raise CalledNotification.new(circuit_switch.message)
-    rescue CalledNotification => notification
-      config.reporter.call(notification.to_message(called_path: called_path))
     end
   end
 end

data/lib/circuit_switch/workers/run_count_updater.rb

@@ -1,18 +1,31 @@
+require 'active_job'
+require 'active_support/core_ext/module/delegation'
+
 module CircuitSwitch
   class RunCountUpdater < ::ActiveJob::Base
     delegate :config, to: ::CircuitSwitch
 
-    def perform(limit_count:, called_path:, reported:)
-      circuit_switch =
-        if reported
-          # Wait for Reporter saves circuit_switch
-          sleep(3)
-          CircuitSwitch.find_by!(caller: called_path)
-        else
-          CircuitSwitch.find_or_initialize_by(caller: called_path)
+    def perform(key:, limit_count:, called_path:, reported:, initially_closed:)
+      # Wait for Reporter saves circuit_switch
+      sleep(3) if reported
+
+      first_raise = true
+      begin
+        circuit_switch = key ? CircuitSwitch.find_by(key: key) : CircuitSwitch.find_by(caller: called_path)
+        if reported && circuit_switch.nil?
+          raise ActiveRecord::RecordNotFound.new('Couldn\'t find CircuitSwitch::CircuitSwitch')
         end
-      circuit_switch.due_date ||= config.due_date
-      circuit_switch.assign(run_limit_count: limit_count).increment_run_count
+
+        circuit_switch ||= CircuitSwitch.new(key: key, caller: called_path, run_is_terminated: initially_closed)
+        circuit_switch.due_date ||= config.due_date
+        circuit_switch.assign(run_limit_count: limit_count).increment_run_count!
+      rescue ActiveRecord::RecordInvalid => e
+        raise e unless first_raise
+
+        first_raise = false
+        sleep(2)
+        retry
+      end
     end
   end
 end

data/lib/circuit_switch.rb

@@ -1,12 +1,9 @@
-require "circuit_switch/configuration.rb"
-require "circuit_switch/core"
-require "circuit_switch/notification"
-require "circuit_switch/orm/active_record/circuit_switch"
-require "circuit_switch/railtie" if defined?(Rails::Railtie)
-require "circuit_switch/version"
-require "circuit_switch/workers/due_date_notifier"
-require "circuit_switch/workers/reporter"
-require "circuit_switch/workers/run_count_updater"
+require_relative 'circuit_switch/configuration'
+require_relative 'circuit_switch/builder'
+require_relative 'circuit_switch/orm/active_record/circuit_switch'
+require_relative 'circuit_switch/railtie' if defined?(Rails::Railtie)
+require_relative 'circuit_switch/version'
+require_relative 'circuit_switch/workers/due_date_notifier'
 
 module CircuitSwitch
   class << self
@@ -18,73 +15,69 @@ module CircuitSwitch
       @config ||= Configuration.new
     end
 
+    # @param key [String] Named key to find switch instead of caller
     # @param if [Boolean, Proc] Call proc when `if` is truthy (default: true)
     # @param close_if [Boolean, Proc] Call proc when `close_if` is falsy (default: false)
-    # @param close_if_reach_limit [Boolean] Stop calling proc when run count reaches limit (default: true)
+    # @param close_if_reach_limit [Boolean] Stop calling proc when run count reaches limit (default: false)
     # @param limit_count [Integer] Limit count. Use `run_limit_count` default value if it's nil
     #   Can't be set 0 when `close_if_reach_limit` is true (default: nil)
+    # @param initially_closed [Boolean] Create switch with terminated mode (default: false)
     # @param [Proc] block
-    def run(
-      if: true,
-      close_if: false,
-      close_if_reach_limit: true,
-      limit_count: nil,
-      &block
-    )
-      Core.new.run(
+    def run(key: nil, if: nil, close_if: nil, close_if_reach_limit: nil, limit_count: nil, initially_closed: nil, &block)
+      arguments = {
+        key: key,
         if: binding.local_variable_get(:if),
         close_if: close_if,
         close_if_reach_limit: close_if_reach_limit,
         limit_count: limit_count,
-        &block
-      )
+        initially_closed: initially_closed,
+      }.select { |_, v| v }
+      Builder.new.run(**arguments, &block)
     end
 
+    # @param key [String] Named key to find switch instead of caller
     # @param if [Boolean, Proc] Report when `if` is truthy (default: true)
     # @param stop_report_if [Boolean, Proc] Report when `close_if` is falsy (default: false)
     # @param stop_report_if_reach_limit [Boolean] Stop reporting when reported count reaches limit (default: true)
     # @param limit_count [Integer] Limit count. Use `report_limit_count` default value if it's nil
     #   Can't be set 0 when `stop_report_if_reach_limit` is true (default: nil)
-    def report(
-      if: true,
-      stop_report_if: false,
-      stop_report_if_reach_limit: true,
-      limit_count: nil
-    )
+    def report(key: nil, if: nil, stop_report_if: nil, stop_report_if_reach_limit: nil, limit_count: nil)
       if block_given?
         raise ArgumentError.new('CircuitSwitch.report doesn\'t receive block. Use CircuitSwitch.run if you want to pass block.')
       end
 
-      Core.new.report(
+      arguments = {
+        key: key,
         if: binding.local_variable_get(:if),
         stop_report_if: stop_report_if,
         stop_report_if_reach_limit: stop_report_if_reach_limit,
         limit_count: limit_count
-      )
+      }.select { |_, v| v }
+      Builder.new.report(**arguments)
     end
 
     # Syntax sugar for `CircuitSwitch.run`
+    # @param key [String] Named key to find switch instead of caller
     # @param if [Boolean, Proc] `CircuitSwitch.run` is runnable when `if` is truthy (default: true)
     # @param close_if [Boolean, Proc] `CircuitSwitch.run` is runnable when `close_if` is falsy (default: false)
     # @param close_if_reach_limit [Boolean] `CircuitSwitch.run` is NOT runnable when run count reaches limit (default: true)
     # @param limit_count [Integer] Limit count. Use `run_limit_count` default value if it's nil. Can't be set 0 (default: nil)
+    # @param initially_closed [Boolean] Create switch with terminated mode (default: false)
     # @return [Boolean]
-    def open?(
-      if: true,
-      close_if: false,
-      close_if_reach_limit: true,
-      limit_count: nil
-    )
+    def open?(key: nil, if: nil, close_if: nil, close_if_reach_limit: nil, limit_count: nil, initially_closed: nil)
       if block_given?
         raise ArgumentError.new('CircuitSwitch.open doesn\'t receive block. Use CircuitSwitch.run if you want to pass block.')
       end
 
-      Core.new.run(
+      arguments = {
+        key: key,
         if: binding.local_variable_get(:if),
         close_if: close_if,
         close_if_reach_limit: close_if_reach_limit,
-        limit_count: limit_count
-      ) {}.run?
+        limit_count: limit_count,
+        initially_closed: initially_closed,
+      }.select { |_, v| v }
+      Builder.new.run(**arguments) {}.run?
     end
   end
 end

data/lib/generators/circuit_switch/migration_generator.rb

@@ -4,9 +4,19 @@ module CircuitSwitch
   class MigrationGenerator < ActiveRecord::Generators::Base
     desc 'Create a migration to manage circuit switches state'
     source_root File.expand_path('templates', __dir__)
+    argument :migration_type, required: false, type: :array, default: ['create'],
+      desc: 'Type of migration to create or add key column or make key unique. By default to create.',
+      banner: 'create or add_key'
 
     def generate_migration
-      migration_template 'migration.rb.erb', 'db/migrate/create_circuit_switches.rb', migration_version: migration_version
+      case migration_type
+      when ['add_key']
+        migration_template 'add_key.rb.erb', 'db/migrate/add_key_to_circuit_switches.rb', migration_version: migration_version
+      when ['make_key_unique']
+        migration_template 'make_key_unique.rb.erb', 'db/migrate/make_key_unique_for_circuit_switches.rb', migration_version: migration_version
+      else
+        migration_template 'migration.rb.erb', 'db/migrate/create_circuit_switches.rb', migration_version: migration_version
+      end
     end
 
     def migration_version

data/lib/generators/circuit_switch/templates/add_key.rb.erb

@@ -0,0 +1,13 @@
+class AddKeyToCircuitSwitches < ActiveRecord::Migration<%= migration_version %>
+  def up
+    add_column :circuit_switches, :key, :string, after: :id
+    CircuitSwitch::CircuitSwitch.all.each { |switch| switch.update_column(:key, switch.caller) }
+    change_column_null :circuit_switches, :key, false
+    add_index :circuit_switches, :key
+  end
+
+  def down
+    remove_index :circuit_switches, :key
+    remove_column :circuit_switches, :key
+  end
+end

data/lib/generators/circuit_switch/templates/initializer.rb

@@ -16,6 +16,9 @@ CircuitSwitch.configure do |config|
   # Excluded paths to report
   # config.silent_paths =  [CIRCUIT_SWITCH]
 
+  # Alias column name for circuit_switches.key through alias_attribute
+  # config.key_column_name = :key
+
   # Notifier to notify circuit_switch's due_date come and it's time to clean code!
   # Specify proc to call your report tool: like;
   # config.due_date_notifier = -> (message) { Slack::Web::Client.new.chat_postMessage(channel: '#your_channel', text: message) }
@@ -26,10 +29,10 @@ CircuitSwitch.configure do |config|
 
   # Option to contain error backtrace for report
   # You don't need backtrace when you report to some bug report tool.
-  # You may be want backtrace when report to plain feed; e.g. Slack or email.
+  # You may want backtrace when reporting to a plain feed; e.g. Slack or email.
   # config.with_backtrace = false
 
-  # Allowd backtrace paths to report
+  # Allowed backtrace paths to report
   # Specify with `with_backtrace` option.
   # Allowed all paths when set `[]`.
   # config.allowed_backtrace_paths = [Dir.pwd]

data/lib/generators/circuit_switch/templates/make_key_unique.rb.erb

@@ -0,0 +1,11 @@
+class MakeKeyUniqueForCircuitSwitches < ActiveRecord::Migration<%= migration_version %>
+  def up
+    remove_index :circuit_switches, :key
+    add_index :circuit_switches, :key, unique: true
+  end
+
+  def down
+    remove_index :circuit_switches, :key
+    add_index :circuit_switches, :key
+  end
+end

data/lib/generators/circuit_switch/templates/migration.rb.erb

@@ -1,6 +1,7 @@
 class CreateCircuitSwitches < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :circuit_switches do |t|
+      t.string :key, null: false
       t.string :caller, null: false
       t.integer :run_count, default: 0, null: false
       t.integer :run_limit_count, default: 10, null: false
@@ -11,5 +12,7 @@ class CreateCircuitSwitches < ActiveRecord::Migration<%= migration_version %>
       t.date :due_date, null: false
       t.timestamps
     end
+
+    add_index :circuit_switches, [:key], unique: true
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuit_switch
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - makicamel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-10 00:00:00.000000000 Z
+date: 2021-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -102,6 +116,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/main.yml"
 - ".gitignore"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -113,6 +128,7 @@ files:
 - bin/setup
 - circuit_switch.gemspec
 - lib/circuit_switch.rb
+- lib/circuit_switch/builder.rb
 - lib/circuit_switch/configuration.rb
 - lib/circuit_switch/core.rb
 - lib/circuit_switch/notification.rb
@@ -127,7 +143,9 @@ files:
 - lib/circuit_switch/workers/run_count_updater.rb
 - lib/generators/circuit_switch/install_generator.rb
 - lib/generators/circuit_switch/migration_generator.rb
+- lib/generators/circuit_switch/templates/add_key.rb.erb
 - lib/generators/circuit_switch/templates/initializer.rb
+- lib/generators/circuit_switch/templates/make_key_unique.rb.erb
 - lib/generators/circuit_switch/templates/migration.rb.erb
 homepage: https://github.com/makicamel/circuit_switch
 licenses: