affairs_of_state 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2757335e832c9809fa86e7c365dda4d6fe31b49ab837665ecbd80ec2f3b27ac2
-  data.tar.gz: 18c9e1b16df324170b4af93859379540e56aafa27068490a743bd155b3a9c83a
+  metadata.gz: 73f6fed4bcc0422024de20521810e21f4d9a77411382af6d6b8f52c79f941ca7
+  data.tar.gz: b128a4dcea99c0c3e192792ffea7a6a6b670f58994c26bd2c8d808360fd620bf
 SHA512:
-  metadata.gz: 6e9b37707ae931a4a9231b4b453b075db2d0c1e16c4bddf1696f20adcf26bd5b23744e6f185602d50e036465d1cf060dd2b4951857d252d387a5c140b4a18029
-  data.tar.gz: 03c8db3940a2c167922048afecfa75d1ad4f28fcb386e16fc57bbbe6101c2f8416fece5ba12bba7af21407746149ec0252d46a7ce407b618b7db9af1f535ad7b
+  metadata.gz: 8fe6d2bf961248735b23fa41afaa2ebe8712a9ea55896537c6dd66efcabe1426491635e8fa3be707bbb068756a7fc3f726893cb6cefc36a61b36f6785a1c3f45
+  data.tar.gz: b5df8b2a439fead18dc1e79340141137b307ecb1024d7e82884f17312f9231f3e26d680e5bd31309da2447e183ee27b8a7d5ae1470e89929172c5422dd806eeb

data/README.md

@@ -60,7 +60,7 @@ or
 affairs_of_state :active, :inactive, if: :only_validate_if_this_method_returns_true
 ```
 
-Currently it is limited only be called once per model.
+It can be called multiple times per model, provided as each time is with a different column, and that none of the statuses overlap. If either of these are not true it will raise on load.
 
 
 ## Methods
@@ -72,10 +72,11 @@ widget = Widget.first
 widget.cancelled! if widget.active?
 ```
 
-You can also access all your statuses on the model like so:
+You can also access all your statuses on the model. If only one is defined it is default, otherwise the column name needs to be passed in:
 
 ```ruby
-Widget::STATUSES  # -> ["active", "cancelled"]
+Widget.statuses  # -> ["active", "cancelled"]
+Widget.statuses(:status)  # -> ["active", "cancelled"]
 ```
 
 It also provides scopes automagically:
@@ -85,10 +86,11 @@ Widget.active
 Widget.cancelled
 ```
 
-For select inputs in forms there is a convenience method that returns all states in the format expected by `options_for_select`
+For select inputs in forms there is a convenience method that returns all states in the format expected by `options_for_select`. Again if only one is defined on the model it returns as default, if multiple are defined the column name needs to be passed in:
 
 ```ruby
 <%= f.select :status, options_for_select(Widget.statuses_for_select) %>
