pikelet 1.1.2 → 2.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92134160fa79ab2d8985325efe9593aab5380451
-  data.tar.gz: 48510ce920f6fd195814d84688584b0d5c079da2
+  metadata.gz: 580f25b1ccc1b345208d99f759cbca4d42e86933
+  data.tar.gz: 6e333e33e68c71825143a2b393c0376f20f35c5f
 SHA512:
-  metadata.gz: ebfab61d3e579d5316e86c2495eba1ad7d57795c3fbed235c4f969ae9dc5892ee26f24622809a34c3e75f1a292dd5affb53365cf4e5e118f9fa756640c081e6d
-  data.tar.gz: fa71ad390ba4ece29732b2917b7f0de1ae4b4e6121755b7390241aa9859753a17a696397296c83a28ab007a32064a43fda10c2b14b17b8b9e32d38f012e40f26
+  metadata.gz: cd176128b19db2521917463563b00e5e6ca4caefd8086be747ae24b6ee36f80273690e33fcbe36879cfc9e9afd327dd4e65415d35554cf420fa234b7f9cd8166
+  data.tar.gz: 6ad11890c1fb69fc6c3641faeba9183b71a13153a350466df873ba37a12abbd27c46866a651198d0d41e28061c47d111a9e1b4035c90619ba526eaf9dd1a3ff9

data/README.md

@@ -4,6 +4,16 @@
 [![Build status][build-badge]][build]
 [![Coverage Status][coverage-badge]][coverage]
 
+## Beta notes
+
+The next release of Pikelet will be capable of formatting flat-file databases
+for output. As part of this I will be dropping CSV support as it is
+constraining my options and, as far as I know, nobody is using it. For the
+time being I want to let it evolve as a pure flat-file database parser. In a
+future release I may restore CSV support, but I make no promises.
+
+## Introduction
+
 A [pikelet][pikelet-recipe] is a small, delicious pancake popular in Australia
 and New Zealand. Also, the stage name of Australian musician
 [Evelyn Morris][pikelet-musician]. Also, a simple flat-file database parser
@@ -17,8 +27,7 @@ record types. Each record type has a different structure, though some types
 share common fields, and all types have a type signature.
 
 However, Pikelet will also handle more typical flat-file databases comprised
-of homogeneous records. Additionally, it will work equally as well with CSV
-files as it will with fixed-width records.
+of homogeneous records.
 
 ## Installation
 
@@ -124,38 +133,6 @@ When we parse the data, we end up with this:
       postal_code="45678Y",
       state="Someplace">
 
-### Handling CSV files
-
-What happens if we were given the data in the previous example in CSV form?
-
-    NAME,Nicolaus,Copernicus
-    ADDR,123 South Street,Nowhereville,45678Y,Someplace
-
-In this case instead of describing fields with a boundary range, we just
-give it a simple (zero-based) index, like so:
-
-    Pikelet.define do
-      type_signature 0
-
-      record "NAME" do
-        first_name 1
-        last_name  2
-      end
-
-      record "ADDR" do
-        street_address 1
-        city           2
-        postal_code    3
-        state          4
-      end
-    end
-
-This yields the same results as above.
-
-Note that this ability to handle CSV was not planned - it just sprang
-fully-formed from the implementation. One of those pleasant little surprises
-that happens sometimes. If only I had a use for it.
-
 ### Inheritance
 
 Now we go back to our original example, starting with a simple list of names,

data/lib/pikelet/field_definition.rb

@@ -1,17 +1,38 @@
 module Pikelet
   class FieldDefinition
-    attr_reader :index, :parser
+    attr_reader :index, :parser, :width
 
-    def initialize(index, parse: nil, &parser)
+    def initialize(index, parse: nil, &block)
+      raise ArgumentError, "index must be a range" unless index.is_a? Range
       @index = index
-      @parser = parser || parse || :strip
+      @width = index.size
+      @parser = parse || block || :strip
       @parser = @parser.to_proc unless @parser.respond_to? :call
     end
 
