riker 0.1.0.pre2 → 0.1.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86f0741a4cd82edba656094d41663f3a119ee7a6e6019d2417d3f12ef459dcdc
-  data.tar.gz: b82ff16ca094921419d09c2c4e8f2888dc35b228d086916135b6977ff2138656
+  metadata.gz: e87101245bca559270ab4ae68b854ddedcf0bcd3a946bdae50571ddb9717b074
+  data.tar.gz: 702df1dedeacc6dd92dda5a9e90f0640fb1763d9c766e613c4e9669727cae002
 SHA512:
-  metadata.gz: acde908c28b815b7e77d75e0a8a68cb94c2f106b03bcb56fb608dc812465de8692ffd630c080279a7eb275a90b37a414c25699e1091d77a2632dbb78c18da576
-  data.tar.gz: 21b81e7a1f99bd1236d60b4603b6614751fad3e1158eaf39fe3593536d7a21d4b81bc9b2d492beed713b4a24a4ccb256ba6b3bf53582db0dd69d1199f330dea2
+  metadata.gz: 4fa7e7eef30b47313061ed59cf958b7fb94ca4db2ea461ca94485b9253a3b52223734729ef51fe97bb33456403731aa68281255486aef21218625db708b06609
+  data.tar.gz: 7c24626c3b722677bd57cb5f83fd092e042b2b06fa170b7edc7fa1e18e2c1eb2cb06cd871bcabfd0cba06046502e9a47eb112f2882c40ee16daabceeac5c9514

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    riker (0.1.0.pre1)
+    riker (0.1.0.pre4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -12,7 +12,7 @@ High-Performance, Dependency-Free Command Pattern For Ruby
 ### In your gemfile:
 
 ```ruby
-gem 'riker', '0.1.0.pre2'
+gem 'riker', '0.1.0.pre4'
 ```
 
 ### In your code:
@@ -23,9 +23,12 @@ class SimpleGreeting
 
   param :first_name
   param :last_name, required: false
+  param :punctuation, default: '.'
 
   execute do
-    "Hello #{first_name} #{last_name}".strip
+    return "Hello #{first_name}#{punctuation}" if last_name.nil?
+
+    "Hello #{first_name} #{last_name}#{punctuation}"
   end
 end
 ```
@@ -34,8 +37,38 @@ end
 
 ```ruby
 SimpleGreeting.run!(first_name: 'Will')
-# => "Hello Will
+# => "Hello Will."
 
 SimpleGreeting.run!(first_name: 'Will', last_name: 'Riker')
-# => "Hello Will Riker
+# => "Hello Will Riker."
+
+SimpleGreeting.run!(first_name: 'Will', last_name: 'Riker', punctuation: '!')
+# => "Hello Will Riker!"
+```
+
+## Default Procs
+
+### In your code:
+
+```ruby
+class CaptainsLog
+  extend Riker
+
+  param :stardate, default: -> { Time.now.to_f }
+  param :message
+
+  execute do
+    "Captain's Log; Stardate: #{stardate}\n\n#{message}"
+  end
+end
+```
+
+### In use:
+
+```ruby
+CaptainsLog.run!(message: "The Borg are attacking!")
+# => "Captain's Log; Stardate: 1664393978.915553\n\nThe Borg are attacking!"
+
+CaptainsLog.run(message: "We've traveled back in time!", stardate: 42.1337)
+# => "Captain's Log; Stardate: 42.1337\n\nWe've traveled back in time!"
 ```

data/lib/riker/command/function.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Riker
+  class Command
+    # Individual Function
+    #
+    # Repsonible for debugging and writing out functions
+    # for a command to provide the needed functionality
+    # that is setup for it.
+    #
+    class Function
+      # @param command [Riker::Command]
+      def initialize(command)
+        @command = command
+      end
+
+      # @return [Symbol]
+      def name
+        raise NotImplementedError
+      end
+
+      # @return [Riker::Command::FunctionDetails]
+      def details
+        raise NotImplementedError
+      end
+
+      private
+
+      # @return [Riker::Command]
+      attr_reader :command
+    end
+  end
+end

data/lib/riker/command/function_details.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Riker
+  class Command
+    # Function Detail Data
+    #
+    # Holds information needed to write a function to a class
+    # with `class_eval` on a class object.
+    #
+    class FunctionDetails
+      # @return [String]
+      attr_reader :code
+
+      # @return [String]
+      attr_reader :file
+
+      # @return [Integer]
+      attr_reader :line
+
+      def initialize(code, file, line)
+        @code = code
+        @file = file
+        @line = line
+      end
+    end
+  end
+end

data/lib/riker/command/function_writer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'run_bang_function'
+require_relative 'initialize_function'
+
+module Riker
+  class Command
+    # Function Writer
+    #
+    # This is responsible for creating the functions that
+    # are needed to create a command pattern class.
+    #
+    class FunctionWriter
+      DEFAULT_FUNCTIONS = [
+        RunBangFunction,
+        InitializeFunction
+      ].freeze
+
+      # @return [Riker::Command]
+      attr_reader :command
+
+      # @return [Array<Riker::Command::Function>]
+      attr_reader :functions
+
+      # @param command [Riker::Command]
+      def initialize(command)
+        @command = command
+        @functions = DEFAULT_FUNCTIONS.map { |func| func.new(command) }
+      end
+
+      # @param klass [Class]
+      def write!(klass)
+        klass.define_method(:execute, &command.execute_block)
+        define_default_setters!(klass)
+        define_attr_readers!(klass)
+        write_functions!(klass)
+      end
+
+      private
+
+      # @param klass [Class]
+      def write_functions!(klass)
+        functions.each do |function|
+          details = function.details
+          klass.class_eval(details.code, details.file, details.line)
+        end
+      end
+
+      # @param klass [Class]
+      def define_attr_readers!(klass)
+        klass.attr_reader(*command.parameters.map(&:name))
+      end
+
+      # @param klass [Class]
+      def define_default_setters!(klass)
+        command.parameters.each do |param|
+          param.default.build_default_function!(klass)
+        end
+      end
+    end
+  end
+end

data/lib/riker/command/initialize_function.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Riker
+  class Command
+    # Run!
+    #
+    # Represents the `initialize` method for your command
+    #
+    class InitializeFunction < Function
+      # @return [Symbol]
+      def name
+        :initialize
+      end
+
+      # @return [Riker::Command::FunctionDetails]
+      def details
+        FunctionDetails.new(<<~RUBY, __FILE__, __LINE__ + 1)
+          def initialize(#{command.parameters.ctor_args})  # def initialize(foo:)
+            #{command.parameters.variable_sets}            #   @foo = foo
+          end                                              # end
+        RUBY
+      end
+    end
+  end
+end

data/lib/riker/command/parameters.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Riker
+  class Command
+    # Command Parameters
+    #
+    # This is responsible for keeping track of the command's
+    # parameters. This includes how they are used and applied
+    # to the construction of a command.
+    #
+    class Parameters
+      include Enumerable
+      class ParamNameTaken < ::Riker::Error; end
+      class InvalidParamName < ::Riker::Error; end
+
+      def initialize
+        # @var [Hash<Symbol, Parameter>]
+        @params = {}
+      end
+
+      # @param name [Symbol]
+      # @return [Parameters]
+      #
+      def add(name, **options)
+        validate_name!(name)
+        @params[name] = Parameter.new(name, **options)
+
+        self
+      end
+
+      # @return [String]
+      def ctor_args
+        map(&:ctor_arg).join(', ')
+      end
+
+      # @return [String]
+      def variable_sets
+        map(&:variable_set).join("\n")
+      end
+
+      # @yield [Parameter]
+      def each(&block)
+        @params.values.each(&block)
+      end
+
+      private
+
+      def validate_name!(name)
+        raise InvalidParamName unless name.is_a?(Symbol)
+        raise ParamNameTaken if @params.key?(name)
+      end
+    end
+  end
+end

data/lib/riker/command/run_bang_function.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Riker
+  class Command
+    # Run!
+    #
+    # Represents the `run!` static method for your command
+    #
+    class RunBangFunction < Function
+      # @return [Symbol]
+      def name
+        :run!
+      end
+
+      # @return [Riker::Command::FunctionDetails]
+      def details
+        FunctionDetails.new(<<~RUBY, __FILE__, __LINE__ + 1)
+          def self.run!(**arguments)    # def initialize(**arguments)
+            command = new(**arguments)  #   command = new(**arguments)
+            command.execute             #   command.execute
+          end                           # end
+        RUBY
+      end
+    end
+  end
+end

data/lib/riker/command.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'command/parameters'
+require_relative 'command/function'
+require_relative 'command/function_details'
+require_relative 'command/function_writer'
+
 module Riker
   # Command Builder
   #
@@ -7,48 +12,18 @@ module Riker
   # track of the build of a command in your application
   #
   class Command
-    # @return [Riker::Parameters]
+    # @return [Riker::Command::Parameters]
     attr_reader :parameters
 
+    # @return [Riker::Command::FunctionWriter]
+    attr_reader :function_writer
+
     # @return [Proc, nil]
     attr_accessor :execute_block
 
     def initialize
-      @parameters = CommandParameters.new
-    end
-
-    # @param klass [Class]
-    def build!(klass)
-      klass.define_method(:execute, &execute_block)
-      define_init!(klass)
-      define_run_bang!(klass)
-      define_attr_readers!(klass)
-    end
-
-    private
-
-    # @param klass [Class]
-    def define_init!(klass)
-      klass.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-        def initialize(#{parameters.ctor_args})  # def initialize(foo:)
-          #{parameters.variable_sets}            #   @foo = foo
-        end                                      # end
-      RUBY
-    end
-
-    # @param klass [Class]
-    def define_run_bang!(klass)
-      klass.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-        def self.run!(**arguments)    # def initialize(**arguments)
-          command = new(**arguments)  #   command = new(**arguments)
-          command.execute             #   command.execute
-        end                           # end
-      RUBY
-    end
-
-    # @param klass [Class]
-    def define_attr_readers!(klass)
-      klass.attr_reader(*parameters.map(&:name))
+      @parameters = Parameters.new
+      @function_writer = FunctionWriter.new(self)
     end
   end
 end

data/lib/riker/parameter/default_value.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Riker
+  class Parameter
+    # Default Parameter Value
+    #
+    # Sometimes we want to have parameters default to sensible
+    # defaults.  This class's responsibility is to keep track
+    # this and set's up work to ensure defaults setup properly.
+    #
+    class DefaultValue
+      # @return [Symbol]
+      attr_reader :name
+
+      # @return [BasicObject]
+      def self.no_value
+        :__no_default__
+      end
+
+      # @param name [Symbol]
+      # @param value [Object, Proc]
+      def initialize(name, value)
+        @name = name
+        @present = value != :__no_default__
+        @value_proc = value.is_a?(Proc) ? value : -> { value }
+      end
+
+      # @return [Boolean]
+      def present?
+        @present
+      end
+
+      # @return [Symbol, nil]
+      def function_name
+        return unless present?
+
+        @function_name ||= :"default_value_for_#{name}"
+      end
+
+      def build_default_function!(klass)
+        return unless present?
+
+        klass.define_method(function_name, &@value_proc)
+        klass.send(:private, function_name)
+      end
+    end
+  end
+end

data/lib/riker/parameter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'parameter/default_value'
+
 module Riker
   # Single Command Parameter
   #
@@ -7,11 +9,20 @@ module Riker
     # @return [Symbol]
     attr_reader :name
 
+    # @return [DefaultValue]
+    attr_reader :default
+
     # @param name [Symbol]
     # @param required [Boolean]
-    def initialize(name, required: true)
+    # @param default [Object, Proc]
+    def initialize(
+      name,
+      required: true,
+      default: DefaultValue.no_value
+    )
       @name = name
       @required = required
+      @default = DefaultValue.new(name, default)
     end
 
     # @return [Boolean]
@@ -32,6 +43,7 @@ module Riker
     private
 
     def fallback_default
+      return default.function_name if default.present?
       return if required?
 
       'nil'

data/lib/riker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Riker
-  VERSION = '0.1.0.pre2'
+  VERSION = '0.1.0.pre4'
 end

data/lib/riker.rb

@@ -3,7 +3,6 @@
 require_relative 'riker/version'
 require_relative 'riker/error'
 require_relative 'riker/command'
-require_relative 'riker/command_parameters'
 require_relative 'riker/parameter'
 
 # The Commander of the USS Enterprise
@@ -26,6 +25,6 @@ module Riker
     raise Error, "execute block already called for #{self}!" if command.execute_block
 
     command.execute_block = block
-    command.build!(self)
+    command.function_writer.write!(self)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riker
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre2
+  version: 0.1.0.pre4
 platform: ruby
 authors:
 - Benjamin Falk
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-26 00:00:00.000000000 Z
+date: 2022-10-07 00:00:00.000000000 Z
 dependencies: []
 description: High-Performance, Dependency-Free Command Pattern For Ruby
 email:
@@ -29,9 +29,15 @@ files:
 - bin/setup
 - lib/riker.rb
 - lib/riker/command.rb
-- lib/riker/command_parameters.rb
+- lib/riker/command/function.rb
+- lib/riker/command/function_details.rb
+- lib/riker/command/function_writer.rb
+- lib/riker/command/initialize_function.rb
+- lib/riker/command/parameters.rb
+- lib/riker/command/run_bang_function.rb
 - lib/riker/error.rb
 - lib/riker/parameter.rb
+- lib/riker/parameter/default_value.rb
 - lib/riker/version.rb
 - sig/riker.rbs
 homepage:
@@ -55,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: High-Performance, Dependency-Free Command Pattern For Ruby

data/lib/riker/command_parameters.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Riker
-  # Command Parameters
-  #
-  # This is responsible for keeping track of the command's
-  # parameters. This includes how they are used and applied
-  # to the construction of a command.
-  #
-  class CommandParameters
-    include Enumerable
-    class ParamNameTaken < ::Riker::Error; end
-    class InvalidParamName < ::Riker::Error; end
-
-    def initialize
-      # @var [Hash<Symbol, Parameter>]
-      @params = {}
-    end
-
-    # @param name [Symbol]
-    # @return [Parameters]
-    #
-    def add(name, **options)
-      validate_name!(name)
-      @params[name] = Parameter.new(name, **options)
-
-      self
-    end
-
-    # @return [String]
-    def ctor_args
-      map(&:ctor_arg).join(', ')
-    end
-
-    # @return [String]
-    def variable_sets
-      map(&:variable_set).join("\n")
-    end
-
-    # @yield [Parameter]
-    def each(&block)
-      @params.values.each(&block)
-    end
-
-    private
-
-    def validate_name!(name)
-      raise InvalidParamName unless name.is_a?(Symbol)
-      raise ParamNameTaken if @params.key?(name)
-    end
-  end
-end