squib 0.12.0 → 0.13.0

data/spec/import/data_frame_spec.rb

@@ -1,251 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'squib/import/data_frame'
-
-describe Squib::DataFrame do
-  let(:basic) do
-    {
-      'Name' => ['Mage', 'Rogue', 'Warrior'],
-      'Cost' => [1, 2, 3],
-    }
-  end
-
-  let(:uneven) do
-     {
-       'Name' => ['Mage', 'Rogue', 'Warrior'],
-       'Cost' => [1, 2],
-     }
-  end
-
-  let(:whitespace) do
-     {
-       'Name \n\r\t' => ['  Mage \t\r\n'],
-     }
-  end
-
-  let(:defined) do
-    {
-      'nrows' => [1,2,3],
-    }
-  end
-
-  context 'is Enumerable and like a hash, so it' do
-    it 'responds to each' do
-      expect(subject).to respond_to(:each)
-    end
-
-    it 'responds to any?' do
-      expect(subject.any?).to be false
-    end
-
-    it 'responds to []' do
-      data = Squib::DataFrame.new basic
-      expect(data['Cost']).to eq([1, 2, 3])
-    end
-
-    it 'responds to []=' do
-      data = Squib::DataFrame.new basic
-      data[:a] = 2
-      expect(data[:a]).to eq(2)
-    end
-  end
-
-  context :columns do
-    it 'provides a list of columns' do
-      data = Squib::DataFrame.new basic
-      expect(data.columns).to eq %w(Name Cost)
-    end
-  end
-
-  context :ncolumns do
-    it 'provides column count' do
-      data = Squib::DataFrame.new basic
-      expect(data.ncolumns).to eq 2
-    end
-  end
-
-  context :row do
-    it 'returns a hash of each row' do
-      data = Squib::DataFrame.new basic
-      expect(data.row(0)).to eq ({'Name' => 'Mage', 'Cost' => 1})
-      expect(data.row(1)).to eq ({'Name' => 'Rogue', 'Cost' => 2})
-    end
-
-    it 'returns nil for uneven data' do
-      data = Squib::DataFrame.new uneven
-      expect(data.row(2)).to eq ({'Name' => 'Warrior', 'Cost' => nil})
-    end
-  end
-
-  context :nrows do
-    it 'returns a row count on even data' do
-      data = Squib::DataFrame.new basic
-      expect(data.nrows).to eq 3
-    end
-
-    it 'returns largest row count on uneven data' do
-      data = Squib::DataFrame.new basic
-      expect(data.nrows).to eq 3
-    end
-  end
-
-  context :json do
-    it 'returns quoty json' do
-      data = Squib::DataFrame.new basic
-      expect(data.to_json).to eq "{\"Name\":[\"Mage\",\"Rogue\",\"Warrior\"],\"Cost\":[1,2,3]}"
-    end
-
-    it 'returns pretty json' do
-      data = Squib::DataFrame.new basic
-      str = <<-EOS
-{
-  "Name": [
-    "Mage",
-    "Rogue",
-    "Warrior"
-  ],
-  "Cost": [
-    1,
-    2,
-    3
-  ]
-}
-EOS
-      expect(data.to_pretty_json).to eq str.chomp
-    end
-  end
-
-  context :def_column do
-    it 'creates name for Name column' do
-      data = Squib::DataFrame.new basic
-      expect(data).to respond_to(:name)
-      expect(data.name).to eq %w(Mage Rogue Warrior)
-      expect(data.cost).to eq [1, 2, 3]
-    end
-
-    it 'does not redefine methods' do
-      data = Squib::DataFrame.new defined
-      expect(data).to respond_to(:nrows)
-      expect(data.nrows).to eq 3
-    end
-
-    it 'defines a new column from empty data frame' do
-      data = Squib::DataFrame.new
-      expect(data).not_to respond_to(:snark)
-      data['snark'] = [1,2,3]
-      expect(data.snark).to eq [1,2,3]
-    end
-  end
-
-  context :snake_case do
-    subject { Squib::DataFrame.new }
-    it 'strips leading & trailing whitespace' do
-      expect(subject.send(:snake_case, '  A ')).to eq :a
-    end
-
-    it 'converts space to _' do
-      expect(subject.send(:snake_case, 'A b')).to eq :a_b
-    end
-
-    it 'handles multiwhitespace' do
-      expect(subject.send(:snake_case, 'A     b')).to eq :a_b
-    end
-
-    it 'handles camelcase' do
-      expect(subject.send(:snake_case, 'fooBar')).to eq :foo_bar
-    end
-
-    it 'handles camelcase with multiple capitals' do
-      expect(subject.send(:snake_case, 'FOOBar')).to eq :foo_bar
-    end
-  end
-
-  context :col? do
-    it 'returns true if a column exists' do
-      data = Squib::DataFrame.new basic
-      expect(data.col? 'Name').to be true
-    end
-
-    it 'returns false if a column does not exist' do
-      data = Squib::DataFrame.new basic
-      expect(data.col? 'ROUS').to be false
-    end
-  end
-
-  context :wrap_n_pad do
-    subject { Squib::DataFrame.new basic }
-
-    it 'returns a handles a single line' do
-      expect(subject.send(:wrap_n_pad, 'a', 3)).
-        to eq "| a                                  |\n"
-    end
-
-    it 'wraps multiple a lines at 34 characters' do
-      expect(subject.send(:wrap_n_pad, 'a' * 40, 3)).
-        to eq <<-EOS
-| aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa |
-    | aaaaaa                             |
-EOS
-    end
-  end
-
-  context :to_pretty_text do
-
-    let(:verbose) do
-      {
-        'Name' => ['Mage', 'Rogue', 'Warrior'],
-        'Cost' => [1, 2, 3],
-        'Description' => [
-          'Magic, dude.',
-          'I like to be sneaky',
-          'I have a long story to tell to test the word-wrapping ability of pretty text formatting.'
-          ],
-        'Snark' => [nil, '', ' ']
-      }
-    end
-
-    it 'returns fun ascii art of the card' do
-      data = Squib::DataFrame.new verbose
-      expect(data.to_pretty_text).to eq <<-EOS
-            ╭------------------------------------╮
-       Name | Mage                               |
-       Cost | 1                                  |
-Description | Magic, dude.                       |
-      Snark |                                    |
-            ╰------------------------------------╯
-            ╭------------------------------------╮
-       Name | Rogue                              |
-       Cost | 2                                  |
-Description | I like to be sneaky                |
-      Snark |                                    |
-            ╰------------------------------------╯
-            ╭------------------------------------╮
-       Name | Warrior                            |
-       Cost | 3                                  |
-Description | I have a long story to tell to tes |
-            | t the word-wrapping ability of pre |
-            | tty text formatting.               |
-      Snark |                                    |
-            ╰------------------------------------╯
-EOS
-    end
-
-    let(:utf8_fun) do
-      {
-      'Fun with UTF8!' => ['👊'],
-      }
-    end
-
-    it 'is admittedly janky with multibyte chars' do
-      # I hate how Ruby handles multibyte chars. Blech!
-      data = Squib::DataFrame.new utf8_fun
-      expect(data.to_pretty_text).to eq <<-EOS
-               ╭------------------------------------╮
-Fun with UTF8! | 👊                                  |
-               ╰------------------------------------╯
-EOS
-    end
-  end
-
-end

