pikelet 2.0.0.beta.1 → 2.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 580f25b1ccc1b345208d99f759cbca4d42e86933
-  data.tar.gz: 6e333e33e68c71825143a2b393c0376f20f35c5f
+  metadata.gz: 38ba6a85d7364f3d8a5b93bb24cc8d64bac5de91
+  data.tar.gz: e6e9e5e60b8ac35c8669fa992327ee422d3871f6
 SHA512:
-  metadata.gz: cd176128b19db2521917463563b00e5e6ca4caefd8086be747ae24b6ee36f80273690e33fcbe36879cfc9e9afd327dd4e65415d35554cf420fa234b7f9cd8166
-  data.tar.gz: 6ad11890c1fb69fc6c3641faeba9183b71a13153a350466df873ba37a12abbd27c46866a651198d0d41e28061c47d111a9e1b4035c90619ba526eaf9dd1a3ff9
+  metadata.gz: b0a0c5500a5f72c17735608a678f78fbdd9c433c086be1875e1077d11da3e2463c3704cf75621f4a4c6ff569e8ea8873d82bd26d06f4042ee47b8b9a68a83c08
+  data.tar.gz: e65c43af74592ffe8462c91dab56abc0d67bbb82880ba227b0342f3ea542827686653dadbf46873dc244a2e0d55313c5d23e5daf821ce78f200ea62e2ead15ab

data/lib/pikelet/field_definition.rb

@@ -1,23 +1,25 @@
 module Pikelet
   class FieldDefinition
-    attr_reader :index, :parser, :width
+    attr_reader :index, :parser, :formatter, :padding, :alignment, :width
 
-    def initialize(index, parse: nil, &block)
+    def initialize(index, parse: nil, format: nil, pad: nil, align: nil, &block)
       raise ArgumentError, "index must be a range" unless index.is_a? Range
       @index = index
       @width = index.size
       @parser = parse || block || :strip
-      @parser = @parser.to_proc unless @parser.respond_to? :call
+      @formatter = format || :to_s
+      @padding = pad && pad.to_s || " "
+      @alignment = align || :left
     end
 
     def parse(record)
       if value = record[index]
-        parser.call(value)
+        parser.to_proc.call(value)
       end
     end
 
     def format(value)
-      pad(truncate(value))
+      pad(truncate(formatter.to_proc.call(value)))
     end
 
     def insert(value, record)
@@ -27,12 +29,20 @@ module Pikelet
 
     private
 
+    def blank
+      @blank ||= padding * width
+    end
+
     def truncate(value)
-      value.to_s[0...width]
+      value[0...width]
     end
 
     def pad(value)
-      (" " * (width - value.size)) + value
+      if alignment == :left
+        value + blank[value.size...width]
+      else
+        blank[-width..-(1+value.size)] + value
+      end
     end
   end
 end

data/lib/pikelet/version.rb

@@ -1,3 +1,3 @@
 module Pikelet
-  VERSION = "2.0.0.beta.1"
+  VERSION = "2.0.0.beta.2"
 end

data/spec/pikelet/field_definition_spec.rb

@@ -3,9 +3,26 @@ require "pikelet"
 require "csv"
 
 describe Pikelet::FieldDefinition do
+  let(:parser)     { { } }
+  let(:formatter)  { { } }
+  let(:padding)    { { } }
+  let(:alignment)  { { } }
+  let(:block)      { nil }
+  let(:definition) { Pikelet::FieldDefinition.new(index, **parser, **formatter, **padding, **alignment, &block) }
+
+  describe "defaults" do
+    let(:index) { 0...1 }
+
+    subject { definition }
+
+    its(:parser)    { is_expected.to eq :strip }
+    its(:formatter) { is_expected.to eq :to_s }
+    its(:padding)   { is_expected.to eq " " }
+    its(:alignment) { is_expected.to eq :left }
+  end
+
   describe "#parse" do
     let(:data)       { "The quick brown fox" }
-    let(:definition) { Pikelet::FieldDefinition.new(index) }
 
     subject(:parsed) { definition.parse(data) }
 
@@ -26,38 +43,38 @@ describe Pikelet::FieldDefinition do
     end
 
     context "given a custom parser" do
-      let(:parser) { ->(value) { value } }
+      let(:block_parser) { ->(value) { value } }
 
       before do
-        allow(parser).to receive(:call)
+        allow(block_parser).to receive(:call).and_call_original
         parsed
       end
 
       context "as a block" do
-        let(:index)      { 4...9 }
-        let(:definition) { Pikelet::FieldDefinition.new(index, &parser) }
+        let(:index) { 4...9 }
+        let(:block) { block_parser }
 
         it "yields the value to the parser" do
-          expect(parser).to have_received(:call).with("quick")
+          expect(block_parser).to have_received(:call).with("quick")
         end
       end
 
       context "as a parse option" do
-        let(:index)      { 10...15 }
-        let(:definition) { Pikelet::FieldDefinition.new(index, parse: parser) }
+        let(:index)  { 10...15 }
+        let(:parser) { { parse: block_parser } }
 
         it "yields the value to the parser" do