+<%= f.select :status, options_for_select(Widget.statuses_for_select(:status)) %>
 ```
 
 

data/affairs_of_state.gemspec

@@ -16,12 +16,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = AffairsOfState::VERSION
 
-  gem.add_dependency "activerecord", ">= 6.0"
-  gem.add_dependency "activesupport", ">= 6.0"
+  gem.add_dependency "activerecord", "~> 6.0"
+  gem.add_dependency "activesupport", "~> 6.0"
 
-  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec", "~> 3.0"
   gem.add_development_dependency "sqlite3", "~> 1.4.0"
-  gem.add_development_dependency "pry"
-  gem.add_development_dependency "rake"
+  gem.add_development_dependency "pry", "~> 0.12.0"
+  gem.add_development_dependency "rake", "~> 12"
 
 end

data/lib/affairs_of_state/active_record_extension.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+module AffairsOfState
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def affairs_of_state(*statuses, column: :status, allow_blank: false, scopes: true, if: nil)
+        # config object that defines behaviour
+        config = AffairsOfState::Config.new(
+          statuses: statuses,
+          column: column,
+          allow_blank: !!allow_blank,
+          scopes: scopes,
+          if: binding.local_variable_get(:if)
+        )
+
+        # check for conflicts with existing calls
+        raise ArgumentError, "Affairs of State: #{ self } has already been called on `#{ config.column }`" if affairs_of_state_configs[config.column]
+        overlapping_statuses = affairs_of_state_configs.values.map(&:statuses) & config.statuses
+        raise ArgumentError, "Affairs of State: #{ self } already has a status #{ overlapping_statuses }" if overlapping_statuses.any?
+
+        # status methods
+        config.statuses.each do |status|
+          define_method("#{ status }?") do
+            self.send(config.column) == status
+          end
+
+          define_method("#{ status }!") do
+            self.send("#{ config.column }=", status)
+            self.save
+          end
+        end
+
+        # column validation
+        validates(config.column, inclusion: { in: config.statuses, allow_blank: config.allow_blank }, if: config.if)
+
+        # scopes
+        if config.scopes
+          config.statuses.each do |status|
+            self.scope(status.to_sym, -> { where(config.column => status) })
+          end
+        end
+
+        # cache the config on the object
+        affairs_of_state_configs[config.column] = config
+
+        include InstanceMethods
+        extend SingletonMethods
+
+        true
+      end
+
+      def affairs_of_state_configs
+        @affairs_of_state_configs ||= {}
+      end
+    end
+
+    module InstanceMethods
+    end
+
+    module SingletonMethods
+      def statuses_for_select(column=nil)
+        statuses(column).map{ |s| [s.humanize, s] }
+      end
+
+      def statuses(column=nil)
+        if !column && affairs_of_state_configs.length == 1
+          affairs_of_state_configs.values.first.statuses
+        elsif !column && affairs_of_state_configs.length > 1
+          raise ArgumentError, "column is required"
+        elsif column
+          affairs_of_state_configs[column.to_sym]&.statuses
+        end
+      end
+    end
+  end
+end

data/lib/affairs_of_state/config.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
 module AffairsOfState
   class Config
-    attr_accessor :column, :allow_blank, :scopes, :if
-    attr_reader :statuses
+    attr_reader :statuses, :column, :allow_blank, :scopes, :if
 
-    def statuses=(val)
-      @statuses = val.flatten.map(&:to_s)
+    DISALLOWED_STATUSES = [ "new" ].freeze
 
+    def initialize(statuses:, column:, allow_blank:, scopes:, if:)
+      @column = column
+      @allow_blank = !!allow_blank
+      @scopes = !!scopes
+      @if = binding.local_variable_get(:if)
+      @statuses = statuses.flatten.map(&:to_s)
       @statuses.each do |status|
-        raise ArgumentError.new("Affairs of State: '#{ status }' is not a valid status") if ["new"].include?(status)
+        raise ArgumentError.new("Affairs of State: '#{ status }' is not a valid status") if DISALLOWED_STATUSES.include?(status)
       end
-
-      @statuses
     end
   end
 end

data/lib/affairs_of_state/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module AffairsOfState
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/affairs_of_state.rb

@@ -1,65 +1,12 @@
+# frozen_string_literal: true
 require "active_support"
 require "active_support/concern"
 require "active_record"
 
 require "affairs_of_state/version"
 require "affairs_of_state/config"
-
-module AffairsOfState
-  extend ActiveSupport::Concern
-
-  class_methods do
-    def affairs_of_state(*statuses, column: :status, allow_blank: false, scopes: true, if: nil)
-      raise ArgumentError.new("Affairs of State: cannot be invoked multiple times on the same model") if @affairs_of_state_config
-
-      affairs_of_state_config.statuses = statuses
-      affairs_of_state_config.column = column
-      affairs_of_state_config.allow_blank = allow_blank
-      affairs_of_state_config.scopes = scopes
-      affairs_of_state_config.if = binding.local_variable_get(:if)
-
-      const_set(:STATUSES, affairs_of_state_config.statuses)
-
-      affairs_of_state_config.statuses.each do |status|
-        define_method("#{ status }?") do
-          self.send(self.class.affairs_of_state_config.column) == status
-        end
-
-        define_method("#{ status }!") do
-          self.send("#{ self.class.affairs_of_state_config.column }=", status)
-          self.save
-        end
-      end
-
-      validates(affairs_of_state_config.column, inclusion: { in: affairs_of_state_config.statuses, allow_blank: affairs_of_state_config.allow_blank }, if: affairs_of_state_config.if)
-
-      if affairs_of_state_config.scopes
-        affairs_of_state_config.statuses.each do |status|
-          self.scope(status.to_sym, -> { where(affairs_of_state_config.column => status) })
-        end
-      end
-
-      include InstanceMethods
-      extend SingletonMethods
-
-      true
-    end
-
-    def affairs_of_state_config
-      @affairs_of_state_config ||= AffairsOfState::Config.new
-    end
-  end
-
-  module InstanceMethods
-  end
-
-  module SingletonMethods
-    def statuses_for_select
-      affairs_of_state_config.statuses.map{ |s| [s.humanize, s] }
-    end
-  end
-end
+require "affairs_of_state/active_record_extension"
 
 ActiveSupport.on_load(:active_record) do