data/spec/layout_parser_spec.rb

@@ -1,226 +0,0 @@
-require 'spec_helper'
-
-describe Squib::LayoutParser do
-
-  it 'loads a normal layout with no extends' do
-    layout = subject.load_layout(layout_file('no-extends.yml'))
-    expect(layout).to eq({ 'frame' => {
-            'x' => 38,
-            'valign' => :middle,
-            'str' => 'blah',
-            'font' => 'Mr. Font',
-            }
-          }
-        )
-  end
-
-  it 'loads with a single extends' do
-    layout = subject.load_layout(layout_file('single-extends.yml'))
-    expect(layout).to eq({ 'frame' => {
-            'x' => 38,
-            'y' => 38,
-            },
-          'title' => {
-            'extends' => 'frame',
-            'x' => 38,
-            'y' => 50,
-            'width' => 100,
-            }
-          }
-        )
-  end
-
-  it 'applies the extends regardless of order' do
-    layout = subject.load_layout(layout_file('pre-extends.yml'))
-    expect(layout).to eq({ 'frame' => {
-            'x' => 38,
-            'y' => 38,
-            },
-          'title' => {
-            'extends' => 'frame',
-            'x' => 38,
-            'y' => 50,
-            'width' => 100,
-            }
-          }
-        )
-  end
-
-  it 'applies the single-level extends multiple times' do
-    layout = subject.load_layout(layout_file('single-level-multi-extends.yml'))
-    expect(layout).to eq({ 'frame' => {
-            'x' => 38,
-            'y' => 38,
-            },
-          'title' => {
-            'extends' => 'frame',
-            'x' => 38,
-            'y' => 50,
-            'width' => 100,
-            },
-          'title2' => {
-            'extends' => 'frame',
-            'x' => 75,
-            'y' => 150,
-            'width' => 150,
-            },
-          }
-        )
-  end
-
-  it 'applies multiple extends in a single rule' do
-    layout = subject.load_layout(layout_file('multi-extends-single-entry.yml'))
-    expect(layout).to eq({ 'aunt' => {
-            'a' => 101,
-            'b' => 102,
-            'c' => 103,
-            },
-          'uncle' => {
-            'x' => 104,
-            'y' => 105,
-            'b' => 106,
-            },
-          'child' => {
-            'extends' => ['uncle', 'aunt'],
-            'a' => 107, # my own
-            'b' => 102, # from the younger aunt
-            'c' => 103, # from aunt
-            'x' => 108, # my own
-            'y' => 105, # from uncle
-            },
-          }
-        )
-  end
-
-  it 'applies multi-level extends' do
-    layout = subject.load_layout(layout_file('multi-level-extends.yml'))
-    expect(layout).to eq({ 'frame' => {
-            'x' => 38,
-            'y' => 38,
-            },
-          'title' => {
-            'extends' => 'frame',
-            'x' => 38,
-            'y' => 50,
-            'width' => 100,
-            },
-          'subtitle' => {
-            'extends' => 'title',
-            'x' => 38,
-            'y' => 150,
-            'width' => 100,
-            },
-          }
-        )
-  end
-
-  it 'fails on a self-circular extends' do
-    file = layout_file('self-circular-extends.yml')
-    expect { subject.load_layout(file)}
-      .to raise_error(RuntimeError, 'Invalid layout: circular extends with \'a\'')
-  end
-
-  it 'fails on a easy-circular extends' do
-    file = layout_file('easy-circular-extends.yml')
-    expect { subject.load_layout(file)}
-      .to raise_error(RuntimeError, 'Invalid layout: circular extends with \'a\'')
-  end
-
-  it 'hard on a easy-circular extends' do
-    file = layout_file('hard-circular-extends.yml')
-    expect { subject.load_layout(file)}
-      .to raise_error(RuntimeError, 'Invalid layout: circular extends with \'a\'')
-  end
-
-  it 'redefines keys on multiple layouts' do
-    a = layout_file('multifile-a.yml')
-    b = layout_file('multifile-b.yml')
-    layout = subject.load_layout([a, b])
-    expect(layout).to eq({
-        'title'    => { 'x' => 300 },
-        'subtitle' => { 'x' => 200 },
-        'desc'     => { 'x' => 400 }
-        })
-  end
-
-  it 'evaluates extends on each file first' do
-    a = layout_file('multifile-extends-a.yml')
-    b = layout_file('multifile-extends-b.yml')
-    layout = subject.load_layout([a, b])
-    expect(layout).to eq({
-        'grandparent' => { 'x' => 100 },
-        'parent_a'    => { 'x' => 110, 'extends' => 'grandparent' },
-        'parent_b'    => { 'x' => 130, 'extends' => 'grandparent' },
-        'child_a'     => { 'x' => 113, 'extends' => 'parent_a' },
-        'child_b'     => { 'x' => 133, 'extends' => 'parent_b' }
-        })
-  end
-
-  it 'loads nothing on an empty layout file' do
-    layout = subject.load_layout(layout_file('empty.yml'))
-    expect(layout).to eq({})
-  end
-
-  it 'handles extends on a rule with no args' do
-    layout = subject.load_layout(layout_file('empty-rule.yml'))
-    expect(layout).to eq({
-      'empty' => nil
-    })
-  end
-
-  it 'logs an error when a file is not found' do
-    expect(Squib.logger).to receive(:error).once
-    subject.load_layout('yeti')
-  end
-
-  it 'freaks out if you extend something doesn\'t exist' do
-    expect(Squib.logger)
-      .to receive(:error)
-      .with("Processing layout: 'verbal' attempts to extend a missing 'kaisersoze'")
-    layout = subject.load_layout(layout_file('extends-nonexists.yml'))
-    expect(layout).to eq({
-      'verbal' => {
-          'font_size' => 25,
-          'extends' => 'kaisersoze'
-        }
-      })
-  end
-
-  it 'does unit conversion when extending' do
-    layout = subject.load_layout(layout_file('extends-units.yml'))
-    expect(layout).to eq({
-      'parent' => { 'x' => '0.5in', 'y' => '1in'},
-      'child'  => { 'x' => 450.0, 'y' => 150.0, 'extends' => 'parent' },
-    })
-  end
-
-  it 'does unit conversion on non-300 dpis' do
-    parser = Squib::LayoutParser.new(100)
-    layout = parser.load_layout(layout_file('extends-units.yml'))
-    expect(layout).to eq({
-      'parent' => { 'x' => '0.5in', 'y' => '1in'},
-      'child'  => { 'x' => 150.0, 'y' => 50.0, 'extends' => 'parent' },
-    })
-  end
-
-  it 'does mixed unit conversion when extending' do
-    layout = subject.load_layout(layout_file('extends-units-mixed.yml'))
-    expect(layout).to eq({
-      'parent' => { 'x' => '0.5in', 'y' => '1in'},
-      'child'  => { 'x' => 450.0, 'y' => 150.0, 'extends' => 'parent' },
-    })
-  end
-
-  it 'loads progressively on multiple calls' do
-    a = layout_file('multifile-a.yml')
-    b = layout_file('multifile-b.yml')
-    layout = subject.load_layout(a)
-    layout = subject.load_layout(b, layout)
-    expect(layout).to eq({
-        'title'    => { 'x' => 300 },
-        'subtitle' => { 'x' => 200 },
-        'desc'     => { 'x' => 400 }
-        })
-  end
-
-end