squib 0.11.0 → 0.12.0

data/lib/squib/api/data.rb

@@ -3,6 +3,7 @@ require 'csv'
 require_relative '../args/input_file'
 require_relative '../args/import'
 require_relative '../args/csv_opts'
+require_relative '../import/data_frame'
 
 module Squib
 
@@ -12,7 +13,7 @@ module Squib
     import = Args::Import.new.load!(opts)
     s = Roo::Excelx.new(input.file[0])
     s.default_sheet = s.sheets[input.sheet[0]]
-    data = {}
+    data = Squib::DataFrame.new
     s.first_column.upto(s.last_column) do |col|
       header = s.cell(s.first_row, col).to_s
       header.strip! if import.strip?
@@ -39,14 +40,14 @@ module Squib
     csv_opts = Args::CSV_Opts.new(opts)
     table = CSV.parse(data, csv_opts.to_hash)
     check_duplicate_csv_headers(table)
-    hash = Hash.new
+    hash = Squib::DataFrame.new
     table.headers.each do |header|
       new_header = header.to_s
       new_header = new_header.strip if import.strip?
       hash[new_header] ||= table[header]
     end
     if import.strip?
-      new_hash = Hash.new
+      new_hash = Squib::DataFrame.new
       hash.each do |header, col|
         new_hash[header] = col.map do |str|
           str = str.strip if str.respond_to?(:strip)
@@ -78,9 +79,9 @@ module Squib
 
   # @api private
   def explode_quantities(data, qty)
-    return data unless data.key? qty.to_s.strip
+    return data unless data.col? qty.to_s.strip
     qtys = data[qty]
-    new_data = {}
+    new_data = Squib::DataFrame.new
     data.each do |col, arr|
       new_data[col] = []
       qtys.each_with_index do |qty, index|

data/lib/squib/api/groups.rb

@@ -2,13 +2,20 @@ require 'set'
 
 module Squib
 
-  # An idea for later...
-  # def enable_group_env group
-  #   ENV['SQUIB_BUILD'] ||= ''
-  #   ENV['SQUIB_BUILD'] += ','
-  #   ENV['SQUIB_BUILD'] += group
-  # end
-  # module_function :enable_group_env
+  # DSL method. See http://squib.readthedocs.io
+  def enable_build_globally group
+    groups = (ENV['SQUIB_BUILD'] ||= '').split(',')
+    ENV['SQUIB_BUILD'] = (groups << group).uniq.join(',')
+  end
+  module_function :enable_build_globally
+
+  # DSL method. See http://squib.readthedocs.io
+  def disable_build_globally group
+    groups = (ENV['SQUIB_BUILD'] ||= '').split(',')
+    groups.delete(group.to_s)
+    ENV['SQUIB_BUILD'] = groups.uniq.join(',')
+  end
+  module_function :disable_build_globally
 
   class Deck
 

data/lib/squib/api/save.rb

@@ -3,6 +3,7 @@ require_relative '../args/hand_special'
 require_relative '../args/save_batch'
 require_relative '../args/sheet'
 require_relative '../args/showcase_special'
+require_relative '../graphics/save_pdf'
 
 module Squib
   class Deck
@@ -18,7 +19,7 @@ module Squib
     def save_pdf(opts = {})
       range = Args::CardRange.new(opts[:range], deck_size: size)
       sheet = Args::Sheet.new(custom_colors, { file: 'output.pdf' }).load!(opts, expand_by: size, layout: layout, dpi: dpi)
-      render_pdf(range, sheet)
+      Graphics::SavePDF.new(self).render_pdf(range, sheet)
     end
 
     # DSL method. See http://squib.readthedocs.io

data/lib/squib/args/sheet.rb

@@ -12,14 +12,23 @@ module Squib
       include ColorValidator
       include DirValidator
 
-      def initialize(custom_colors = {}, dsl_method_defaults = {}, deck_size = 1)
+      def initialize(custom_colors = {}, dsl_method_defaults = {}, deck_size = 1, dpi = 300)
         @custom_colors = custom_colors
         @dsl_method_defaults = dsl_method_defaults
         @deck_size = deck_size