-    def parse(text)
-      if value = text[index]
+    def parse(record)
+      if value = record[index]
         parser.call(value)
       end
     end
+
+    def format(value)
+      pad(truncate(value))
+    end
+
+    def insert(value, record)
+      record[index] = format(value)
+      record
+    end
+
+    private
+
+    def truncate(value)
+      value.to_s[0...width]
+    end
+
+    def pad(value)
+      (" " * (width - value.size)) + value
+    end
   end
 end

data/lib/pikelet/file_definition.rb

@@ -23,8 +23,22 @@ module Pikelet
       parse_records(hashes, method: :parse_hash, &block)
     end
 
+    def format(records)
+      records.map { |record| format_record(record, width: width) }
+    end
+
+    def width
+      record_definitions.values.map(&:width).max
+    end
+
     private
 
+    def format_record(record, width:)
+      record_definition = record.respond_to?(:type_signature) && record_definitions[record.type_signature]
+      record_definition ||= base_record_definition
+      record_definition.format(record, width: width)
+    end
+
     def parse_records(data, method:, &block)
       records = Enumerator.new do |y|
         data.each do |data|

data/lib/pikelet/record_definition.rb

@@ -22,8 +22,19 @@ module Pikelet
       record_class.new(*hash.values_at(*field_definitions.keys))
     end
 
+    def format(record, width: nil)
+      width ||= self.width
+      field_definitions.each_with_object(" " * width) do |(field_name, field_definition), result|
+        field_definition.insert(record.send(field_name.to_sym), result)
+      end
+    end
+
     def record_class
       @record_class ||= Struct.new(*field_definitions.keys.map(&:to_sym))
     end
+
+    def width
+      field_definitions.values.map(&:width).inject(&:+)
+    end
   end
 end

data/lib/pikelet/version.rb

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

data/spec/pikelet/field_definition_spec.rb

@@ -3,90 +3,139 @@ require "pikelet"
 require "csv"
 
 describe Pikelet::FieldDefinition do
-  let(:data)       { "The quick brown fox" }
-  let(:definition) { Pikelet::FieldDefinition.new(index) }
+  describe "#parse" do
+    let(:data)       { "The quick brown fox" }
+    let(:definition) { Pikelet::FieldDefinition.new(index) }
 
-  subject(:result) { definition.parse(data) }
+    subject(:parsed) { definition.parse(data) }
 
-  context "for a fixed-width field" do
-    let(:index) { 4...9 }
+    context "for a fixed-width field" do
+      let(:index) { 4...9 }
 
-    it "extracts the field content from the data" do
-      expect(result).to eq "quick"
+      it "extracts the field content from the data" do
+        expect(parsed).to eq "quick"
+      end
     end
-  end
 
-  context "given whitespace" do
-    let(:index) { 3...16 }
+    context "given whitespace" do
+      let(:index) { 3...16 }
 
-    it "strips leading and trailing whitespace" do
-      expect(result).to eq "quick brown"
+      it "strips leading and trailing whitespace" do
+        expect(parsed).to eq "quick brown"
+      end
     end
-  end
 
-  context "given a CSV row" do
-    let(:data)  { CSV.parse("The,quick,brown,fox").first }
-    let(:index) { 2 }
+    context "given a custom parser" do
+      let(:parser) { ->(value) { value } }
 
-    it "extracts the field" do
-      expect(result).to eq "brown"
-    end
-  end
+      before do
+        allow(parser).to receive(:call)
+        parsed
+      end
 
-  context "given a custom parser" do
-    let(:parser) { ->(value) { value } }
+      context "as a block" do
+        let(:index)      { 4...9 }
+        let(:definition) { Pikelet::FieldDefinition.new(index, &parser) }
 
-    before do
-      allow(parser).to receive(:call)
-      result
+        it "yields the value to the parser" do
+          expect(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) }
+
+        it "yields the value to the parser" do
+          expect(parser).to have_received(:call).with("brown")
+        end
+      end
     end
 
