enolib 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aeeb10368acccea0f1381c34c6101a552493aea19ef50d8bdc7616f9a898cc7
-  data.tar.gz: 576efc4e4191c945a4d262789e2d353d3521d712b63d1ce4236937d7a556e387
+  metadata.gz: 6b0463dcfa44839c7fecdb048f3678504d0616264bb71e3fe8ada2f97b9b8130
+  data.tar.gz: f4c541da00922054b230d6ff35860bfa49832fc24b064b52948ebb09d90da5e5
 SHA512:
-  metadata.gz: a37196b8d2b69595e22f68b2b9025f64ec01028442ceddf4d6181cea71903f570561d0c2487d515bbad98ecde76c912284be282f8b3c54590cd026c716c8da33
-  data.tar.gz: e9c8143539d6eb1fbf7a6e594208a70d5d6cad25f77d471556b1091d7bd4b3cfd268dbb28a0b764cbc0701b01184bd428cedfd6aecea24bac9d9c222ec8873f6
+  metadata.gz: 237cf74c59338475dfc4f0b8f4d8e5e5c7ced6aa57a41c9afb2a88d442d0c478e3459eadb956407d2f05109c6177cf9458d8e3c38e7fd489741d7774945f6b88
+  data.tar.gz: cd1266e224fbf84ef250dbbd71c65196a2d0d31eb9ef8ed1b6c0a903fc1b00f222966317b8e5c18e3d197b2c0dc9132253f4102634a0708a0d08ee034f136f53

data/lib/enolib/constants.rb

@@ -12,5 +12,5 @@ module Enolib
     list_item: 'list_item',
     multiline_field_begin: 'field',
     section: 'section'
-  }
+  }.freeze
 end

data/lib/enolib/context.rb

@@ -33,27 +33,27 @@ module Enolib
             shared_indent = Float::INFINITY
 
             element[:comments].each_with_index do |comment, index|
-              if comment.has_key?(:comment)
-                first_non_empty_line_index = index unless first_non_empty_line_index
-                last_non_empty_line_index = index
+              next unless comment.has_key?(:comment)
 
-                indent = comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN]
-                shared_indent = indent if indent < shared_indent
-              end
+              first_non_empty_line_index ||= index
+              last_non_empty_line_index = index
+
+              indent = comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN]
+              shared_indent = indent if indent < shared_indent
             end
 
             if first_non_empty_line_index
-                non_empty_lines = element[:comments][first_non_empty_line_index..last_non_empty_line_index]
-
-                non_empty_lines.map do |comment|
-                  if !comment.has_key?(:comment)
-                    ''
-                  elsif (comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN]) == shared_indent
-                    comment[:comment]
-                  else
-                    (' ' * (comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN] - shared_indent)) + comment[:comment]
-                  end
-                end.join("\n")
+              non_empty_lines = element[:comments][first_non_empty_line_index..last_non_empty_line_index]
+
+              non_empty_lines.map do |comment|
+                if !comment.has_key?(:comment)
+                  ''
+                elsif (comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN]) == shared_indent
+                  comment[:comment]
+                else
+                  (' ' * (comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN] - shared_indent)) + comment[:comment]
+                end
+              end.join("\n")
             else
               nil
             end
@@ -214,7 +214,7 @@ module Enolib
         end
       end
 
-      return element[:computed_value]
+      element[:computed_value]
     end
   end
 end

data/lib/enolib/elements/element_base.rb

@@ -16,7 +16,7 @@ module Enolib
       end
 
       unless message
-        raise ArgumentError.new('A message or message function must be provided')
+        raise ArgumentError, 'A message or message function must be provided'
       end
 
       Errors::Validation.comment_error(@context, message, @instruction)
@@ -30,7 +30,7 @@ module Enolib
       end
 
       unless message
-        raise ArgumentError.new('A message or message function must be provided')
+        raise ArgumentError, 'A message or message function must be provided'
       end
 
       Errors::Validation.element_error(@context, message, @instruction)
@@ -42,7 +42,7 @@ module Enolib
       @touched = true
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       begin
@@ -60,7 +60,7 @@ module Enolib
       end
 
       unless message
-        raise ArgumentError.new('A message or message function must be provided')
+        raise ArgumentError, 'A message or message function must be provided'
       end
 
       Errors::Validation.key_error(@context, message, @instruction)
@@ -70,13 +70,13 @@ module Enolib
       loader = Proc.new if block_given?
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _comment(loader, required: false)
     end
 
-    def optional_string_comment()
+    def optional_string_comment
       _comment(required: false)
     end
 
@@ -88,13 +88,13 @@ module Enolib
       loader = Proc.new if block_given?
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _comment(loader, required: true)
     end
 
