ytools 0.1.0

data/lib/ytools/templates/yaml_object.rb

@@ -0,0 +1,11 @@
+require 'erb'
+
+module YTools
+  class YamlObject
+
+    # ERB bindings
+    def erb_binding
+      binding
+    end
+  end
+end

data/lib/ytools/version.rb

@@ -0,0 +1,12 @@
+require 'scanf'
+
+module YTools
+  class Version
+    CURRENT = File.read(File.dirname(__FILE__) + '/../VERSION')
+    MAJOR, MINOR, TINY = CURRENT.scanf('%d.%d.%d')
+
+    def self.to_s
+      CURRENT
+    end
+  end
+end

data/lib/ytools/yaml_object.rb

@@ -0,0 +1,112 @@
+require 'yaml'
+
+module YTools
+  class YamlObject
+    def self.from_files(files)
+      yo = YTools::YamlObject.new
+      files.each do |file|
+        if File.exists?(file)
+          contents = nil
+          File.open(file, 'r') { |f| contents = f.read}
+          yo.merge(YAML::load(contents))
+        end
+      end
+      yo
+    end
+
+    attr_reader :ypath, :yroot, :yhash
+
+    def initialize(hash=nil, root=nil, ypath=nil)
+      if hash.nil?
+        @yhash = {}
+      else
+        @yhash = hash.dup
+      end
+
+      @ypath = ypath || '/'
+      @methods = {}
+      @yroot = root || self
+
+      merge(@yhash)
+    end
+
+    def merge(hash)
+      hash.each do |key, value|
+        add_entry(key, value)
+      end
+    end
+    
+    def method_missing(sym, *args, &block)
+      method_name = sym.to_s
+      hash_key = @methods[method_name]
+
+      if hash_key.nil?
+        raise YTools::PathError.new("Unable to locate attribute '#{relative_ypath}/#{method_name}'")
+      else
+        @yhash[hash_key]
+      end
+    end
+
+    def [](key)
+      value = @yhash[key]
+      if value.nil?
+        raise YTools::PathError.new("Unable to locate key \"#{relative_ypath}@['#{key}']\"")
+      end
+      value
+    end
+
+    def []=(key, value)
+      add_entry(key, value)
+    end
+
+    def to_s
+      @yhash.to_s
+    end
+
+    private
+    def relative_ypath
+      if ypath == '/'
+        ''
+      else
+        ypath
+      end
+    end
+
+    def add_entry(key, value)
+      method_name = key.to_s.gsub(/-/, '_').gsub(/\./, '_')
+      child_path = if method_name =~ /(@|\/|[|])/
+                     "|#{key}|"
+                   elsif key =~ /(\.|-)/
+                     key
+                   else
+                     method_name
+                   end
+      hash_key = @methods[method_name]
+
+      if hash_key.nil? # The item hasn't been defined yet
+        value = hashify(value, "#{relative_ypath}/#{child_path}")
+        @methods[method_name] = key
+        @yhash[key] = value
+      else # The item is already defined
+        original_value = @yhash[hash_key]
+        
+        if original_value.is_a?(YamlObject) && value.is_a?(Hash)
+          original_value.merge(value)
+        elsif !value.is_nil?
+          @yhash[key] = hashify(value, "#{relative_ypath}/#{child_path}")
+        end
+      end
+    end
+
+    def hashify(obj, hash_path)
+      if obj.is_a?(Hash)
+        obj = YamlObject.new(obj, yroot, hash_path)
+      elsif obj.is_a?(Array)
+        0.upto(obj.length - 1).each do |i|
+          obj[i] = hashify(obj[i], "#{hash_path}[#{i}]")
+        end
+      end
+      obj
+    end
+  end
+end

data/lib/ytools/yreader.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+
+module YTools
+
+  class YReader
+    def read(yaml_files)
+      root = {}
+
+      yaml_files.each do |yaml_file|
+        if File.exists?(yaml_file)
+          yaml = YAML::load(File.read(yaml_file))
+          if !yaml.is_a?(Hash)
+            raise PathError.new("The yaml file wasn't a hash!")
+          end
+
+          
+        end
+      end
+    end
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1,15 @@
+require 'ytools/yaml_object'
+
+def attempting(&block)
+  lambda &block
+end
+
+def attempting_to(&block)
+  lambda &block
+end
+
+module YamlObjectHelper
+  def yo(hash)
+    YTools::YamlObject.new(hash, nil)
+  end
+end