-    context "as a block" do
-      let(:index)      { 4...9 }
-      let(:definition) { Pikelet::FieldDefinition.new(index, &parser) }
+    context "given a shorthand parser" do
+      let(:parser) { :upcase }
+
+      context "as a block" do
+        let(:index)      { 10...15 }
+        let(:definition) { Pikelet::FieldDefinition.new(index, &parser) }
+
+        it "invokes the named method on the value" do
+          expect(parsed).to eq "BROWN"
+        end
+      end
+
+      context "as a parse option" do
+        let(:index)      { 4...9 }
+        let(:definition) { Pikelet::FieldDefinition.new(index, parse: parser) }
 
-      it "yields the value to the parser" do
-        expect(parser).to have_received(:call).with("quick")
+        it "invokes the named method on the value" do
+          expect(parsed).to eq "QUICK"
+        end
       end
     end
 
-    context "as a parse option" do
-      let(:index)      { 10...15 }
-      let(:definition) { Pikelet::FieldDefinition.new(index, parse: parser) }
+    context "given an index not covered in the data" do
+      let(:index) { 999..999 }
 
-      it "yields the value to the parser" do
-        expect(parser).to have_received(:call).with("brown")
+      it "parses as nil" do
+        expect(parsed).to be_nil
       end
     end
   end
 
-  context "given a shorthand parser" do
-    let(:parser) { :upcase }
+  describe "#insert" do
+    let(:index)      { 4...9 }
+    let(:record)     { "The _____ brown fox" }
+    let(:value)      { "quick" }
+    let(:definition) { Pikelet::FieldDefinition.new(index) }
 
-    context "as a block" do
-      let(:index)      { 10...15 }
-      let(:definition) { Pikelet::FieldDefinition.new(index, &parser) }
+    subject(:result) { definition.insert(value, record) }
 
-      it "invokes the named method on the value" do
-        expect(result).to eq "BROWN"
-      end
+    before do
+      allow(definition).to receive(:format).with(value) { value }
     end
 
-    context "as a parse option" do
-      let(:index)      { 4...9 }
-      let(:definition) { Pikelet::FieldDefinition.new(index, parse: parser) }
+    it "formats the value" do
+      result
+      expect(definition).to have_received(:format).with(value)
+    end
 
-      it "invokes the named method on the value" do
-        expect(result).to eq "QUICK"
-      end
+    it "inserts the formatted value into record" do
+      expect(result).to eq "The quick brown fox"
     end
   end
 
-  context "given an index not covered in the data" do
-    let(:index) { 999..999 }
+  describe "#format" do
+    let(:index) { 4...9 }
+
+    subject(:formatted) { definition.format(value) }
+
+    context "with the default formatter" do
+      let(:definition) { Pikelet::FieldDefinition.new(index) }
 
-    it "parses as nil" do
-      expect(result).to be_nil
+      context "given a value that fits the field exactly" do
+        let(:value) { "quick" }
+
+        it "returns the value" do
+          expect(formatted).to eq "quick"
+        end
+      end
+
+      context "given a value larger than the field" do
+        let(:value) { "quickk" }
+
+        it "truncates the value" do
+          expect(formatted).to eq "quick"
+        end
+      end
+
+      context "givem a value smaller than the field" do
+        let(:value) { "quik" }
+
+        it "pads the the value with spaces at the left" do
+          expect(formatted).to eq " quik"
+        end
+      end
     end
   end
 end

data/spec/pikelet/record_definition_spec.rb

@@ -5,17 +5,25 @@ describe Pikelet::RecordDefinition do
   let(:data)  { "Hello world" }
   let(:definition) do
     Pikelet::RecordDefiner.new(nil, base_definition: nil).define do
-      hello 0...5
-      world 6..-1
+      hello 0... 5
+      world 6...11
     end
   end
-  let(:record)  { definition.parse(data) }
 
   describe "#parse_hash" do
-    let(:record_hash)  { Hash[record.to_h.to_a.reverse] }
+    let(:record)      { definition.parse(data) }
+    let(:record_hash) { Hash[record.to_h.to_a.reverse] }
 
     subject { definition.parse_hash(record_hash) }
 
     it { is_expected.to eq record }
   end