-    def required_string_comment()
+    def required_string_comment
       _comment(required: true)
     end
 

data/lib/enolib/elements/field.rb

@@ -10,14 +10,14 @@ module Enolib
       loader = Proc.new if block_given?
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _value(loader, required: false)
     end
 
     def parent
-      return @parent || Section.new(@context, @instruction[:parent])
+      @parent || Section.new(@context, @instruction[:parent])
     end
 
     def required_string_value
@@ -28,7 +28,7 @@ module Enolib
       loader = Proc.new if block_given?
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _value(loader, required: true)
@@ -37,27 +37,5 @@ module Enolib
     def to_s
       "#<Enolib::Field key=#{@instruction[:key]} value=#{print_value}>"
     end
-
-    private
-
-    def _value(loader = nil, required:)
-      @touched = true
-
-      value = @context.value(@instruction)
-
-      if value
-        return value unless loader
-
-        begin
-          loader.call(value)
-        rescue => message
-          raise Errors::Validation.value_error(@context, message, @instruction)
-        end
-      else
-        return nil unless required
-
-        raise Errors::Validation.missing_value(@context, @instruction)
-      end
-    end
   end
 end

data/lib/enolib/elements/fieldset.rb

@@ -33,13 +33,13 @@ module Enolib
         next if except && except.include?(key) || only && !only.include?(key)
 
         entries.each do |entry|
-          unless entry.touched  # TODO: Revisit instance var existance question in ruby
-            if message.is_a?(Proc)
-              message = message.call(entry)
-            end
-
-            raise Errors::Validation.unexpected_element(@context, message, entry[:instruction])
+          next if entry.touched  # TODO: Revisit instance var existance question in ruby
+          
+          if message.is_a?(Proc)
+            message = message.call(entry)
           end
+
+          raise Errors::Validation.unexpected_element(@context, message, entry[:instruction])
         end
       end
     end

data/lib/enolib/elements/list.rb

@@ -50,7 +50,7 @@ module Enolib
       if loader
         _comment(loader, required: false)
       else
-        raise ArgumentError.new('A loader block or Proc must be provided')
+        raise ArgumentError, 'A loader block or Proc must be provided'
       end
     end
 
@@ -66,7 +66,7 @@ module Enolib
       @touched = true
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _items.map { |item| item.optional_value(loader) }
@@ -88,7 +88,7 @@ module Enolib
       @touched = true
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _items.map { |item| item.required_value(loader) }

data/lib/enolib/elements/section.rb

@@ -61,13 +61,13 @@ module Enolib
         elements.each do |element|
           untouched = element._untouched
 
-          if untouched
-            if message.is_a?(Proc)
-              message = message.call(Element.new(@context, untouched, self))
-            end
+          next unless untouched
 
-            raise Errors::Validation.unexpected_element(@context, message, untouched)
+          if message.is_a?(Proc)
+            message = message.call(Element.new(@context, untouched, self))
           end
+
+          raise Errors::Validation.unexpected_element(@context, message, untouched)
         end
       end
     end
@@ -270,9 +270,7 @@ module Enolib
     def touch
       @touched = true
 
-      _elements.each do |element|
-        element.touch
-      end
+      _elements.each(&:touch)
     end
 
     private
@@ -291,7 +289,7 @@ module Enolib
         if required || @all_elements_required
           raise Errors::Validation.missing_element(@context, key, @instruction, 'missing_element')
         elsif required == nil
-          return MissingElement.new(key, self)
+          return MissingSectionElement.new(key, self)
         else
           return nil
         end

data/lib/enolib/elements/section_element.rb

@@ -17,7 +17,7 @@ module Enolib
     def to_empty
       unless instance_variable_defined?(:@empty)
         if instance_variable_defined?(:@yielded)
-          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as an empty.")
+          raise TypeError, "This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as an empty."
         end
 
         unless @instruction[:type] == :empty_element
@@ -35,7 +35,7 @@ module Enolib
     def to_field
       unless instance_variable_defined?(:@field)
         if instance_variable_defined?(:@yielded)
-          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a field.")
+          raise TypeError, "This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a field."
         end
 
         unless @instruction[:type] == :field ||
@@ -54,7 +54,7 @@ module Enolib
     def to_fieldset
       unless instance_variable_defined?(:@fieldset)
         if instance_variable_defined?(:@yielded)
-          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a fieldset.")
+          raise TypeError, "This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a fieldset."
         end
 
         unless @instruction[:type] == :fieldset || @instruction[:type] == :empty_element
@@ -71,7 +71,7 @@ module Enolib
     def to_list
       unless instance_variable_defined?(:@list)
         if instance_variable_defined?(:@yielded)
