lumb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d04469fb5b0430d7325228a3328c35e22f4135d7
-  data.tar.gz: 57278168ccc84c5b95e644819de2d64b53053c2e
+  metadata.gz: 902575b84bd52419a99e856ea05a00ab9e4f652f
+  data.tar.gz: ec05125ec3a9349bdd68d8a83314d0d1ed85035d
 SHA512:
-  metadata.gz: e36397b790b4292e8b17b7b5d76b5ec5f9a68a5cf5879df3dd10eef6ab20b885eacca7d9844b2eb555063024a1af16f65a3f8950a79213b15a0c7dfc42eb2993
-  data.tar.gz: d7df30d72062ae9b332def6994e07603eb8ec9328539f417eae298266f36b194fcb2be96b8fbafb3ffe8f40ed9093a2eb8371603a491691d4f1a2351cce9f68e
+  metadata.gz: 691e0ca905584e8b8be064f185100382fe0e05fa9cf7183679ab5c4985599d7c04dce9f7b55129a6997db92d95761e6dfc05ef2bb0a4fb5a682a22c389f3fddd
+  data.tar.gz: 4a7b70db605483b2124e9e5ac124734d0b69aab491792d5b8b813839dfe311dac9127f9890ff6c12471a3539c83046d0df14ec89be939ef10959703e408f365c

data/lib/lumb.rb

@@ -1,124 +1,9 @@
-require 'parslet'
+require 'lumb/table'
+require 'lumb/structure'
+require 'lumb/entry'
+require 'lumb/value'
+require 'lumb/parser'
 
 module Lumb
-  class Parser < Parslet::Parser
-    rule(:newlines)    { match['\r\n'].repeat(1) }
-    rule(:space)       { match[' \t\r\n'].repeat(1) }
-    rule(:hspace)      { match[' \t'].repeat(1) }
-    rule(:delim_space) { hspace | newlines.present? }
-
-    rule(:identifier)  { match['a-z'] >> match['a-z0-9_-'].repeat }
-    rule(:type)        { match['A-Z'] >> match['a-z'].repeat }
-    rule(:number)      { match['0-9'].repeat(1) }
-
-    rule(:struct_item) {
-      identifier.as(:field) >>
-      str('=')              >>
-      type.as(:type)        >>
-      delim_space.as(:ws)
-    }
-
-    rule(:entry_item) {
-      identifier.as(:field) >>
-      str('=')              >>
-      number.as(:value)     >>
-      delim_space.as(:ws)
-    }
-
-    rule(:struct) {
-      struct_item.repeat(1).as(:items) >>
-      newlines.as(:ws)
-    }
-
-    rule(:entry) {
-      entry_item.repeat(1).as(:items) >>
-      newlines.as(:ws)
-    }
-
-    rule(:file) {
-      space.maybe.as(:ws_pre)  >>
-      struct.as(:struct)        >>
-      space.maybe.as(:ws_mid)  >>
-      entry.repeat.as(:entries) >>
-      space.maybe.as(:ws_post)
-    }
-
-    root(:file)
-  end
-
-  class Transform < Parslet::Transform
-    rule(:field => simple(:field), :type => simple(:type), :ws => simple(:ws)) {
-      StructItem.new(field, type, ws)
-    }
-    rule(:field => simple(:field), :value => simple(:value), :ws => simple(:ws)) {
-      EntryItem.new(field, value, ws)
-    }
-    rule(:items => sequence(:items), :ws => simple(:ws)) {
-      if items.first.is_a? StructItem
-        LogStruct.new(items, ws)
-      else
-        LogEntry.new(items, ws)
-      end
-    }
-    rule(:ws_pre => simple(:ws_pre), :struct => simple(:struct), :ws_mid => simple(:ws_mid), :entries => sequence(:entries), :ws_post => simple(:ws_post)) {
-      LogFile.new(struct, entries, ws_pre, ws_mid, ws_post)
-    }
-  end
-
-  class StructItem
-    def initialize(field, type, ws)
-      @field, @type, @ws = field, type, ws
-    end
-
-    def to_s
-      "#{@field}=#{@type}#{@ws}"
-    end
-  end
-
-  class EntryItem
-    def initialize(field, value, ws)
-      @field, @value, @ws = field, value, ws
-    end
-
-    def to_s
-      "#{@field}=#{@value}#{@ws}"
-    end
-  end
-
-  class LogStruct
-    def initialize(items, ws)
-      @items, @ws = items, ws
-    end
-
-    def to_s
-      "#{@items.join}#{@ws}"
-    end
-  end
-
-  class LogEntry
-    def initialize(items, ws)
-      @items, @ws = items, ws
-    end
-
-    def to_s
-      "#{@items.join}#{@ws}"
-    end
-  end
-
-  class LogFile
-    def initialize(struct, entries, ws_pre, ws_mid, ws_post)
-      @struct, @entries, @ws_pre, @ws_mid, @ws_post = struct, entries, ws_pre, ws_mid, ws_post
-    end
-
-    def to_s
-      "#{@ws_pre}#{@struct}#{@ws_mid}#{@entries.join}#{@ws_post}"
-    end
-  end
-
-  def self.parse(str)
-    Transform.new.apply(Parser.new.parse(str))
-  rescue Parslet::ParseFailed => failure
-    puts failure.cause.ascii_tree
-  end
 end
 