+
+  describe "#format" do
+    let(:record) { OpenStruct.new(hello: "Hello", world: "world") }
+
+    subject { definition.format(record) }
+
+    it { is_expected.to eq "Hello world" }
+  end
 end

data/spec/pikelet_spec.rb

@@ -9,190 +9,205 @@ describe Pikelet do
     end
   end
 
-  let(:records) { definition.parse(data).to_a }
-
-  subject { records }
-
-  describe "for a simple flat file" do
+  describe "#format" do
     let(:definition) do
       Pikelet.define do
-        name   0... 4
-        number 4...13
+        type_signature 0...4
+
+        record "NAME" do
+          first_name  4...14
+          last_name  14...24
+        end
+
+        record "ADDR" do
+          street_address  4...24
+          city           24...44
+          postal_code    44...54
+          state          54...74
+        end
       end
     end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        John012345678
-        Sue 087654321
-      FILE
+    let(:records) do
+      [
+        { type_signature: 'NAME', first_name: "Nicolaus", last_name: 'Copernicus' },
+        { type_signature: 'ADDR', street_address: "123 South Street", city: "Nowhereville", postal_code: "45678Y", state: "Someplace" }
+      ].map(&OpenStruct.method(:new))
     end
 
-    it { is_expected.to have(2).records }
+    subject(:formatted) { definition.format(records) }
 
-    its(:first) { is_expected.to match_hash(name: "John", number: "012345678") }
-    its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321") }
+    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" }
   end
 
-  describe "for a file with heterogeneous records" do
-    let(:definition) do
-      Pikelet.define do
-        type_signature 0...1
+  describe "#parse" do
+    let(:records) { definition.parse(data).to_a }
 
-        record 'A' do
-          name   1... 5
-          number 5...14
-        end
+    subject { records }
 
-        record 'B' do
-          number  1...10
-          name   10...14
+    describe "for a simple flat file" do
+      let(:definition) do
+        Pikelet.define do
+          name   0... 4
+          number 4...13
         end
       end
-    end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        AJohn012345678
-        B087654321Sue
-      FILE
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          John012345678
+          Sue 087654321
+        FILE
+      end
+
+      it { is_expected.to have(2).records }
+
+      its(:first) { is_expected.to match_hash(name: "John", number: "012345678") }
+      its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321") }
     end
 
+    describe "for a file with heterogeneous records" do
+      let(:definition) do
+        Pikelet.define do
+          type_signature 0...1
 
-    it { is_expected.to have(2).records }
+          record 'A' do
+            name   1... 5
+            number 5...14
+          end
 
-    its(:first) { is_expected.to match_hash(name: "John", number: "012345678", type_signature: "A") }
-    its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321", type_signature: "B") }
-  end
+          record 'B' do
+            number  1...10
+            name   10...14
+          end
+        end
+      end
 
-  describe "for a CSV file" do
-    let(:definition) do
-      Pikelet.define do
-        name   0
-        number 1
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          AJohn012345678
+          B087654321Sue
+        FILE
       end
-    end
 
-    let(:data) do
-      CSV.parse <<-FILE.gsub(/^\s*/, "")
-        John,012345678
-        Sue,087654321
-      FILE
-    end
 
-    it { is_expected.to have(2).records }
+      it { is_expected.to have(2).records }
 
-    its(:first) { is_expected.to match_hash(name: "John", number: "012345678") }
-    its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321") }
-  end
+      its(:first) { is_expected.to match_hash(name: "John", number: "012345678", type_signature: "A") }
+      its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321", type_signature: "B") }
+    end
 
-  describe "inheritance" do
-    let(:definition) do
-      Pikelet.define do
-        type_signature 0...6
+    describe "inheritance" do
+      let(:definition) do
+        Pikelet.define do
+          type_signature 0...6
 
-        record 'SIMPLE' do
-          name 6...10
+          record 'SIMPLE' do
+            name 6...10
 
