awesome-cheeba 1.0.1

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/version.rb

@@ -0,0 +1,3 @@
+module Cheeba
+  VERSION  = '1.0.1'
+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/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/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

data/test/test_cheeba.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'minitest/unit'
+$: << 'lib' << 'test'
+require 'cheeba'
+MiniTest::Unit.autorun
+
+class TestCheeba < MiniTest::Unit::TestCase
+  def setup
+    @files  = "#{File.dirname(__FILE__)}/files"
+    @test = "#{@files}/test.cash"
+    @opt = Cheeba::Defaults.options.merge(Cheeba::Indicators.options)
+    @hom = ENV['HOME']
+    @dot = "#{@hom}/.cheeba"
+    @hsh = {
+      "grocery_list" => {
+        "meatsez" => {
+          1 => {"count"=>5, "model"=>"Spam"},
+          2 => {"count"=>1, "model"=>"Log of ground beef"}},
+        "beer"=>{1=>{"count"=>1, "model"=>"24 pack - Coors Lite"}},
+        "cigarettes" => {
+          1 => {"count"=>2, "model"=>"Carton - Basic Ultra Menthol Box 100"}},
+        "other" => {
+          1 => {"count"=>2, "model"=>"Economy-Size Pork & Beans"},
+          2 => {"count"=>1, "model"=>"Jumbo Miracle Whip"},
+          3 => {"count"=>2, "model"=>"White Wonder Bread"}}}}
+    @exp = 
+      ["grocery_list:",
+       "  meatsez:",
+       "    1:",
+       "      count: 5",
+       "      model: Spam",
+       "    2:",
+       "      count: 1",
+       "      model: Log of ground beef",
+       "  cigarettes:",
+       "    1:",
+       "      count: 2",
+       "      model: Carton - Basic Ultra Menthol Box 100",
+       "  beer:",
+       "    1:",
+       "      count: 1",
+       "      model: 24 pack - Coors Lite",
+       "  other:",
+       "    1:",
+       "      count: 2",
+       "      model: Economy-Size Pork & Beans",
+       "    2:",
+       "      count: 1",
+       "      model: Jumbo Miracle Whip",
+       "    3:",
+       "      count: 2",
+       "      model: White Wonder Bread"]
+  end
+
+  def test_read_hash
+    act = Cheeba.read("#{@files}/hashes.cash")    
+    assert_equal @hsh, act
+  end
+
+  def test_read_hash_options_symbolize_keys
+    hsh = ":awesome: dude"
+    exp = {:awesome => "dude"}
+    act = Cheeba.read(hsh, {:symbolize_keys => true})    
+    assert_equal exp, act
+  end
+
+  def test_read_string
+    str = IO.read("#{@files}/hashes.cash")
+    act = Cheeba.read(str)
+    assert_equal @hsh, act
+  end
+
+  def test_parse_hash
+    act = Cheeba.parse(@hsh)
+    assert_equal @exp, act
+  end
+
+  def test_write
+    File.delete(@test) if File.exists?(@test)
+    refute(File.exists?(@test), "dude!")
+    Cheeba.write(@hsh, @test)
+    act = (IO.readlines(@test).map {|x| x.chomp})
+    assert(File.exists?(@test))
+    assert_equal @exp, act
+    File.delete(@test) 
+  end
+
+  def test_dotfile
+    File.delete(@dot) if File.exists?(@dot) 
+    refute(File.exists?(@dot), "dude!")
+    Cheeba.dotfile 
+    assert(File.exists?(@dot)) 
+    exp_keys = Cheeba::Defaults.options
+    act_keys = Cheeba::Reader.read(@dot, @opt.merge({:symbolize_keys => true}))
+    assert_equal exp_keys, act_keys
+    File.delete(@dot) 
+  end
+
+  def test_dotfile_exists
+    len = Dir.entries(@hom).length
+    mv_by_test = (File.exists?(@dot) ? "#{@dot}.mv_by_test" : "")
+    File.rename(@dot, mv_by_test) unless mv_by_test.empty?
+    refute(File.exists?(@dot), "dude!")
+    dot = Cheeba.dotfile
+    assert File.exists?(@dot) 
+    assert File.exists?(dot)
+    assert_equal len, (Dir.entries(@hom).length - 1)
+    File.delete(@dot) if File.exists?(@dot) 
+    File.delete(dot) if File.exists?(dot) 
+    refute(File.exists?(@dot), "dude!")
+    refute(File.exists?(dot), "dude!")
+    File.rename(mv_by_test, @dot) if File.exists?(mv_by_test)
+  end
+
+  def test_read_raise_on_empty_string
+    assert_raises(Cheeba::Reader::EmptyInputError) {Cheeba.read("")} 
+  end
+end

