squib 0.18.0 → 0.19.0a

data/lib/squib/args/arg_loader.rb

@@ -1,138 +1,138 @@
-require_relative '../constants'
-require_relative '../conf'
-require 'ostruct'
-
-# Intended to be used a a mix-in,
-# For example use see Box as an example
-module Squib::Args::ArgLoader
-
-  # wrapper for compatibility
-  def extract!(args, deck)
-    @deck = deck
-    load!(args,
-          expand_by: deck.size,
-          layout: deck.layout,
-          dpi: deck.dpi,
-          cell_px: deck.cell_px)
-  end
-
-  # Main class invoked by the client (i.e. dsl/ methods)
-  def load!(args, expand_by: 1, layout: {}, dpi: 300, cell_px: 37.5)
-    @dpi = dpi
-    @cell_px = cell_px
-    args[:layout] = prep_layout_args(args[:layout], expand_by: expand_by)
-    expand_and_set_and_defaultify(args: args, by: expand_by, layout: layout)
-    validate
-    convert_units dpi: dpi, cell_px: cell_px
-    self
-  end
-
-  def expand_and_set_and_defaultify(args: {}, by: 1, layout: {})
-    attributes = self.class.parameters.keys
-    attributes.each do |p|
-      args[p] = defaultify(p, args, layout)
-      val = if expandable_singleton?(p, args[p])
-              [args[p]] * by
-            else
-              args[p] # not an expanding parameter
-            end
-      instance_variable_set "@#{p}", val
-    end
-    self.class.class_eval { attr_reader *(attributes) }
-  end
-
-  # Must be:
-  #  (a) an expanding parameter, and
-  #  (b) a singleton already (i.e. doesn't respond to :each)
-  def expandable_singleton?(p, arg)
-    self.class.expanding_parameters.include?(p) && !arg.respond_to?(:each)
-  end
-
-  # Incorporate defaults and layouts
-  #  (1) Use whatever is specified if it is
-  #  (2) Go over all layout specifications (if any) and look them up
-  #     - Use layout when it's specified for that card
-  #     - Use "default" if no layout was specified, or the layout itself did not specify
-  #           Defaut can be overriden for a given dsl method (@dsl_method_defaults)
-  #           (e.g stroke width is 0.0 for text, non-zero everywhere else)
-  #
-  def defaultify(p, args, layout)
-    return args[p] if args.key? p # arg was specified, no defaults used
-    defaults = self.class.parameters.merge(@dsl_method_defaults || {})
-    args[:layout].map do |layout_arg|
-      return defaults[p] if layout_arg.nil?  # no layout specified, use default
-      unless layout.key? layout_arg.to_s     # specified a layout, but it doesn't exist in layout. Oops!
-        Squib.logger.warn("Layout \"#{layout_arg.to_s}\" does not exist in layout file - using default instead")
-        return defaults[p]
-      end
-      if layout[layout_arg.to_s].key?(p.to_s)
-        layout[layout_arg.to_s][p.to_s]     # param specified in layout
-      else
-        defaults[p]                         # layout specified, but not this param
-      end
-    end
-  end
-
-  # Do singleton expansion on the layout argument as well
-  # Treated differently since layout is not always specified
-  def prep_layout_args(layout_args, expand_by: 1)
-    unless layout_args.respond_to?(:each)
-      layout_args = [layout_args] * expand_by
-    end
-    layout_args || []
-  end
-
-  # For each parameter/attribute foo we try to invoke a validate_foo
-  def validate
-    self.class.parameters.each do |param, default|
-      method = "validate_#{param}"
-      if self.respond_to? method
-        attribute = "@#{param}"
-        val = instance_variable_get(attribute)
-        if val.respond_to? :each
-          new_val = val.map.with_index{ |v, i| send(method, v, i) }
-          instance_variable_set(attribute, new_val)
-        else
-          instance_variable_set(attribute, send(method, val))
-        end
-      end
-    end
-  end
-
-  # Access an individual arg for a given card
-  # @return an OpenStruct that looks just like the mixed-in class
-  # @api private
-  def [](i)
-    card_arg = OpenStruct.new
-    self.class.expanding_parameters.each do |p|
-      p_val = instance_variable_get("@#{p}")
-      card_arg[p] = p_val[i]
-    end
-    card_arg
-  end
-
-  # Convert units
-  def convert_units(dpi: 300, cell_px: 37.5)
-    self.class.params_with_units.each do |p|
-      p_str = "@#{p}"
-      p_val = instance_variable_get(p_str)
-      if p_val.respond_to? :each
-        arr = p_val.map { |x| Squib::Args::UnitConversion.parse(x, dpi, cell_px) }
-        instance_variable_set p_str, arr
-      else
-        instance_variable_set p_str, Squib::Args::UnitConversion.parse(p_val, dpi, cell_px)
-      end
-    end
-    self
-  end
-
-  # Return the deck's configuration
-  # This keeps the @deck local to this mixin instead of forcing args classes
-  # to "know" that @deck works.
-  #
-  # It also makes unit testing easier. Sue me.
-  def deck_conf
-    @deck.conf
-  end
-
-end
+require_relative '../constants'
+require_relative '../conf'
+require 'ostruct'
+
+# Intended to be used a a mix-in,
+# For example use see Box as an example
+module Squib::Args::ArgLoader
+
+  # wrapper for compatibility
+  def extract!(args, deck)
+    @deck = deck
+    load!(args,
+          expand_by: deck.size,
+          layout: deck.layout,
+          dpi: deck.dpi,
+          cell_px: deck.cell_px)
+  end
+
+  # Main class invoked by the client (i.e. dsl/ methods)
+  def load!(args, expand_by: 1, layout: {}, dpi: 300, cell_px: 37.5)
+    @dpi = dpi
+    @cell_px = cell_px
+    args[:layout] = prep_layout_args(args[:layout], expand_by: expand_by)
+    expand_and_set_and_defaultify(args: args, by: expand_by, layout: layout)
+    validate
+    convert_units dpi: dpi, cell_px: cell_px
+    self
+  end
+
+  def expand_and_set_and_defaultify(args: {}, by: 1, layout: {})
+    attributes = self.class.parameters.keys
+    attributes.each do |p|
+      args[p] = defaultify(p, args, layout)
+      val = if expandable_singleton?(p, args[p])
+              [args[p]] * by
+            else
+              args[p] # not an expanding parameter
+            end
+      instance_variable_set "@#{p}", val
+    end
+    self.class.class_eval { attr_reader *(attributes) }
+  end
+
+  # Must be:
+  #  (a) an expanding parameter, and
+  #  (b) a singleton already (i.e. doesn't respond to :each)
+  def expandable_singleton?(p, arg)
+    self.class.expanding_parameters.include?(p) && !arg.respond_to?(:each)
+  end
+
+  # Incorporate defaults and layouts
+  #  (1) Use whatever is specified if it is
+  #  (2) Go over all layout specifications (if any) and look them up
+  #     - Use layout when it's specified for that card
+  #     - Use "default" if no layout was specified, or the layout itself did not specify
+  #           Defaut can be overriden for a given dsl method (@dsl_method_defaults)
+  #           (e.g stroke width is 0.0 for text, non-zero everywhere else)
+  #
+  def defaultify(p, args, layout)
+    return args[p] if args.key? p # arg was specified, no defaults used
+    defaults = self.class.parameters.merge(@dsl_method_defaults || {})
+    args[:layout].map do |layout_arg|
+      return defaults[p] if layout_arg.nil?  # no layout specified, use default
+      unless layout.key? layout_arg.to_s     # specified a layout, but it doesn't exist in layout. Oops!
+        Squib.logger.warn("Layout \"#{layout_arg.to_s}\" does not exist in layout file - using default instead")
+        return defaults[p]
+      end
+      if layout[layout_arg.to_s].key?(p.to_s)
+        layout[layout_arg.to_s][p.to_s]     # param specified in layout
+      else
+        defaults[p]                         # layout specified, but not this param
+      end
+    end
+  end
+
+  # Do singleton expansion on the layout argument as well
+  # Treated differently since layout is not always specified
+  def prep_layout_args(layout_args, expand_by: 1)
+    unless layout_args.respond_to?(:each)
+      layout_args = [layout_args] * expand_by
+    end
+    layout_args || []
+  end
+
+  # For each parameter/attribute foo we try to invoke a validate_foo
+  def validate
+    self.class.parameters.each do |param, default|
+      method = "validate_#{param}"
+      if self.respond_to? method
+        attribute = "@#{param}"
+        val = instance_variable_get(attribute)
+        if val.respond_to? :each
+          new_val = val.map.with_index{ |v, i| send(method, v, i) }
+          instance_variable_set(attribute, new_val)
+        else
+          instance_variable_set(attribute, send(method, val))
+        end
+      end
+    end
+  end
+
+  # Access an individual arg for a given card
+  # @return an OpenStruct that looks just like the mixed-in class
+  # @api private
+  def [](i)
+    card_arg = OpenStruct.new
+    self.class.expanding_parameters.each do |p|
+      p_val = instance_variable_get("@#{p}")
+      card_arg[p] = p_val[i]
+    end
+    card_arg
+  end
+
+  # Convert units
+  def convert_units(dpi: 300, cell_px: 37.5)
+    self.class.params_with_units.each do |p|
+      p_str = "@#{p}"
+      p_val = instance_variable_get(p_str)
+      if p_val.respond_to? :each
+        arr = p_val.map { |x| Squib::Args::UnitConversion.parse(x, dpi, cell_px) }
+        instance_variable_set p_str, arr
+      else
+        instance_variable_set p_str, Squib::Args::UnitConversion.parse(p_val, dpi, cell_px)
+      end
+    end
+    self
+  end
+
+  # Return the deck's configuration
+  # This keeps the @deck local to this mixin instead of forcing args classes
+  # to "know" that @deck works.
+  #
+  # It also makes unit testing easier. Sue me.
+  def deck_conf
+    @deck.conf
+  end
+
+end