-          record 'FANCY' do
-            number 10...19
+            record 'FANCY' do
+              number 10...19
+            end
           end
         end
       end
-    end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        SIMPLEJohn012345678
-        FANCY Sue 087654321
-      FILE
-    end
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          SIMPLEJohn012345678
+          FANCY Sue 087654321
+        FILE
+      end
 
-    it { is_expected.to have(2).records }
+      it { is_expected.to have(2).records }
 
-    its(:first) { is_expected.to match_hash(name: "John", type_signature: "SIMPLE") }
-    its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321", type_signature: "FANCY") }
-  end
+      its(:first) { is_expected.to match_hash(name: "John", type_signature: "SIMPLE") }
+      its(:last)  { is_expected.to match_hash(name: "Sue",  number: "087654321", type_signature: "FANCY") }
+    end
 
-  describe "given a block for field parsing" do
-    let(:definition) do
-      Pikelet.define do
-        value(0...4) { |value| value.to_i }
+    describe "given a block for field parsing" do
+      let(:definition) do
+        Pikelet.define do
+          value(0...4) { |value| value.to_i }
+        end
       end
-    end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        5637
-      FILE
-    end
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          5637
+        FILE
+      end
 
-    subject { records.first }
+      subject { records.first }
 
-    its(:value) { is_expected.to eq 5637 }
-  end
+      its(:value) { is_expected.to eq 5637 }
+    end
 
-  describe "given a parse option" do
-    let(:definition) do
-      Pikelet.define do
-        value 0...4, parse: ->(value) { value.to_i }
+    describe "given a parse option" do
+      let(:definition) do
+        Pikelet.define do
+          value 0...4, parse: ->(value) { value.to_i }
+        end
       end
-    end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        5637
-      FILE
-    end
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          5637
+        FILE
+      end
 
-    subject { records.first }
+      subject { records.first }
 
-    its(:value) { is_expected.to eq 5637 }
-  end
+      its(:value) { is_expected.to eq 5637 }
+    end
 
-  describe "given a shorthand parse option" do
-    let(:definition) do
-      Pikelet.define do
-        value 0...4, parse: :to_i
+    describe "given a shorthand parse option" do
+      let(:definition) do
+        Pikelet.define do
+          value 0...4, parse: :to_i
+        end
       end
-    end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        5637
-      FILE
-    end
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          5637
+        FILE
+      end
 
-    subject { records.first }
+      subject { records.first }
 
-    its(:value) { is_expected.to eq 5637 }
-  end
+      its(:value) { is_expected.to eq 5637 }
+    end
 
-  describe "given a block when parsing" do
-    let(:collected_records) { [] }
+    describe "given a block when parsing" do
+      let(:collected_records) { [] }
 
-    let(:definition) do
-      Pikelet.define do
-        name   0... 4
-        number 4...13
+      let(:definition) do
+        Pikelet.define do
+          name   0... 4
+          number 4...13
+        end
       end
-    end
 
-    let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
-        John012345678
-        Sue 087654321
-      FILE
-    end
+      let(:data) do
+        <<-FILE.split(/[\r\n]+/).map(&:lstrip)
+          John012345678
+          Sue 087654321
+        FILE
+      end
 
-    before do
-      definition.parse(data) do |record|
-        collected_records << record.to_h
+      before do
+        definition.parse(data) do |record|
+          collected_records << record.to_h
+        end
       end
-    end
 
-    it 'yields each record to the block' do
-      expect(collected_records).to contain_exactly(*records.map(&:to_h))
+      it 'yields each record to the block' do
+        expect(collected_records).to contain_exactly(*records.map(&:to_h))
+      end
     end
   end
 
@@ -205,7 +220,7 @@ describe Pikelet do
     end
 
     let(:data) do
-      <<-FILE.gsub(/^\s*/, "").split(/[\r\n]+/)
+      <<-FILE.split(/[\r\n]+/).map(&:lstrip)
         John012345678
         Sue 087654321
       FILE

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pikelet
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0.beta.1
 platform: ruby
 authors:
 - John Carney
@@ -151,9 +151,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.3