+        @dpi = dpi
       end
 
       def self.parameters
         {
+          crop_margin_bottom: 0,
+          crop_margin_left: 0,
+          crop_margin_right: 0,
+          crop_margin_top: 0,
+          crop_marks: false,
+          crop_stroke_color: :black,
+          crop_stroke_dash: '',
+          crop_stroke_width: 1.5,
           dir: '_output',
           file: 'sheet.png',
           fill_color: :white,
@@ -39,7 +48,16 @@ module Squib
       end
 
       def self.params_with_units
-        [ :gap, :height, :margin, :trim_radius, :trim, :width ]
+        [ :crop_margin_bottom, :crop_margin_left, :crop_margin_right,
+          :crop_margin_top, :gap, :height, :margin, :trim_radius, :trim,
+          :width
+        ]
+      end
+
+      def validate_crop_stroke_dash(arg)
+        arg.to_s.split.collect do |x|
+          UnitConversion.parse(x, @dpi).to_f
+        end
       end
 
       def validate_fill_color(arg)
@@ -66,6 +84,43 @@ module Squib
         "#{dir}/#{file}"
       end
 
+      def crop_coords(x, y, deck_w, deck_h)
+        [
+          { # Vertical, Upper-left
+            x1: x + trim + crop_margin_left, y1: 0,
+            x2: x + trim + crop_margin_left, y2: margin - 1
+          },
+          { # Vertical , Upper-right
+            x1: x + deck_w - trim - crop_margin_right, y1: 0,
+            x2: x + deck_w - trim - crop_margin_right, y2: margin - 1
+          },
+          { # Vertical , Lower-left
+            x1: x + trim + crop_margin_left, y1: height,
+            x2: x + trim + crop_margin_left, y2: height - margin + 1
+          },
+          { # Vertical , Lower-right
+            x1: x + deck_w - trim - crop_margin_right, y1: height,
+            x2: x + deck_w - trim - crop_margin_right, y2: height - margin + 1
+          },
+          { # Horizont al, Upper-left
+            x1: 0         , y1: y + trim + crop_margin_top,
+            x2: margin - 1, y2: y + trim + crop_margin_top
+          },
+          { # Horizontal, Upper-Right
+            x1: width             , y1: y + trim + crop_margin_top,
+            x2: width - margin + 1, y2: y + trim + crop_margin_top
+          },
+          { # Horizontal, Lower-Left
+            x1: 0         , y1: y + deck_h - trim - crop_margin_bottom,
+            x2: margin - 1, y2: y + deck_h - trim - crop_margin_bottom
+          },
+          { # Horizontal, Lower-Right
+            x1: width,              y1: y + deck_h - trim - crop_margin_bottom,
+            x2: width - margin + 1, y2: y + deck_h - trim - crop_margin_bottom
+          },
+        ]
+      end
+
     end
 
   end

data/lib/squib/card.rb

@@ -51,6 +51,14 @@ module Squib
       @cairo_context.restore
     end
 
+    def finish!
+      begin
+        @cairo_surface.finish
+      rescue Cairo::SurfaceFinishedError
+        # do nothin - if it's already finished that's fine
+      end
+    end
+
     ########################
     ### BACKEND GRAPHICS ###
     ########################

data/lib/squib/conf.rb

@@ -3,6 +3,14 @@ require 'yaml'
 require_relative 'args/typographer'
 
 module Squib
+  USER_CONFIG = {}
+
+  def configure(opts)
+    str_hash = opts.inject({}) { |h, (k, v)| h[k.to_s] = v; h }
+    USER_CONFIG.merge! str_hash
+  end
+  module_function :configure
+
   # @api private
   class Conf
 
@@ -40,7 +48,7 @@ module Squib
     }
 
     def initialize(config_hash = DEFAULTS)
-      @config_hash = config_hash
+      @config_hash = config_hash.merge USER_CONFIG # programmatic overrides yml
       @typographer = Args::Typographer.new(config_hash)
       normalize_antialias
     end

data/lib/squib/deck.rb

@@ -26,7 +26,7 @@ module Squib
     # Attributes for the width, height (in pixels) and number of cards
     # These are expected to be immuatble for the life of Deck
     # @api private
-    attr_reader :width, :height, :cards
+    attr_reader :width, :height, :cards, :progress_bar
 
     # Delegate these configuration options to the Squib::Conf object
     def_delegators :conf, :antialias, :backend, :count_format, :custom_colors, :dir,
@@ -73,6 +73,7 @@ module Squib
       if block_given?
         instance_eval(&block) # here we go. wheeeee!
       end
