command_model 2.0.0 → 2.1.0

data/gemfiles/6.1.gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: ..
+  specs:
+    command_model (2.0.1)
+      activemodel (> 6.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.7.7)
+      activesupport (= 6.1.7.7)
+    activesupport (6.1.7.7)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    concurrent-ruby (1.2.3)
+    diff-lcs (1.5.1)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
+    minitest (5.22.3)
+    rake (13.1.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.13)
+
+PLATFORMS
+  arm64-darwin-23
+  x86_64-linux
+
+DEPENDENCIES
+  activemodel (~> 6.1.0)
+  command_model!
+  rake (~> 13.1.0)
+  rspec (~> 3.13.0)
+
+BUNDLED WITH
+   2.4.3

data/gemfiles/{5.1.gemfile → 7.0.gemfile}

@@ -1,5 +1,5 @@
 source "https://rubygems.org"
 
-gem "activemodel", "~> 5.1.0"
+gem "activemodel", "~> 7.0.0"
 
 gemspec :path=>"../"

data/gemfiles/7.0.gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: ..
+  specs:
+    command_model (2.0.1)
+      activemodel (> 6.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.4.3)
+      activesupport (= 7.0.4.3)
+    activesupport (7.0.4.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    concurrent-ruby (1.2.3)
+    diff-lcs (1.5.1)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
+    minitest (5.22.3)
+    rake (13.1.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  arm64-darwin-23
+  x86_64-linux
+
+DEPENDENCIES
+  activemodel (~> 7.0.0)
+  command_model!
+  rake (~> 13.1.0)
+  rspec (~> 3.13.0)
+
+BUNDLED WITH
+   2.4.3

data/gemfiles/7.1.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activemodel", "~> 7.1.0"
+
+gemspec :path=>"../"

data/gemfiles/7.1.gemfile.lock

@@ -0,0 +1,60 @@
+PATH
+  remote: ..
+  specs:
+    command_model (2.0.1)
+      activemodel (> 6.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.1.3.2)
+      activesupport (= 7.1.3.2)
+    activesupport (7.1.3.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    base64 (0.2.0)
+    bigdecimal (3.1.7)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
+    diff-lcs (1.5.1)
+    drb (2.2.1)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
+    minitest (5.22.3)
+    mutex_m (0.2.0)
+    rake (13.1.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  arm64-darwin-23
+  x86_64-linux
+
+DEPENDENCIES
+  activemodel (~> 7.1.0)
+  command_model!
+  rake (~> 13.1.0)
+  rspec (~> 3.13.0)
+
+BUNDLED WITH
+   2.4.3

data/lib/command_model/convert.rb

@@ -61,7 +61,7 @@ module CommandModel
         return nil if value.blank?
         return value if value.kind_of? Date
         value = value.to_s
-        if value =~ /\A(\d\d\d\d)-(\d\d)-(\d\d)\z/
+        if value =~ /\A(\d{4,5})-(\d\d)-(\d\d)\z/
           ::Date.civil($1.to_i, $2.to_i, $3.to_i)
         else
           ::Date.strptime(value, "%m/%d/%Y")

data/lib/command_model/model.rb

@@ -1,18 +1,15 @@
 module CommandModel
-  class TypecastError < StandardError
-    attr_reader :original_error
-
-    def initialize(original_error)
-      @original_error = original_error
-    end
-  end
-
   class Model
     include ActiveModel::Validations
     include ActiveModel::Conversion
     extend ActiveModel::Naming
 
-    Parameter = Struct.new(:name, :converters, :validations)
+    def self.inherited(subclass)
+      subclass.instance_variable_set :@parameters, parameters.dup.freeze
+      subclass.instance_variable_set :@dependencies, dependencies.dup.freeze
+    end
+
+    Parameter = Data.define(:name, :converters, :validations)
 
     # Parameter requires one or more attributes as its first parameter(s).
     # It accepts an options hash as its last parameter.
@@ -34,11 +31,12 @@ module CommandModel
     #   parameter :height, :weight,
     #     convert: [CommandModel::Convert::StringMutator.new { |s| s.gsub(",", "")}, :integer],
     #     presence: true,
-    #     numericality: { :greater_than_or_equal_to => 0 }
+    #     numericality: { greater_than_or_equal_to: 0 }
     def self.parameter(*args)
       options = args.last.kind_of?(Hash) ? args.pop.clone : {}
       converters = options.delete(:convert)
 
+      @parameters ||= [].freeze
       args.each do |name|
         attr_reader name
 
@@ -48,13 +46,13 @@ module CommandModel
           attr_writer name
         end
         validates name, options.clone if options.present? # clone options because validates mutates the hash :(
-        parameters.push Parameter.new name, converters, options
+        @parameters = (@parameters + [Parameter.new(name, converters, options)]).freeze
       end
     end
 
     # Returns array of all parameters defined for class
     def self.parameters
-      @parameters ||= []
+      @parameters ||= [].freeze
     end
 
     def self.attr_type_converting_writer(name, converters) #:nodoc
@@ -90,6 +88,38 @@ module CommandModel
       end
     end
 
+    Dependency = Data.define(:name, :default, :allow_blank)
+
+    # Dependency requires one or more attributes as its first parameter(s). A dependency is something that is required
+    # for the command to execute that is not user supplied input. For example, a database connection, a logger, or the
+    # current user.
+    #
+    # ==== Keyword Arguments
+    #
+    # * default - An object that will be used as the default value for the dependency or a callable object that will be
+    #   called to get the default value.
+    # * allow_blank - If true, the dependency can be nil or blank. If false, the dependency must be present.
+    #
+    # ==== Examples
+    #
+    #   dependency :current_user
+    #   dependency :stdout, default: -> { $stdout }
+    def self.dependency(*names, default: nil, allow_blank: false)
+      @dependencies ||= [].freeze
+      names.each do |name|
+        name = name.to_sym
+        attr_reader name
+        private attr_writer name
+        default_callable = default.respond_to?(:call) ? default : -> { default }
+        @dependencies = (@dependencies + [Dependency.new(name, default_callable, allow_blank)]).freeze
+      end
+    end
+
+    # Returns array of all dependencies defined for class.
+    def self.dependencies
+      @dependencies ||= [].freeze
+    end
+
     # Executes a block of code if the command model is valid.
     #
     # Accepts either a command model or a hash of attributes with which to
@@ -97,18 +127,19 @@ module CommandModel
     #
     # ==== Examples
     #
-    #   RenameUserCommand.execute(:login => "john") do |command|
+    #   RenameUserCommand.execute(login: "john") do |command|
     #     if allowed_to_rename_user?
     #       self.login = command.login
     #     else
     #       command.errors.add :base, "not allowed to rename"
     #     end
     #   end
-    def self.execute(attributes_or_command, &block)
+    def self.execute(attributes_or_command, dependencies={}, &block)
       command = if attributes_or_command.kind_of? self
+        raise ArgumentError, "cannot pass dependencies with already initialized command" if dependencies.present?
         attributes_or_command
       else
-        new(attributes_or_command)
+        new(attributes_or_command, dependencies)
       end
 
       command.call &block
@@ -137,9 +168,23 @@ module CommandModel
     # Accepts a parameters hash or another of the same class. If another
     # instance of the same class is passed in then the parameters are copied
     # to the new object.
-    def initialize(parameters={})
+    def initialize(parameters={}, dependencies={})
       @type_conversion_errors = {}
       set_parameters parameters
+
+      dependencies = dependencies.symbolize_keys
+      self.class.dependencies.each do |dependency|
+        value = dependencies.fetch(dependency.name, dependency.default.call)
+        if value.blank? && !dependency.allow_blank
+          raise ArgumentError, "Dependency #{dependency.name} cannot be blank"
+        end
+        self.send "#{dependency.name}=", dependencies.fetch(dependency.name, dependency.default.call)
+      end
+
+      unknown_dependencies = dependencies.keys - self.class.dependencies.map(&:name)
+      if unknown_dependencies.present?
+        raise ArgumentError, "Unknown dependencies: #{bad_dependencies.join(", ")}"
+      end
     end
 
     # Executes the command by calling the method +execute+ if the validations

data/lib/command_model/version.rb

@@ -1,3 +1,3 @@
 module CommandModel
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/spec/convert_spec.rb

@@ -30,7 +30,7 @@ describe "CommandModel::Convert" do
       expect(subject.("")).to eq(nil)
     end
 
-    it "raises TypecastError when invalid string" do
+    it "raises ConvertError when invalid string" do
       expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
       expect { subject.("0.1") }.to raise_error(CommandModel::Convert::ConvertError)
     end
@@ -52,7 +52,7 @@ describe "CommandModel::Convert" do
       expect(subject.("")).to eq(nil)
     end
 
-    it "raises TypecastError when invalid string" do
+    it "raises ConvertError when invalid string" do
       expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
     end
   end
@@ -81,7 +81,7 @@ describe "CommandModel::Convert" do
       expect(subject.("")).to eq(nil)
     end
 
-    it "raises TypecastError when invalid string" do
+    it "raises ConvertError when invalid string" do
       expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
     end
   end
@@ -93,6 +93,7 @@ describe "CommandModel::Convert" do
       expect(subject.("01/01/2000")).to eq(Date.civil(2000,1,1))
       expect(subject.("1/1/2000")).to eq(Date.civil(2000,1,1))
       expect(subject.("2000-01-01")).to eq(Date.civil(2000,1,1))
+      expect(subject.("29000-01-01")).to eq(Date.civil(29000,1,1))
     end
 
     it "returns existing date unchanged" do
@@ -108,7 +109,7 @@ describe "CommandModel::Convert" do
       expect(subject.("")).to eq(nil)
     end
 
-    it "raises TypecastError when invalid string" do
+    it "raises ConvertError when invalid string" do
       expect { subject.("asdf") }.to raise_error(CommandModel::Convert::ConvertError)
       expect { subject.("3/50/1290") }.to raise_error(CommandModel::Convert::ConvertError)
     end

data/spec/model_spec.rb

@@ -6,7 +6,7 @@ class ExampleCommand < CommandModel::Model
 end
 
 describe CommandModel::Model do
-  let(:example_command) { ExampleCommand.new :name => "John" }
+  let(:example_command) { ExampleCommand.new name: "John" }
   let(:invalid_example_command) { ExampleCommand.new }
 
   describe "self.parameter" do
@@ -38,7 +38,7 @@ describe CommandModel::Model do
     end
 
     it "accepts multiple attributes with convert" do
-      klass.parameter :foo, :bar, :convert => :integer
+      klass.parameter :foo, :bar, convert: :integer
       expect(klass.new.methods).to include(:foo)
       expect(klass.new.methods).to include(:foo=)
       expect(klass.new.methods).to include(:bar)
@@ -46,7 +46,7 @@ describe CommandModel::Model do
     end
 
     it "accepts multiple attributes with validation" do
-      klass.parameter :foo, :bar, :presence => true
+      klass.parameter :foo, :bar, presence: true
       expect(klass.new.methods).to include(:foo)
       expect(klass.new.methods).to include(:foo=)
       expect(klass.new.methods).to include(:bar)
@@ -72,6 +72,27 @@ describe CommandModel::Model do
       expect(instance).to_not be_valid
       expect(instance.errors[:name]).to be_present
     end
+
+    it "works when model is inherited" do
+      klass.parameter :foo
+      expect(klass.parameters.map(&:name)).to eq([:foo])
+
+      klass_b = Class.new(klass)
+      expect(klass_b.parameters.map(&:name)).to eq([:foo])
+      klass_b.parameter :bar
+      expect(klass.parameters.map(&:name)).to eq([:foo])
+      expect(klass_b.parameters.map(&:name)).to eq([:foo, :bar])
+
+      klass_c = Class.new(klass_b)
+      expect(klass.parameters.map(&:name)).to eq([:foo])
+      expect(klass_b.parameters.map(&:name)).to eq([:foo, :bar])
+      expect(klass_c.parameters.map(&:name)).to eq([:foo, :bar])
+
+      klass_c.parameter :baz
+      expect(klass.parameters.map(&:name)).to eq([:foo])
+      expect(klass_b.parameters.map(&:name)).to eq([:foo, :bar])
+      expect(klass_c.parameters.map(&:name)).to eq([:foo, :bar, :baz])
+    end
   end
 
   describe "self.parameters" do
@@ -89,13 +110,65 @@ describe CommandModel::Model do
     end
   end
 
+  describe "self.dependency" do
+    let(:klass) { Class.new(CommandModel::Model) }
+
+    it "creates an attribute reader" do
+      klass.dependency :foo, allow_blank: true
+      expect(klass.new.methods).to include(:foo)
+    end
+
+    it "accepts multiple attributes" do
+      klass.dependency :foo, :bar, allow_blank: true
+      expect(klass.new.methods).to include(:foo)
+      expect(klass.new.methods).to include(:bar)
+    end
+
+    it "accepts multiple attributes with default" do
+      klass.dependency :foo, :bar, default: -> { "baz" }
+      expect(klass.new.methods).to include(:foo)
+      expect(klass.new.methods).to include(:bar)
+    end
+
+    it "works when model is inherited" do
+      klass.dependency :foo
+      expect(klass.dependencies.map(&:name)).to eq([:foo])
+
+      klass_b = Class.new(klass)
+      expect(klass_b.dependencies.map(&:name)).to eq([:foo])
+      klass_b.dependency :bar
+      expect(klass.dependencies.map(&:name)).to eq([:foo])
+      expect(klass_b.dependencies.map(&:name)).to eq([:foo, :bar])
+
+      klass_c = Class.new(klass_b)
+      expect(klass.dependencies.map(&:name)).to eq([:foo])
+      expect(klass_b.dependencies.map(&:name)).to eq([:foo, :bar])
+      expect(klass_c.dependencies.map(&:name)).to eq([:foo, :bar])
+
+      klass_c.dependency :baz
+      expect(klass.dependencies.map(&:name)).to eq([:foo])
+      expect(klass_b.dependencies.map(&:name)).to eq([:foo, :bar])
+      expect(klass_c.dependencies.map(&:name)).to eq([:foo, :bar, :baz])
+    end
+  end
+
+  describe "self.dependencies" do
+    it "returns all dependencies in class" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :foo
+      klass.dependency :bar
+
+      expect(klass.dependencies.map(&:name)).to eq([:foo, :bar])
+    end
+  end
+
   describe "self.execute" do
     it "accepts object of same kind and returns it" do
       expect(ExampleCommand.execute(example_command) {}).to eq(example_command)
     end
 
     it "accepts attributes, creates object, and returns it" do
-      c = ExampleCommand.execute(:name => "John") {}
+      c = ExampleCommand.execute(name: "John") {}
       expect(c).to be_kind_of(ExampleCommand)
       expect(c.name).to eq("John")
     end
@@ -129,6 +202,25 @@ describe CommandModel::Model do
 
       expect(example_command).to_not be_success
     end
+
+    it "uses default dependencies when not provided" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :stdout, default: -> { $stdout }
+      klass.parameter :name
+      m = klass.execute(name: "John")
+      expect(m.stdout).to eq($stdout)
+      expect(m.execution_attempted?).to eq(true)
+    end
+
+    it "accepts dependencies from arguments" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :stdout, default: -> { $stdout }
+      klass.parameter :name
+      writer = StringIO.new
+      m = klass.execute({name: "John"}, stdout: writer)
+      expect(m.stdout).to eq(writer)
+      expect(m.execution_attempted?).to eq(true)
+    end
   end
 
   describe "self.success" do
@@ -151,15 +243,46 @@ describe CommandModel::Model do
 
   describe "initialize" do
     it "assigns parameters from hash" do
-      m = ExampleCommand.new :name => "John"
+      m = ExampleCommand.new name: "John"
       expect(m.name).to eq("John")
     end
 
     it "assigns parameters from other CommandModel" do
-      other = ExampleCommand.new :name => "John"
+      other = ExampleCommand.new name: "John"
       m = ExampleCommand.new other
       expect(m.name).to eq(other.name)
     end
+
+    it "assigns default dependencies when not provided" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :stdout, default: -> { $stdout }
+      klass.parameter :name
+      m = klass.new name: "John"
+      expect(m.stdout).to eq($stdout)
+    end
+
+    it "assigns dependencies from arguments" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :stdout, default: -> { $stdout }
+      klass.parameter :name
+      writer = StringIO.new
+      m = klass.new({name: "John"}, stdout: writer)
+      expect(m.stdout).to eq(writer)
+    end
+
+    it "raises error when dependency is missing" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :stdout
+      klass.parameter :name
+      expect { klass.new name: "John" }.to raise_error(StandardError)
+    end
+
+    it "does not raise error when allow blank dependency is missing" do
+      klass = Class.new(CommandModel::Model)
+      klass.dependency :stdout, allow_blank: true
+      klass.parameter :name
+      expect { klass.new name: "John" }.to_not raise_error
+    end
   end
 
   describe "call" do