marty 2.5.2 → 2.5.4

data/lib/marty/schema_helper.rb

@@ -1,53 +1,43 @@
 class Marty::SchemaHelper
   include Delorean::Model
 
-  delorean_fn :enum_is, sig: 2 do
-    |var, value|
-    {"properties"=> {var => { "enum"=> value}}}
+  delorean_fn :enum_is, sig: 2 do |var, value|
+    { 'properties' => { var => { 'enum' => value } } }
   end
 
-  delorean_fn :bool_is, sig: 2 do
-    |var, value|
-    {"allOf"=>[{"required"=>[var]},
-               {"properties"=> {var => { "type"=> "boolean", "enum"=> [value]}}}]}
+  delorean_fn :bool_is, sig: 2 do |var, value|
+    { 'allOf' => [{ 'required' => [var] },
+                  { 'properties' => { var => { 'type' => 'boolean', 'enum' => [value] } } }] }
   end
 
-  delorean_fn :or, sig: [1, 20] do
-    |*args|
-    {"anyOf"=>args}
+  delorean_fn :or, sig: [1, 20] do |*args|
+    { 'anyOf' => args }
   end
 
-  delorean_fn :and, sig: [1, 20] do
-    |*args|
-    {"allOf"=>args}
+  delorean_fn :and, sig: [1, 20] do |*args|
+    { 'allOf' => args }
   end
 
-  delorean_fn :not, sig: 1 do
-    |arg|
-    {"not"=>{"allOf"=>[arg]}}
+  delorean_fn :not, sig: 1 do |arg|
+    { 'not' => { 'allOf' => [arg] } }
   end
 
   # if conds is true, var_array columns we be required
-  delorean_fn :disallow_if_conds, sig: [2, 20] do
-    |var_array, *conds_array|
-    {"anyOf"=>[{"not"=>{"allOf"=> conds_array}},
-               {"properties"=> var_array.each_with_object({}) do
-                  |v,h|
-                  h[v] = { "not" => {} }
-                end
-               }]}
+  delorean_fn :disallow_if_conds, sig: [2, 20] do |var_array, *conds_array|
+    { 'anyOf' => [{ 'not' => { 'allOf' => conds_array } },
+                  { 'properties' => var_array.each_with_object({}) do |v, h|
+                     h[v] = { 'not' => {} }
+                                    end
+                  }] }
   end
 
-
   # if param is present, disallow cols
-  delorean_fn :disallow_if_present, sig: [2, 20] do
-    |dep_column, *var_array|
+  delorean_fn :disallow_if_present, sig: [2, 20] do |dep_column, *var_array|
     dep_check(dep_column,
-              {"properties"=> var_array.each_with_object({}) do
-                 |v,h|
-                 h[v] = { "not" => {} }
-               end
-              })
+              'properties' => var_array.each_with_object({}) do |v, h|
+                h[v] = { 'not' => {} }
+                              end
+             )
   end
 
   # if param is not present, disallow cols
@@ -57,30 +47,26 @@ class Marty::SchemaHelper
   #  it will report both the required clause and the not clauses
   #  as failed.   so the caller will see a message that a
   #  required field is missing (which is not really a required field)
-  delorean_fn :disallow_if_not_present, sig: [2, 20] do
-    |dep_column, *var_array|
-    { "anyOf" => [
-        {"required" => [dep_column] },
-        {"properties"=> var_array.each_with_object({}) do
-           |v,h|
-           h[v] = { "not" => {} }
-         end
-        }]}
+  delorean_fn :disallow_if_not_present, sig: [2, 20] do |dep_column, *var_array|
+    { 'anyOf' => [
+      { 'required' => [dep_column] },
+      { 'properties' => var_array.each_with_object({}) do |v, h|
+         h[v] = { 'not' => {} }
+                        end
+      }
+    ] }
   end
 
   # if conds is true, var_array columns are not allowed
-  delorean_fn :required_if, sig: [2, 20] do
-    |var_array, *conds_array|
-    {"anyOf"=>[{"not"=>{"allOf"=> conds_array}},
-               {"required"=>var_array}]}
+  delorean_fn :required_if, sig: [2, 20] do |var_array, *conds_array|
+    { 'anyOf' => [{ 'not' => { 'allOf' => conds_array } },
+                  { 'required' => var_array }] }
   end
 
   # if dep_column is present, checks must pass