+      @cards.each { |c| c.finish! }
     end
 
     # Directly accesses the array of cards in the deck

data/lib/squib/graphics/save_doc.rb

@@ -1,51 +1,6 @@
 module Squib
   class Deck
 
-    # :nodoc:
-    # @api private
-    def render_pdf(range, sheet)
-      file         = "#{sheet.dir}/#{sheet.file}"
-      cc           = Cairo::Context.new(Cairo::PDFSurface.new(file, sheet.width * 72.0 / @dpi, sheet.height * 72.0 / @dpi))
-      cc.scale(72.0 / @dpi, 72.0 / @dpi) # for bug #62
-      x, y         = sheet.margin, sheet.margin
-      card_width   = @width  - 2 * sheet.trim
-      card_height  = @height - 2 * sheet.trim
-      @progress_bar.start("Saving PDF to #{file}", range.size) do |bar|
-        range.each do |i|
-          card = @cards[i]
-          cc.translate(x, y)
-          cc.rectangle(sheet.trim, sheet.trim, card_width, card_height)
-          cc.clip
-          case card.backend.downcase.to_sym
-          when :memory
-            cc.set_source(card.cairo_surface, 0, 0)
-            cc.paint
-          when :svg
-            card.cairo_surface.finish
-            cc.save
-            cc.scale(0.8, 0.8) # I really don't know why I needed to do this at all. But 0.8 is the magic number to get this to scale right
-            cc.render_rsvg_handle(RSVG::Handle.new_from_file(card.svgfile), nil)
-            cc.restore
-          else
-            abort "No such back end supported for save_pdf: #{backend}"
-          end
-          bar.increment
-          cc.reset_clip
-          cc.translate(-x, -y)
-          x += card.width + sheet.gap - 2 * sheet.trim
-          if x > (sheet.width - card_width - sheet.margin)
-            x = sheet.margin
-            y += card.height + sheet.gap - 2 * sheet.trim
-            if y > (sheet.height - card_height - sheet.margin)
-              cc.show_page # next page
-              x, y = sheet.margin, sheet.margin
-            end
-          end
-        end
-      end
-      cc.target.finish
-    end
-
     # :nodoc:
     # @api private
     def render_sheet(range, batch, sheet)

data/lib/squib/graphics/save_pdf.rb

@@ -0,0 +1,85 @@
+require_relative '../args/sheet'
+
+module Squib
+  module Graphics
+    class SavePDF
+
+      def initialize(deck)
+        @deck = deck
+      end
+
+      # :nodoc:
+      # @api private
+      def render_pdf(range, sheet)
+        cc = init_cc(sheet)
+        cc.scale(72.0 / @deck.dpi, 72.0 / @deck.dpi) # for bug #62
+        x, y         = sheet.margin, sheet.margin
+        card_width   = @deck.width  - 2 * sheet.trim
+        card_height  = @deck.height - 2 * sheet.trim
+        track_progress(range, sheet) do |bar|
+          range.each do |i|
+            card = @deck.cards[i]
+            cc.translate(x, y)
+            cc.rectangle(sheet.trim, sheet.trim, card_width, card_height)
+            cc.clip
+            case card.backend.downcase.to_sym
+            when :memory
+              cc.set_source(card.cairo_surface, 0, 0)
+              cc.paint
+            when :svg
+              card.cairo_surface.finish
+              cc.save
+              cc.scale(0.8, 0.8) # I really don't know why I needed to do this at all. But 0.8 is the magic number to get this to scale right
+              cc.render_rsvg_handle(RSVG::Handle.new_from_file(card.svgfile), nil)
+              cc.restore
+            else
+              abort "No such back end supported for save_pdf: #{backend}"
+            end
+            bar.increment
+            cc.reset_clip
+            cc.translate(-x, -y)
+            draw_crop_marks(cc, x, y, sheet) if sheet.crop_marks
+            x += card.width + sheet.gap - 2 * sheet.trim
+            if x > (sheet.width - card_width - sheet.margin)
+              x = sheet.margin
+              y += card.height + sheet.gap - 2 * sheet.trim
+              if y > (sheet.height - card_height - sheet.margin)
+                cc.show_page # next page
+                x, y = sheet.margin, sheet.margin
+              end
+            end
+          end
+        end
+        cc.target.finish
+      end
+
+      private
+
+      # Initialize the Cairo Context
+      def init_cc(sheet)
+        Cairo::Context.new(Cairo::PDFSurface.new(
+          "#{sheet.dir}/#{sheet.file}",
+          sheet.width * 72.0 / @deck.dpi,  #PDF thinks in 72 DPI "points"
+          sheet.height * 72.0 / @deck.dpi)
+        )
+      end
+
+      def track_progress(range, sheet)
+        msg = "Saving PDF to #{sheet.full_filename}"
+        @deck.progress_bar.start(msg, range.size) { |bar| yield(bar) }
+      end
+
+      def draw_crop_marks(cc, x, y, sheet)
+        sheet.crop_coords(x, y, @deck.width, @deck.height).each do |coord|
+          cc.move_to(coord[:x1], coord[:y1])
+          cc.line_to(coord[:x2], coord[:y2])
+          cc.set_source_color(sheet.crop_stroke_color)
+          cc.set_dash(sheet.crop_stroke_dash)
+          cc.set_line_width(sheet.crop_stroke_width)
+          cc.stroke
+        end
+      end
+
+    end
+  end
+end