data/spec/path/executor_spec.rb

@@ -0,0 +1,45 @@
+require 'helpers'
+require 'ytools/errors'
+require 'ytools/path/executor'
+
+module YTools::Path
+
+  module ExecutorHelper
+    def process(path, *files)
+      real_files = []
+      files.each do |file|
+        real_files << File.join(File.dirname(__FILE__), 'yamls', file)
+      end
+
+      Executor.new(path, real_files).process!
+    end
+  end
+
+  describe "Executor" do
+    include ExecutorHelper
+
+    it "should be able to find a simple string in a yaml file" do
+      process('/a/b', '1.yml').should eql("this")
+    end
+
+    it "should be able to find a numebr in the yaml file" do
+      process('/a/b', '2.yml').should eql('42')
+    end
+
+    it "should be able to find an indexed element" do
+      process('/a/b[2]', '3.yml').should eql('blah')
+    end
+
+    it "should be able to find descendant selectors" do
+      process('/a//c[2]', '4.yml').should eql('2')
+    end
+
+    it "should be able to print all the elements in a list" do
+      process('/a//c', '4.yml').should eql("0\n1\n2\n3")
+    end
+
+    it "should be able to pull out the keys for a hash" do
+      process('/a', '5.yml').should eql("b\nc\nd")
+    end
+  end
+end

data/spec/path/lexer_spec.rb

@@ -0,0 +1,127 @@
+require 'ytools/path/lexer'
+
+module YTools::Path
+
+  module PathHelper
+    def lexer(path)
+      Lexer.new(path)
+    end
+    
+    def check_token(path, type, count=nil)
+      count ||= 1
+      lex = lexer(path)
+
+      if count == 0
+        return lex.next # '/'
+      end
+
+      tok = nil
+      0.upto(count) do
+        tok = lex.next
+      end
+      
+      tok.type.should eql(type)
+      tok
+    end
+
+    def check_path(path, part, count=nil)
+      tok = check_token(path, :path_part, count)
+      tok.path.should eql(part)
+    end
+  end
+
+  describe "Token struct" do
+    it "should have a 'value' method that returns the underlying implementation string/number" do
+      Token.new("/42", 1, 2, :number).value.should eql(42)
+    end
+  end
+
+  describe "Lexer" do
+    include PathHelper
+
+    it "should be able to parse a simple path separator" do
+      tok = check_token('/', :path_separator, 0)
+      tok.offset.should eql(0)
+      tok.length.should eql(1)
+    end
+
+    it "should be able to parse a '[' character" do
+      check_token('/[', :lbrace)
+    end
+
+    it "should be able to parse a ']' character" do
+      check_token('/]', :rbrace)
+    end
+
+    it "should correctly parse a number" do
+      tok = check_token('/42', :number)
+      tok.value.should eql(42)
+    end
+
+    it "should know the position of the number" do
+      tok = check_token('/42', :number)
+      tok.length.should eql(2)
+      tok.offset.should eql(1)
+    end
+
+    it "should always return nil when examining past the end of the line." do
+      lex = lexer('/')
+      lex.next.should_not be(nil)
+      lex.next.should be(nil)
+    end
+
+    it "should return nil on indexing past the end of the path." do
+      lex = lexer('/this is a path')
+      lex[50].should be(nil)
+    end
+
+    it "should be able to find a basic path part" do
+      check_path('/path_token', 'path_token')
+    end
+
+    it "should be able to find a path using bars" do
+      check_path('/|complex/path/parts|', 'complex/path/parts')
+    end
+
+    it "should fail when a barred path isn't closed" do
+      attempting_to { check_path('/|noend bar', nil) }.should raise_error(YTools::PathError, /bar/)
+    end
+
+    it "should handle the basic backslash escape of special characters" do
+      check_path("/bath\\|here", 'bath|here')
+    end
+
+    it "should fail when a backslash character is unescaped" do
+      attempting_to { check_path("/back\\slash", nil) }.should raise_error(YTools::PathError, /backslash/)
+    end
+
+    it "should fail when the backslash character is last" do
+      attempting_to { check_path("/back\\", nil) }.should raise_error(YTools::PathError, /Last/)
+    end
+
+    it "should succeed to parse multiple paths according to slashes" do
+      check_path('/this/goes', 'goes', 3)
+    end
+
+    it "should be able to parse numbers within and at the end of path parts" do
+      check_path('/to2be42', 'to2be42')
+    end
+
+    it "should handle negative numbers" do
+      tok = check_token('/-42', :number)
+      tok.offset.should eql(0)
+      tok.value.should eql(-42)
+    end
+
+    it "should be able to peek into the token stream" do
+      lex = lexer('/this/that/other')
+      lex.peek.type.should eql(:path_separator)
+      lex.peek(1).value.should eql("this")
+      lex.peek(2).type.should eql(:path_separator)
+
+      lex.next.type.should eql(:path_separator)
+      lex.next.value.should eql("this")
+      lex.next.type.should eql(:path_separator)
+    end
+  end
+end