-  ::ActiveRecord::Base.send :include, AffairsOfState
+  ::ActiveRecord::Base.send :include, AffairsOfState::ActiveRecordExtension
 end

data/spec/affairs_of_state_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe AffairsOfState do
@@ -6,57 +7,63 @@ describe AffairsOfState do
       affairs_of_state :active, :inactive, :cancelled
     end
 
-    it "should set the constant" do
-      expect(Pie::STATUSES).to eq(["active", "inactive", "cancelled"])
-    end
+    subject { Pie }
 
     it "should validate the column is set" do
-      expect(Pie.new(status: nil)).to_not be_valid
+      expect(subject.new(status: nil)).to_not be_valid
     end
 
     it "should validate that we're not setting it to something stupid" do
-      expect(Pie.new(status: "delicious_pie")).to_not be_valid
+      expect(subject.new(status: "delicious_pie")).to_not be_valid
     end
 
     describe "boolean methods" do
       it "should find the set status" do
-        p = Pie.new status: "active"
+        p = subject.new status: "active"
         expect(p.active?).to be_truthy
       end
 
       it "should not find if a different status is set" do
-        p = Pie.new status: "inactive"
+        p = subject.new status: "inactive"
         expect(p.cancelled?).to be_falsy
       end
     end
 
     describe "update methods" do
       it "should set the value" do
-        p = Pie.create! status: "active"
+        p = subject.create! status: "active"
         expect(p.inactive!).to be_truthy
         expect(p.status).to eq("inactive")
       end
     end
 
+    it "should have the statuses method with the nil default" do
+      expect(subject.statuses).to eq(["active", "inactive", "cancelled"])
+    end
+
+    it "should have the statuses method" do
+      expect(subject.statuses(:status)).to eq(["active", "inactive", "cancelled"])
+    end
+
     it "should provide a method to pass to dropdowns" do
-      expect(Pie.statuses_for_select).to eq([["Active", "active"], ["Inactive", "inactive"], ["Cancelled", "cancelled"]])
+      expect(subject.statuses_for_select).to eq([["Active", "active"], ["Inactive", "inactive"], ["Cancelled", "cancelled"]])
     end
 
     describe "scopes" do
       it "should have a finder to match the status name" do
-        Pie.create! status: "active"
-        Pie.create! status: "inactive"
-        Pie.create! status: "active"
-        Pie.create! status: "cancelled"
-
-        expect(Pie.active.size).to eq(2)
-        expect(Pie.inactive.size).to eq(1)
-        expect(Pie.cancelled.size).to eq(1)
+        subject.create! status: "active"
+        subject.create! status: "inactive"
+        subject.create! status: "active"
+        subject.create! status: "cancelled"
+
+        expect(subject.active.size).to eq(2)
+        expect(subject.inactive.size).to eq(1)
+        expect(subject.cancelled.size).to eq(1)
       end
     end
 
     after(:each) do
-      Pie.destroy_all
+      subject.destroy_all
     end
   end
 
@@ -67,16 +74,18 @@ describe AffairsOfState do
       affairs_of_state :active, :inactive, column: :super_status
     end
 
+    subject { Pie2 }
+
     it "should validate the column is set" do
