boost_info 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73d4ca44feede1ed7606e7a82341982cedefa81d
-  data.tar.gz: 97e80dbb95417f24197e775b097e2819e6dbec48
+  metadata.gz: 0114ee49982c750a6dd040d3ad3cbe442016bc04
+  data.tar.gz: 9294cc5f854ce61386ca2fd54291ebb72fa5c0ae
 SHA512:
-  metadata.gz: ae9647cbe4d07c4ffd648fc657035cbd6db29e2b28690f38756f4bd98b1030b4ea792e7fc6623744d8d7073befc5c788f300629edd173514313421651d05a22f
-  data.tar.gz: 3d175935226d8bf31b7f62d27f9ac2d39b6b07f2a5e17b52250f690956c4c47a5e41ad1d1ace9c7775e110c189f820f2c49a69ed527500e4eeae9f0dd57667fd
+  metadata.gz: f59e7d7de56fbd7ca43ddd23e0b854bd243c27a39069ced005d7bb2565d66f050a18fbe83e297631805670c6e7a577788c87f37d2f12e1c8932b2ecfe70e4699
+  data.tar.gz: f87f5e05fe8e597d1fd23c26a0c5c8c5b6eec943891593fc8c097d92ba984950886ab7159da53cf15b2157da207198196e58587c8e0abddd67adee7932ec100c

data/README.md

@@ -27,7 +27,7 @@ BoostInfo.parse(file, options={})
 
 Available options: 
 
-- **symbolize_names**: convert all keys to symbols (default: false)
+- **symbolize_keys**: convert all keys to symbols (default: false)
 
 ### Generating INFO
 

data/boost_info.gemspec

@@ -5,6 +5,7 @@ require 'boost_info/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "boost_info"
+  spec.description   = "Simple parser for Boost INFO format."
   spec.version       = BoostInfo::VERSION
   spec.authors       = ["Igor Vetrov", "Alexander Tsygankov"]
   spec.email         = ["capybarov@gmail.com"]

data/lib/boost_info/generator.rb

@@ -1,43 +1,63 @@
-require 'boost_info/node'
-
 module BoostInfo
   class Generator
-    def initialize(hash, opts={})
-      raise TypeError unless hash.is_a?(Hash)
-      @hash = hash
+    def initialize(root_node, opts={})
+      @root_node = root_node
       @opts = opts
       @opts[:indent] ||= 4
     end
 
-    def generate
-      @result = ''
-      level = 0
-      iterate_hash(@hash, level)
-      @result
+    def to_hash
+      build_hash(@root_node)
+    end
+
+    def to_info
+      build_info(@root_node, 0).join("\n") + "\n"
     end
 
     private
 
-      def iterate_hash(hash, level)
-        hash.each do |k,v|
-          k = k.to_s
-          if v.is_a?(Hash)
-            # Wrap hash in curly braces
-            @result << add_indent("#{ k } {\n", level)
-            iterate_hash(v, level + 1)
-            @result << add_indent("}\n", level)
-          else
-            v = v.to_s
-            # Wrap spaces and special symbols in double quotes
-            v = %["#{ v }"] if v[/[\s\/:;.,]/]
-            @result << add_indent("#{ k } #{ v }\n", level)
-          end
+    def build_hash(parent_node)
+      hash = {}
+      parent_node.childrens.each do |node|
+        key = @opts[:symbolize_keys] ? node.key.to_sym : node.key
+        if node.childrens
+          hash[key] = build_hash(node)
+        else
+          hash[key] = node.value
         end
       end
+      hash
+    end
 
-      def add_indent(string, level)
-        indent = @opts[:indent] * level
-        "#{ ' ' * indent if indent > 0}#{string}"
+    def build_info(parent_node, level)
+      lines = []
+      last_node_index = parent_node.childrens.size - 1
+      parent_node.childrens.each_with_index do |node,index|
+        if node.childrens.nil?
+          value = wrap_in_quotes(node.value)
+          lines << add_indent("#{node.key} #{value}", level)
+        elsif node.childrens.any?
+          lines << add_indent("#{node.key} {", level)
+          nested_lines = build_info(node, level + 1)
+          lines.concat(nested_lines)
+        elsif node.childrens.empty?
+          lines << add_indent("#{node.key} { }", level)
+        end
+        if level > 0 && index == last_node_index
+          lines << add_indent("}", level - 1)
+        end
       end