-          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a list.")
+          raise TypeError, "This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a list."
         end
 
         unless @instruction[:type] == :list || @instruction[:type] == :empty_element

data/lib/enolib/elements/value_element_base.rb

@@ -10,7 +10,7 @@ module Enolib
       loader = Proc.new if block_given?
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _value(loader, required: false)
@@ -24,7 +24,7 @@ module Enolib
       loader = Proc.new if block_given?
 
       unless loader
-        raise ArgumentError.new('A loader function must be provided')
+        raise ArgumentError, 'A loader function must be provided'
       end
 
       _value(loader, required: true)
@@ -38,7 +38,7 @@ module Enolib
       end
 
       unless message
-        raise ArgumentError.new('A message or message function must be provided')
+        raise ArgumentError, 'A message or message function must be provided'
       end
 
       Errors::Validation.value_error(@context, message, @instruction)

data/lib/enolib/errors/parsing.rb

@@ -3,7 +3,7 @@
 module Enolib
   module Errors
     module Parsing
-      UNTERMINATED_ESCAPED_KEY = /^\s*#*\s*(`+)(?!`)((?:(?!\1).)+)$/
+      UNTERMINATED_ESCAPED_KEY = /^\s*#*\s*(`+)(?!`)((?:(?!\1).)+)$/.freeze
 
       def self.cyclic_dependency(context, instruction, instruction_chain)
         first_occurrence = instruction_chain.find_index(instruction)
@@ -24,9 +24,9 @@ module Enolib
         end
 
         ParseError.new(
-          context.messages::cyclic_dependency(copy_instruction[:line] + Enolib::HUMAN_INDEXING, copy_instruction[:template]),
+          context.messages.cyclic_dependency(copy_instruction[:line] + Enolib::HUMAN_INDEXING, copy_instruction[:template]),
           reporter.snippet,
-          Selections::select_template(copy_instruction)
+          Selections.select_template(copy_instruction)
         )
       end
 