data/lib/lumb/entry.rb

@@ -0,0 +1,35 @@
+module Lumb
+  class Entry
+    attr_reader :items, :ws
+
+    def initialize(structure, items, ws)
+      @structure, @items, @ws = structure, items, ws
+
+      @slots = []
+      @items.each do |item|
+        @slots[@structure.slot_index(item.slot)] = item.value
+      end
+
+      @structure.items.each.with_index do |item, idx|
+        if @slots[idx].nil?
+          raise "slot '#{item.slot}' is missing from entry"
+        elsif @slots[idx].type != item.type
+          raise "type mismatch: expected '#{item.type}', got '#{@slots[idx].type}'"
+        end
+      end
+    end
+
+    def slot(name)
+      @slots[@structure.slot_index(name)]
+    end
+  end
+
+  class EntryItem
+    attr_reader :slot, :value, :ws
+
+    def initialize(slot, value, ws)
+      @slot, @value, @ws = slot.to_sym, value, ws
+    end
+  end
+end
+

data/lib/lumb/parser.rb

@@ -0,0 +1,98 @@
+require 'parslet'
+
+module Lumb
+  class Parser < Parslet::Parser
+    rule(:newlines)    { match['\r\n'].repeat(1) }
+    rule(:space)       { match[' \t\r\n'].repeat(1) }
+    rule(:hspace)      { match[' \t'].repeat(1) }
+    rule(:delim_space) { hspace | newlines.present? }
+
+    rule(:slot)        { match['a-z'] >> match['a-zA-Z0-9_-'].repeat }
+    rule(:type)        { match['A-Z'] >> match['a-z'].repeat }
+    rule(:number)      { (match['+-'].maybe >> match['0-9'].repeat(1)).as(:number) }
+    rule(:symbol)      { (str(':') >> match['\S'].repeat(1)).as(:symbol) }
+    rule(:date) {
+      (match['0-9'].repeat(4, 4) >>
+       str('-') >>
+       match['0-9'].repeat(2, 2) >>
+       str('-') >>
+       match['0-9'].repeat(2, 2)).as(:date)
+    }
+
+    rule(:value) {
+      date | number | symbol
+    }
+
+    rule(:struct_item) {
+      slot.as(:slot)      >>
+      str('=')            >>
+      type.as(:type)      >>
+      delim_space.as(:ws)
+    }
+
+    rule(:entry_item) {
+      slot.as(:slot)      >>
+      str('=')            >>
+      value.as(:value)    >>
+      delim_space.as(:ws)
+    }
+
+    rule(:struct) {
+      struct_item.repeat(1).as(:items) >>
+      newlines.as(:ws)
+    }
+
+    rule(:entry) {
+      entry_item.repeat(1).as(:items) >>
+      newlines.as(:ws)
+    }
+
+    rule(:table) {
+      space.maybe.as(:ws_pre)  >>
+      struct.as(:struct)        >>
+      space.maybe.as(:ws_mid)  >>
+      entry.repeat.as(:entries) >>
+      space.maybe.as(:ws_post)
+    }
+
+    root(:table)
+  end
+
+  class Transform < Parslet::Transform
+    rule(:number => simple(:number)) {
+      Value.new(:Num, number)
+    }
+    rule(:symbol => simple(:symbol)) {
+      Value.new(:Sym, symbol)
+    }
+    rule(:date => simple(:date)) {
+      Value.new(:Date, date)
+    }
+    rule(:slot => simple(:slot), :type => simple(:type), :ws => simple(:ws)) {
+      StructureItem.new(slot, type, ws)
+    }
+    rule(:slot => simple(:slot), :value => simple(:value), :ws => simple(:ws)) {
+      EntryItem.new(slot, value, ws)
+    }
+    rule(:items => sequence(:items), :ws => simple(:ws)) { |dict|
+      items, ws = dict[:items], dict[:ws]
+
+      if items.first.is_a? StructureItem
+        @structure = Structure.new(items, ws)
+      else
+        Entry.new(@structure, items, ws)
+      end
+    }
+    rule(:ws_pre => simple(:ws_pre), :struct => simple(:struct), :ws_mid => simple(:ws_mid), :entries => sequence(:entries), :ws_post => simple(:ws_post)) {
+      Table.new(struct, entries, ws_pre, ws_mid, ws_post)
+    }
+  end
+
+  def self.parse(str)
+    Transform.new.apply(Parser.new.parse(str))
+  rescue Parslet::ParseFailed => failure
+    puts failure.cause.ascii_tree
+    raise
+  end
+end
+