data/spec/path/parser_spec.rb

@@ -0,0 +1,104 @@
+require 'helpers'
+require 'ytools/errors'
+require 'ytools/path/lexer'
+require 'ytools/path/parser'
+
+module YTools::Path
+
+  module PathParserHelper
+    # Call private methods on the parser
+    def pm(path, method=nil)
+      method ||= :parse!
+      parser = Parser.new(path)
+      parser.send(method)
+    end
+  end
+
+  describe "Path Parser" do
+    include PathParserHelper
+
+    describe "while doing index operations" do
+      it "should fail when the number is nil" do
+        attempting { pm("[", :index_selector) }.should raise_error(ParseError, /Missing number/)
+      end
+
+      it "should fail when the index isn't a number" do
+        attempting { pm("[not_a_number]", :index_selector) }.should raise_error(ParseError, /Only numbers/)
+      end
+
+      it "should fail when the RBRACE isn't present" do
+        attempting { pm("[1", :index_selector) }.should raise_error(ParseError, /Unclosed/)
+      end
+
+      it "should fail when the final index token isn't an RBRACE" do
+        attempting { pm("[1/", :index_selector) }.should raise_error(ParseError, /Missing '\]'/)
+      end
+
+      it "should be able to pull an index selector" do
+        pm("[23]", :index_selector).index.should eql(23)
+      end
+    end
+
+    describe "while doing path node operations" do
+      it "should be able to pull the node name" do
+        pm("node", :path_node).child.should eql('node')
+      end
+
+      it "should be able to chain an index selector" do
+        pm("node[1]", :path_node).subselector.index.should eql(1)
+      end
+    end
+
+    describe "while doing child selector operations" do
+      it "should be able to find descendent selectors" do
+        pm("//descendant", :child_selector).should be_a(DescendantSelector)
+      end
+
+      it "should be able to find simple child selectors" do
+        pm("/child", :child_selector).should be_a(ChildSelector)
+      end
+
+      it "should fail when the path doesn't begin with a '/'" do
+        attempting_to { pm("child", :child_selector) }.should raise_error(ParseError, /Missing/)
+      end
+
+      it "should fail when the slash doesn't have anything after it" do
+        attempting_to { pm("/", :child_selector) }.should raise_error(ParseError, /Unfinished/)
+      end
+    end
+
+    describe "while doing root operations" do
+      it "should be able to set the root selector correctly" do
+        pm("/a", :root_selector).should be_a(RootSelector)
+      end
+
+      it "should not set the root selector ond descendant paths" do
+        pm("//a", :root_selector).should be_a(DescendantSelector)
+      end
+
+      it "should not set the root selector on a basic path" do
+        pm("a", :root_selector).should be_a(ChildSelector)
+      end
+
+      it "should correctly identify the child selector" do
+        pm("/a[1]", :root_selector).subselector.child.should eql('a')
+        pm("/a[1]", :root_selector).subselector.subselector.index.should eql(1)
+      end
+    end
+
+    describe "while doing a full parse of a line" do
+      it "should be able to pull out all of the selectors" do
+        sel = pm("/a/b[2]//c")
+        sel.should be_a(RootSelector)
+        sel.subselector.should be_a(ChildSelector)
+        sel.subselector.subselector.should be_a(ChildSelector)
+        sel.subselector.subselector.subselector.should be_a(IndexSelector)
+        sel.subselector.subselector.subselector.subselector.should be_a(DescendantSelector)
+      end
+
+      it "should return nil on an empty string" do
+        pm("").should be(nil)
+      end
+    end
+  end
+end