yamlr 2.0.0

data/lib/yamlr/reader/format.rb

@@ -0,0 +1,116 @@
+module Yamlr
+  module Reader
+    module Format
+      # format datatypes in the parsed hash
+      #
+      def self.format(phs)
+        self.adjust_options(phs)
+        self.stripper(phs)
+        self.key_to_int(phs)
+        self.val_to_int(phs)
+        self.key_to_sym(phs)
+        self.val_to_sym(phs)
+        self.key_to_true(phs)
+        self.val_to_true(phs)
+        phs
+      end
+
+      # strips keys and values
+      #
+      def self.stripper(phs)
+        psp = phs[:opt][:strip]
+        psk = phs[:opt][:strip_keys]
+        psv = phs[:opt][:strip_vals]
+        phs[:key] = phs[:key].to_s.strip if psp or psk
+        phs[:val] = phs[:val].to_s.strip if psp or psv
+      end
+
+      # adjusts options
+      #
+      def self.adjust_options(phs)
+        if phs[:opt][:auto_sym]
+          phs[:opt][:auto_sym_keys] = true
+          phs[:opt][:auto_sym_vals] = true
+        end
+      end
+
+      # true key
+      #
+      def self.key_to_true(phs)
+        x = []
+        x << phs[:opt][:auto_true].is_a?(TrueClass)
+        x << phs[:opt][:auto_true_keys].is_a?(TrueClass)
+        if x.any?
+          case
+          when (phs[:key].to_s.strip == "true") then phs[:key] = true
+          when (phs[:key].to_s.strip == "false") then phs[:key] = false
+          end
+        end
+      end
+
+      # true val
+      #
+      def self.val_to_true(phs)
+        x = []
+        x << phs[:opt][:auto_true].is_a?(TrueClass)
+        x << phs[:opt][:auto_true_vals].is_a?(TrueClass)
+        if x.any?
+          case
+          when (phs[:val].to_s.strip == "true") then phs[:val] = true
+          when (phs[:val].to_s.strip == "false") then phs[:val] = false
+          end
+        end
+      end
+
+      # symbolize key
+      #
+      def self.key_to_sym(phs)
+        is_str = !phs[:key].is_a?(Integer)
+        x = []
+        x << (phs[:opt][:sym_str] && is_str).is_a?(TrueClass)
+        x << (phs[:opt][:sym_str_keys] && is_str).is_a?(TrueClass)
+        x << phs[:opt][:symbolize].is_a?(TrueClass)
+        x << (phs[:ask] && phs[:opt][:auto_sym_keys] && is_str).is_a?(TrueClass)
+        x << phs[:opt][:symbolize_keys].is_a?(TrueClass)
+        phs[:key] = phs[:key].to_s.to_sym if x.any?
+      end
+
+      # symbolize val
+      #
+      def self.val_to_sym(phs)
+        is_str = !phs[:val].is_a?(Integer)
+        x = []
+        x << (phs[:opt][:sym_str] && is_str).is_a?(TrueClass)
+        x << (phs[:opt][:sym_str_vals] && is_str).is_a?(TrueClass)
+        x << phs[:opt][:symbolize].is_a?(TrueClass)
+        x << (phs[:asv] && phs[:opt][:auto_sym_vals] && is_str).is_a?(TrueClass)
+        x << phs[:opt][:symbolize_vals].is_a?(TrueClass)
+        phs[:val] = phs[:val].to_s.to_sym if (x.any? && !phs[:val].to_s.strip.empty?)
+      end
+
+      # key is parsed as string, so try to_i
+      #
+      def self.key_to_int(phs)
+        x = []
+        x << phs[:opt][:int].is_a?(TrueClass)
+        x << phs[:opt][:int_keys].is_a?(TrueClass)
+        phs[:key] = self.string_to_int(phs[:key]) if x.any?
+      end
+
+      # val is parsed as string, so try to_i
+      #
+      def self.val_to_int(phs)
+        x = []
+        x << phs[:opt][:int].is_a?(TrueClass)
+        x << phs[:opt][:int_vals].is_a?(TrueClass)
+        phs[:val] = self.string_to_int(phs[:val]) if x.any?
+      end
+
+      # returns int if string is convertable
+      #
+      def self.string_to_int(string)
+        string.to_s.strip =~ /^\d+$/ ? string.to_s.to_i : string
+      end
+    end
+  end
+end