-      expect(Pie2.new(status: nil, super_status: "active")).to be_valid
+      expect(subject.new(status: nil, super_status: "active")).to be_valid
     end
 
     it "should know the accessors" do
-      expect(Pie2.new(status: nil, super_status: "inactive").inactive?).to be(true)
+      expect(subject.new(status: nil, super_status: "inactive").inactive?).to be(true)
     end
 
     it "should know the setters" do
-      instance = Pie2.create!(status: nil, super_status: "inactive")
+      instance = subject.create!(status: nil, super_status: "inactive")
       expect(instance.active!).to be(true)
       expect(instance.super_status).to eq("active")
     end
@@ -89,8 +98,10 @@ describe AffairsOfState do
       affairs_of_state :active, :inactive, allow_blank: true
     end
 
+    subject { Pie3 }
+
     it "should validate the column is set" do
-      expect(Pie3.new(status: nil)).to be_valid
+      expect(subject.new(status: nil)).to be_valid
     end
   end
 
@@ -101,8 +112,10 @@ describe AffairsOfState do
       affairs_of_state [:on, :off]
     end
 
+    subject { Pie4 }
+
     it "should work too if that's what floats your boat" do
-      expect(Pie4::STATUSES).to eq(["on", "off"])
+      expect(subject.statuses).to eq(["on", "off"])
     end
   end
 
@@ -113,8 +126,10 @@ describe AffairsOfState do
       affairs_of_state :active, :inactive, scopes: false
     end
 
-    it "should work too if that's what floats your boat" do
-      expect(Pie5).to_not respond_to(:active)
+    subject { Pie5 }
+
+    it "should not respond if the scopes are not needed" do
+      expect(subject).to_not respond_to(:active)
     end
   end
 
@@ -127,15 +142,17 @@ describe AffairsOfState do
       attr_accessor :is_going_to_validate
     end
 
+    subject { Pie6 }
+
     it "should enforce the validation if the :if param is true" do
-      p = Pie6.new
+      p = subject.new
       p.is_going_to_validate = true
       p.status = "pie"
       expect(p).to_not be_valid
     end
 
     it "should not enforce the validation if the :if param evaluates to false" do
-      p = Pie6.new
+      p = subject.new
       p.is_going_to_validate = false
       p.status = "pie"
       expect(p).to be_valid
@@ -155,15 +172,17 @@ describe AffairsOfState do
       end
     end
 
+    subject { Pie7 }
+
     it "should enforce the validation if the :if param is true" do
-      p = Pie7.new
+      p = subject.new
       p.is_going_to_validate = true
       p.status = "pie"
       expect(p).to_not be_valid
     end
 
     it "should not enforce the validation if the :if param evaluates to false" do
-      p = Pie7.new
+      p = subject.new
       p.is_going_to_validate = false
       p.status = "pie"
       expect(p).to be_valid
@@ -177,13 +196,65 @@ describe AffairsOfState do
   end
 
   describe "multiple invocations" do