data/test/test_reader.rb

@@ -0,0 +1,210 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'minitest/unit'
+$: << 'lib' << 'test'
+require 'cheeba/reader'
+require 'cheeba/indicators'
+require 'cheeba/defaults'
+MiniTest::Unit.autorun
+
+class TestReader < MiniTest::Unit::TestCase
+  def setup
+    @file_com = "test/files/comments.cash"
+    @file_arr = "test/files/arrays.cash"
+    @file_hsh = "test/files/hashes.cash"
+    @file_mix = "test/files/mixed.cash"
+    @file_mal = "test/files/malformed.cash"
+    @file_bla = "test/files/blank.cash"
+    @file_spl = "test/files/split.cash"
+    opt   = Cheeba::Indicators.options
+    @opt  = Cheeba::Defaults.options.merge(opt)
+    @reader = Cheeba::Reader
+  end
+
+  def test_test_files_exists
+    assert File.exists?(@file_com)
+    assert File.exists?(@file_arr)
+    assert File.exists?(@file_hsh)
+    assert File.exists?(@file_mix)
+    assert File.exists?(@file_mal)
+    assert File.exists?(@file_bla)
+    assert File.exists?(@file_spl)
+  end
+  
+  def test_parse_string
+    exp1 = {"awesome" => "dude"}
+    exp2 = {1 => {"awesome" => "dude"}, :lst => {1 => "1"}}
+    act1 = @reader.read("awesome: dude", @opt.merge({:list => false}))
+    act2 = @reader.read("awesome: dude", @opt.merge({:list => true}))
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+  end
+
+  def test_parse_empty_string_raise_emptystringerror
+    assert_raises(Cheeba::Reader::EmptyInputError) {@reader.read("", @opt)}
+  end
+  
+  def test_parse_blank_file_raise_emptyfileerror
+    assert_raises(Cheeba::Reader::EmptyFileError) {@reader.read(@file_bla, @opt)}
+  end
+
+  def test_parse_blank_file_raise_invalidinputerror
+    assert_raises(Cheeba::Reader::InvalidInputError) {@reader.read({}, @opt)}
+  end
+
+  def test_parse_split_raise_rootnodeerror
+    assert_raises(Cheeba::Reader::Builder::RootNodeError) {
+      @reader.read(@file_spl, @opt.merge({:list => true}))
+    }
+  end
+
+  def test_parse_file_array
+    exp1 = ["", 1, 2, [["", "awesome", "awesome"]], 4, 5, 6, [7, [8], "dude"], ""]
+    exp2 = {1 => ["", 1, 2, [["", "awesome", "awesome"]], 4, 5, 6, [7, [8], "dude"], ""],
+       :lst=> {
+         1  => "1",
+         2  => "1",
+         3  => "1",
+         4  => "1",
+         5  => "1,3",
+         6  => "1,3,0",
+         7  => "1,3,0",
+         8  => "1,3,0",
+         9  => "1",
+         10 => "1",
+         11 => "1",
+         12 => "1,7",
+         13 => "1,7,1",
+         14 => "1,7",
+         15 => "1"}}
+    act1 = @reader.read(@file_arr, @opt.merge({:list => false}))
+    act2 = @reader.read(@file_arr, @opt.merge({:list => true}))
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+  end
+
+  def test_parse_file_hash
+    exp1 = {"grocery_list" => 
+      {"meatsez" => 
+        {1 => {"count" => 5, "model" => "Spam"},
+         2 => {"count" => 1, "model" => "Log of ground beef"}},
+       "beer" => {1 => {"count" => 1, "model" => "24 pack - Coors Lite"}},
+       "cigarettes" => 
+        {1 => {"count" => 2, "model" => "Carton - Basic Ultra Menthol Box 100"}},
+       "other" => 
+        {1 => {"count" => 2, "model" => "Economy-Size Pork & Beans"},
+         2 => {"count" => 1, "model" => "Jumbo Miracle Whip"},
+         3 => {"count" => 2, "model" => "White Wonder Bread"}}}}
+    exp2 = {1  =>  {"grocery_list" => 
+      {"meatsez" => 
+        {1 => {"count" => 5, "model" => "Spam"},
+         2 => {"count" => 1, "model" => "Log of ground beef"}},
+       "beer" => {1 => {"count" => 1, "model" => "24 pack - Coors Lite"}},
+       "cigarettes" => 
+        {1 => {"count" => 2, "model" => "Carton - Basic Ultra Menthol Box 100"}},
+       "other" => 
+        {1 => {"count" => 2, "model" => "Economy-Size Pork & Beans"},
+         2 => {"count" => 1, "model" => "Jumbo Miracle Whip"},
+         3 => {"count" => 2, "model" => "White Wonder Bread"}}}},
+       :lst => 
+        {1 => "1,grocery_list",
+         2 => "1,grocery_list,beer",
+         3 => "1,grocery_list,beer,1",
+         4 => "1,grocery_list,beer,1",
+         5 => "1,grocery_list,beer,1",
+         6 => "1,grocery_list,meatsez",
+         7 => "1,grocery_list,meatsez,1",
+         8 => "1,grocery_list,meatsez,1",
+         9 => "1,grocery_list,meatsez,1",
+         10 => "1,grocery_list,meatsez,2",
+         11 => "1,grocery_list,meatsez,2",
+         12 => "1,grocery_list,meatsez,2",
+         13 => "1,grocery_list,cigarettes",
+         14 => "1,grocery_list,cigarettes,1",
+         15 => "1,grocery_list,cigarettes,1",
+         16 => "1,grocery_list,cigarettes,1",
+         17 => "1,grocery_list,other",
+         18 => "1,grocery_list,other,1",
+         19 => "1,grocery_list,other,1",
+         20 => "1,grocery_list,other,1",
+         21 => "1,grocery_list,other,2",
+         22 => "1,grocery_list,other,2",
+         23 => "1,grocery_list,other,2",
+         24 => "1,grocery_list,other,3",
+         25 => "1,grocery_list,other,3",
+         26 => "1,grocery_list,other,3"}}
+    act1 = @reader.read(@file_hsh, @opt.merge({:list  =>  false}))
+    act2 = @reader.read(@file_hsh, @opt.merge({:list  =>  true}))
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+  end
+
+  def test_parse_file_mixed
+    exp1 = {1=>1,
+      2 => ["", "one", "two", {5=>{6=>6, 7=>7}, 8=>{"dude"=>"dude"}}, ""],
+      3 =>"awesome"}
+    exp2 = {1=>
+      {1=>1,
+      2=>["", "one", "two", {5=>{6=>6, 7=>7}, 8=>{"dude"=>"dude"}}, ""],
+      3=>"awesome"},
+      :lst => {
+        1 => "1",
+        2 => "1,2",
+        3 => "1,2",
+        4 => "1,2",
+        5 => "1,2",
+        6 => "1,2,3,5",
+        7 => "1,2,3,5",
+        8 => "1,2,3,5",
+        9 => "1,2,3,8",
+        10 => "1,2,3,8",
+        11 => "1,2",
+        12 => "1"}}
+    act1 = @reader.read(@file_mix, @opt.merge({:list => false}))
+    act2 = @reader.read(@file_mix, @opt.merge({:list => true}))
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+  end
+
+  def test_parse_file_comments
+    exp1 = {1=>1, 2=>2, 3=>3, 4=>[1, 2, 3]}
+    exp2 = {1=>{1=>1, 2=>2, 3=>3, 4=>[1, 2, 3]},
+      :lst => {
+        1 => "#COMMENT: dude",
+        2 => "1",
+        3 => "#COMMENT: awesome",
+        4 => "1",
+        5 => "#COMMENT: ",
+        6 => "#COMMENT: camaro",
+        7 => "#COMMENT: ",
+        8 => "1",
+        9 => "#COMMENT: #",
+        10 => "#COMMENT: nice",
+        11 => "#COMMENT: one",
+        12 => "#COMMENT: bro!",
+        13 => "#COMMENT: ",
+        14 => "1,4",
+        15 => "1,4",
+        16 => "1,4",
+        17 => "1,4"}}
+    act1 = @reader.read(@file_com, @opt.merge({:list => false}))
+    act2 = @reader.read(@file_com, @opt.merge({:list => true}))
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+  end
+
+  def test_parse_file_malformed
+    exp1 = {}
+    exp2 = {
+      1=>{}, 
+      :lst => {
+        1 => "#MALFORMED: 2341234", 
+        2 => "#MALFORMED: awesome", 
+        3 => "#MALFORMED: dude"}}
+    act1 = @reader.read(@file_mal, @opt.merge({:list => false}))
+    act2 = @reader.read(@file_mal, @opt.merge({:list => true}))
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+  end
+end