+      lines
+    end
+
+    def add_indent(string, level)
+      indent = @opts[:indent] * level
+      "#{' ' * indent if indent > 0}#{string}"
+    end
+
+    def wrap_in_quotes(value)
+      string = value.to_s
+      string =~ /[\s\/:;.,{}]/ ? '"' + string + '"' : string
+    end
   end
 end

data/lib/boost_info/node.rb

@@ -2,67 +2,156 @@
 
 module BoostInfo
   class Node
-    attr_accessor :level, :name, :value, :parent, :children
+    attr_accessor :root, :key, :value, :parent, :childrens
 
-    def initialize(level, name, value=nil)
-      # Instance initializer
-      @level = level
-      @name = name
-      @value = value
-      @parent = nil
-      @children = []
+    def initialize(params={})
+      @root = params[:root]
+      @key = params[:key].to_s if params[:key] # normalize key
+      @value = params[:value]
+      @parent = params[:parent]
+
+      @childrens = nil
     end
 
-    def to_s
-      # String representation for node
-      if @value
-        "#{'| '*@level}#{@level} #{@name} = #{@value}"
+    def get(key_to_get, params={})
+      return [] unless @childrens
+
+      if key_to_get.is_a?(Regexp)
+        @childrens.select { |c| c.key =~ key_to_get }
       else
-        "#{'| '*@level}#{@level} #{@name}"
+        @childrens.select { |c| c.key == key_to_get.to_s }
       end
     end
 
-    def to_h(symbolize=false)
-      key = symbolize ? @name.to_sym : @name
-      if has_children?
-        result = {}
-        @children.each { |c| result.merge!(c.to_h(symbolize)) }
-        { key => result }
-      else
-        { key => @value }
+    def find_by_path(path, params={})
+      if path.size > 1
+        next_node_key = path.shift
+        node = get(next_node_key).first
+        node.find_by_path(path) if node
+      elsif path.size == 1
+        last_key = path.last.to_s
+        get(last_key).first
       end
     end
 
-    def add_child(child)
-      # Add child node and assign parent to child node
-      child.parent = self
-      @children << child
+    def find_by_key(key, params={})
+      result = []
+      childrens.each do |node|
+        if key.is_a?(Regexp)
+          result << node if node.key =~ key
+        else
+          result << node if node.key == key.to_s
+        end
+
+        if node.childrens
+          result_from_children = node.find_by_key(key, params)
+          result.concat(result_from_children)
+        end
+      end
+      result
     end
 
-    def has_children?
-      # Check children existence
-      @children.size > 0
+    def parents
+      result = []
+      unless root
+        result << parent
+        result.concat(parent.parents)
+      end
+      result
     end
 
-    def has_parent?
-      # Check parent existence
-      @parent != nil
+    def siblings
+      parent_childrens = (parent && parent.childrens) || []
+      parent_childrens.reject { |c| c == self }
     end
 
-    def find(name)
-      # Recursive node search by name
-      return self if @name == name
-      result_node = nil
-      @children.each do |node|
-        if node.name==name then result_node = node; break end
-        if node.has_children?
-          found_node = node.find(name)
-          if found_node
-            if found_node.name==name then result_node = found_node; break end
-          end
-        end
+    def auto_insert(path, value, params={})
+      params[:force] ||= true
+      if params[:force]
+        params[:delete_if] = ->(node) { node.childrens.nil? }
+      end
+
+      current_node = self
+      path.each do |new_key|
+        existing_node = current_node.get(new_key).first
+        current_node = if existing_node && existing_node.childrens
+                        existing_node
+                      else
+                        current_node.insert(new_key, value, params)
+                      end
+      end
+      current_node
+    end
+
+    def insert(key, value, params={})
+      node = Node.new(key: key, value: value)
+      insert_node(node, params)
+      node
+    end
+
+    def insert_node(node, params={})
+      node.parent = self
+      @childrens ||= []
+      @childrens.delete_if(&params[:delete_if]) if params[:delete_if]
+
+      if params[:after]
+        insert_node_after(params[:after], node)
+      elsif params[:before]
+        insert_node_before(params[:before], node)
+      elsif params[:prepend]
+        @childrens.unshift(node)
+      else
+        @childrens << node
       end
