cleaner method sigs

lib/squib/args/box.rb

@@ -2,8 +2,7 @@ require_relative 'arg_loader'
 
 module Squib::Args
 
-  module_function
+  module_function def extract_box(opts, deck, dsl_method_defaults = {})
-  def extract_box(opts, deck, dsl_method_defaults = {})
     Box.new(deck, dsl_method_defaults).extract!(opts, deck)
   end
 

lib/squib/args/card_range.rb

@@ -1,32 +1,34 @@
-module Squib
+module Squib::Args
-  # @api private
-  module Args
-    class CardRange
-      include Enumerable
 
-      def initialize(input, deck_size: 1)
+  module_function def extract_range(opts, deck)
-        @range = validate(input, deck_size)
+    CardRange.new(opts[:range], deck_size: deck.size)
-      end
+  end
+
+  class CardRange
+    include Enumerable
 
-      # Hook into enumerable by delegating to @range
+    def initialize(input, deck_size: 1)
-      def each(&block)
+      @range = validate(input, deck_size)
-        @range.each { |i| block.call(i) }
+    end
-      end
 
-      def size
+    # Hook into enumerable by delegating to @range
-        @range.size
+    def each(&block)
-      end
+      @range.each { |i| block.call(i) }
+    end
 
-      private
+    def size
-      def validate(input, deck_size)
+      @range.size
-        input ||= :all # default
+    end
-        input = 0..(deck_size - 1) if input == :all
-        input = (input.to_i)..(input.to_i) if input.respond_to? :to_i
-        raise ArgumentError.new("#{input} must be Enumerable (i.e. respond_to :each).") unless input.respond_to? :each
-        raise ArgumentError.new("#{input} is outside of deck range of 0..#{deck_size - 1}") if (!input.max.nil?) && (input.max > (deck_size - 1))
-        input
-      end
 
+    private
+    def validate(input, deck_size)
+      input ||= :all # default
+      input = 0..(deck_size - 1) if input == :all
+      input = (input.to_i)..(input.to_i) if input.respond_to? :to_i
+      raise ArgumentError.new("#{input} must be Enumerable (i.e. respond_to :each).") unless input.respond_to? :each
+      raise ArgumentError.new("#{input} is outside of deck range of 0..#{deck_size - 1}") if (!input.max.nil?) && (input.max > (deck_size - 1))
+      input
     end
+
   end
 end

lib/squib/args/draw.rb

@@ -2,91 +2,92 @@ require 'cairo'
 require_relative 'arg_loader'
 require_relative 'color_validator'
 
-module Squib
+module Squib::Args
-  # @api private
-  module Args
 
-    class Draw
+  module_function def extract_draw(opts, deck, dsl_method_defaults = {})
-      include ArgLoader
+    Draw.new(deck.custom_colors, dsl_method_defaults).extract!(opts, deck)
-      include ColorValidator
+  end
 
-      def initialize(custom_colors, dsl_method_defaults = {})
+  class Draw
-        @custom_colors = custom_colors
+    include ArgLoader
-        @dsl_method_defaults = dsl_method_defaults
+    include ColorValidator
-      end
 
-      def self.parameters
+    def initialize(custom_colors, dsl_method_defaults = {})
-        { color: :black,
+      @custom_colors = custom_colors
-          fill_color: '#0000',
+      @dsl_method_defaults = dsl_method_defaults
-          stroke_color: :black,
+    end
-          stroke_width: 2.0,
-          stroke_strategy: :fill_first,
-          join: :miter,
-          cap: 'butt',
-          dash: ''
-        }
-      end
 
-      def self.expanding_parameters
+    def self.parameters
-        parameters.keys # all of them are expandable
+      { color: :black,
-      end
+        fill_color: '#0000',
+        stroke_color: :black,
+        stroke_width: 2.0,
+        stroke_strategy: :fill_first,
+        join: :miter,
+        cap: 'butt',
+        dash: ''
+      }
+    end
 
-      def self.params_with_units
+    def self.expanding_parameters
-        [:stroke_width]
+      parameters.keys # all of them are expandable
-      end
+    end
 