data/lib/lumb/structure.rb

@@ -0,0 +1,36 @@
+module Lumb
+  class Structure
+    attr_reader :items, :ws
+
+    def initialize(items, ws)
+      @items, @ws = items, ws
+
+      @slots = {}
+      @items.map.with_index do |item, idx|
+        @slots[item.slot] = idx
+      end
+    end
+
+    def slot_index(name)
+      @slots[name.to_sym]
+    end
+
+    def slot_type(name_or_index)
+      name_or_index = slot_index(name_or_index) unless name_or_index.is_a? Fixnum
+      @items[name_or_index].type
+    end
+  end
+
+  class StructureItem
+    attr_reader :slot, :type, :ws
+
+    def initialize(slot, type, ws)
+      @slot, @type, @ws = slot.to_sym, type.to_sym, ws
+
+      if not [:Num, :Sym, :Date].include? @type
+        raise "unrecognized type #{@type}"
+      end
+    end
+  end
+end
+

data/lib/lumb/table.rb

@@ -0,0 +1,4 @@
+module Lumb
+  Table = Struct.new(:structure, :entries, :ws_pre, :ws_mid, :ws_post)
+end
+

data/lib/lumb/value.rb

@@ -0,0 +1,23 @@
+require 'date'
+
+module Lumb
+  class Value
+    attr_reader :type, :value, :raw
+
+    def initialize(type, raw)
+      @type = type
+      @value = nil
+      @raw = raw
+
+      case @type
+      when :Num
+        @value = @raw.to_i
+      when :Sym
+        @value = @raw.to_s[1..-1].to_sym
+      when :Date
+        @value = Date.parse(@raw)
+      end
+    end
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jeremy Ruten
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-21 00:00:00.000000000 Z
+date: 2016-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -26,13 +26,16 @@ dependencies:
         version: '1.7'
 description: 
 email: jeremy.ruten@gmail.com
-executables:
-- lumb
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- bin/lumb
 - lib/lumb.rb
+- lib/lumb/entry.rb
+- lib/lumb/parser.rb
+- lib/lumb/structure.rb
+- lib/lumb/table.rb
+- lib/lumb/value.rb
 homepage: https://github.com/yjerem/lumb
 licenses:
 - MIT

data/bin/lumb

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'lumb'
-
-print Lumb.parse(File.read(ARGV.first)).to_s
-