-      result_node
+      node
+    end
+
+    def insert_node_after(key, node)
+      index = @childrens.index { |c| c.key == key.to_s }
+      index += 1 if index
+      index = @childrens.size if index > @childrens.size || index.nil?
+      @childrens.insert(index, node)
+      node
+    end
+
+    def insert_node_before(key, node)
+      index = @childrens.index { |c| c.key == key.to_s }
+      index ||= 0
+      @childrens.insert(index, node)
+      node
+    end
+
+    def delete(key)
+      node = find_children(key.to_s)
+      return unless node
+
+      delete_children(node)
+    end
+
+    def find_children(key_to_find)
+      return unless @childrens
+      key_to_find = key_to_find.to_s
+      @childrens.find { |children| children.key == key_to_find }
+    end
+
+    def delete_children(node)
+      return unless @childrens
+
+      node.parent = nil
+
+      index = @childrens.index(node)
+      @childrens.delete_at(index)
+      @childrens = nil if @childrens.empty?
+
+      node
+    end
+
+    def to_h(params={})
+      BoostInfo::Generator.new(self, params).to_hash
+    end
+
+    def to_info(params={})
+      BoostInfo::Generator.new(self, params).to_info
     end
   end
 end

data/lib/boost_info/parser.rb

@@ -1,138 +1,130 @@
 require 'boost_info/node'
 
 module BoostInfo
-  class ParseError < StandardError; end
-
   class Parser
-    attr_accessor :nodes
+    class ParseError < StandardError; end
 
-    # Boost info tokens
-    @@tokens = '{}'
-    @@open_token = '{'
-    @@close_token = '}'
+    attr_accessor :root_node
 
-    def initialize(source, opts={})
-      unless source.is_a?(String)
-        raise TypeError, "no implicit conversion of #{source.class} into String"
-      end
+    OPEN_TOKEN = '{'
+    CLOSE_TOKEN ='}'
 
-      # Initialize instance variables
-      @nodes = []
-      @level = 0
+    def initialize(source, opts={})
       @source = source
-      @tokens = []
       @opts = opts
       @opts[:symbolize_keys] ||= false
-
-      # without empty lines and comments
-      tokenize! { |token| @tokens << token }
+      @root_node = Node.new(root: true)
     end
 
-    def parse
-      # Parse source
-      opens = @source.count(@@open_token)
-      closes = @source.count(@@close_token)
-      if opens != closes
-        raise BoostInfo::ParseError, "open [#{opens}] and close tokens [#{closes}] does not match..."
-      end
-      nodes = {}
-      @tokens.each do |token|
-        if @@open_token == token
-          @level += 1
-        elsif @@close_token == token
-          @level -= 1
-        else
-          list = token.split
-          if list.size > 2
-            val = list[1..-1].join(" ")
-          else
-            val = list[1]
-          end
-          val = val.gsub(/\A["]+|["]+\z/, "") if val
-          node = Node.new(@level, list[0], val)
-          nodes[@level] = node
-          if @level == 0
-            @nodes << node
-          else
-            nodes[@level] = node unless nodes.has_key?(@level)
-            nodes[@level-1].add_child(node)
-          end
-        end
+    def self.from_info(source, opts={})
+      unless source.is_a?(String)
+        fail TypeError, "no implicit conversion of #{source.class} into String"
       end
-      self
+      new(source, opts).parse_info
     end
 
-    def find(name)
-      # Recursive node search by name
-      result_node = nil
-      @nodes.each do |node|
-        result_node = node.find(name)
-        break if result_node
+    def self.from_hash(source, opts={})
+      unless source.is_a?(Hash)
+        fail TypeError, "no implicit conversion of #{source.class} into Hash"
       end
-      result_node
+      new(source, opts).parse_hash
     end
 
-    def [](offset)
-      # Get elements by key
-      find(offset)
-    end
+    def parse_info
+      lines = process_source(@source)
+      traverse_info(@root_node, lines, -1)
 
-    def print_node(node)
-      # Print node with children
-      puts node
-      node.children.each { |child| print_node(child) }
-      puts "#{'| '*node.level}#{node.level} #{node.name} close" if node.has_children?
+      @root_node
     end
 
-    def print_tree
-      # Print parsed tree
-      @nodes.each { |node| print_node(node) }
+    def parse_hash
+      traverse_hash(@source, @root_node)
+
+      @root_node
     end
 