-  delorean_fn :dep_check, sig: [2, 20] do
-    |dep_column, *checks|
-    {"dependencies"=> {dep_column =>
-                       {"type"=>"object",
-                        "allOf"=> checks}}}
+  delorean_fn :dep_check, sig: [2, 20] do |dep_column, *checks|
+    { 'dependencies' => { dep_column =>
+                       { 'type' => 'object',
+                        'allOf' => checks } } }
   end
-
 end

data/lib/marty/util.rb

@@ -8,16 +8,17 @@ module Marty::Util
   def self.get_posting
     sid = Netzke::Base.session && Netzke::Base.session[:posting]
     return unless sid.is_a? Integer
+
     sid && Marty::Posting.find_by_id(sid)
   end
 
   def self.get_posting_time
-    snap = self.get_posting
+    snap = get_posting
     snap ? snap.created_dt : Float::INFINITY
   end
 
   def self.warped?
-    self.get_posting_time != Float::INFINITY
+    get_posting_time != Float::INFINITY
   end
 
   def self.logger
@@ -34,21 +35,21 @@ module Marty::Util
   end
 
   def self.pg_range_to_human(r)
-    return r if r == "empty" || r.nil?
+    return r if r == 'empty' || r.nil?
 
     m = pg_range_match(r)
 
     raise "bad PG range #{r}" unless m
 
-    if m[:start] == ""
-      res = ""
+    if m[:start] == ''
+      res = ''
     else
-      op = m[:open] == "(" ? ">" : ">="
+      op = m[:open] == '(' ? '>' : '>='
       res = "#{op}#{m[:start]}"
     end
 
-    if m[:end] != ""
-      op = m[:close] == ")" ? "<" : "<="
+    if m[:end] != ''
+      op = m[:close] == ')' ? '<' : '<='
       res += "#{op}#{m[:end]}"
     end
 
@@ -56,7 +57,7 @@ module Marty::Util
   end
 
   def self.human_to_pg_range(r)
-    return r if r == "empty"
+    return r if r == 'empty'
 
     m = /\A
     ((?<op0>\>|\>=)(?<start>[^\<\>\=]*?))?
@@ -66,17 +67,17 @@ module Marty::Util
     raise "bad range #{r}" unless m
 
     if m[:op0]
-      open = m[:op0] == ">" ? "(" : "["
+      open = m[:op0] == '>' ? '(' : '['
       start = "#{open}#{m[:start]}"
     else
-      start = "["
+      start = '['
     end
 
     if m[:op1]
-      close = m[:op1] == "<" ? ")" : "]"
+      close = m[:op1] == '<' ? ')' : ']'
       ends = "#{m[:end]}#{close}"
     else
-      ends = "]"
+      ends = ']'
     end
 
     "#{start},#{ends}"
@@ -88,7 +89,7 @@ module Marty::Util
       sql = 'select pg_is_in_recovery();'
       result = ActiveRecord::Base.connection.execute(sql)
       status = result[0]['pg_is_in_recovery'] == 't' if result && result[0]
-    rescue => e
+    rescue StandardError => e
       Marty::Util.logger.error 'unable to determine recovery status'
     end
     status
@@ -97,14 +98,14 @@ module Marty::Util
   def self.deep_round(obj, digits)
     case obj
     when Array
-      obj.map {|o| deep_round(o, digits)}
+      obj.map { |o| deep_round(o, digits) }
     when Hash
-      obj.inject({}) { |result, (key, value)|
+      obj.inject({}) do |result, (key, value)|
         result[key] = deep_round(value, digits)
         result
-      }
+      end
     else
-      obj.is_a?(Float)? obj.round(digits) : obj
+      obj.is_a?(Float) ? obj.round(digits) : obj
     end
   end
 
@@ -113,7 +114,7 @@ module Marty::Util
     engine = Marty::ScriptSet.new.get_engine(script_name)
     res = engine.background_eval(node_name,
                                  params,
-                                 ["result", "title", "format"],
+                                 ['result', 'title', 'format'],
                                 )
 
     promise_id = res.__promise__.id
@@ -127,18 +128,18 @@ module Marty::Util
     engine = Marty::ScriptSet.new.get_engine(script)
     format = engine.evaluate(node, 'format')
     title  = params.delete(:title) || engine.evaluate(node, 'title')