data/lib/squib/graphics/showcase.rb

@@ -33,7 +33,7 @@ module Squib
     # :nodoc:
     # @api private
     def trim_rounded(src, trim, radius)
-      trim_cc = Cairo::Context.new(Cairo::ImageSurface.new(src.width - 2.0 * trim, src.height - 2.0 * trim))
+      trim_cc = Cairo::Context.new(Cairo::ImageSurface.new(@width - 2.0 * trim, @height - 2.0 * trim))
       trim_cc.rounded_rectangle(0, 0, trim_cc.target.width, trim_cc.target.height, radius, radius)
       trim_cc.set_source(src, -1 * trim, -1 * trim)
       trim_cc.clip

data/lib/squib/import/data_frame.rb

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+
+require 'json'
+require 'forwardable'
+
+module Squib
+  class DataFrame
+    include Enumerable
+
+    def initialize(hash = {}, def_columns = true)
+      @hash = hash
+      columns.each { |col| def_column(col) } if def_columns
+    end
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def [](i)
+      @hash[i]
+    end
+
+    def []=(col, v)
+      @hash[col] = v
+      def_column(col)
+      return v
+    end
+
+    def columns
+      @hash.keys
+    end
+
+    def ncolumns
+      @hash.keys.size
+    end
+
+    def col?(col)
+      @hash.key? col
+    end
+
+    def row(i)
+      @hash.inject(Hash.new) { |ret, (name, arr)| ret[name] = arr[i]; ret }
+    end
+
+    def nrows
+      @hash.inject(0) { |max, (_n, col)| col.size > max ? col.size : max }
+    end
+
+    def to_json
+      @hash.to_json
+    end
+
+    def to_pretty_json
+      JSON.pretty_generate(@hash)
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_pretty_text
+      max_col = columns.inject(0) { |max, c | c.length > max ? c.length : max }
+      top    = " ╭#{'-' * 36}╮\n"
+      bottom = " ╰#{'-' * 36}╯\n"
+      str =  ''
+      0.upto(nrows - 1) do | i |
+        str += (' ' * max_col) + top
+        row(i).each do |col, data|
+          str += "#{col.rjust(max_col)} #{wrap_n_pad(data, max_col)}"
+        end
+        str += (' ' * max_col) + bottom
+      end
+      return str
+    end
+
+    private
+
+    def snake_case(str)
+      str.to_s.
+          strip.
+          gsub(/\s+/,'_').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z]+)([A-Z])/,'\1_\2').
+          downcase.
+          to_sym
+    end
+
+    def wrap_n_pad(str, max_col)
+      str.to_s.
+          concat(' '). # handle nil & empty strings
+          scan(/.{1,34}/).
+          map { |s| (' ' * max_col) + " | " + s.ljust(34) }.
+          join(" |\n").
+          lstrip.      # initially no whitespace next to key
+          concat(" |\n")
+    end
+
+    def def_column(col)
+      raise "Column #{col} - does not exist" unless @hash.key? col
+      method_name = snake_case(col)
+      return if self.class.method_defined?(method_name) #warn people? or skip?
+      define_singleton_method method_name do
+        @hash[col]
+      end
+    end
+
+  end
+end