@@ -37,41 +37,41 @@ module Enolib
         return unterminated_escaped_key(context, instruction, match.end(1)) if match
 
         ParseError.new(
-          context.messages::invalid_line(instruction[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.invalid_line(instruction[:line] + Enolib::HUMAN_INDEXING),
           context.reporter.new(context).report_line(instruction).snippet,
-          Selections::select_line(instruction)
+          Selections.select_line(instruction)
         )
       end
 
       def self.missing_element_for_continuation(context, continuation)
         ParseError.new(
-          context.messages::missing_element_for_continuation(continuation[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.missing_element_for_continuation(continuation[:line] + Enolib::HUMAN_INDEXING),
           context.reporter.new(context).report_line(continuation).snippet,
-          Selections::select_line(continuation)
+          Selections.select_line(continuation)
         )
       end
 
       def self.missing_fieldset_for_fieldset_entry(context, entry)
         ParseError.new(
-          context.messages::missing_fieldset_for_fieldset_entry(entry[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.missing_fieldset_for_fieldset_entry(entry[:line] + Enolib::HUMAN_INDEXING),
           context.reporter.new(context).report_line(entry).snippet,
-          Selections::select_line(entry)
+          Selections.select_line(entry)
         )
       end
 
       def self.missing_list_for_list_item(context, item)
         ParseError.new(
-          context.messages::missing_list_for_list_item(item[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.missing_list_for_list_item(item[:line] + Enolib::HUMAN_INDEXING),
           context.reporter.new(context).report_line(item).snippet,
-          Selections::select_line(item)
+          Selections.select_line(item)
         )
       end
 
       def self.non_section_element_not_found(context, copy)
         ParseError.new(
-          context.messages::non_section_element_not_found(copy[:line] + Enolib::HUMAN_INDEXING, copy[:template]),
+          context.messages.non_section_element_not_found(copy[:line] + Enolib::HUMAN_INDEXING, copy[:template]),
           context.reporter.new(context).report_line(copy).snippet,
-          Selections::select_line(copy)
+          Selections.select_line(copy)
         )
       end
 
@@ -81,23 +81,23 @@ module Enolib
         reporter.indicate_line(super_section) if super_section[:type] != :document
 
         ParseError.new(
-          context.messages::section_hierarchy_layer_skip(section[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.section_hierarchy_layer_skip(section[:line] + Enolib::HUMAN_INDEXING),
           reporter.snippet,
-          Selections::select_line(section)
+          Selections.select_line(section)
         )
       end
 
       def self.section_not_found(context, copy)
         ParseError.new(
-          context.messages::section_not_found(copy[:line] + Enolib::HUMAN_INDEXING, copy[:template]),
+          context.messages.section_not_found(copy[:line] + Enolib::HUMAN_INDEXING, copy[:template]),
           context.reporter.new(context).report_line(copy).snippet,
-          Selections::select_line(copy)
+          Selections.select_line(copy)
         )
       end
 
       def self.unterminated_escaped_key(context, instruction, selection_column)
         ParseError.new(
-          context.messages::unterminated_escaped_key(instruction[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.unterminated_escaped_key(instruction[:line] + Enolib::HUMAN_INDEXING),
           context.reporter.new(context).report_line(instruction).snippet,
           {
             from: {
@@ -105,16 +105,16 @@ module Enolib
               index: instruction[:ranges][:line][RANGE_BEGIN] + selection_column,
               line: instruction[:line]
             },
-            to: Selections::cursor(instruction, :line, RANGE_END)
+            to: Selections.cursor(instruction, :line, RANGE_END)
           }
         )
       end
 
       def self.two_or_more_templates_found(context, copy, first_template, second_template)
         ParseError.new(
-          context.messages::two_or_more_templates_found(copy[:template]),
+          context.messages.two_or_more_templates_found(copy[:template]),
           context.reporter.new(context).report_line(copy).question_line(first_template).question_line(second_template).snippet,
-          Selections::select_line(copy)
+          Selections.select_line(copy)
         )
       end
 
@@ -126,9 +126,9 @@ module Enolib
         end
 
         ParseError.new(
-          context.messages::unterminated_multiline_field(field[:key], field[:line] + Enolib::HUMAN_INDEXING),
+          context.messages.unterminated_multiline_field(field[:key], field[:line] + Enolib::HUMAN_INDEXING),
           reporter.snippet,
-          Selections::select_line(field)
+          Selections.select_line(field)
         )
       end
     end

data/lib/enolib/errors/selections.rb

@@ -7,7 +7,7 @@ module Enolib
     DOCUMENT_BEGIN = {
       from: { column: 0, index: 0, line: 0 },
       to: { column: 0, index: 0, line: 0 }
-    }
+    }.freeze
 
     def self.last_in(element)
       if (element[:type] == :field ||

data/lib/enolib/errors/validation.rb

@@ -6,40 +6,40 @@ module Enolib
       def self.comment_error(context, message, element)
         ValidationError.new(
           context.messages.comment_error(message),
-          context.reporter.new(context).report_comments(element).snippet(),
-          Selections::select_comments(element)
+          context.reporter.new(context).report_comments(element).snippet,
+          Selections.select_comments(element)
         )
       end
 
       def self.element_error(context, message, element)
         ValidationError.new(
           message,
-          context.reporter.new(context).report_element(element).snippet(),
-          Selections::select_element(element)
+          context.reporter.new(context).report_element(element).snippet,
+          Selections.select_element(element)
         )
       end
 
       def self.key_error(context, message, element)
         ValidationError.new(
           context.messages.key_error(message),
-          context.reporter.new(context).report_line(element).snippet(),
-          Selections::select_key(element)
+          context.reporter.new(context).report_line(element).snippet,
+          Selections.select_key(element)
         )
       end
 
       def self.missing_comment(context, element)
         ValidationError.new(
           context.messages::MISSING_COMMENT,
-          context.reporter.new(context).report_line(element).snippet(), # TODO: Question-tag an empty line before an element with missing comment
-          Selections::selection(element, :line, RANGE_BEGIN)
+          context.reporter.new(context).report_line(element).snippet, # TODO: Question-tag an empty line before an element with missing comment
+          Selections.selection(element, :line, RANGE_BEGIN)
         )
       end
 
       def self.missing_element(context, key, parent, message)
         ValidationError.new(
           key ? context.messages.send(message + '_with_key', key) : context.messages.const_get(message.upcase), # TODO: Solve the upcase rather through a different generated message type, e.g. method instead of constant
-          context.reporter.new(context).report_missing_element(parent).snippet(),
-          parent[:type] == :document ? Selections::DOCUMENT_BEGIN : Selections::selection(parent, :line, RANGE_END)
+          context.reporter.new(context).report_missing_element(parent).snippet,
+          parent[:type] == :document ? Selections::DOCUMENT_BEGIN : Selections.selection(parent, :line, RANGE_END)
         )
       end
 
@@ -51,28 +51,30 @@ module Enolib
            element[:type] == :multiline_field_begin
           message = context.messages.missing_field_value(element[:key])
 
-          if element[:ranges].has_key?(:template)
-            selection[:from] = Selections::cursor(element, :template, RANGE_END)
-          elsif element[:ranges].has_key?(:element_operator)
-            selection[:from] = Selections::cursor(element, :element_operator, RANGE_END)
-          else
-            selection[:from] = Selections::cursor(element, :line, RANGE_END)
-          end
+          selection[:from] =
+            if element[:ranges].has_key?(:template)
+              Selections.cursor(element, :template, RANGE_END)
+            elsif element[:ranges].has_key?(:element_operator)
+              Selections.cursor(element, :element_operator, RANGE_END)
+            else
+              Selections.cursor(element, :line, RANGE_END)
+            end
         elsif element[:type] == :fieldset_entry
           message = context.messages.missing_fieldset_entry_value(element[:key])
-          selection[:from] = Selections::cursor(element, :entry_operator, RANGE_END)
+          selection[:from] = Selections.cursor(element, :entry_operator, RANGE_END)
         elsif element[:type] == :list_item
           message = context.messages.missing_list_item_value(element[:parent][:key])
-          selection[:from] = Selections::cursor(element, :item_operator, RANGE_END)
+          selection[:from] = Selections.cursor(element, :item_operator, RANGE_END)
         end
 
-        snippet = context.reporter.new(context).report_element(element).snippet()
+        snippet = context.reporter.new(context).report_element(element).snippet
 
-        if element[:type] == :field and element.has_key?(:continuations)
-          selection[:to] = Selections::cursor(element[:continuations].last, :line, RANGE_END)
-        else
-          selection[:to] = Selections::cursor(element, :line, RANGE_END)
-        end
+        selection[:to] =
+          if element[:type] == :field && element.has_key?(:continuations)
+            Selections.cursor(element[:continuations].last, :line, RANGE_END)
+          else
+            Selections.cursor(element, :line, RANGE_END)
+          end
 
         ValidationError.new(message, snippet, selection)
       end
@@ -80,63 +82,64 @@ module Enolib
       def self.unexpected_element(context, message, element)
         ValidationError.new(
           message || context.messages::UNEXPECTED_ELEMENT,
-          context.reporter.new(context).report_element(element).snippet(),
-          Selections::select_element(element)
+          context.reporter.new(context).report_element(element).snippet,
+          Selections.select_element(element)
         )
       end
 
       def self.unexpected_multiple_elements(context, key, elements, message)
         ValidationError.new(
           key ? context.messages.send(message + '_with_key', key) : context.messages.const_get(message.upcase), # TODO: Solve the upcase rather through a different generated message type, e.g. method instead of constant
-          context.reporter.new(context).report_elements(elements).snippet(),
-          Selections::select_element(elements[0])
+          context.reporter.new(context).report_elements(elements).snippet,
+          Selections.select_element(elements[0])
         )
       end
 
       def self.unexpected_element_type(context, key, section, message)
         ValidationError.new(
           key ? context.messages.send(message + '_with_key', key) : context.messages.const_get(message.upcase), # TODO: Solve the upcase rather through a different generated message type, e.g. method instead of constant
-          context.reporter.new(context).report_element(section).snippet(),
-          Selections::select_element(section)
+          context.reporter.new(context).report_element(section).snippet,
+          Selections.select_element(section)
         )
       end
 
       def self.value_error(context, message, element)
         if element.has_key?(:mirror)
-          snippet = context.reporter.new(context).report_line(element).snippet()
+          snippet = context.reporter.new(context).report_line(element).snippet
           select = select_key(element)
         elsif element[:type] == :multiline_field_begin
           if element.has_key?(:lines)
-            snippet = context.reporter.new(context).report_multiline_value(element).snippet()
-            select = Selections::selection(element[:lines][0], :line, RANGE_BEGIN, element[:lines][-1], :line, RANGE_END)
+            snippet = context.reporter.new(context).report_multiline_value(element).snippet
+            select = Selections.selection(element[:lines][0], :line, RANGE_BEGIN, element[:lines][-1], :line, RANGE_END)
           else
-            snippet = context.reporter.new(context).report_element(element).snippet()
-            select = Selections::selection(element, :line, RANGE_END)
+            snippet = context.reporter.new(context).report_element(element).snippet
+            select = Selections.selection(element, :line, RANGE_END)
           end
         else
-          snippet = context.reporter.new(context).report_element(element).snippet()
-          select = {}
-
-          if element[:ranges].has_key?(:value)
-            select[:from] = Selections::cursor(element, :value, RANGE_BEGIN)
-          elsif element[:ranges].has_key?(:element_operator)
-            select[:from] = Selections::cursor(element, :element_operator, RANGE_END)
-          elsif element[:ranges].has_key?(:entry_operator)
-            select[:from] = Selections::cursor(element, :entry_operator, RANGE_END)
-          elsif element[:type] == :list_item
-            select[:from] = Selections::cursor(element, :item_operator, RANGE_END)
-          else
-            # TODO: Possibly never reached - think through state permutations
-            select[:from] = Selections::cursor(element, :line, RANGE_END)
-          end
-
-          if element.has_key?(:continuations)
-            select[:to] = Selections::cursor(element[:continuations][-1], :line, RANGE_END)
-          elsif element[:ranges].has_key?(:value)
-            select[:to] = Selections::cursor(element, :value, RANGE_END)
-          else
-            select[:to] = Selections::cursor(element, :line, RANGE_END)
-          end
+          snippet = context.reporter.new(context).report_element(element).snippet
+          select = {
+            from:
+              if element[:ranges].has_key?(:value)
+                Selections.cursor(element, :value, RANGE_BEGIN)
+              elsif element[:ranges].has_key?(:element_operator)
+                Selections.cursor(element, :element_operator, RANGE_END)
+              elsif element[:ranges].has_key?(:entry_operator)
+                Selections.cursor(element, :entry_operator, RANGE_END)
+              elsif element[:type] == :list_item
+                Selections.cursor(element, :item_operator, RANGE_END)
+              else
+                # TODO: Possibly never reached - think through state permutations
+                Selections.cursor(element, :line, RANGE_END)
+              end,
+            to:
+              if element.has_key?(:continuations)
+                Selections.cursor(element[:continuations][-1], :line, RANGE_END)
+              elsif element[:ranges].has_key?(:value)
+                Selections.cursor(element, :value, RANGE_END)
+              else
+                Selections.cursor(element, :line, RANGE_END)
+              end
+          }
         end
 
         ValidationError.new(context.messages.value_error(message), snippet, select)

data/lib/enolib/grammar_regexp.rb

@@ -98,6 +98,6 @@ module Enolib
 
     NOT_EMPTY = /(?:#{EARLY_DETERMINED}|#{LATE_DETERMINED})/.source
 
-    REGEX = /[^\S\n]*(?:#{EMPTY}|#{NOT_EMPTY})[^\S\n]*(?=\n|$)/
+    REGEX = /[^\S\n]*(?:#{EMPTY}|#{NOT_EMPTY})[^\S\n]*(?=\n|$)/.freeze
   end
 end

data/lib/enolib/lookup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RANGE_BEGIN = 0
 RANGE_END = 1
 
@@ -63,7 +65,6 @@ def check_fieldset_by_line(fieldset, line)
   return false unless fieldset.has_key?(:entries) &&
                       line <= fieldset[:entries].last[:line]
 
-
   fieldset[:entries].each do |entry|
     return { element: entry, instruction: entry } if line == entry[:line]
     return { element: fieldset, instruction: nil } if line < entry[:line]
@@ -190,13 +191,13 @@ module Enolib
     match = nil
     if index
       if index < 0 || index > context.input.length
-        raise IndexError.new("You are trying to look up an index (#{index}) outside of the document's index range (0-#{context.input.length})")
+        raise IndexError, "You are trying to look up an index (#{index}) outside of the document's index range (0-#{context.input.length})"
       end
 
       match = check_in_section_by_index(context.document, index)
     else
       if line < 0 || line >= context.line_count
-        raise IndexError.new("You are trying to look up a line (#{line}) outside of the document's line range (0-#{context.line_count - 1})")
+        raise IndexError, "You are trying to look up a line (#{line}) outside of the document's line range (0-#{context.line_count - 1})"
       end
 
       match = check_in_section_by_line(context.document, line)

data/lib/enolib/parser.rb

@@ -7,8 +7,8 @@ module Enolib
       @depth = 0
       @index = 0
       @line = 0
-      @unresolved_non_section_elements = nil
-      @unresolved_sections = nil
+      @unresolved_non_section_elements = {}
+      @unresolved_sections = {}
     end
 
     def run
@@ -164,7 +164,7 @@ module Enolib
 
         elsif match[Grammar::SPACED_LINE_CONTINUATION_OPERATOR_INDEX]
 
-          if !last_continuable_element
+          unless last_continuable_element
             instruction = tokenize_error_context
             raise Errors::Parsing.missing_element_for_continuation(@context, instruction)
           end
@@ -197,7 +197,7 @@ module Enolib
 
         elsif match[Grammar::DIRECT_LINE_CONTINUATION_OPERATOR_INDEX]
 
-          if !last_continuable_element
+          unless last_continuable_element
             instruction = tokenize_error_context
             raise Errors::Parsing.missing_element_for_continuation(@context, instruction)
           end
@@ -292,8 +292,6 @@ module Enolib
               instruction[:ranges][:copy_operator] = copy_operator_offset
             end
 
-            @unresolved_sections = {} unless @unresolved_sections
-
             if @unresolved_sections.has_key?(template)
               @unresolved_sections[template][:targets].push(instruction)
             else
@@ -381,9 +379,9 @@ module Enolib
             length: terminator_match.end(0),
             line: @line,
             ranges: {
-              key:  terminator_match.offset(2),
+              key: terminator_match.offset(2),
               line: [@index, terminator_match.end(0)],
-              multiline_field_operator: terminator_match.offset(1),
+              multiline_field_operator: terminator_match.offset(1)
             },
             type: :multiline_field_end
           }
@@ -444,8 +442,6 @@ module Enolib
           last_continuable_element = nil
           last_non_section_element = instruction
 
-          @unresolved_non_section_elements = {} unless @unresolved_non_section_elements
-
           if @unresolved_non_section_elements.has_key?(template)
             @unresolved_non_section_elements[template][:targets].push(instruction)
           else
@@ -461,15 +457,10 @@ module Enolib
         end
       end
 
-      if @context.input[-1] == "\n"
-        @context.line_count = @line + 1
-      else
-        @context.line_count = @line
-      end
-
+      @context.line_count = @context.input[-1] == "\n" ? @line + 1 : @line
       @context.meta.concat(comments) if comments
 
-      resolve if @unresolved_non_section_elements || @unresolved_sections
+      resolve unless @unresolved_non_section_elements.empty? && @unresolved_sections.empty?
     end
 
     private
@@ -529,24 +520,25 @@ module Enolib
         merge_map = {}
 
         section[:elements].each do |section_element|
-          if section_element[:type] != :section || merge_map.has_key?(section_element[:key])
-            merge_map[section_element[:key]] = false # non-mergable (no section or multiple instructions with same key)
-          else
-            merge_map[section_element[:key]] = { section: section_element }
-          end
+          merge_map[section_element[:key]] =
+            if section_element[:type] != :section || merge_map.has_key?(section_element[:key])
+              false # non-mergable (no section or multiple instructions with same key)
+            else
+              { section: section_element }
+            end
         end
 
         template[:elements].each do |section_element|
-          if merge_map.has_key?(section_element[:key])
-            merger = merge_map[section_element[:key]]
+          next unless merge_map.has_key?(section_element[:key])
 
-            next unless merger
+          merger = merge_map[section_element[:key]]
 
-            if section_element[:type] != :section || merger.has_key?(:template)
-              merge_map[section_element[:key]] = false # non-mergable (no section or multiple template instructions with same key)
-            else
-              merger[:template] = section_element
-            end
+          next unless merger
+
+          if section_element[:type] != :section || merger.has_key?(:template)
+            merge_map[section_element[:key]] = false # non-mergable (no section or multiple template instructions with same key)
+          else
+            merger[:template] = section_element
           end
         end
 
@@ -692,7 +684,7 @@ module Enolib
         else
           instruction = {
             line: @line,
-            ranges: { line: [@index, @context.input.length]}
+            ranges: { line: [@index, @context.input.length] }
           }
 
           instruction[:type] = :unparsed if first_instruction

data/lib/enolib/reporters/html_reporter.rb

@@ -86,10 +86,10 @@ module Enolib
     end
 
     def markup(gutter, content, tag_class = '')
-       "<div class=\"eno-report-line #{tag_class}\">" +
-       "<div class=\"eno-report-gutter\">#{gutter.rjust(10)}</div>" +
-       "<div class=\"eno-report-content\">#{escape(content)}</div>" +
-       '</div>'
+      "<div class=\"eno-report-line #{tag_class}\">" \
+      "<div class=\"eno-report-gutter\">#{gutter.rjust(10)}</div>" \
+      "<div class=\"eno-report-content\">#{escape(content)}</div>" \
+      '</div>'
     end
 
     def print

data/lib/enolib/reporters/reporter.rb

@@ -31,7 +31,7 @@ module Enolib
 
     def report_element(element)
       @snippet[element[:line]] = :emphasize
-      tag_element(element, :indicate)
+      tag_children(element, :indicate)
 
       self
     end
@@ -39,7 +39,7 @@ module Enolib
     def report_elements(elements)
       elements.each do |element|
         @snippet[element[:line]] = :emphasize
-        tag_element(element, :indicate)
+        tag_children(element, :indicate)
       end
 
       self
@@ -65,7 +65,7 @@ module Enolib
       if parent[:type] == :section
         tag_section(parent, :question, false)
       else
-        tag_element(parent, :question)
+        tag_children(parent, :question)
       end
 
       self
@@ -139,10 +139,10 @@ module Enolib
 
               @index[item[:line]] = item
 
-              if item.has_key?(:continuations)
-                item[:continuations].each do |continuation|
-                  @index[continuation[:line]] = continuation
-                end
+              next unless item.has_key?(:continuations)
+
+              item[:continuations].each do |continuation|
+                @index[continuation[:line]] = continuation
               end
             end
           end
@@ -153,10 +153,10 @@ module Enolib
 
               @index[entry[:line]] = entry
 
-              if entry.has_key?(:continuations)
-                entry[:continuations].each do |continuation|
-                  @index[continuation[:line]] = continuation
-                end
+              next unless entry.has_key?(:continuations)
+
+              entry[:continuations].each do |continuation|
+                @index[continuation[:line]] = continuation
               end
             end
           end
@@ -209,14 +209,15 @@ module Enolib
       scan_line
     end
 
-    def tag_element(element, tag)
-      if element[:type] == :field || element[:type] == :list_item || element[:type] == :fieldset_entry
+    def tag_children(element, tag)
+      case element[:type]
+      when :field, :list_item, :fieldset_entry
         return tag_continuations(element, tag)
-      elsif element[:type] == :list
+      when :list
         return tag_continuables(element, :items, tag)
-      elsif element[:type] == :fieldset && element.has_key?(:entries)
+      when :fieldset
         return tag_continuables(element, :entries, tag)
-      elsif element[:type] == :multiline_field_begin
+      when :multiline_field_begin
         if element.has_key?(:lines)
           element[:lines].each do |line|
             @snippet[line[:line]] = tag
@@ -226,30 +227,29 @@ module Enolib
         if element.has_key?(:end)
           @snippet[element[:end][:line]] = tag
           return element[:end][:line] + 1
-        elsif element.has_key?(:lines)
-          return element[:lines][-1][:line] + 1
-        else
-          return element[:line] + 1
         end
-      elsif element[:type] == :section
+
+        return element[:lines][-1][:line] + 1 if element.has_key?(:lines)
+        return element[:line] + 1
+      when :section
         return tag_section(element, tag)
       end
     end
 
-    def tag_section(section, tag, recursive=true)
+    def tag_section(section, tag, recursive = true)
       scan_line = section[:line] + 1
 
       section[:elements].each do |element|
         while scan_line < element[:line]
-          @snippet[scan_line] = :indicate
+          @snippet[scan_line] = tag
           scan_line += 1
         end
 
         break if element[:type] == :section && !recursive
 
-        @snippet[element[:line]] = :indicate
+        @snippet[element[:line]] = tag
 
-        scan_line = tag_element(element, tag)
+        scan_line = tag_children(element, tag)
       end
 
       scan_line

data/lib/enolib/reporters/terminal_reporter.rb

@@ -18,14 +18,14 @@ INDICATORS = {
   emphasize: '>',
   indicate: '*',
   question: '?'
-}
+}.freeze
 
 GUTTER_STYLE = {
   display: BRIGHT_BLACK_BACKGROUND,
   emphasize: BLACK + BRIGHT_RED_BACKGROUND,
   indicate: BLACK + WHITE_BACKGROUND,
   question: BLACK + WHITE_BACKGROUND
-}
+}.freeze
 
 RANGE_STYLE = {
   'element_operator': WHITE,
@@ -42,7 +42,7 @@ RANGE_STYLE = {
   'key': BOLD + BRIGHT_WHITE,
   'template': BOLD + BRIGHT_WHITE,
   'value': DIM + WHITE
-}
+}.freeze
 
 module Enolib
   class TerminalReporter < Reporter
@@ -76,12 +76,12 @@ module Enolib
 
       content = ''
       if instruction
-        if instruction[:type] == :comment or instruction[:type] == :unparsed
+        if instruction[:type] == :comment || instruction[:type] == :unparsed
           content = BRIGHT_BLACK + @context.input[instruction[:ranges][:line][RANGE_BEGIN]...instruction[:ranges][:line][RANGE_END]] + RESET
         else
           content = @context.input[instruction[:ranges][:line][RANGE_BEGIN]...instruction[:ranges][:line][RANGE_END]]
 
-          instruction[:ranges].sort_by { |type, range| range[0] }.reverse_each do |type, range|
+          instruction[:ranges].sort_by { |_type, range| range[0] }.reverse_each do |type, range|
             next if type == :line
 
             before = content[0...range[RANGE_BEGIN] - instruction[:ranges][:line][RANGE_BEGIN]]

data/lib/enolib/reporters/text_reporter.rb

@@ -7,7 +7,7 @@ module Enolib
       emphasize: '>',
       indicate: '*',
       question: '?'
-    }
+    }.freeze
 
     def initialize(context)
       super(context)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enolib
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Simon Repp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-21 00:00:00.000000000 Z
+date: 2019-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep-cover
@@ -52,6 +52,34 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The cross-language eno standard library
 email: simon@fdpl.io
 executables: []