cheeba 1.0.4

data/lib/cheeba/reader/format.rb

@@ -0,0 +1,130 @@
+module Cheeba
+  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"): phs[:key] = true
+          when (phs[:key].to_s.strip == "false"): 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"): phs[:val] = true
+          when (phs[:val].to_s.strip == "false"): phs[:val] = false
+          end
+        end
+      end
+      
+      #
+      # symbolize key
+      #
+      def self.key_to_sym(phs)
+        is_str = (phs[:key] =~ /^\d*$/).nil?
+        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? && !phs[:key].to_s.strip.empty?)
+      end
+      
+      #
+      # symbolize val
+      #
+      def self.val_to_sym(phs)
+        is_str = (phs[:val] =~ /^\d*$/).nil?
+        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)
+        if string.to_i.to_s == string.to_s.gsub(/^0+/, "") 
+          string.to_i
+        else
+          string
+        end
+      end
+    end
+  end
+end

data/lib/cheeba/reader/node.rb

@@ -0,0 +1,61 @@
+module Cheeba
+  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/cheeba/reader/parser.rb

@@ -0,0 +1,64 @@
+module Cheeba
+  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)
+        chb = Cheeba::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]
+
+        case line
+        when chb.left_match(arr, spc):             [:arr, Regexp.last_match.captures]
+        when chb.left_match(com, spc):             [:com, Regexp.last_match.captures]
+        when chb.hashkey_sym(hsh, sym, spc):       [:hky, Regexp.last_match.captures, nil, true]
+        when chb.hashkey(hsh, spc):                [:hky, Regexp.last_match.captures]
+        when chb.hashpair_sym_all(hsh, sym, spc):  [:hpr, Regexp.last_match.captures, true, true]
+        when chb.hashpair_sym_key(hsh, sym, spc):  [:hpr, Regexp.last_match.captures, true]
+        when chb.hashpair_sym_val(hsh, sym, spc):  [:hpr, Regexp.last_match.captures, nil, true]
+        when chb.hashpair(hsh, sym, spc):          [:hpr, Regexp.last_match.captures]
+        when /^\s*$/:                              [:bla]
+        when chb.document(dcs, spc):               [:dcs]
+        when chb.document(dct, spc):               [:dct]
+        else;                                      [:mal, nil, nil, line]
+        end
+      end
+
+      ##
+      # creates hash with array vals, includes options
+      #
+      def self.results_to_hash(results, opt)
+        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/cheeba/reader.rb

@@ -0,0 +1,33 @@
+require 'cheeba/reader/node'
+require 'cheeba/reader/format'
+require 'cheeba/reader/builder'
+require 'cheeba/reader/parser'
+
+module Cheeba
+  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 Cheeba::Reader::EmptyInputError if (input.is_a?(String) && input.strip.empty?)
+      raise Cheeba::Reader::InvalidInputError unless (input.is_a?(String) or input.is_a?(File))
+      input = IO.readlines(input) if File.exists?(input)
+      raise Cheeba::Reader::EmptyFileError if input.empty?
+      hash = {}
+      lineno = 0
+      input.each {|line|
+        parsed_hash    = Cheeba::Reader::Parser.parse(line, options, (lineno += 1)) 
+        formatted_hash = Cheeba::Reader::Format.format(parsed_hash) 
+        Cheeba::Reader::Builder.build(hash, formatted_hash)
+      }
+      hash.delete(:adr) 
+      case
+      when options[:list]: hash
+      when !options[:list]: hash.delete(:lst) && (hash.length == 1) ? hash[1] : hash
+      end
+    end
+  end
+end

data/lib/cheeba/version.rb

@@ -0,0 +1,3 @@
+module Cheeba
+  VERSION  = '1.0.4'
+end

data/lib/cheeba/writer/builder.rb

@@ -0,0 +1,95 @@
+module Cheeba
+  module Writer
+    module Builder
+      def self.build(arr, inp, opt)
+        spc = (opt[:space] * opt[:indent])
+        case
+        when inp.is_a?(Hash):   self.hash_to_array(arr, inp, opt, spc)
+        when inp.is_a?(Array):  self.array_to_lines(arr, inp, opt, spc) 
+        when inp.is_a?(String): 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.inspect : x
+        b = (!y.nil? && y.is_a?(Symbol)) ? y.inspect : 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}#{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}"
+          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/lib/cheeba/writer.rb

@@ -0,0 +1,49 @@
+require 'cheeba/writer/builder'
+
+module Cheeba
+  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 .cash file
+    #
+    def self.build(object, options)
+      raise Cheeba::Writer::EmptyInputError if (object.is_a?(String) && object.strip.empty?)
+      raise Cheeba::Writer::InvalidInputError unless (object.is_a?(String) or object.is_a?(Array) or object.is_a?(Hash))
+      Cheeba::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 Cheeba::Writer::EmptyInputError if (object.is_a?(String) && object.strip.empty?)
+      raise Cheeba::Writer::InvalidInputError unless (object.is_a?(String) or object.is_a?(Array) or object.is_a?(Hash))
+      raise Cheeba::Writer::EmptyFilenameError if File.basename(filename.to_s).strip.empty?
+      raise Cheeba::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 cheeba dotfile to home dir
+    #
+    def self.dotfile(options, home)
+      filename = "#{home.chomp("/")}/.cheeba"
+      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, Cheeba::Indicators.options)
+      new_name ? new_name : filename
+    end
+  end
+end

data/lib/cheeba.rb

@@ -0,0 +1,50 @@
+require 'cheeba/version'
+require 'cheeba/reader'
+require 'cheeba/writer'
+require 'cheeba/indicators'
+require 'cheeba/defaults'
+
+module Cheeba
+  DOTFILE = "#{ENV['HOME']}/.cheeba"
+  #
+  # File to Hash or Array
+  #
+  def self.read(input, options = {})
+    Cheeba::Reader.read(input, self.options(options))
+  end
+ 
+  #
+  # Hash or Array to .cash Array
+  #
+  def self.parse(object, options = {})
+    Cheeba::Writer.build(object, self.options(options))
+  end
+  
+  #
+  # Hash or Array to .cash-file, e.g. filename.cash
+  #
+  def self.write(object, filename, options = {})
+    Cheeba::Writer.write(object, filename, self.options(options))
+  end
+
+  #
+  # writes a .cheeba file HOME, merges with options if :dot is true 
+  #
+  def self.dotfile(home = ENV['HOME'])
+    Cheeba::Writer.dotfile(Cheeba::Defaults.options, home)
+  end
+
+  private
+  
+  #
+  # options
+  #
+  def self.options(options = {})
+    opt = Cheeba::Defaults.options.merge(Cheeba::Indicators.options.merge(options))
+    dot_opt = File.exists?(DOTFILE) ? Cheeba::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/test/files/arrays.cash

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

data/test/files/comments.cash

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

data/test/files/hashes.cash

@@ -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

data/test/files/malformed.cash

@@ -0,0 +1,3 @@
+2341234
+  awesome
+    dude

data/test/files/mixed.cash

@@ -0,0 +1,12 @@
+1:1
+2:
+  -
+  - one
+  - two
+    5:
+      6:6
+      7:7
+    8: 
+      dude:dude
+  -
+3: awesome

data/test/files/split.cash

@@ -0,0 +1,9 @@
+1:1
+2:3
+3:3
+- 1
+- 2
+- 3
+1:1
+2:2
+3:3