affairs_of_state 0.6.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2757335e832c9809fa86e7c365dda4d6fe31b49ab837665ecbd80ec2f3b27ac2
-  data.tar.gz: 18c9e1b16df324170b4af93859379540e56aafa27068490a743bd155b3a9c83a
+  metadata.gz: 37d765f3c10fc68d7888ecde5f4b71736e70a85ccb77311f110f22772a5bfad3
+  data.tar.gz: 0b7a6965aad1f602356640b5d2c666bfcc60566e90fc54fd9c11cbd2394d92ea
 SHA512:
-  metadata.gz: 6e9b37707ae931a4a9231b4b453b075db2d0c1e16c4bddf1696f20adcf26bd5b23744e6f185602d50e036465d1cf060dd2b4951857d252d387a5c140b4a18029
-  data.tar.gz: 03c8db3940a2c167922048afecfa75d1ad4f28fcb386e16fc57bbbe6101c2f8416fece5ba12bba7af21407746149ec0252d46a7ce407b618b7db9af1f535ad7b
+  metadata.gz: 41dc25892417048d6de1ba7e6927ea335e7ce46819e834943358f5bf03b1397dad3e6aa846ea725a5eec162f5c7bc63e2b6ef8c1812e751683eeec255f868031
+  data.tar.gz: f28c08bebd42bf3c3a8b0a49308cc6f01161d5ad6840774ad4fb00f391e5d02e2d4730f6090acea7d274ade88b3eaf5e60eb651218da0563f1e4d21ac688a4f3

data/.github/workflows/ci.yml

@@ -10,6 +10,7 @@ jobs:
         gemfile:
           - "activerecord-6.0.gemfile"
           - "activerecord-6.1.gemfile"
+          - "activerecord-7.0.gemfile"
           - "activerecord-latest.gemfile"
     runs-on: ubuntu-latest
     env:

data/.ruby_version

@@ -0,0 +1 @@
+3.0.2

data/README.md

@@ -38,6 +38,12 @@ If you'd like to use another column, lets say `state`, pass it in as a configura
 affairs_of_state :active, :inactive, column: :state
 ```
 
+You can scope the helper and scope methods by a prefix:
+
+```ruby
+affairs_of_state :active, :inactive, prefix: :admin
+```
+
 You can also turn off validation:
 
 ```ruby
@@ -60,7 +66,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,23 +78,35 @@ widget = Widget.first
 widget.cancelled! if widget.active?
 ```
 
-You can also access all your statuses on the model like so:
+These methods are scoped by the prefix if one is set:
+```ruby
+widget = Widget.first
+widget.admin_cancelled! if widget.admin_active?
+```
+
+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:
+It also provides scopes automagically, scoped by prefix if one is set:
 
 ```ruby
 Widget.active
 Widget.cancelled
 ```
+```ruby
+Widget.admin_active
+Widget.admin_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

@@ -19,9 +19,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency "activerecord", ">= 6.0"
   gem.add_dependency "activesupport", ">= 6.0"
 
-  gem.add_development_dependency "rspec"
-  gem.add_development_dependency "sqlite3", "~> 1.4.0"
-  gem.add_development_dependency "pry"
-  gem.add_development_dependency "rake"
-
+  gem.add_development_dependency "rspec", ">= 3.0"
+  gem.add_development_dependency "sqlite3", ">= 1.4.0"
+  gem.add_development_dependency "rake", ">= 12"
 end

data/gemfiles/activerecord-7.0.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'activerecord', '~> 7.0'

data/lib/affairs_of_state/active_record_extension.rb

@@ -0,0 +1,79 @@
+# 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, prefix: nil)
+        # config object that defines behaviour
+        config = AffairsOfState::Config.new(
+          statuses: statuses,
+          prefix: prefix,
+          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]
+        statuses_and_methods = affairs_of_state_configs.values.map(&:methods_for_statuses).map { |m| m.map{ |(k, v)| [k, v] } }.flatten
+        overlapping_statuses = statuses_and_methods & config.methods_for_statuses.map{ |k, v| [k, v] }.flatten
+        raise ArgumentError, "Affairs of State: #{ self } already has a status #{ overlapping_statuses }" if overlapping_statuses.any?
+
+        # status methods
+        config.methods_for_statuses.each do |status, method_name|
+          define_method("#{ method_name }?") do
+            self.send(config.column) == status
+          end
+
+          define_method("#{ method_name }!") do
+            self.send("#{ config.column }=", status)
+            self.save
+          end
+        end
+
+        # scopes
+        if config.scopes
+          config.methods_for_statuses.each do |status, method_name|
+            self.scope(method_name.to_sym, -> { where(config.column => status) })
+          end
+        end
+
+        # column validation
+        validates(config.column, inclusion: { in: config.statuses, allow_blank: config.allow_blank }, if: config.if)
+
+        # 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,27 @@
+# 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, :methods_for_statuses
 
-    def statuses=(val)
-      @statuses = val.flatten.map(&:to_s)
+    DISALLOWED_STATUSES = [ "new" ].freeze
 