data/lib/squib/args/box.rb

@@ -1,59 +1,59 @@
-require_relative 'arg_loader'
-require_relative 'xywh_shorthands'
-
-module Squib::Args
-
-  module_function def extract_box(opts, deck, dsl_method_defaults = {})
-    Box.new(deck, dsl_method_defaults).extract!(opts, deck)
-  end
-
-  class Box
-    include ArgLoader
-    include XYWHShorthands
-
-    def initialize(deck = nil, dsl_method_defaults = {})
-      @deck = deck
-      @dsl_method_defaults = dsl_method_defaults
-    end
-
-    def self.parameters
-      { x: 0, y: 0,
-        width: :deck, height: :deck,
-        radius: nil, x_radius: 0, y_radius: 0
-      }
-    end
-
-    def self.expanding_parameters
-      parameters.keys # all of them
-    end
-
-    def self.params_with_units
-      parameters.keys # all of them
-    end
-
-    def validate_x(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_y(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
-
-    def validate_width(arg, _i)
-      return arg if @deck.nil?
-      apply_shorthands(arg, @deck, axis: :x)
-    end
-
-    def validate_height(arg, _i)
-      return arg if @deck.nil?
-      apply_shorthands(arg, @deck, axis: :y)
-    end
-
-    def validate_x_radius(arg, i)
-      return radius[i] unless radius[i].nil?
-      arg
-    end
-
-    def validate_y_radius(arg, i)
-      return radius[i] unless radius[i].nil?
-      arg
-    end   
-
-  end
-
-end
+require_relative 'arg_loader'
+require_relative 'xywh_shorthands'
+
+module Squib::Args
+
+  module_function def extract_box(opts, deck, dsl_method_defaults = {})
+    Box.new(deck, dsl_method_defaults).extract!(opts, deck)
+  end
+
+  class Box
+    include ArgLoader
+    include XYWHShorthands
+
+    def initialize(deck = nil, dsl_method_defaults = {})
+      @deck = deck
+      @dsl_method_defaults = dsl_method_defaults
+    end
+
+    def self.parameters
+      { x: 0, y: 0,
+        width: :deck, height: :deck,
+        radius: nil, x_radius: 0, y_radius: 0
+      }
+    end
+
+    def self.expanding_parameters
+      parameters.keys # all of them
+    end
+
+    def self.params_with_units
+      parameters.keys # all of them
+    end
+
+    def validate_x(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_y(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
+
+    def validate_width(arg, _i)
+      return arg if @deck.nil?
+      apply_shorthands(arg, @deck, axis: :x)
+    end
+
+    def validate_height(arg, _i)
+      return arg if @deck.nil?
+      apply_shorthands(arg, @deck, axis: :y)
+    end
+
+    def validate_x_radius(arg, i)
+      return radius[i] unless radius[i].nil?
+      arg
+    end
+
+    def validate_y_radius(arg, i)
+      return radius[i] unless radius[i].nil?
+      arg
+    end   
+
+  end
+
+end

data/lib/squib/args/card_range.rb

@@ -1,34 +1,34 @@
-module Squib::Args
-
-  module_function def extract_range(opts, deck)
-    CardRange.new(opts[:range], deck_size: deck.size)
-  end
-
-  class CardRange
-    include Enumerable
-
-    def initialize(input, deck_size: 1)
-      @range = validate(input, deck_size)
-    end
-
-    # Hook into enumerable by delegating to @range
-    def each(&block)
-      @range.each { |i| block.call(i) }
-    end
-
-    def size
-      @range.size
-    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
+module Squib::Args
+
+  module_function def extract_range(opts, deck)
+    CardRange.new(opts[:range], deck_size: deck.size)
+  end
+
+  class CardRange
+    include Enumerable
+
+    def initialize(input, deck_size: 1)
+      @range = validate(input, deck_size)
+    end
+
+    # Hook into enumerable by delegating to @range
+    def each(&block)
+      @range.each { |i| block.call(i) }
+    end
+
+    def size
+      @range.size
+    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

data/lib/squib/args/color_validator.rb

@@ -1,7 +1,7 @@
-module Squib::Args::ColorValidator
-
-  def colorify(color, custom_colors = {})
-    custom_colors[color.to_s] || color.to_s
-  end
-
-end
+module Squib::Args::ColorValidator
+
+  def colorify(color, custom_colors = {})
+    custom_colors[color.to_s] || color.to_s
+  end
+
+end

data/lib/squib/args/coords.rb

@@ -1,49 +1,49 @@
-require_relative 'arg_loader'
-require_relative 'xywh_shorthands'
-
-module Squib::Args
-  module_function def extract_coords(opts, deck)
-    Coords.new.extract!(opts, deck)
-  end
-
-  class Coords
-    include ArgLoader
-    include XYWHShorthands
-
-    def self.parameters
-      { x: 0,    y: 0,
-        x1: 100, y1: 100,
-        x2: 150, y2: 150,
-        x3: 100, y3: 150,
-        cx1: 0 , cy1: 0,
-        cx2: 0 , cy2: 0,
-        inner_radius: 50, outer_radius: 100,
-        radius: 100,
-        n: 5,
-        arc_start: 0, arc_end: 2 * Math::PI, arc_direction: :clockwise, arc_close: false,
-     }
-    end
-
-    def self.expanding_parameters
-      parameters.keys # all of them
-    end
-
-    def self.params_with_units
-      parameters.keys # all of them
-    end
-
-    def validate_x(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_y(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
-    def validate_x1(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_y1(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
-    def validate_x2(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_y2(arg,_i) apply_shorthands(arg, @deck, axis: :y)end
-    def validate_x3(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_y3(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
-    def validate_cx1(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_cy1(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
-    def validate_cx2(arg, i) apply_shorthands(arg, @deck, axis: :x) end
-    def validate_cy2(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
-  end
-
-end
+require_relative 'arg_loader'
+require_relative 'xywh_shorthands'
+
+module Squib::Args
+  module_function def extract_coords(opts, deck)
+    Coords.new.extract!(opts, deck)
+  end
+
+  class Coords
+    include ArgLoader
+    include XYWHShorthands
+
+    def self.parameters
+      { x: 0,    y: 0,
+        x1: 100, y1: 100,
+        x2: 150, y2: 150,
+        x3: 100, y3: 150,
+        cx1: 0 , cy1: 0,
+        cx2: 0 , cy2: 0,
+        inner_radius: 50, outer_radius: 100,
+        radius: 100,
+        n: 5,
+        arc_start: 0, arc_end: 2 * Math::PI, arc_direction: :clockwise, arc_close: false,
+     }
+    end
+
+    def self.expanding_parameters
+      parameters.keys # all of them
+    end
+
+    def self.params_with_units
+      parameters.keys # all of them
+    end
+
+    def validate_x(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_y(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
+    def validate_x1(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_y1(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
+    def validate_x2(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_y2(arg,_i) apply_shorthands(arg, @deck, axis: :y)end
+    def validate_x3(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_y3(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
+    def validate_cx1(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_cy1(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
+    def validate_cx2(arg, i) apply_shorthands(arg, @deck, axis: :x) end
+    def validate_cy2(arg,_i) apply_shorthands(arg, @deck, axis: :y) end
+  end
+
+end

data/lib/squib/args/csv_opts.rb

@@ -1,22 +1,22 @@
-require 'csv'
-
-module Squib::Args
-  class CSV_Opts
-
-    def initialize(opts)
-      opts = opts.keep_if { |k, _v| CSV::DEFAULT_OPTIONS.key? k}
-      @hash = CSV::DEFAULT_OPTIONS.merge(opts).merge(required)
-    end
-
-    def to_hash
-      @hash
-    end
-
-    private
-
-    def required
-      { headers: true, converters: :numeric }
-    end
-
-  end
-end
+require 'csv'
+
+module Squib::Args
+  class CSV_Opts
+
+    def initialize(opts)
+      opts = opts.keep_if { |k, _v| CSV::DEFAULT_OPTIONS.key? k}
+      @hash = CSV::DEFAULT_OPTIONS.merge(opts).merge(required)
+    end
+
+    def to_hash
+      @hash
+    end
+
+    private
+
+    def required
+      { headers: true, converters: :numeric }
+    end
+
+  end
+end

data/lib/squib/args/dir_validator.rb

@@ -1,11 +1,11 @@
-module Squib::Args::DirValidator
-
-  def ensure_dir_created(dir)
-    unless Dir.exists?(dir)
-      Squib.logger.warn "Dir '#{dir}' does not exist, creating it."
-      FileUtils.mkdir_p dir
-    end
-    return dir
-  end
-
-end
+module Squib::Args::DirValidator
+
+  def ensure_dir_created(dir)
+    unless Dir.exist?(dir)
+      Squib.logger.warn "Dir '#{dir}' does not exist, creating it."
+      FileUtils.mkdir_p dir
+    end
+    return dir
+  end
+
+end