-      def validate_join(arg, _i)
+    def self.params_with_units
-        case arg.to_s.strip.downcase
+      [:stroke_width]
-        when 'miter'
+    end
-          Cairo::LINE_JOIN_MITER
-        when 'round'
-          Cairo::LINE_JOIN_ROUND
-        when 'bevel'
-          Cairo::LINE_JOIN_BEVEL
-        end
-      end
 
-      def validate_cap(arg, _i)
+    def validate_join(arg, _i)
-        case arg.to_s.strip.downcase
+      case arg.to_s.strip.downcase
-        when 'butt'
+      when 'miter'
-          Cairo::LINE_CAP_BUTT
+        Cairo::LINE_JOIN_MITER
-        when 'round'
+      when 'round'
-          Cairo::LINE_CAP_ROUND
+        Cairo::LINE_JOIN_ROUND
-        when 'square'
+      when 'bevel'
-          Cairo::LINE_CAP_SQUARE
+        Cairo::LINE_JOIN_BEVEL
-        end
       end
+    end
 
-      def validate_dash(arg, _i)
+    def validate_cap(arg, _i)
-        arg.to_s.split.collect do |x|
+      case arg.to_s.strip.downcase
-          UnitConversion.parse(x, @dpi).to_f
+      when 'butt'
-        end
+        Cairo::LINE_CAP_BUTT
+      when 'round'
+        Cairo::LINE_CAP_ROUND
+      when 'square'
+        Cairo::LINE_CAP_SQUARE
       end
+    end
 
-      def validate_fill_color(arg, _i)
+    def validate_dash(arg, _i)
-        colorify(arg, @custom_colors)
+      arg.to_s.split.collect do |x|
+        UnitConversion.parse(x, @dpi).to_f
       end
+    end
 
-      def validate_stroke_color(arg, _i)
+    def validate_fill_color(arg, _i)
-        colorify(arg, @custom_colors)
+      colorify(arg, @custom_colors)
-      end
+    end
 
-      def validate_color(arg, _i)
+    def validate_stroke_color(arg, _i)
-        colorify(arg, @custom_colors)
+      colorify(arg, @custom_colors)
-      end
+    end
 
-      def validate_stroke_strategy(arg, _i)
+    def validate_color(arg, _i)
-        case arg.to_s.downcase.strip
+      colorify(arg, @custom_colors)
-        when 'fill_first'
+    end
-          :fill_first
-        when 'stroke_first'
-          :stroke_first
-        else
-          raise "Only 'stroke_first' or 'fill_first' allowed"
-        end
-      end
 
+    def validate_stroke_strategy(arg, _i)
+      case arg.to_s.downcase.strip
+      when 'fill_first'
+        :fill_first
+      when 'stroke_first'
+        :stroke_first
+      else
+        raise "Only 'stroke_first' or 'fill_first' allowed"
+      end
     end
 
   end
+
 end

lib/squib/dsl/background.rb

@@ -26,8 +26,8 @@ module Squib
 
       def run(opts)
         warn_if_unexpected opts
-        range = Args::CardRange.new(opts[:range], deck_size: deck.size)
+        range = Args.extract_range opts, deck
-        draw  = Args::Draw.new(@deck.custom_colors).extract!(opts, deck)
+        draw  = Args.extract_draw opts, deck
         range.each { |i| @deck.cards[i].background(draw.color[i]) }
       end
     end

lib/squib/dsl/grid.rb

@@ -25,9 +25,9 @@ module Squib
 
       def run(opts)
         warn_if_unexpected opts
-        range = Args::CardRange.new(opts[:range], deck_size: deck.size)
+        range = Args.extract_range opts, deck
-        draw  = Args::Draw.new(@deck.custom_colors).extract!(opts, deck)
+        draw  = Args.extract_draw opts, deck
-        box   = Args.extract_box(opts, deck)
+        box   = Args.extract_box opts, deck
         range.each { |i| deck.cards[i].grid(box[i], draw[i]) }
       end
     end