+    def initialize(statuses:, column:, allow_blank:, scopes:, if:, prefix:)
+      @column = column
+      @allow_blank = !!allow_blank
+      @scopes = !!scopes
+      @if = binding.local_variable_get(:if)
+      @prefix = prefix.presence
+      @statuses = statuses.flatten.map(&:to_s)
+      @methods_for_statuses = @statuses.to_h do |s|
+        if @prefix
+          [s.to_s, "#{ prefix }_#{ s }"]
+        else
+          [s.to_s, s.to_s]
+        end
+      end
       @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.2"
 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
@@ -172,18 +191,113 @@ describe AffairsOfState do
 
   describe "invalid status name" do
     it "should raise a good warning" do
-      expect(->{ class Pie8 < ActiveRecord::Base ; affairs_of_state :new ; end }).to raise_error(ArgumentError, "Affairs of State: 'new' is not a valid status")
+      expect{ class Pie8 < ActiveRecord::Base ; affairs_of_state :new ; end }.to raise_error(ArgumentError, "Affairs of State: 'new' is not a valid status")
     end
   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 Pie10 < 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 Pie11 < 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 collision between prefixes" do
+      expect {
+        class Pie12 < ActiveRecord::Base
+          self.table_name = "pies"
+
+          affairs_of_state :admin_active, :admin_inactive
+          affairs_of_state :dormant, :active, column: :super_status, prefix: :admin
+        end
+      }.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
+
+  describe "multiple invocations with prefix" do
+    class Pie13 < ActiveRecord::Base
+      self.table_name = "pies"
+
+      affairs_of_state :active, :inactive
+      affairs_of_state :moderated, :unmoderated, column: :super_status
+      affairs_of_state :positive, :mixed, :negative, column: :sentiment, prefix: :sentiment
+    end
+
+    subject { Pie13 }
+
+    it "returns the statuses" do
+      expect(subject.statuses(:sentiment)).to eq([ "positive", "mixed", "negative" ])
+    end
+
+    it "adds the setter and getter methods with the prefix" do
+      p = subject.new
+      expect(p).to_not be_sentiment_positive
+      expect(p).to_not be_sentiment_mixed
+      expect(p).to_not be_sentiment_negative
+      p.sentiment_mixed!
+      expect(p).to be_sentiment_mixed
+    end
+
+    it "adds the scopes with the prefix" do
+      p = subject.create! sentiment: "positive", status: "active", super_status: "unmoderated"
+      subject.create! sentiment: "mixed", status: "active", super_status: "unmoderated"
+      subject.create! sentiment: "negative", status: "active", super_status: "unmoderated"
+      expect(subject.sentiment_positive).to eq([p])
     end
   end
 end

data/spec/config_spec.rb

@@ -1,47 +1,69 @@
+# 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,
+      prefix: prefix
+    )
+  end
+  let(:column) { "state" }
+  let(:statuses) { [ :created, [ :destroyed ] ] }
+  let(:allow_blank) { "sure" }
+  let(:scopes) { nil }
+  let(:if_condition) { "false" }
+  let(:prefix) { nil }
 
-  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
 
-    it "flattens" do
-      subject.statuses = ["a", [:b]]
-      expect(subject.statuses).to eq(["a", "b"])
+    it "has :methods_for_statuses which is the same key values" do
+      expect(subject.methods_for_statuses).to eq({ "created" => "created", "destroyed" => "destroyed" })
     end
+  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
+
+  context "with prefix" do
+    let(:prefix) { :admin }
+
+    it "has :statuses just the same" do
+      expect(subject.statuses).to eq(["created", "destroyed"])
+    end
+
+    it "has :methods_for_statuses" do
+      expect(subject.methods_for_statuses).to eq({ "created" => "admin_created", "destroyed" => "admin_destroyed" })
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
 require "affairs_of_state"
 
-require "pry"
 require "sqlite3"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
+  config.filter_run_when_matching :focus
+  # config.raise_errors_for_deprecations!
 end
 
-## Create an AR model to test with
+# Create an AR model to test with
 I18n.enforce_available_locales = false
 
 ActiveRecord::Base.establish_connection(
@@ -19,4 +21,5 @@ ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'pies'")
 ActiveRecord::Base.connection.create_table(:pies) do |t|
   t.string :status
   t.string :super_status
+  t.string :sentiment
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: affairs_of_state
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Kevin McPhillips
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-12 00:00:00.000000000 Z
+date: 2022-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,56 +44,42 @@ dependencies:
     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
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-- !ruby/object:Gem::Dependency
-  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.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:
@@ -105,6 +91,7 @@ files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
+- ".ruby_version"
 - Gemfile
 - LICENSE
 - README.md
@@ -112,8 +99,10 @@ files:
 - affairs_of_state.gemspec
 - gemfiles/activerecord-6.0.gemfile
 - gemfiles/activerecord-6.1.gemfile
+- gemfiles/activerecord-7.0.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