-          expect(parser).to have_received(:call).with("brown")
+          expect(block_parser).to have_received(:call).with("brown")
         end
       end
     end
 
     context "given a shorthand parser" do
-      let(:parser) { :upcase }
+      let(:symbol_parser) { :upcase }
 
       context "as a block" do
-        let(:index)      { 10...15 }
-        let(:definition) { Pikelet::FieldDefinition.new(index, &parser) }
+        let(:index) { 10...15 }
+        let(:block) { symbol_parser }
 
         it "invokes the named method on the value" do
           expect(parsed).to eq "BROWN"
@@ -65,8 +82,8 @@ describe Pikelet::FieldDefinition do
       end
 
       context "as a parse option" do
-        let(:index)      { 4...9 }
-        let(:definition) { Pikelet::FieldDefinition.new(index, parse: parser) }
+        let(:index)  { 4...9 }
+        let(:parser) { { parse: symbol_parser } }
 
         it "invokes the named method on the value" do
           expect(parsed).to eq "QUICK"
@@ -87,7 +104,6 @@ describe Pikelet::FieldDefinition do
     let(:index)      { 4...9 }
     let(:record)     { "The _____ brown fox" }
     let(:value)      { "quick" }
-    let(:definition) { Pikelet::FieldDefinition.new(index) }
 
     subject(:result) { definition.insert(value, record) }
 
@@ -106,34 +122,106 @@ describe Pikelet::FieldDefinition do
   end
 
   describe "#format" do
-    let(:index) { 4...9 }
-
     subject(:formatted) { definition.format(value) }
 
-    context "with the default formatter" do
-      let(:definition) { Pikelet::FieldDefinition.new(index) }
+    describe "truncation" do
+      let(:index) { 4...9 }
 
       context "given a value that fits the field exactly" do
         let(:value) { "quick" }
 
-        it "returns the value" do
-          expect(formatted).to eq "quick"
+        it "does not truncate the value" do
+          expect(formatted).to eq value
         end
       end
 
-      context "given a value larger than the field" do
-        let(:value) { "quickk" }
+      context "given a value that overflows the field" do
+        let(:value) { "12345678" }
 
         it "truncates the value" do
-          expect(formatted).to eq "quick"
+          expect(formatted).to eq value[0...5]
+        end
+      end
+    end
+
+    describe "given a custom formatter" do
+      let(:index)           { 4...5 }
+      let(:block_formatter) { ->(value) { value } }
+      let(:formatter)       { { format: block_formatter} }
+      let(:value)           { "brown" }
+
+      before do
+        allow(block_formatter).to receive(:call).and_call_original
+        formatted
+      end
+
+      it "yields the raw value to the formatter" do
+        expect(block_formatter).to have_received(:call).with("brown")
+      end
+    end
+
+    describe "using a shorthand formatter" do
+      let(:index)     { 4...9 }
+      let(:formatter) { { format: :upcase } }
+      let(:value)     { "brown" }
+
+      it "invokes the named method on the raw value" do
+        expect(formatted).to eq "BROWN"
+      end
+    end
+
+    describe "padding & alignment" do
+      let(:index) { 3...7 }
+
+      context "given a value that fits the field exactly" do
+        let(:value)         { "1234" }
+
+        it "does not pad the field" do
+          expect(formatted).to eq value
         end
       end
 
-      context "givem a value smaller than the field" do
-        let(:value) { "quik" }
+      context "given a value that underflows the field" do
+        let(:value) { "12" }
+
+        context "with left alignment" do
+          let(:alignment) { { align: :left } }
+
+          context "with single-character padding" do
+            let(:padding) { { pad: '-' } }
+
+            it "pads the field on the right" do
+              expect(formatted).to eq "12--"
+            end
+          end
+
+          context "with multi-character padding" do
+            let(:padding) { { pad: '<->' } }
+
+            it "pads the field on the right" do
+              expect(formatted).to eq "12><"
+            end
+          end
+        end
+
+        context "with right alignment" do
+          let(:alignment) { { align: :right } }
+
+          context "with single-character padding" do
+            let(:padding) { { pad: '-' } }
+
+            it "pads the field on the left" do
+              expect(formatted).to eq "--12"
+            end
+          end
+
+          context "with multi-character padding" do
+            let(:padding) { { pad: '<->' } }
 
-        it "pads the the value with spaces at the left" do
-          expect(formatted).to eq " quik"
+            it "pads the field on the left" do
+              expect(formatted).to eq "><12"
+            end
+          end
         end
       end
     end

data/spec/pikelet_spec.rb

@@ -39,8 +39,8 @@ describe Pikelet do
 
     it { is_expected.to have(2).lines }
 
-    its(:first) { is_expected.to eq "NAME  NicolausCopernicus                                                  " }
-    its(:last)  { is_expected.to eq "ADDR    123 South Street        Nowhereville    45678Y           Someplace" }
+    its(:first) { is_expected.to eq "NAMENicolaus  Copernicus                                                  " }
+    its(:last)  { is_expected.to eq "ADDR123 South Street    Nowhereville        45678Y    Someplace           " }
   end
 
   describe "#parse" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pikelet
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.1
+  version: 2.0.0.beta.2
 platform: ruby
 authors:
 - John Carney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-18 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler