nodaire 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9b7c87d8f3775b1d06a7cf203296efcf40bf95904ba9ed7e8a1f09d0d946e21
-  data.tar.gz: 2185bc3eea0363808665f4dbc6f6a04c7cb483544c92698dfd00200eee61673f
+  metadata.gz: 76e0ecf8fe992a52851c1c2f92aba32c4fa1e8c66a5442f7766521860624bdda
+  data.tar.gz: ecee4fc90ee93e2728177cce12b4d53383a0cbd6133cf8b4fc8a1e321a54b8e9
 SHA512:
-  metadata.gz: ac327bc203d061ee6bef827b3d43b5c3c6e8cd6f754c5e4cce9bf63dac8996452de348de057218c27da87170d45db9e8ca81f3d52ac25df8106136944940d867
-  data.tar.gz: '06508af2ec0ea395bc4b45c59c77d0b41490c6abf8cbc7ff565e86195b855e6bf24c4bcb2243d73a3da17f2e1b780ec04c50618709b41b0f098680503b148677'
+  metadata.gz: 47c3f94ae222712071c9a0cce903c9b400cfbc6ebda95fb3ff384b49cc42cade26cb3207bbaf298bfad7e5d60bfa6d402ddd48b0999f936b7cf5bcfa86040f52
+  data.tar.gz: f326c0167bcb4ba1af947e6689cb3059693d96116d83a65e6f1bb12f21801bf7d70f8898ac4c196a1d8abc01f1211314021d9a031b18d717fec6f8e1556e7a08

data/README.md

@@ -86,6 +86,6 @@ bundle install
 Analyse the code and run unit tests using Bundler:
 
 ```sh
-bundle exec rubocop
-bundle exec rspec
+bundle exec rake rubocop
+bundle exec rake spec
 ```

data/lib/nodaire/base.rb

@@ -5,7 +5,7 @@
 #
 module Nodaire
   # The version number.
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
   # The date when this version was released.
-  DATE = '2019-08-18'
+  DATE = '2019-08-22'
 end

data/lib/nodaire/errors.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module Nodaire
   ##
   # This exception is raised if a parser error occurs.

data/lib/nodaire/indental.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 require_relative 'base'
-require_relative 'api/indental'
+require_relative 'indental/indental'

data/lib/nodaire/{api → indental}/indental.rb

@@ -2,7 +2,7 @@
 
 require 'json'
 
-require_relative '../parsers/indental_parser'
+require_relative 'parser'
 
 ##
 # Interface for documents in _Indental_ format.

data/lib/nodaire/indental/lexer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../lexer'
+require_relative '../util'
+
+class Nodaire::Indental
+  # @private
+  INDENT_CHARS_ERROR = 'Indented with non-space characters'
+  # @private
+  INDENT_LEVEL_ERROR = 'Unexpected indent level'
+
+  # @private
+  class Lexer < Nodaire::Lexer
+    Token = Struct.new(:type, :key, :value, :line_num)
+
+    def self.tokenize(source)
+      lines_with_number(strip_js_wrapper(source))
+        .reject { |line, _| line.match(/^\s*(;.*)?$/) }
+        .map { |line, num| token_for_line(line, num) }
+    end
+
+    def self.token_for_line(line, num)
+      return error_token(INDENT_CHARS_ERROR, num) unless spaces_indent?(line)
+
+      case line.match(/^\s*/)[0].size
+      when 0 then category_token(line, num)
+      when 2 then key_or_list_token(line, num)
+      when 4 then list_item_token(line, num)
+      else error_token(INDENT_LEVEL_ERROR, num)
+      end
+    end
+
+    def self.spaces_indent?(line)
+      indent = line.match(/^\s*/)[0]
+      indent.match(/[^ ]/).nil?
+    end
+
+    def self.category_token(string, line_num)
+      Token.new :category, normalize(string), nil, line_num
+    end
+
+    def self.key_or_list_token(string, line_num)
+      key_value = string.match(/^(.+?) :( .+)?$/)
+
+      if key_value
+        key, value = key_value.captures
+        Token.new :key_value, normalize(key), normalize(value), line_num
+      else
+        Token.new :list_name, normalize(string), nil, line_num
+      end
+    end
+
+    def self.list_item_token(string, line_num)
+      Token.new :list_item, nil, normalize(string), line_num
+    end
+
+    def self.error_token(message, line_num)
+      Token.new :error, nil, normalize(message), line_num
+    end
+
+    def self.normalize(input)
+      Nodaire.squeeze(input)
+    end
+  end
+end

data/lib/nodaire/indental/parser.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative 'lexer'
+require_relative '../parser'
+require_relative '../util'
+
+class Nodaire::Indental
+  # @private
+  class Parser < Nodaire::Parser
+    attr_reader :data
+
+    def initialize(source, strict, options = {})
+      super(strict, options)
+
+      @symbolize_names = option(:symbolize_names, false)
+      @data = {}
+      @category = nil
+
+      parse! Nodaire::Indental::Lexer.tokenize(source)
+    end
+
+    private
+
+    Category = Struct.new(:name, :list_id, keyword_init: true)
+
+    attr_accessor :category
+    attr_reader :symbolize_names
+
+    def parse!(tokens)
+      tokens.each { |token| parse_token!(normalize_token(token)) }
+    end
+
+    def parse_token!(token)
+      case token.type
+      when :category then parse_category! token
+      when :key_value then parse_key_value! token
+      when :list_name then parse_list_name! token
+      when :list_item then parse_list_item! token
+      when :error then parse_error! token
+      end
+    end
+
+    def parse_category!(token)
+      if data.include?(token.key)
+        oops! 'Duplicate category', token.line_num
+        self.category = nil
+      else
+        add_category! token
+      end
+    end
+
+    def parse_key_value!(token)
+      return oops!('No category specified', token.line_num) if category.nil?
+
+      if data[category.name].include?(token.key)
+        oops! 'Duplicate key', token.line_num
+        category.list_id = nil
+      else
+        add_key_value! token
+      end
+    end
+
+    def parse_list_name!(token)
+      return oops!('No category specified', token.line_num) if category.nil?
+
+      if data[category.name].include?(token.key)
+        oops! 'Duplicate key for list', token.line_num
+        category.list_id = nil
+      else
+        add_list! token
+      end
+    end
+
+    def parse_list_item!(token)
+      if category.nil? || category.list_id.nil?
+        oops! 'No list specified', token.line_num
+      else
+        add_list_item! token
+      end
+    end
+
+    def add_category!(token)
+      self.category = Category.new(
+        name: token.key,
+        list_id: nil
+      )
+      data[token.key] = {}
+    end
+
+    def add_key_value!(token)
+      data[category.name][token.key] = token.value
+      category.list_id = nil
+    end
+
+    def add_list!(token)
+      data[category.name][token.key] = []
+      category.list_id = token.key
+    end
+
+    def add_list_item!(token)
+      data[category.name][category.list_id] << token.value
+    end
+
+    def parse_error!(token)
+      oops! token.value, token.line_num
+    end
+
+    def normalize_token(token)
+      token.tap { |t| t.key = normalize_key(t.key) }
+    end
+
+    def normalize_key(key)
+      return if key.nil?
+
+      if symbolize_names
+        Nodaire.symbolize(key)
+      else
+        key.upcase
+      end
+    end
+  end
+end

data/lib/nodaire/lexer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Nodaire
+  # @private
+  class Lexer
+    JS_WRAPPER_REGEXP = %r{
+      ^ \s*[^\n`]+ = [[:blank:]]* ` [[:blank:]]* \n
+      (.*\n)
+      [[:blank:]]* ` \s* $
+    }mx.freeze
+
+    def self.lines_with_number(source)
+      (source || '')
+        .split("\n").each_with_index
+        .map { |line, idx| [line, idx + 1] }
+    end
+
+    def self.strip_js_wrapper(source)
+      (source || '').sub(JS_WRAPPER_REGEXP, '\1')
+    end
+  end
+end

data/lib/nodaire/{parsers/parser.rb → parser.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../errors'
+require_relative 'base'
+require_relative 'errors'
 
 # @private
 class Nodaire::Parser

data/lib/nodaire/tablatal.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 require_relative 'base'
-require_relative 'api/tablatal'
+require_relative 'tablatal/tablatal'

data/lib/nodaire/tablatal/parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../parser'
+require_relative '../util'
+
+class Nodaire::Tablatal
+  # @private
+  class Parser < Nodaire::Parser
+    attr_reader :data
+
+    def initialize(string, strict, options = {})
+      super(strict, options)
+
+      @symbolize_names = option(:symbolize_names, false)
+      @data = []
+      @keys = []
+
+      parse! string
+    end
+
+    def keys
+      @keys.map(&:name)
+    end
+
+    private
+
+    attr_reader :symbolize_names
+
+    Key = Struct.new(:name, :range, keyword_init: true)
+
+    def parse!(string)
+      lines = (string || '').strip.split("\n")
+                            .reject { |line| line.match(/^\s*(;.*)?$/) }
+      return if lines.empty?
+
+      @keys = filter_keys(make_keys(lines.shift.scan(/(\S+\s*)/).flatten))
+      @data = lines.map { |line| make_line(line) }.compact
+    end
+
+    def make_keys(segs)
+      keys = []
+      start = 0
+      segs.each_with_index do |seg, idx|
+        len = seg.size if idx < segs.size - 1
+        range_end = len ? start + len - 1 : -1
+        keys << Key.new(name: normalize_key(seg), range: start..range_end)
+        start += len if len
+      end
+      keys
+    end
+
+    def filter_keys(keys)
+      result = []
+      keys.each do |key|
+        if result.any? { |k| k.name == key.name }
+          oops! "Duplicate key #{key.name}", 1
+        else
+          result << key
+        end
+      end
+      result
+    end
+
+    def make_line(line)
+      @keys.map { |key| [key.name, Nodaire.squeeze(line[key.range])] }.to_h
+    end
+
+    def normalize_key(string)
+      if symbolize_names
+        Nodaire.symbolize(string)
+      else
+        Nodaire.squeeze(string).upcase
+      end
+    end
+  end
+end

data/lib/nodaire/{api → tablatal}/tablatal.rb

@@ -2,7 +2,7 @@
 
 require 'csv'
 
-require_relative '../parsers/tablatal_parser'
+require_relative 'parser'
 
 ##
 # Interface for documents in _Tablatal_ format.

data/lib/nodaire/util.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Nodaire
+  ##
+  # Normalize the whitespace in a string.
+  #
+  # This strips the string and replaces each sequence of whitespace with
+  # a single space.
+  #
+  # @param [String] string
+  #
+  # @since 0.4.0
+  # @return [String]
+  #
+  def self.squeeze(string)
+    (string || '').gsub(/\s+/, ' ').strip
+  end
+
+  ##
+  # Convert a string into a normalized symbol.
+  #
+  # This converts to lower case and replaces each sequence of non-alphanumeric
+  # characters with an underscore.
+  #
+  # @param [String] string
+  #
+  # @since 0.4.0
+  # @return [Symbol]
+  #
+  def self.symbolize(string)
+    squeeze(string).downcase.gsub(/[^a-z0-9]+/, '_').to_sym
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nodaire
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Liam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-18 00:00:00.000000000 Z
+date: 2019-08-22 00:00:00.000000000 Z
 dependencies: []
 description: Nodaire is a collection of text file parsers.
 email: nodaire@liamcooke.com
@@ -19,15 +19,18 @@ files:
 - LICENSE
 - README.md
 - lib/nodaire.rb
-- lib/nodaire/api/indental.rb
-- lib/nodaire/api/tablatal.rb
 - lib/nodaire/base.rb
 - lib/nodaire/errors.rb
 - lib/nodaire/indental.rb
-- lib/nodaire/parsers/indental_parser.rb
-- lib/nodaire/parsers/parser.rb
-- lib/nodaire/parsers/tablatal_parser.rb
+- lib/nodaire/indental/indental.rb
+- lib/nodaire/indental/lexer.rb
+- lib/nodaire/indental/parser.rb
+- lib/nodaire/lexer.rb
+- lib/nodaire/parser.rb
 - lib/nodaire/tablatal.rb
+- lib/nodaire/tablatal/parser.rb
+- lib/nodaire/tablatal/tablatal.rb
+- lib/nodaire/util.rb
 homepage: https://github.com/slisne/nodaire
 licenses:
 - MIT

data/lib/nodaire/parsers/indental_parser.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'parser'
-
-class Nodaire::Indental
-  # @private
-  class Parser < Nodaire::Parser
-    attr_reader :data
-
-    def initialize(string, strict, options = {})
-      super(strict, options)
-
-      @symbolize_names = option(:symbolize_names, false)
-      @data = {}
-      @category_ids = {}
-      @category = nil
-
-      parse! string
-    end
-
-    private
-
-    Category = Struct.new(:name, :key_ids, :list_id, keyword_init: true)
-
-    attr_accessor :category
-    attr_reader :symbolize_names, :category_ids
-
-    def parse!(string)
-      lines = lines_to_parse(string)
-      lines = lines[1...-1] if js_wrapper?(lines)
-      lines.each { |line, num| parse_line! line, num }
-    end
-
-    def lines_to_parse(string)
-      (string || '')
-        .split("\n").each_with_index
-        .reject { |line, _| line.match(/^\s*(;.*)?$/) }
-        .map { |line, idx| [line, idx + 1] }
-    end
-
-    def js_wrapper?(lines)
-      !lines.empty? &&
-        lines.first[0].match(/=\s*`\s*$/) &&
-        lines.last[0].strip == '`'
-    end
-
-    def parse_line!(line, num)
-      case line.match(/^\s*/)[0].size
-      when 0 then parse_category! line.strip, num
-      when 2 then parse_key_or_list! line.strip, num
-      when 4 then parse_list_item! line.strip, num
-      else oops! 'Unexpected indent', num
-      end
-    end
-
-    def parse_category!(cat, num)
-      id = normalize_sym(cat)
-
-      if category_ids.include?(id)
-        oops! 'Duplicate category', num
-        self.category = nil
-      else
-        self.category = Category.new(
-          name: symbolize_names ? id : normalize_text(cat),
-          key_ids: {},
-          list_id: nil
-        )
-        data[category.name] = {}
-        category_ids[id] = category.name
-      end
-    end
-
-    def parse_key_or_list!(line, num)
-      return oops!('No category specified', num) if category.nil?
-
-      if line.include?(' : ')
-        key, value = line.split(' : ', 2)
-        parse_key_value!(key, value, num)
-      else
-        parse_list!(line, num)
-      end
-    end
-
-    def parse_key_value!(key, value, num)
-      id = normalize_sym(key)
-      key_name = symbolize_names ? id : normalize_text(key)
-
-      if category.key_ids.include?(id)
-        oops! 'Duplicate key', num
-      else
-        data[category.name][key_name] = normalize_text(value)
-        category.key_ids[id] = key_name
-      end
-
-      category.list_id = nil
-    end
-
-    def parse_list!(key, num)
-      id = normalize_sym(key)
-      list_name = symbolize_names ? id : normalize_text(key)
-
-      if category.key_ids.include?(id)
-        oops! 'Duplicate key for list', num
-        category.list_id = nil
-      else
-        data[category.name][list_name] = []
-        category.key_ids[id] = list_name
-        category.list_id = id
-      end
-    end
-
-    def parse_list_item!(item, num)
-      if category.nil? || category.list_id.nil?
-        oops! 'No list specified', num
-      else
-        list_name = category.key_ids[category.list_id]
-        data[category.name][list_name] << normalize_text(item)
-      end
-    end
-
-    def normalize_text(string)
-      string.split.join(' ')
-    end
-
-    def normalize_sym(key)
-      key.downcase.gsub(/[\s_-]+/, ' ').split.join('_').to_sym
-    end
-  end
-end

data/lib/nodaire/parsers/tablatal_parser.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'parser'
-
-class Nodaire::Tablatal
-  # @private
-  class Parser < Nodaire::Parser
-    attr_reader :data
-
-    def initialize(string, strict, options = {})
-      super(strict, options)
-
-      @symbolize_names = option(:symbolize_names, false)
-
-      @data = []
-      @keys = []
-      @key_ids = {}
-
-      parse! string
-    end
-
-    def keys
-      @keys.map(&:name)
-    end
-
-    private
-
-    attr_reader :symbolize_names, :key_ids
-
-    Key = Struct.new(:name, :range, keyword_init: true)
-
-    def parse!(string)
-      lines = (string || '').strip.split("\n")
-                            .reject { |line| line.match(/^\s*(;.*)?$/) }
-      return if lines.empty?
-
-      @keys = make_keys(lines.shift.scan(/(\S+\s*)/).flatten)
-      @data = lines.map { |line| make_line(line) }.compact
-    end
-
-    def make_keys(segs)
-      [].tap do |keys|
-        start = 0
-        segs.each_with_index do |seg, idx|
-          len = seg.size if idx < segs.size - 1
-          id = normalize_sym(seg)
-          key_name = symbolize_names ? id : normalize_text(seg)
-
-          if key_ids.include?(id)
-            oops! "Duplicate key #{key_name}", 1
-          else
-            range_end = len ? start + len - 1 : -1
-            key_ids[id] = key_name
-            keys << Key.new(name: key_name, range: start..range_end)
-          end
-
-          start += len if len
-        end
-      end
-    end
-
-    def make_line(line)
-      @keys.map { |key| [key.name, normalize_text(line[key.range])] }.to_h
-    end
-
-    def normalize_text(string)
-      string ? string.split.join(' ') : ''
-    end
-
-    def normalize_sym(key)
-      key.downcase.gsub(/[_-]+/, ' ').split.join('_').to_sym
-    end
-  end
-end