nested_string_parser 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0fd6dba43658f034613dd768a23e82fee6303aa
-  data.tar.gz: f3a0577e9190dedf881b3ea4808be5c982185baa
+  metadata.gz: 7bc979b99001df7bd41db9bcd1755e93d4a520b3
+  data.tar.gz: 921e53f32bdcaa6d781eed16804246442263ad55
 SHA512:
-  metadata.gz: adf100b54e17ca969da8360aa70cbc0072ddd934a5315c17f2dfffeb8481cd5b6f4bcf9d178c47c41f3ab35e660c3d986e0a57ee8c3f193b1ffe85c4dea64899
-  data.tar.gz: 46954bed6b8b365c8c10a6b462ae345ac0b89e293e60f8675efc75015072aeb658039f1136245037da1587e7233a3fc94afed96e4c4d7f67f524965a3b741d0a
+  metadata.gz: cecb511ad6f63c406884220096aa74e568c78b9d47caaee94666215a7fa60392c7f249039a88da9fdacb3aaf69b73408fae50792aa3949d7c96e5a1b11f9eea0
+  data.tar.gz: 3f37047b78246cc086e71080c8cc5d72ed327d6833e577a24473bd3667113000ee7fb6f201146c44d73f02a618c41f1990a3680a95de0006f3dd62f7ff0768da

data/lib/nested_string_parser.rb

@@ -7,14 +7,40 @@ module NestedStringParser
     def initialize     s=nil ; @nesting, @value, @children = (s ? s.gsub(/^( *)[^ ].*/, '\1').length : -1), (s && s.strip), [] ; end
     def add_child?     child ; (child.nesting > self.nesting) ? add_child(child) : parent.add_child?(child)                    ; end
     def add_child      child ; @children << child ; child.parent = self ; child                                                ; end
+    def nest_child     child ; add_child(child).tap { |c| c.nesting = nesting + 1 }                                            ; end
     def nb?              str ; str && str.strip != ""                                                                          ; end
     def accept str=nil, *ss ; nb?(str) ? add_child?(Node.new(str)).accept(*ss) : (ss.size > 0 ? self.accept(*ss) : self)       ; end
     def root                 ; parent ? parent.root : self                                                                     ; end
-    def format        indent ; "#{indent}#{value}\n#{children.map { |c| c.format "#{indent}  " }.join}"                        ; end
+    def format        indent ; %[#{indent}#{value}\n#{children.map { |c| c.format "#{indent}  " }.join}]                       ; end
+    def find            name ; children.detect { |k| k.value == name }                                                         ; end
   end
 
-  def self.parse str ; NestedStringParser::Node.new.accept(*str.split(/\n/)).root ; end
-  module StringExtension ; def parse_nested_string ; NestedStringParser.parse self ; end ; end
+  # rows is an array of arrays
+  # | A | B | C |
+  # | A | B | D |
+  # | A | E | F |
+  # | A | E | G |
+  # | B | H | J |
+  # | B | H | K |
+  # same as
+  # A
+  #   B
+  #     C
+  #     D
+  #   E
+  #     F
+  #     G
+  # B
+  #   H
+  #     J
+  #     K
+  #
+  def self.from_rows rows, root=new_node
+    rows.each { |row| row.inject(root) { |node, name| node.find(name) || node.nest_child(new_node name) } } ; root
+  end
 
-  def self.patch ; ::String.send :include, StringExtension ; end
+  def self.new_node     val=nil ; NestedStringParser::Node.new.tap { |n| n.value = val }        ; end
+  def self.parse            str ; new_node.accept(*str.split(/\n/)).root                        ; end
+  module Extension              ; def parse_nested_string ; NestedStringParser.parse self.to_s  ; end ; end
+  def self.patch klass=::String ; klass.send :include, Extension                                ; end
 end

data/lib/nested_string_parser/version.rb

@@ -1,3 +1,3 @@
 module NestedStringParser
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/from_rows_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require "nested_string_parser"
+
+RSpec::describe NestedStringParser do
+  it "parses nothing at all" do
+    node = NestedStringParser.from_rows []
+
+    expect(node.value   ).to eq nil
+    expect(node.nesting ).to eq(-1)
+    expect(node.children).to eq []
+  end
+
+  it "parses a single item" do
+    node = NestedStringParser.from_rows [["hello"]]
+
+    expect(node.value        ).to eq nil
+    expect(node.nesting      ).to eq(-1)
+    expect(node.children.size).to eq 1
+
+    child = node.children.first
+    expect(child.value   ).to eq "hello"
+    expect(child.nesting ).to eq 0
+    expect(child.children).to eq []
+  end
+
+  QUARKS_IN_ROWS = [
+                    %w{ quarks G1 up                 },
+                    %w{ quarks G1 down               },
+                    %w{ quarks G2 strange            },
+                    %w{ quarks G2 charmed            },
+                    %w{ quarks G3 top                },
+                    %w{ quarks G3 bottom             },
+                    %w{ leptons G1 electron          },
+                    %w{ leptons G1 electron-neutrino },
+                    %w{ leptons G2 muon              },
+                    %w{ leptons G2 muon-neutrino     },
+                    %w{ leptons G3 tau               },
+                    %w{ leptons G3 tau-neutrino      },
+                   ]
+
+  it "parses a single item" do
+    node = NestedStringParser.from_rows QUARKS_IN_ROWS
+
+    expect(node.value                ).to eq nil
+    expect(node.nesting              ).to eq(-1)
+    expect(node.children.map(&:value)).to eq %w{ quarks leptons }
+
+    quarks = node.children[0]
+    expect(quarks.nesting                ).to eq 0
+    expect(quarks.children.map(&:value)  ).to eq %w{ G1 G2 G3 }
+    expect(quarks.children.map(&:nesting)).to eq [1,1,1]
+    expect(quarks.children.map { |q| q.children.map(&:nesting) }).to eq [[2,2], [2,2], [2,2]]
+    expect(quarks.children.map { |q| q.children.map(&:value)   }).to eq [%w{up down}, %w{strange charmed}, %w{top bottom}]
+
+    leptons = node.children[1]
+    expect(leptons.nesting                ).to eq 0
+    expect(leptons.children.map(&:value)  ).to eq %w{ G1 G2 G3 }
+    expect(leptons.children.map(&:nesting)).to eq [1,1,1]
+    expect(leptons.children.map { |q| q.children.map(&:nesting) }).to eq [[2,2], [2,2], [2,2]]
+    expect(leptons.children.map { |q| q.children.map(&:value)   }).to eq [%w{electron electron-neutrino}, %w{muon muon-neutrino}, %w{tau tau-neutrino}]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested_string_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-14 00:00:00.000000000 Z
+date: 2017-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,6 +69,7 @@ files:
 - lib/nested_string_parser/version.rb
 - mit-license.txt
 - nested_string_parser.gemspec
+- spec/from_rows_spec.rb
 - spec/parse_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/conanite/nested_string_parser
@@ -97,5 +98,6 @@ specification_version: 4
 summary: Parse multi-line string with indentation, return a structure where nesting
   is based on line indentation
 test_files:
+- spec/from_rows_spec.rb
 - spec/parse_spec.rb
 - spec/spec_helper.rb