-    def child_source(node)
-      result = '  '*node.level + node.name + (node.value ? " #{ node.value }" : '')
-      if node.has_children?
-        result += " {\n"
-        node.children.each { |child| result += self.child_source(child) }
-        result += '  '*node.level + "}\n"
-      else
-        result += "\n"
+    private
+
+    def process_source(source)
+      lines = []
+      source.each_line do |line|
+        new_line = line.sub(/;.+[^"']$/, '').strip # remove comments
+        next if new_line.empty?
+        # include file
+        if new_line.match(/#include\s+(\S+)/)
+          file_path = strip_quotes(Regexp.last_match(1))
+          file = File.open(file_path)
+          lines_to_include = process_source(file)
+          lines.concat(lines_to_include)
+        # process inline section
+        elsif new_line.match(/#{OPEN_TOKEN}.*#{CLOSE_TOKEN}/)
+          splitted_lines = line.sub('{', "{\n").sub('}', "\n}").lines
+            .map(&:strip)
+            .reject(&:empty?)
+          lines.concat(splitted_lines)
+        #just add the line
+        else
+          lines << new_line
+        end
       end
-      result
-    end
 
-    def to_s
-      self.to_h.to_info
+      open_tokens = lines.count { |line| line.end_with?(OPEN_TOKEN) }
+      close_tokens = lines.count { |line| line.end_with?(CLOSE_TOKEN) }
+      if open_tokens != close_tokens
+        fail ParseError, "open [#{open_tokens}] and close tokens [#{close_tokens}] does not match..."
+      end
+      lines
     end
 
-    def to_h
-      result = {}
-      @nodes.each { |n| result.merge!(n.to_h(@opts[:symbolize_keys])) }
-      result
-    end
+    def traverse_info(parent_node, lines, index_start)
+      index_end = lines.size - 1
+      lines.each_with_index do |line,index|
+        next if index <= index_start
 
-    private
+        index_end = index
 
-      def tokenize!
-        # tokenize boost info format
-        lines = []
-        @source.split("\n").each do |line|
-          lines << line.split(';')[0].strip unless line.strip.empty? || line.strip[0] == ';'
+        key, value = extract_key_and_value(line)
+        node = Node.new(key: key, value: value)
+        parent_node.insert_node(node) if key
+
+        case line
+        when /#{OPEN_TOKEN}/
+          index_start = traverse_info(node, lines, index)
+        when /#{CLOSE_TOKEN}/
+          parent_node.childrens ||= []
+          break
         end
-        lines.each do |line|
-          token = ''
-          line.each_char do |char|
-            if '{}'.include?(char)
-              token = token.strip
-              yield token unless token.empty?
-              yield char
-              token = ''
-            else
-              token += char
-            end
-          end
-          yield token.strip unless token.empty?
+      end
+      index_end
+    end
+
+    def traverse_hash(hash, parent_node)
+      hash.each do |k,v|
+        node = parent_node.insert(k, v)
+        if v.is_a?(Hash)
+          node.childrens = []
+          traverse_hash(v, node)
         end
       end
+      parent_node
+    end
+
+    def extract_key_and_value(string)
+      key = nil
+      value = nil
+
+      tokens = string.split(/\s+/)
+      raw_key = tokens.shift.sub('}', '').strip
+      key = raw_key unless raw_key.empty?
+
+      tokens.pop if tokens.last == OPEN_TOKEN
+      value = strip_quotes(tokens.join(' ')) unless tokens.empty?
+      value = value.to_i if value.to_s =~ /^\d+$/
+      [key, value]
+    end
+
+    def strip_quotes(string)
+      string.gsub(/^["']+|["']+$/, '')
+    end
   end
 end

data/lib/boost_info/version.rb

@@ -1,3 +1,3 @@
 module BoostInfo
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

data/lib/boost_info.rb

@@ -5,16 +5,22 @@ require 'boost_info/generator'
 
 module BoostInfo
   def self.parse(source, opts={})
-    BoostInfo::Parser.new(source, opts).parse.to_h
+    root_node = BoostInfo::Parser.from_info(source, opts)
+    root_node.to_h(opts)
   end
 
-  def self.generate(hash, opts={})
-    BoostInfo::Generator.new(hash, opts).generate
+  def self.from_hash(hash, opts={})
+    BoostInfo::Parser.from_hash(hash, opts)
+  end
+
+  def self.from_info(source, opts={})
+    BoostInfo::Parser.from_info(source, opts)
   end
 end
 
 class Hash
   def to_info(opts={})
-    BoostInfo.generate(self, opts)
+    root_node = BoostInfo::Parser.from_hash(self, opts)
+    root_node.to_info(opts)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boost_info
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Igor Vetrov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
+date: 2015-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,7 +53,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.6'
-description: 
+description: Simple parser for Boost INFO format.
 email:
 - capybarov@gmail.com
 executables: []
@@ -95,8 +95,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Simple parser for Boost INFO format
 test_files: []
+has_rdoc: