yamlr 2.0.0

data/.autotest

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+# Autotest.add_hook :initialize do |at|
+#   at.testlib = "minitest/unit"
+#
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception "vendor"
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,10 @@
+=== 1.0.0 / 2009-04-20
+
+* 1 major enhancement
+
+  * Birthday!
+
+=== 2.0.0 / 2015-03-22
+
+* Changed gem name to Yamlr
+* Works on Ruby 1.9.3 or higher

data/Manifest.txt

@@ -0,0 +1,35 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/yamlr
+lib/yamlr.rb
+lib/yamlr/defaults.rb
+lib/yamlr/errors.rb
+lib/yamlr/indicators.rb
+lib/yamlr/reader.rb
+lib/yamlr/reader/builder.rb
+lib/yamlr/reader/format.rb
+lib/yamlr/reader/node.rb
+lib/yamlr/reader/parser.rb
+lib/yamlr/version.rb
+lib/yamlr/writer.rb
+lib/yamlr/writer/builder.rb
+test/files/2009.yml
+test/files/arrays.yml
+test/files/blank.yml
+test/files/comments.yml
+test/files/hashes.yml
+test/files/malformed.yml
+test/files/mixed.yml
+test/files/nested.yml
+test/files/split.yml
+test/test_reader.rb
+test/test_reader_builder.rb
+test/test_reader_format.rb
+test/test_reader_parser.rb
+test/test_writer.rb
+test/test_writer_builder.rb
+test/test_yamlr.rb
+yamlr.gemspec

data/README.txt

@@ -0,0 +1,53 @@
+= Yamlr
+
+* http://github.com/step1profit/yamlr
+* http://seattlerb.org
+
+== DESCRIPTION:
+
+Yamlr is a minimal YAML parser written in Ruby.
+
+== FEATURES:
+
+* Parse Array/Hash/String
+* Read/write .yml files
+* Dotfile configurable
+* Serialize keys
+* Robust command line support
+* No variables or fancy YAML features
+
+== INSTALLATION:
+
+gem install yamlr
+
+== SYNOPSIS:
+
+* FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* ruby 1.9.3 or higher
+
+== LICENSE:
+
+The MIT License (MIT)
+
+Copyright (c) 2008 - 2015 SoAwesomeMan, Step1Profit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,24 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "hoe"
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+
+# https://github.com/jbarnette/hoe-git
+Hoe.plugin :git
+Hoe.plugin :yard
+# https://github.com/flavorjones/hoe-gemspec
+Hoe.plugin :gemspec
+
+Hoe.spec "yamlr" do
+  developer('Step1Profit', 'sales@step1profit.com')
+
+  license "MIT"
+end
+
+# vim: syntax=ruby

data/bin/yamlr

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+require 'pp'
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'yamlr'
+
+module YamlrOpt
+  DESC = Yamlr::Defaults.descriptions
+  def self.command
+    hsh = {}
+    hsh[:opt] = {}
+    ops = nil
+    OptionParser.new do |opts|
+      opts.banner = "Yamlr #{Yamlr::VERSION}"
+      opts.on("-r", "--read FILENAME", String, String, ".yml file to Ruby Hash or Array") do |x|
+        hsh[:cmd] = 1
+        hsh[:arg] = [x]
+      end
+
+      opts.on("-w", "--write FILENAME,FILENAME", Array, "Hash or Array => .yml file") do |x|
+        hsh[:cmd] = 2
+        hsh[:arg] = x
+      end
+
+      opts.on("-d", "--dotfile [HOME]", String, "Create .yamlrc dotfile") do |x|
+        x.nil? ? (y = Yamlr.dotfile) : (y = Yamlr.dotfile(x))
+        z = "#{File.dirname(y).chomp("/")}/.yamlrc"
+        puts "existed: #{z}, moved to: #{y}" if File.basename(y) != ".yamlrc"
+        puts "created: #{z}"
+        return
+      end
+
+      opts.on("-v", "--version", "Display verison number") do
+        STDOUT.write("Yamlr #{Yamlr::VERSION}\n\r")
+        return
+      end
+
+      opts.on("-h", "--help", "Show this message") do
+        puts opts
+        return
+      end
+
+      Yamlr::Defaults.constants.sort.each do |x|
+        next if x == "DOTFILE"
+        opts.on("--[no-]#{x.downcase}", DESC[x.downcase]) do |y|
+          hsh[:opt]["#{x.downcase}".to_sym] = y
+          puts "use options with --read or --write" && return if hsh[:cmd].nil?
+        end
+      end
+      ops = opts
+    end.parse!
+    puts ops unless hsh.has_key?(:cmd)
+    return unless hsh.has_key?(:cmd)
+    self.run(hsh[:cmd], hsh[:arg], hsh[:opt])
+  end
+
+  def self.run(cmd, arg, opt)
+    x = Yamlr.read(arg[0], opt)
+    case cmd
+    when 1 then pp x
+    when 2 then Yamlr.write(arg[0], arg[1], opt)
+    end
+  end
+end
+
+YamlrOpt.command

data/lib/yamlr.rb

@@ -0,0 +1,46 @@
+require 'yamlr/version'
+require 'yamlr/reader'
+require 'yamlr/writer'
+require 'yamlr/indicators'
+require 'yamlr/defaults'
+
+module Yamlr
+  DOTFILE = "#{ENV['HOME']}/.yamlr"
+
+  # File to Hash or Array
+  #
+  def self.read(input, options = {})
+    Yamlr::Reader.read(input, self.options(options))
+  end
+
+  # Hash or Array to .yml Array
+  #
+  def self.parse(object, options = {})
+    Yamlr::Writer.build(object, self.options(options))
+  end
+
+  # Hash or Array to .yml file, e.g. filename.yml
+  #
+  def self.write(object, filename, options = {})
+    Yamlr::Writer.write(object, filename, self.options(options))
+  end
+
+  # writes a .yamlr file HOME, merges with options if :dot is true
+  #
+  def self.dotfile(home = ENV['HOME'])
+    Yamlr::Writer.dotfile(Yamlr::Defaults.options, home)
+  end
+
+  private
+
+  # options
+  #
+  def self.options(options = {})
+    opt = Yamlr::Defaults.options.merge(Yamlr::Indicators.options.merge(options))
+    dot_opt = File.exists?(DOTFILE) ? Yamlr::Reader.read(DOTFILE, opt.merge({:symbolize_keys => true})) : nil
+    unless opt[:dot]
+      opt = opt.merge(dot_opt) if (dot_opt && dot_opt[:dot])
+    end
+    opt
+  end
+end

data/lib/yamlr/defaults.rb

@@ -0,0 +1,78 @@
+module Yamlr
+  module Defaults
+    INT             = true
+    INT_KEYS        = false
+    INT_VALS        = false
+    SYMBOLIZE       = false
+    SYMBOLIZE_KEYS  = false
+    SYMBOLIZE_VALS  = false
+    SYM_STR         = false
+    SYM_STR_KEYS    = false
+    SYM_STR_VALS    = false
+    AUTO_SYM        = true
+    AUTO_SYM_KEYS   = false
+    AUTO_SYM_VALS   = false
+    AUTO_TRUE       = true
+    AUTO_TRUE_KEYS  = false
+    AUTO_TRUE_VALS  = false
+    STRIP           = true
+    STRIP_KEYS      = false
+    STRIP_VALS      = false
+    LIST            = false
+    DOT             = true
+    DOTFILE         = "#{ENV['HOME']}/.yamlrc"
+    YAML            = false
+    DOCS            = false
+
+    def self.descriptions
+      { "auto_sym"       => "conv keys & vals: \":both\" => :both",
+        "auto_sym_keys"  => "conv keys: \":key\" => :key",
+        "auto_sym_vals"  => "conv vals: \":val\" => :val",
+        "auto_true"      => "conv keys & vals: \"true\" => true",
+        "auto_true_keys" => "conv keys: \"true\" => true",
+        "auto_true_vals" => "conv vals: \"true\" => true",
+        "docs"           => "doc separator first level hash nodes",
+        "dot"            => "use dotfile if it exists",
+        "int"            => "conv keys & vals: \"1\" => 1",
+        "int_keys"       => "conv keys: \"1\" => 1",
+        "int_vals"       => "conv vals: \"1\" => 1",
+        "list"           => "return hash of addresses & comments",
+        "strip"          => "strip keys & vals: \" both \" => \"both\"",
+        "strip_keys"     => "strip keys: \" key \" => \"key\"",
+        "strip_vals"     => "strip vals: \" val \" => \"val\"",
+        "sym_str"        => "conv str (no int) k & v: \"b\" => :b",
+        "sym_str_keys"   => "conv string keys(no int): \"key\" => :key",
+        "sym_str_vals"   => "conv string vals(no int): \"val\" => :val",
+        "symbolize"      => "force conv keys & vals: \"both\" => :both",
+        "symbolize_keys" => "force conv keys: \"key\" => :key",
+        "symbolize_vals" => "force conv vals: \"val\" => :val",
+        "yaml"           => "write files with YAML type array syntax"}
+    end
+
+    def self.options
+      { :int            => INT,
+        :int_keys       => INT_KEYS,
+        :int_vals       => INT_VALS,
+        :symbolize      => SYMBOLIZE,
+        :symbolize_keys => SYMBOLIZE_KEYS,
+        :symbolize_vals => SYMBOLIZE_VALS,
+        :sym_str        => SYM_STR,
+        :sym_str_keys   => SYM_STR_KEYS,
+        :sym_str_vals   => SYM_STR_VALS,
+        :auto_sym       => AUTO_SYM,
+        :auto_sym_keys  => AUTO_SYM_KEYS,
+        :auto_sym_vals  => AUTO_SYM_VALS,
+        :auto_true      => AUTO_TRUE,
+        :auto_true_keys => AUTO_TRUE_KEYS,
+        :auto_true_vals => AUTO_TRUE_VALS,
+        :strip          => STRIP,
+        :strip_keys     => STRIP_KEYS,
+        :strip_vals     => STRIP_VALS,
+        :list           => LIST,
+        :dot            => DOT,
+        :dotfile        => DOTFILE,
+        :yaml           => YAML,
+        :docs           => DOCS}
+    end
+  end
+end

data/lib/yamlr/errors.rb

@@ -0,0 +1,8 @@
+module Yamlr
+  module Errors
+    class EmptyFilenameError < StandardError; end
+    class EmptyInputError < StandardError; end
+    class InvalidInputError < StandardError; end
+    class InvalidFilenameError < StandardError; end
+  end
+end

data/lib/yamlr/indicators.rb

@@ -0,0 +1,25 @@
+module Yamlr
+  module Indicators
+    DOC_START   = '---'
+    DOC_TERM    = '...'
+    HASH        = ':'
+    SYMBOL      = ':'
+    ARRAY       = '-'
+    COMMENT     = '#'
+    LINE_END    = "\n"
+    SPACE       = "\s"
+    INDENT      = 2
+
+    def self.options
+      { :doc_start  => DOC_START,
+        :doc_term   => DOC_TERM,
+        :hash       => HASH,
+        :symbol     => SYMBOL,
+        :array      => ARRAY,
+        :comment    => COMMENT,
+        :line_end   => LINE_END,
+        :space      => SPACE,
+        :indent     => INDENT }
+    end
+  end
+end

data/lib/yamlr/reader.rb

@@ -0,0 +1,33 @@
+require 'yamlr/reader/node'
+require 'yamlr/reader/format'
+require 'yamlr/reader/builder'
+require 'yamlr/reader/parser'
+
+module Yamlr
+  module Reader
+    class EmptyFileError < StandardError; end
+    class EmptyInputError < StandardError; end
+    class InvalidInputError < StandardError; end
+    #
+    # parses file or string into Ruby Array, or Hash
+    #
+    def self.read(input, options)
+      raise Yamlr::Reader::EmptyInputError if input.is_a?(String) && input.strip.empty?
+      raise Yamlr::Reader::InvalidInputError unless input.is_a?(String) or input.is_a?(File)
+      input = File.exists?(input) ? IO.readlines(input) : input.split("\n")
+      raise Yamlr::Reader::EmptyFileError if input.empty?
+      hash = {}
+      lineno = 0
+      input.each {|line|
+        parsed_hash    = Yamlr::Reader::Parser.parse(line, options, (lineno += 1))
+        formatted_hash = Yamlr::Reader::Format.format(parsed_hash)
+        Yamlr::Reader::Builder.build(hash, formatted_hash)
+      }
+      hash.delete(:adr)
+      case
+      when options[:list] then hash
+      when !options[:list] then hash.delete(:lst) && (hash.length == 1) ? hash[1] : hash
+      end
+    end
+  end
+end

data/lib/yamlr/reader/builder.rb

@@ -0,0 +1,249 @@
+module Yamlr
+  module Reader
+    module Builder
+      #
+      # Abbreviations:
+      # adr = address
+      # phs = parsed hash
+      # hsh = hash
+      # lst = list
+      # met = meta
+      # cur = current
+      # spc = spaces
+      # idt = indent
+      # idx = index
+      #
+      # dcs = doc_start
+      # dct = doc_term
+      # hpr = hsh_pair
+      # hky = hsh_key
+      # arr = array
+      # com = comment
+      # mal = malformed
+      # msg = message
+      # bla = blank
+      #
+      class RootNodeError < StandardError; end
+
+      ##
+      # adds parsed_hash of line to hash
+      #
+      def self.build(hsh, phs)
+        add = false
+        upd = nil
+        msg = phs[:msg]
+        self.doc_new(hsh) if hsh.empty? && msg != "doc"
+        val = phs[:val]
+        lst = hsh[:lst]
+
+        unless [:com, :mal, :bla].include?(msg)
+          cur = self.cur(hsh)
+          key = phs[:key]
+          spc = phs[:spc]
+          idt = phs[:opt][:indent]
+          adr = hsh[:adr]
+          idx = self.index(spc, idt)
+          upd = self.update(adr, idx)
+          las = self.adr_obj(hsh, hsh[:adr])
+          add = true
+        end
+
+        case msg
+        when :dcs then self.doc_start(hsh)
+        when :dct then self.doc_term(hsh)
+        when :hpr then self.hsh_pair(las, key, val)
+        when :hky then self.hsh_key(las, adr, key)
+        when :bla then self.blank(lst)
+        when :arr
+          raise RootNodeError if cur.is_a?(Hash) && !cur.empty? && spc == 0
+          if las.is_a?(Hash) && las.empty?
+            self.adr_obj_to_array(hsh, hsh[:adr])
+            las = self.adr_obj(hsh, hsh[:adr])
+          end
+          self.arr_parse(las, adr, val, upd)
+        when :com then self.comment(lst, val)
+        when :mal then self.malformed(lst, val)
+        end
+
+        self.add_to_list(lst, adr) if add
+      end
+
+      ##
+      # sub-parses array message, and logic from update-method
+      #
+      def self.arr_parse(las, adr, val, upd)
+        case upd
+        when "eq" then self.array_val(las, val)
+        when "lt" then self.array_val(las, val)
+        when "gt" then self.array_new(las, adr, val)
+        else; raise "error"
+        end
+      end
+
+      # current hash, returns array of "doc"
+      #
+      def self.cur(hsh)
+        hsh[hsh.length - 2]
+      end
+
+      # address array to string usable in eval on root node
+      #
+      def self.to_adr(adr)
+        m = adr.map {|x|
+          case
+          when x.is_a?(Symbol) then "[:#{x}]"
+          when x.is_a?(String) then "['#{x}']"
+          when x.is_a?(Integer) then "[#{x}]"
+          end
+        }
+        m.join
+      end
+
+      # returns the actual object at an address in tree
+      #
+      def self.adr_obj(hsh, adr)
+        m = self.to_adr(adr)
+        eval("hsh#{m.to_s}")
+      end
+
+      # converts an object in tree to empty array
+      #
+      def self.adr_obj_to_array(hsh, adr)
+        m = self.to_adr(adr)
+        eval("hsh#{m.to_s} = []")
+      end
+
+      # calculates index based on spaces divided by indent unit
+      #
+      def self.index(spc, idt)
+        ((spc % idt) != 0) ? 0 : spc / idt
+      end
+
+      # if indentation less than before, jump up tree, remove extra indices
+      #
+      def self.update(adr, idx)
+        ret =  nil
+        len = (adr.length - 1)
+        if idx < len
+          # remove indices after current index
+          adr.replace(adr[0..idx])
+          ret = "lt"
+        elsif idx == len
+          ret = "eq"
+        elsif idx > len
+          ret = "gt"
+        end
+        ret
+      end
+
+      # create keypair for new doc
+      #
+      def self.doc_new(hsh)
+        hsh[:lst] ||= {}
+        hsh[:adr] ||= []
+        len = hsh.length - 1
+        hsh[len] = {}
+        hsh[:adr].clear
+        hsh[:adr] << len
+      end
+
+      # new array in tree, provides logic for last modified object
+      #
+      def self.array_new(las, adr, val)
+        case
+        when las.is_a?(Array) && las.empty?
+          x = [val]
+          las = x
+          adr << las.rindex(x)
+        when las.is_a?(Array) && las.last.is_a?(String) && las.last.empty?
+          x = [val]
+          las[-1] = [val]
+          adr << las.rindex(x)
+        when las.is_a?(Array)
+          x = [val]
+          las << x
+          adr << las.rindex(x)
+        end
+      end
+
+      # start document
+      #
+      def self.doc_start(hsh)
+        self.doc_new(hsh)
+        self.add_to_list(hsh[:lst], "#DOC_START")
+      end
+
+      # document terminate
+      #
+      def self.doc_term(hsh)
+        self.add_to_list(hsh[:lst], "#DOC_TERM")
+      end
+
+      # add val to array in tree
+      #
+      def self.array_val(las, val)
+        case
+        # when x is a hash, it's already addressed
+        when las.is_a?(Array)
+          las << val
+        else
+          raise las.inspect
+        end
+      end
+
+      # add hashkey to tree
+      #
+      def self.hsh_key(las, adr, key)
+        case
+        when las.is_a?(Hash)
+          las[key] = {}
+        when las.is_a?(Array)
+          x = {key => {}}
+          las << x
+          adr << las.rindex(x)
+        end
+        adr << key
+      end
+
+      # add hashpair to tree
+      #
+      def self.hsh_pair(las, key, val)
+        case
+        when las.is_a?(Array)
+          x = {key => val}
+          las << x
+        when las.is_a?(Hash)
+          las[key] = val
+        end
+      end
+
+      # list stores hsh addresses of lines, comments, etc.
+      #
+      def self.add_to_list(lst, adr)
+        case adr.class.to_s
+        when "String" then x = adr
+        when "Array" then  x = adr.join(",")
+        end
+        lst[lst.length + 1] = x
+      end
+
+      # add blank to list
+      #
+      def self.blank(lst)
+        self.add_to_list(lst, "#BLANK")
+      end
+
+      # add comment to list
+      #
+      def self.comment(lst, val)
+        lst[lst.length + 1] = "#COMMENT: #{val}"
+      end
+
+      # add malformed to list
+      #
+      def self.malformed(lst, val)
+        lst[lst.length + 1] = "#MALFORMED: #{val}"
+      end
+    end
+  end
+end