data/lib/yamlr/reader/node.rb

@@ -0,0 +1,53 @@
+module Yamlr
+  module Reader
+    module Node
+      # hashpair
+      #
+      def self.hashpair(hsh, sym, spc)
+        /^(#{spc}*)(\S*)#{hsh}#{spc}*(.*)#{spc}*$/
+      end
+
+      # hashpair, both key and val are symbol
+      #
+      def self.hashpair_sym_all(hsh, sym, spc)
+        /^(#{spc}*)(#{sym}\S*)#{hsh}#{spc}*(#{sym}.*)#{spc}*$/
+      end
+
+      # hashpair, key is symbol
+      #
+      def self.hashpair_sym_key(hsh, sym, spc)
+        /^(#{spc}*)(#{sym}\S*)#{hsh}#{spc}*(.*)#{spc}*$/
+      end
+
+      # hashpair, value is symbol
+      #
+      def self.hashpair_sym_val(hsh, sym, spc)
+        /^(#{spc}*)(\S*)#{hsh}#{spc}*(#{sym}.*)#{spc}*$/
+      end
+
+      # hashkey is symbol
+      #
+      def self.hashkey_sym(hsh, sym, spc)
+        /^(#{spc}*)(#{sym}\S*)#{hsh}#{spc}*$/
+      end
+
+      # hashkey is awesome
+      #
+      def self.hashkey(hsh, spc)
+        /^(#{spc}*)(\S*)#{hsh}#{spc}*$/
+      end
+
+      # docstart and docterm
+      #
+      def self.document(idc, spc)
+        /^#{spc}*#{idc}#{spc}*$/
+      end
+
+      # comments and arrays
+      #
+      def self.left_match(idc, spc)
+        /^(#{spc}*)#{idc}(#{spc}*)(.*)#{spc}*$/
+      end
+    end
+  end
+end

data/lib/yamlr/reader/parser.rb

@@ -0,0 +1,68 @@
+module Yamlr
+  module Reader
+    module Parser
+      class IndentError < StandardError; end
+
+      def self.parse(line, opts, num)
+        results = self.parse_line(line, opts)
+        phs = self.results_to_hash(results, opts)
+        self.check_indent(line, phs[:spc], opts[:indent], num)
+        phs
+      end
+
+      # invalid number of spaces, line num and truncated line for context
+      #
+      def self.check_indent(line, spc, idt, num)
+        raise IndentError, "#{num} #{line[1..50]}" if spc % idt != 0
+      end
+
+      # parses line, returns array, dependent on Node module
+      #
+      def self.parse_line(line, opts)
+        nod = Yamlr::Reader::Node
+        spc = opts[:space]
+        hsh = opts[:hash]
+        sym = opts[:symbol]
+        dcs = opts[:doc_start]
+        dct = opts[:doc_term]
+        arr = opts[:array]
+        com = opts[:comment]
+
+        begin
+          case line
+          when nod.left_match(arr, spc) then            [:arr, Regexp.last_match.captures]
+          when nod.left_match(com, spc) then            [:com, Regexp.last_match.captures]
+          when nod.hashkey_sym(hsh, sym, spc) then      [:hky, Regexp.last_match.captures, nil, true]
+          when nod.hashkey(hsh, spc) then               [:hky, Regexp.last_match.captures]
+          when nod.hashpair_sym_all(hsh, sym, spc) then [:hpr, Regexp.last_match.captures, true, true]
+          when nod.hashpair_sym_key(hsh, sym, spc) then [:hpr, Regexp.last_match.captures, true]
+          when nod.hashpair_sym_val(hsh, sym, spc) then [:hpr, Regexp.last_match.captures, nil, true]
+          when nod.hashpair(hsh, sym, spc) then         [:hpr, Regexp.last_match.captures]
+          when /^\s*$/ then                             [:bla]
+          when nod.document(dcs, spc) then              [:dcs]
+          when nod.document(dct, spc) then              [:dct]
+          else
+            raise 'MALFORMED'
+          end
+        rescue => e
+          # log or whatever
+          [:mal, '', nil, line.strip]
+        end
+      end
+
+      # creates hash with array vals, includes options
+      #
+      def self.results_to_hash(results, opt)
+        #raise results.flatten.to_s + " results.class => #{results.class}"
+        msg, spc, key, val, ask, asv = results.flatten
+        { :msg => msg,
+          :spc => (spc.nil? ? 0 : spc.length),
+          :key => key.to_s.sub(/^:/, ''),
+          :val => val.to_s.sub(/^:/, ''),
+          :ask => ask,
+          :asv => asv,
+          :opt => opt}
+      end
+    end
+  end
+end

data/lib/yamlr/version.rb

@@ -0,0 +1,3 @@
+module Yamlr
+  VERSION  = '2.0.0'
+end

data/lib/yamlr/writer.rb

@@ -0,0 +1,47 @@
+require 'yamlr/writer/builder'
+
+module Yamlr
+  module Writer
+    class EmptyFilenameError < StandardError; end
+    class EmptyInputError < StandardError; end
+    class InvalidInputError < StandardError; end
+    class InvalidFilenameError < StandardError; end
+
+    # array, hash, or string to array of lines of .yml file
+    #
+    def self.build(object, options)
+      raise Yamlr::Writer::EmptyInputError if object.is_a?(String) && object.strip.empty?
+      raise Yamlr::Writer::InvalidInputError unless object.is_a?(String) or object.is_a?(Array) or object.is_a?(Hash)
+      Yamlr::Writer::Builder.build([], object, options)
+    end
+
+    # array, hash, or string to file
+    #
+    def self.write(object, filename, options)
+      filename = "#{ENV['HOME']}/#{File.basename(filename.to_s)}" if (filename =~ /^~/)
+      raise Yamlr::Writer::EmptyInputError if (object.is_a?(String) && object.strip.empty?)
+      raise Yamlr::Writer::InvalidInputError unless (object.is_a?(String) or object.is_a?(Array) or object.is_a?(Hash))
+      raise Yamlr::Writer::EmptyFilenameError if File.basename(filename.to_s).strip.empty?
+      raise Yamlr::Writer::InvalidFilenameError unless File.exists?(File.dirname(filename))
+      File.open(filename, "w") do |file|
+        self.build(object, options).each {|line|
+          file.print("#{line}\n")
+        }
+      end
+      filename
+    end
+
+    # write a yamlr dotfile to home dir
+    #
+    def self.dotfile(options, home)
+      filename = "#{home.chomp("/")}/.yamlrc"
+      new_name = nil
+      if File.exists?(filename)
+        new_name = "#{filename}.#{Time.now.strftime("%Y%m%d%H%M%S")}"
+        File.rename(filename, new_name)
+      end
+      self.write(options, filename, Yamlr::Indicators.options)
+      new_name ? new_name : filename
+    end
+  end
+end

data/lib/yamlr/writer/builder.rb

@@ -0,0 +1,93 @@
+module Yamlr
+  module Writer
+    module Builder
+      def self.build(arr, inp, opt)
+        spc = (opt[:space] * opt[:indent])
+        case
+        when inp.is_a?(Hash) then   self.hash_to_array(arr, inp, opt, spc)
+        when inp.is_a?(Array) then  self.array_to_lines(arr, inp, opt, spc)
+        when inp.is_a?(String) then self.string_to_array(arr, inp, opt, spc)
+        end
+        arr
+      end
+
+      def self.sym_to_str(x, y = nil)
+        a = x.is_a?(Symbol) ? ":#{x}" : x
+        b = y.is_a?(Symbol) ? ":#{y}" : y
+        [a, b]
+      end
+
+      def self.string_to_array(arr, inp, opt, spc)
+        self.array_to_lines(arr, inp.split(opt[:line_end]), opt, spc)
+      end
+
+      def self.hash_to_array(arr, inp, opt, spc)
+        inp.each do |key,val|
+          case
+          when val.is_a?(Hash)
+            key = self.sym_to_str(key)
+            arr << opt[:doc_start] if opt[:docs]
+            arr << "#{key.join}#{opt[:hash]}" unless opt[:docs]
+            self.hash_to_lines(arr, val, val.keys, opt, spc, (opt[:docs] ? 0 : 1))
+          when val.is_a?(Array)
+            arr << opt[:doc_start] if opt[:docs]
+            self.array_to_lines(arr, val, opt)
+          else
+            key, val = self.sym_to_str(key, val)
+            arr << "#{key}#{opt[:hash]} #{val}"
+          end
+        end
+      end
+
+      # line is array, push each indice to array, assumes every indice is a string
+      #
+      def self.array_to_lines(arr, val, opt, spc, idt = nil)
+        idt = 0 if idt.nil?
+        ist = spc * idt
+        ind = opt[:array]
+        until val.empty? do
+          x = val.shift
+          case
+          when x.is_a?(Hash)
+            arr << "#{ist}#{ind}"
+            self.hash_to_lines(arr, x, x.keys, opt, spc, (idt + 1))
+          when x.is_a?(Array)
+            i = idt
+            arr << "#{ist}#{ind}" if opt[:yaml]
+            i += 1
+            self.array_to_lines(arr, x, opt, spc, i)
+          else
+            x = self.sym_to_str(x)
+            arr << "#{ist}#{ind} #{x.join}"
+          end
+        end
+      end
+
+      # recursively add lines to array
+      #
+      def self.hash_to_lines(arr, hsh, kys, opt, spc, idt = nil)
+        idt = 0 if idt.nil?
+        while !kys.empty?
+          ist = spc * idt
+          key = kys.shift
+          val = hsh[key]
+          ind = opt[:hash]
+          case
+          when val.is_a?(Hash)
+            # push key into lines_array
+            arr << "#{ist}#{key}#{ind}"
+            # step indent
+            # call this again (the recursive part)
+            self.hash_to_lines(arr, val, val.keys, opt, spc, (idt + 1))
+          when val.is_a?(Array)
+            arr << "#{ist}#{key}#{ind}"
+            self.array_to_lines(arr, val, opt, spc, (idt + 1))
+          else
+            # if not Writer or Array, it must be String
+            arr << "#{ist}#{key}#{ind} #{val}"
+          end
+        end
+      end
+    end
+  end
+end

data/test/files/2009.yml

@@ -0,0 +1,3 @@
+content:
+  01: 200901.yml
+  02: 200902.yml

data/test/files/arrays.yml

@@ -0,0 +1,15 @@
+-
+- 1
+- 2
+-
+  -
+    -
+    - awesome
+    - awesome
+- 4
+- 5
+- 6
+  - 7
+    - 8 
+  - dude
+- 

data/test/files/comments.yml

@@ -0,0 +1,17 @@
+# dude
+1: 1
+# awesome
+2: 2
+#
+# camaro
+#
+3: 3
+##
+# nice 
+# one 
+# bro!
+#
+4:
+  - 1
+  - 2
+  - 3

data/test/files/hashes.yml

@@ -0,0 +1,26 @@
+grocery_list:
+  beer: 
+    1: 
+      model: 24 pack - Coors Lite
+      count: 1
+  meatsez:
+    1: 
+      model: Spam
+      count: 5
+    2: 
+      model: Log of ground beef
+      count: 1
+  cigarettes:
+    1: 
+      model: Carton - Basic Ultra Menthol Box 100
+      count: 2
+  other:
+    1: 
+      model: Economy-Size Pork & Beans 
+      count: 2
+    2:
+      model: Jumbo Miracle Whip
+      count: 1
+    3: 
+      model: White Wonder Bread
+      count: 2