-    it "raises an error" do
-      expect(->{
-        class Pie9 < ActiveRecord::Base
-          affairs_of_state :not_important
-          affairs_of_state :something
+    class Pie9 < ActiveRecord::Base
+      self.table_name = "pies"
+
+      affairs_of_state :active, :inactive
+      affairs_of_state :moderated, :unmoderated, column: :super_status
+    end
+
+    subject { Pie9 }
+
+    it "declares two status columns" do
+      p = subject.new
+      p.inactive!
+      p.unmoderated!
+      expect(p).to be_inactive
+      expect(p).to be_unmoderated
+    end
+
+    it "raises if called twice on the same column" do
+      expect {
+        class Pie < ActiveRecord::Base
+          self.table_name = "pies"
+
+          affairs_of_state :active, :inactive
+          affairs_of_state :moderated, :unmoderated
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises if called twice with the same status in both" do
+      expect {
+        class Pie < ActiveRecord::Base
+          self.table_name = "pies"
+
+          affairs_of_state :active, :inactive
+          affairs_of_state :dormant, :active, column: :super_status
         end
-      }).to raise_error(ArgumentError, "Affairs of State: cannot be invoked multiple times on the same model")
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises if statuses is called with no argument" do
+      expect {
+        subject.statuses
+      }.to raise_error(ArgumentError)
+    end
+
+    it "returns the statuses for the column" do
+      expect(subject.statuses(:status)).to eq(["active", "inactive"])
+      expect(subject.statuses("super_status")).to eq(["moderated", "unmoderated"])
+    end
+
+    it "raises if statuses_for_select is called with no argument" do
+      expect {
+        subject.statuses_for_select
+      }.to raise_error(ArgumentError)
+    end
+
+    it "returns the statuses_for_select for the column" do
+      expect(subject.statuses_for_select(:status)).to eq([["Active", "active"], ["Inactive", "inactive"]])
+      expect(subject.statuses_for_select("super_status")).to eq([["Moderated", "moderated"], ["Unmoderated", "unmoderated"]])
     end
   end
 end

data/spec/config_spec.rb

@@ -1,47 +1,51 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe AffairsOfState::Config do
-  subject{ AffairsOfState::Config.new }
+  let(:config) do
+    AffairsOfState::Config.new(
+      statuses: statuses,
+      column: column,
+      allow_blank: allow_blank,
+      scopes: scopes,
+      if: if_condition
+    )
+  end
+  let(:column) { "state" }
+  let(:statuses) { [ :created, [ :destroyed ] ] }
+  let(:allow_blank) { "sure" }
+  let(:scopes) { nil }
+  let(:if_condition) { "false" }
 
-  describe "accessors" do
-    let(:expected){ double }
+  subject { config }
 
+  describe "accessors" do
     it "has :column" do
-      subject.column = expected
-      expect(subject.column).to eq(expected)
+      expect(subject.column).to eq(column)
     end
 
     it "has :allow_blank" do
-      subject.allow_blank = expected
-      expect(subject.allow_blank).to eq(expected)
+      expect(subject.allow_blank).to be(true)
     end
 
     it "has :scopes" do
-      subject.scopes = expected
-      expect(subject.scopes).to eq(expected)
+      expect(subject.scopes).to be(false)
     end
 
     it "has :if" do
-      subject.if = expected
-      expect(subject.if).to eq(expected)
+      expect(subject.if).to eq(if_condition)
     end
-  end
 
-  describe "#statuses=" do
-    it "converts to string" do
-      subject.statuses = [:a, :b]
-      expect(subject.statuses).to eq(["a", "b"])
+    it "has :statuses and converts to strings and flattens" do
+      expect(subject.statuses).to eq(["created", "destroyed"])
     end
+  end
 
-    it "flattens" do
-      subject.statuses = ["a", [:b]]
-      expect(subject.statuses).to eq(["a", "b"])
-    end
+  context "with invalid status" do
+    let(:statuses) { [ "new" ] }
 
     it "makes sure no invalid statuses are allowed" do
-      expect(->{
-        subject.statuses = [:new]
-      }).to raise_error(ArgumentError, "Affairs of State: 'new' is not a valid status")
+      expect { subject }.to raise_error(ArgumentError, "Affairs of State: 'new' is not a valid status")
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "affairs_of_state"
 
 require "pry"
@@ -5,9 +6,10 @@ require "sqlite3"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
+  config.filter_run_when_matching :focus
 end
 
-## Create an AR model to test with
+# Create an AR model to test with
 I18n.enforce_available_locales = false
 
 ActiveRecord::Base.establish_connection(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: affairs_of_state
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Kevin McPhillips
@@ -14,44 +14,44 @@ dependencies:
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -70,30 +70,30 @@ dependencies:
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12'
 description: Add a simple state to a gem, without all the hassle of a complex state
   machine.
 email:
@@ -114,6 +114,7 @@ files:
 - gemfiles/activerecord-6.1.gemfile
 - gemfiles/activerecord-latest.gemfile
 - lib/affairs_of_state.rb
+- lib/affairs_of_state/active_record_extension.rb
 - lib/affairs_of_state/config.rb
 - lib/affairs_of_state/version.rb
 - spec/affairs_of_state_spec.rb