-    data   = ({selected_script_name: script,
-               selected_node: node} + params).to_json
+    data   = ({ selected_script_name: script,
+               selected_node: node } + params).to_json
     URI.encode("#{Marty::Util.marty_path}/report?data=#{data}"\
                "&reptitle=#{title}&format=#{format}")
   end
 
   def self.scrub_obj(obj)
-    trav = lambda {|o|
+    trav = lambda { |o|
            if o.is_a?(Hash)
-             return o.each_with_object({}) {|(k, v), h| h[k] = trav.call(v)}
+             return o.each_with_object({}) { |(k, v), h| h[k] = trav.call(v) }
            elsif o.is_a?(Array)
-             return o.map {|v| trav.call(v)}
+             return o.map { |v| trav.call(v) }
            elsif o.to_s.length > 10000
              o.class.to_s
            else

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "2.5.2"
+  VERSION = '2.5.4'
 end

data/lib/marty/xl.rb

@@ -12,10 +12,10 @@ class Marty::Xl
   end
 
   def deep_copy(value)
-    return value.each_with_object({}){|(k, v), h| h[k] = deep_copy(v)} if
+    return value.each_with_object({}) { |(k, v), h| h[k] = deep_copy(v) } if
       value.is_a?(Hash)
 
-    value.is_a?(Array) ? value.map{|v| deep_copy(v)} : value
+    value.is_a?(Array) ? value.map { |v| deep_copy(v) } : value
   end
 
   def merge_cell_edges(a, b)
@@ -25,10 +25,9 @@ class Marty::Xl
 
     return b unless a_border.is_a?(Hash) && a_border[:edges].is_a?(Array)
 
-    non_match = a_border.detect {
-      |key, value|
+    non_match = a_border.detect do |key, value|
       key != :edges && b_border[key] != value
-    }
+    end
 
     a_border[:edges].each do |edge|
       unless b_border[:edges].include? edge
@@ -37,10 +36,9 @@ class Marty::Xl
 
         # add new style/color for the new edge if there is no style
         # match with the old edges:
-        b["border_#{edge}".to_sym] = a_border.each_with_object({}) {
-          |(key, value), h|
+        b["border_#{edge}".to_sym] = a_border.each_with_object({}) do |(key, value), h|
           h[key] = value unless key == :edges
-        } if non_match
+        end if non_match
       end
     end
     b
@@ -48,6 +46,7 @@ class Marty::Xl
 
   def merge_row_edges(a, b)
     return b unless a.count > 0
+
     a.each_index do |ind|
       b[ind] = merge_cell_edges(a[ind], deep_copy(b[ind]))
     end
@@ -70,32 +69,33 @@ class Marty::Xl
     new_row, new_style = rows[r_number], styles[r_number]
 
     (0...column_offset).each do |t|
-      new_row[t] ||= ""
+      new_row[t] ||= ''
       new_style[t] ||= {}
     end
 
     d[1].each_index do |c_index|
-      new_row[c_index+column_offset] = d[1][c_index]
+      new_row[c_index + column_offset] = d[1][c_index]
     end if d[1].kind_of?(Array)
 
-    if (d.length > 2) && d[2].kind_of?(Hash) && d[2]["style"].kind_of?(Array)
-      d[2]["style"].each_index do |c_index|
-        new_style[c_index+column_offset] = d[2]["style"][c_index]
+    if (d.length > 2) && d[2].kind_of?(Hash) && d[2]['style'].kind_of?(Array)
+      d[2]['style'].each_index do |c_index|
+        new_style[c_index + column_offset] = d[2]['style'][c_index]
       end
     end
 
     # apply style for the row as a whole:
     if (d.length > 2) && d[2].kind_of?(Hash)
       d[2].each do |key, value|
-        unless key == :style.to_s
-          row_styles[r_number][key] = value
-        else
+        if key == :style.to_s
           # skip if the style is an array: /style as an array is
           # handled by the 'apply a style to each cell' section/
           next unless value.kind_of?(Hash)
+
           d[1].length.times do |t|
-            new_style[t+column_offset] = value
+            new_style[t + column_offset] = value
           end
+        else
+          row_styles[r_number][key] = value
         end
       end
     end
@@ -107,43 +107,44 @@ class Marty::Xl
     x1, y1, x2, y2, w, h = d[1]
     column_offset, row_offset = offset
 
-    y_coords = y2.is_a?(Integer) || d[0] != "image" ? [y1, y2] : [y1]
-    x_coords = x2.is_a?(Integer) || d[0] != "image" ? [x1, x2] : [x1]
+    y_coords = y2.is_a?(Integer) || d[0] != 'image' ? [y1, y2] : [y1]
+    x_coords = x2.is_a?(Integer) || d[0] != 'image' ? [x1, x2] : [x1]
 
     # add the row offset:
-    y1, y2 = y_coords.map { |y|
+    y1, y2 = y_coords.map do |y|
       if y.is_a?(Integer)
         row_offset + y
-      elsif y.is_a?(Hash) && y["off"].is_a?(Integer)
-        last_row + y["off"]
+      elsif y.is_a?(Hash) && y['off'].is_a?(Integer)
+        last_row + y['off']
       else
         raise "bad offset #{y}"
       end
-    }
+    end
 
     # add the column offset:
-    x1, x2 = x_coords.map { |x|
+    x1, x2 = x_coords.map do |x|
       raise "bad range point #{x}" unless x.is_a? Integer
+
       column_offset + x
-    }
+    end
 
     el[last_row] = [] unless
-      el[last_row] || ["border", "image"].member?(d[0])
+      el[last_row] || ['border', 'image'].member?(d[0])
 
     case d[0]
-    when "conditional_formatting"
+    when 'conditional_formatting'
       el[last_row] << [d[0], [x1, y1, x2, y2], d[2]]
-    when "merge"
+    when 'merge'
       el[last_row] << [d[0], [x1, y1, x2, y2]]
-    when "border"
+    when 'border'
       el << [d[0], [x1, y1, x2, y2], d[2]]
-    when "image"
+    when 'image'
       el << [d[0], [x1, y1, x2, y2, w, h], d[2]]
     end
   end
 
   def position_borders(borders)
-    b_styles  = []
+    b_styles = []
     borders.each do |b|
       top_row, middle_row, bottom_row, edge_h = [], [], [], {}
       br, range, defaults = b
@@ -156,7 +157,7 @@ class Marty::Xl
 
       boxborders = Hash.new do |hash, key|
         hash[key] = {
-          border: defaults.merge( {edges: key.to_s.split('_').map(&:to_sym)} )
+          border: defaults.merge(edges: key.to_s.split('_').map(&:to_sym))
         }
       end
 
@@ -168,16 +169,16 @@ class Marty::Xl
       if col0 == colw
         # vertical line
         edge_h[tro], edge_h[mro], edge_h[bro] =
-          ["left"], ["left"], ["left"]
+          ['left'], ['left'], ['left']
       elsif row0 == rowh
         # horizontal line
         edge_h[tro], edge_h[mro], edge_h[bro] =
-          ["top"]*3, ["top"]*3, ["top"]*3
+          ['top'] * 3, ['top'] * 3, ['top'] * 3
       else
         # box
-        edge_h[tro] = ["top_left", "top_right", "top"]
-        edge_h[mro] = ["left", "right", "nil"]
-        edge_h[bro] = ["bottom_left", "bottom_right", "bottom"]
+        edge_h[tro] = ['top_left', 'top_right', 'top']
+        edge_h[mro] = ['left', 'right', 'nil']
+        edge_h[bro] = ['bottom_left', 'bottom_right', 'bottom']
       end
 
       [top_row, middle_row, bottom_row].each do |r|
@@ -189,7 +190,7 @@ class Marty::Xl
 
             # counter == col0 == (colw - 1) => merge the edges:
             a = boxborders[edge_h[r.object_id][1].to_sym] =
-              merge_cell_edges(a, deep_copy(boxborders[edge_h[r.object_id][1].to_sym])) if
+                  merge_cell_edges(a, deep_copy(boxborders[edge_h[r.object_id][1].to_sym])) if
               counter == (colw - 1)
 
             a = boxborders[edge_h[r.object_id][2].to_sym] unless
@@ -209,7 +210,7 @@ class Marty::Xl
 
           a = i == 0 ? top_row : []
 
-          a = merge_row_edges(a,bottom_row) if
+          a = merge_row_edges(a, bottom_row) if
             i == (rowh - row0 - 1)
 
           a = middle_row unless
@@ -234,43 +235,42 @@ class Marty::Xl
 
       if rlen < rlenmax
         rows[index] ||= []
-        rows[index] += [""] * (rlenmax-rlen)
+        rows[index] += [''] * (rlenmax - rlen)
       end
 
       row_styles[index] ||= {}
 
       rsi = row_styles[index]
 
-      rsi["style"] = styles[index].kind_of?(Array) ? styles[index] : []
+      rsi['style'] = styles[index].kind_of?(Array) ? styles[index] : []
 
       if b_styles[index].kind_of?(Array) && b_styles[index].count > 0
-        len = [rsi["style"].count, b_styles[index].count].max
+        len = [rsi['style'].count, b_styles[index].count].max
 
         len.times do |ind|
           b_styles[index][ind] ||= {}
-          rsi["style"][ind] ||= {}
+          rsi['style'][ind] ||= {}
 
-          rsi["style"][ind] =
-            rsi["style"][ind].merge(b_styles[index][ind])
+          rsi['style'][ind] =
+            rsi['style'][ind].merge(b_styles[index][ind])
         end
 
-        rsi["style"] = rsi["style"].map{ |x| x || {} }
+        rsi['style'] = rsi['style'].map { |x| x || {} }
       end
 
-      wsrows << ["row", rows[index], rsi]
+      wsrows << ['row', rows[index], rsi]
 
       if format[index] && format[index].kind_of?(Array)
         format[index].each do |f|
           raise "wrong number of arguments for #{f[0]}" unless
             [
-             ["conditional_formatting", 3],
-             ["merge", 2]
+              ['conditional_formatting', 3],
+              ['merge', 2]
             ].member?([f[0], f.length])
 
           wsrows << f
         end
       end
-
     end
 
     apply_relative_worksheet_ops(ws, wsrows + images)
@@ -285,18 +285,18 @@ class Marty::Xl
 
     # We got some sort of error if the worksheets is an array
     if worksheets.is_a? Hash
-      ws = wb.add_worksheet(name: "EXCEPTION")
-      ws.add_row ["error", worksheets["error"]]
-      ws.add_row ["backtrace", worksheets["backtrace"]]
+      ws = wb.add_worksheet(name: 'EXCEPTION')
+      ws.add_row ['error', worksheets['error']]
+      ws.add_row ['backtrace', worksheets['backtrace']]
       return
     end
 
     raise "expected worksheets array, got: #{worksheets}" unless
       worksheets.is_a?(Array)
 
-    worksheets << ["No data", []] if worksheets.count == 0
+    worksheets << ['No data', []] if worksheets.count == 0
 
-    worksheets.each { |opl|
+    worksheets.each do |opl|
       name, ops, opts = opl
 
       raise "bad worksheet name: #{name}" unless name.is_a?(String)
@@ -318,17 +318,17 @@ class Marty::Xl
       ws.sheet_view.show_grid_lines = gridlines
 
       apply_relative_worksheet_ops(ws, ops)
-    }
+    end
     @package.use_shared_strings = true
   end
 
   def add_style(style)
-    raise "bad style" unless style.is_a?(Hash) || style.is_a?(Array)
+    raise 'bad style' unless style.is_a?(Hash) || style.is_a?(Array)
 
     if style.is_a?(Array)
-      style.map { |s|
+      style.map do |s|
         styles[s] ||= package.workbook.styles.add_style(s)
-      }
+      end
     else
       styles[style] ||= package.workbook.styles.add_style(style)
     end
@@ -336,71 +336,74 @@ class Marty::Xl
 
   def intern_range(ws, range)
     return range if range.is_a? String
-    raise "bad range #{range}" unless range.is_a?(Array) && range.length==4
+    raise "bad range #{range}" unless range.is_a?(Array) && range.length == 4
+
     x1, y1, x2, y2 = range
 
-    y1, y2 = [y1, y2].map { |y|
+    y1, y2 = [y1, y2].map do |y|
       next y unless y.is_a?(Hash)
-      raise "bad offset #{y}" unless y["off"].is_a?(Integer)
-      ws.rows.last.row_index + y["off"]
-    }
+      raise "bad offset #{y}" unless y['off'].is_a?(Integer)
+
+      ws.rows.last.row_index + y['off']
+    end
 
-    [x1, y1, x2, y2].each { |x|
+    [x1, y1, x2, y2].each do |x|
       raise "bad range point #{x}" unless x.is_a? Integer
-    }
-    Axlsx.cell_r(x1, y1) + ":" + Axlsx.cell_r(x2, y2)
+    end
+    Axlsx.cell_r(x1, y1) + ':' + Axlsx.cell_r(x2, y2)
   end
 
   def recalc_offsets(ops_pos)
     new_ops1, new_ops2, new_ops = [], [], []
     # precalculate the offsets of pos options embedded in another pos opt:
-    ops_pos.each { |d|
-      new_ops1 += d[2].select { |inner_ops|
-        inner_ops if inner_ops[0] == "pos"
-      }.map { |inner|
-        [inner[0], d[1].zip(inner[1]).map { |x,y| x+y }, inner[2] ]
-      }
-    }
+    ops_pos.each do |d|
+      new_ops1 += d[2].select do |inner_ops|
+        inner_ops if inner_ops[0] == 'pos'
+      end.map do |inner|
+        [inner[0], d[1].zip(inner[1]).map { |x, y| x + y }, inner[2]]
+      end
+    end
     # keep the offsets of non-pos options embedded in pos opt:
-    new_ops2 = ops_pos.map { |d|
-      [ d[0], d[1], d[2].select{|inner| inner if inner[0] != "pos" } ]
-    }
+    new_ops2 = ops_pos.map do |d|
+      [d[0], d[1], d[2].select { |inner| inner if inner[0] != 'pos' }]
+    end
     new_ops = new_ops1 + new_ops2
-    count = new_ops.select { |d|
-      d[2].select { |inner_ops|
-        inner_ops if inner_ops[0] == "pos"
-      }.count > 0
-    }.count
+    count = new_ops.select do |d|
+      d[2].select do |inner_ops|
+        inner_ops if inner_ops[0] == 'pos'
+      end.count > 0
+    end.count
 
     count == 0 ? new_ops.sort : recalc_offsets(new_ops)
   end
 
   def apply_relative_worksheet_ops(ws, ops)
-
-    non_pos = ops.select {|opl| opl[0] != "pos" }
-    ops_pos = ops.select {|opl| opl[0] == "pos" }
-    ops_brd = ops.select {|opl| opl[0] == "border" }
+    non_pos = ops.select { |opl| opl[0] != 'pos' }
+    ops_pos = ops.select { |opl| opl[0] == 'pos' }
+    ops_brd = ops.select { |opl| opl[0] == 'border' }
 
     if (ops_pos.count > 0)
       # Wrap all non-pos options in a pos option with offset 0, 0:
-      pos_00_ops = non_pos.count > 0 ? [ ["pos", [0, 0], non_pos] ] : []
+      pos_00_ops = non_pos.count > 0 ? [['pos', [0, 0], non_pos]] : []
       # Recalculate the offsets of embedded pos opts:
-      ops =  pos_00_ops + recalc_offsets(ops_pos)
+      ops = pos_00_ops + recalc_offsets(ops_pos)
     elsif (ops_brd.count > 0)
       # Wrap the non-pos options in a pos opt with offset 0, 0:
-      pos_00_ops = [ ["pos", [0, 0], non_pos] ]
+      pos_00_ops = [['pos', [0, 0], non_pos]]
       ops = pos_00_ops
     end
 
     rows, styles, row_styles, format, borders, images = [], [], [], [], [], []
-    ops.each { |opl|
+    ops.each do |opl|
       raise "bad op #{opl}" unless opl.length > 1
+
       case opl[0]
-      when "pos"
+      when 'pos'
         op, offset, data = opl
         raise "bad offset #{offset}" unless
           offset.is_a?(Array) && offset.length == 2 &&
-          offset.all? {|x| x.is_a? Integer}
+          offset.all? { |x| x.is_a? Integer }
+
         # column offset, row offset:
         column_offset, row_offset = offset
         r_number, last_row = row_offset, row_offset
@@ -409,23 +412,24 @@ class Marty::Xl
           raise "non array data #{d[1]}" unless d[1].is_a?(Array)
           raise "non hash data options #{d[2]}" unless
             [NilClass, Hash, String, Array].member? d[2].class
+
           case d[0]
-          when "row"
+          when 'row'
             position_row(d, column_offset, r_number, rows, styles, row_styles)
             last_row = r_number
             r_number += 1
-          when "conditional_formatting", "merge"
+          when 'conditional_formatting', 'merge'
             position_elem(d, offset, last_row, format)
-          when "border"
+          when 'border'
             position_elem(d, offset, last_row, borders)
-          when "image"
+          when 'image'
             position_elem(d, offset, last_row, images)
           else
             raise "unknown op #{d[0]} embedded in 'position' option"
           end
         end
 
-      when "row"
+      when 'row'
         op, data, options = opl
 
         raise "bad row op #{opl}" unless data.is_a?(Array) || opl.length > 3
@@ -438,11 +442,11 @@ class Marty::Xl
 
         ws.add_row data, options
 
-      when "row_style"
+      when 'row_style'
         op, row_num, style = opl
 
         # FIXME: need to handle Array?
-        raise "non hash arg for row_style" unless style.is_a?(Hash)
+        raise 'non hash arg for row_style' unless style.is_a?(Hash)
         raise "bad row num #{opl}" unless row_num.is_a?(Integer)
 
         style = self.class.symbolize_keys(style, ':')
@@ -452,17 +456,18 @@ class Marty::Xl
 
         row.style = style_id
 
-      when "merge"
+      when 'merge'
         op, range = opl
 
         raise "bad merge op #{opl}" unless opl.length == 2
+
         range = intern_range(ws, range)
 
         ws.merge_cells range
-      when "conditional_formatting"
+      when 'conditional_formatting'
         op, range, format = opl
 
-        raise "non hash arg for format" unless format.is_a?(Hash)
+        raise 'non hash arg for format' unless format.is_a?(Hash)
 
         range = intern_range(ws, range)
 
@@ -471,11 +476,11 @@ class Marty::Xl
         color_scale_a = format[:color_scale]
 
         if color_scale_a
-          raise "color_scale must be an array" unless
+          raise 'color_scale must be an array' unless
             color_scale_a.is_a?(Array)
 
-          raise "non-hash color_scale element" unless
-            color_scale_a.all? {|x| x.is_a?(Hash)}
+          raise 'non-hash color_scale element' unless
+            color_scale_a.all? { |x| x.is_a?(Hash) }
 
           format[:color_scale] = Axlsx::ColorScale.new(*color_scale_a)
         end
@@ -484,13 +489,15 @@ class Marty::Xl
         format[:dxfId] = add_style(dxfid) if dxfid.is_a?(Hash)
 
         ws.add_conditional_formatting(range, format)
-      when "image"
+      when 'image'
         op, range, img = opl
         raise "bad image params #{range}" unless
           range.is_a?(Array) && range.length == 6
+
         x1, y1, x2, y2, w, h = range
         raise "bad image range, width or height #{range}" unless
-          [ x1, y1, w, h ].all? {|x| x.is_a? Integer}
+          [x1, y1, w, h].all? { |x| x.is_a? Integer }
+
         ws.add_image(image_src: "#{Rails.public_path}/images/#{img}",
                      noSelect: true,
                      noMove: true) do |image|
@@ -502,28 +509,27 @@ class Marty::Xl
       else
         raise "unknown op #{opl[0]}"
       end
-    }
-    worksheet_rows(ws,rows,styles,row_styles,format,borders,images) unless
-      [ops_pos.count, ops_brd.count].all?{ |a| a == 0 }
+    end
+    worksheet_rows(ws, rows, styles, row_styles, format, borders, images) unless
+      [ops_pos.count, ops_brd.count].all? { |a| a == 0 }
   end
 
   # recursive symbolize_keys. FIXME: this belongs in a generic
   # library somewhere.
-  def self.symbolize_keys(obj, sym_str=nil)
+  def self.symbolize_keys(obj, sym_str = nil)
     case obj
     when Array
-      obj.map {|x| symbolize_keys(x, sym_str)}
+      obj.map { |x| symbolize_keys(x, sym_str) }
     when Hash
-      obj.inject({}) { |result, (key, value)|
+      obj.inject({}) do |result, (key, value)|
         key = key.to_sym if key.is_a?(String)
         result[key] = symbolize_keys(value, sym_str)
         result
-      }
+      end
     when String
       (sym_str && obj.starts_with?(sym_str)) ? obj[sym_str.length..-1].to_sym : obj
     else
       obj
     end
   end
-
 end