pointrb 0.0.1 → 0.1.0

data/spec/bob_the_helper/file_system/file_system_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe BobTheHelper::FileSystem do
+
+  before(:each) do
+    cleanup_working_directory
+  end
+
+  it "returns the root directory for the project" do
+    path = File.expand_path('../../../../', __FILE__)
+    expect(root_directory).to eq(path)
+  end
+
+  it "returns the tmp directory for tests for the project: <root>/tmp/test'" do
+    path = File.expand_path('../../../../tmp/test', __FILE__)
+    expect(working_directory).to eq(path)
+  end
+
+  it "switches to the temporary directory" do
+    path = ''
+    switch_to_working_directory do
+      path = Dir.pwd
+    end
+    expect(path).to eq(working_directory)
+  end
+
+  it "creates a directory in the tmp directory" do
+    directory_to_be_created = 'blub'
+    path = File.expand_path('../../../../tmp/test/blub', __FILE__)
+
+    created_directory = create_directory(directory_to_be_created)
+
+    expect(created_directory).to eq(path)
+  end
+
+  it "supports creating multiple directories" do
+    directory_to_be_created = %w[ blub bla test123]
+    paths = directory_to_be_created.map { |d| File.expand_path("../../../../tmp/test/#{d}", __FILE__) }
+
+    created_directories = create_directory(*directory_to_be_created)
+
+    expect(created_directories).to eq(paths)
+  end
+
+  it "creates a file in the tmp directory" do
+    file = 'bla.txt'
+    content = 'this is content'
+
+    created_file = create_file(file, content)
+
+    file_content = ''
+    switch_to_working_directory do
+      file_content = File.read(created_file).chomp
+    end
+
+    expect(file_content).to eq(content)
+  end
+
+  it "creates an empty file in the tmp directory" do
+    file = 'bla.txt'
+    created_file = create_file(file)
+
+    file_content = ''
+    switch_to_working_directory do
+      file_content = File.read(created_file).chomp
+    end
+
+    expect(file_content).to eq('')
+  end
+
+  it "creates a file in a subdirectory in the tmp directory" do
+    file = 'test_dir/bla.txt'
+    content = 'this is content'
+
+    created_file = create_file(file, content)
+
+    file_content = ''
+    switch_to_working_directory do
+      file_content = File.read(created_file).chomp
+    end
+
+    expect(file_content).to eq(content)
+  end
+
+  it "reads files from the tmp directory" do
+    file = 'blub123.txt'
+    content = "test 12 3"
+
+    switch_to_working_directory do
+      File.open(file, "wb") do |f|
+        f.write content
+      end
+    end
+
+    file_content = read_file(file)
+    expect(file_content).to eq(content)
+  end
+
+  it "checks if a directory/file exists" do
+    file = 'blub123.txt'
+
+    switch_to_working_directory do
+      File.open(file, "wb") do |f|
+        f.write ''
+      end
+    end
+
+    result = path_exists? file
+    expect(result).to eq(true)
+
+    result = path_exists? 'asfdasdfsadf.txt'
+    expect(result).to eq(false)
+  end
+
+  it "checks existance for multiple files" do
+    files = %w[ blub123.txt asdf.txt asdfe2.txt ]
+
+    switch_to_working_directory do
+      files.each do |file|
+        File.open(file, "wb") do |f|
+          f.write ''
+        end
+      end
+    end
+
+    result = path_exists? *files
+    expect(result).to eq(true)
+  end
+
+  it "checks absence for multiple files" do
+    files = %w[ blub123.txt asdf.txt asdfe2.txt ]
+
+    result = path_does_not_exist? *files
+    expect(result).to eq(true)
+  end
+
+  it "deletes existing directories" do
+    directory_to_be_deleted = 'blub'
+    path = File.expand_path('../../../../tmp/test/blub', __FILE__)
+
+    switch_to_working_directory do
+      FileUtils.mkdir_p 'blub'
+    end
+
+    deleted_directory = delete_directory(directory_to_be_deleted)
+    expect(deleted_directory).to eq(path)
+  end
+
+  it "supports deleting multiple directories" do
+    directories_to_be_deleted = %w[ blub bla test123]
+    paths = directories_to_be_deleted.map { |d| File.expand_path("../../../../tmp/test/#{d}", __FILE__) }
+
+    switch_to_working_directory do
+      directories_to_be_deleted.each do |d| 
+        FileUtils.mkdir_p d
+      end
+    end
+
+    deleted_directories = delete_directory(*directories_to_be_deleted)
+
+    expect(deleted_directories).to eq(paths)
+  end
+
+  it "deletes existing single file" do
+    file_to_be_deleted = 'blub.txt_123'
+    path = File.expand_path('../../../../tmp/test/blub.txt_123', __FILE__)
+
+    switch_to_working_directory do
+      File.open(file_to_be_deleted, "wb") do |f|
+        f.write ''
+      end
+    end
+
+    deleted_file = delete_file(file_to_be_deleted)
+    expect(deleted_file).to eq(path)
+  end
+
+  it "deletes existing multiple files" do
+    files = %w[ blub.txt_123 blub.txt_456 ]
+
+    paths = files.map {|f| File.expand_path("../../../../tmp/test/#{f}", __FILE__) }
+
+    switch_to_working_directory do
+      files.each do |p|
+        File.open(p, "wb") do |f|
+          f.write ''
+        end
+      end
+    end
+
+    deleted_files = delete_file files
+    expect(deleted_files).to eq(paths)
+  end
+
+  it "let you create the temporary directory" do
+    create_working_directory
+    expect(File.exists? working_directory).to eq(true)
+  end
+
+  it "let you delete the temporary directory" do
+    delete_working_directory
+    expect(File.exists? working_directory).to eq(false)
+  end
+
+  it "let you cleanup the temp directory" do
+    cleanup_working_directory
+
+    pattern = File.join(working_directory, '*' )
+    entries = Dir.glob(pattern)
+
+    expect(entries.blank?).to eq(true)
+  end
+
+  it "expand paths to temporary directory" do
+    files = %w[ blub.txt_123 blub.txt_456 /path/abc ./path/abc ]
+    new_path_via_lib = expand_path(files)
+
+    files.each do |f|
+      this_path = new_path_via_lib.shift
+      expect(File.join(working_directory, f)).to eq(this_path)
+    end
+    
+  end
+
+  it "checks forbidden paths during remove operations" do
+    good_paths = %w[ blub.txt_123  /path/to/x /home/user/y ]
+    bad_paths  = [ 
+      '/'
+    ]
+
+    bad_paths.each do |p| 
+      expect { 
+        raise_if_forbidden_path_for_delete_operation(p)
+      }.to raise_error BobTheHelper::FileSystem::Exceptions::InvalidPath
+    end
+
+    good_paths.each do |p| 
+      expect { 
+        raise_if_forbidden_path_for_delete_operation(p)
+      }.to_not raise_error
+    end
+
+    expect { 
+      raise_if_forbidden_path_for_delete_operation(bad_paths)
+    }.to raise_error BobTheHelper::FileSystem::Exceptions::InvalidPath
+
+    expect { 
+      raise_if_forbidden_path_for_delete_operation(good_paths)
+    }.to_not raise_error
+
+  end
+
+  it "checks forbidden paths during create operations" do
+    good_paths = %w[ blub.txt_123  /path/to/x /home/user/y ]
+    bad_paths  = [ 
+      '/path/with/../',
+    ]
+
+    bad_paths.each do |p| 
+      expect { 
+        raise_if_forbidden_path_for_create_operation(p)
+      }.to raise_error BobTheHelper::FileSystem::Exceptions::InvalidPath
+    end
+
+    good_paths.each do |p| 
+      expect { 
+        raise_if_forbidden_path_for_create_operation(p)
+      }.to_not raise_error
+    end
+
+    expect { 
+      raise_if_forbidden_path_for_create_operation(bad_paths)
+    }.to raise_error BobTheHelper::FileSystem::Exceptions::InvalidPath
+
+    expect { 
+      raise_if_forbidden_path_for_create_operation(good_paths)
+    }.to_not raise_error
+  end
+end

data/spec/directory/directory_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Directory do
+
+  it "has a path and a base dir" do
+    Directory.new('path', 'basedir')
+  end
+
+  it "can be created" do
+    dir = Directory.new('path', working_directory)
+    dir.create
+
+    dir_path = File.join(working_directory, 'path')
+    result = File.exists?(dir_path)
+
+    expect(result).to eq(true)
+  end
+
+  it "returns the full path" do
+    dir = Directory.new('path', working_directory)
+    check = File.join(working_directory, 'path') 
+    expect(dir.full_path).to eq(check)
+  end
+
+  it "returns path if it starts with '/'" do
+    path = '/path'
+    dir = Directory.new(path)
+    expect(dir.full_path).to eq(path)
+  end
+end

data/spec/hooks.rb

@@ -0,0 +1,5 @@
+Rspec.configure do |c|
+  c.before(:each) do
+    cleanup_working_directory
+  end
+end

data/spec/layout/layout_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Layout do
+  it "creates the directory structure" do
+    action = Class.new do
+      def create
+        puts "hey, create"
+      end
+    end
+
+    layout = Layout.new
+    layout.actions << action.new
+
+    result = capture(:stdout) do
+      layout.create
+    end
+
+    expect(result.chomp).to eq('hey, create')
+  end
+end

data/spec/layout_constructor/layout_constructor_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe LayoutConstructor do
+  let(:project) do 
+    Class.new do
+      def name
+        'new_project'
+      end
+
+      def path 
+        File.join(working_directory, name)
+      end
+    end.new
+  end
+  let(:layout_constructor) { LayoutConstructor.new(project) }
+
+  it "parses a layout with a name" do
+    layout = "layout :name do; end"
+    file = 'blub.layout'
+    result = layout_constructor.parse_dsl(layout, file)
+    expect(result.name).to eq(:name)
+  end
+
+  it "parses a layout with a directory" do
+    layout = <<-EOB
+    layout :name do
+      directory 'path'
+    end 
+    EOB
+    file = 'blub.layout'
+    result = layout_constructor.parse_dsl(layout, file)
+    #root directory + directory 'path'
+    expect(result.actions.size).to eq(2)
+  end
+
+  it "parses a layout with a nested directory" do
+    layout = <<-EOB
+    layout :name do
+      directory 'path' do
+        directory 'subpath'
+      end
+    end 
+    EOB
+
+    paths = [
+      project.path,
+      File.join(project.path, 'path'),
+      File.join(project.path, 'path', 'subpath'),
+    ]
+    file = 'blub.layout'
+    parsed_layout = layout_constructor.parse_dsl(layout,file)
+    result = parsed_layout.actions.all? { |node| node.full_path == paths.shift }
+
+    expect(result).to eq(true)
+  end
+
+  it "parses a layout with a file" do
+    layout = <<-EOB
+    layout :name do
+      file 'path' do
+        'content'
+      end
+    end 
+    EOB
+
+    paths = [
+      project.path,
+      File.join(project.path, 'path'),
+    ]
+    file = 'blub.layout'
+    parsed_layout = layout_constructor.parse_dsl(layout, file)
+
+    result = parsed_layout.actions.all? { |node| node.full_path == paths.shift }
+    expect(result).to eq(true)
+
+    content = [
+      'content'
+    ]
+
+    result = parsed_layout.actions.find_all{ |a| a.kind_of? PointRbFile}.all?{ |node| node.content == content.shift }
+    expect(result).to eq(true)
+  end
+
+  it "parses a layout with a file and multiple lines" do
+    layout = <<-EOB
+    layout :name do
+      file 'path' do
+       <<-HERE
+       content
+        content
+        content
+       content
+           content
+       content
+       HERE
+      end
+    end 
+    EOB
+
+    file = 'blub.layout'
+    parsed_layout = layout_constructor.parse_dsl(layout, file)
+
+    file_content = [
+'content
+ content
+ content
+content
+    content
+content
+'
+    ]
+
+    result = parsed_layout.actions.find_all{ |a| a.kind_of? PointRbFile}.all?{ |node| node.content == file_content.first}
+    expect(result).to eq(true)
+  end
+
+  it "returns the file name of the parsed layout when an error occured" do
+    layout = "garbage"
+    file = 'blub.layout'
+    expect { parsed_layout = layout_constructor.parse_dsl(layout, file) }.to raise_error(Exceptions::SyntaxErrorInLayout, 'Syntax error in layout-file "blub.layout" at line 1')
+  end
+end

data/spec/layout_file/layout_file_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe LayoutFile do
+
+  before(:all) do
+    @file = 'layouts/new_layout1.layout'
+
+    @content = <<-EOF
+layout :name1 do
+end
+    EOF
+
+    create_file @file, @content 
+
+    @full_path = File.join(working_directory, @file )
+    @layout_file = LayoutFile.new(@full_path)
+  end
+
+  it "returns the path of the layout" do
+    expect(@layout_file.path).to eq(@full_path)
+  end
+
+  it "returns the content of the layout file" do
+    expect(@layout_file.content).to eq(@content)
+  end
+
+  it "raises an Error if an unexisting layout file is given" do
+    expect {
+      LayoutFile.new('invalid path')
+    }.to raise_error Exceptions::FileNotFound
+  end
+
+  it "let you compare instances by path" do
+    file1 = 'layouts/layout1.layout'
+    file2 = 'layouts/layout2.layout'
+
+    create_file file1
+    create_file file2
+
+    layout_file1 = LayoutFile.new(File.join(working_directory, file1))
+    layout_file2 = LayoutFile.new(File.join(working_directory, file2))
+
+    result = ( layout_file1 == layout_file1 )
+    expect(result).to eq(true)
+
+    result = ( layout_file1 == layout_file2 )
+    expect(result).to eq(false)
+  end
+end

data/spec/layout_manager/layout_manager_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe LayoutManager do
+
+  let(:layout_file) do 
+    Class.new do
+      def path
+        "file/path/to/source"
+      end
+
+      def content
+        <<-EOF
+          layout :name do
+            directory "path/to/directory"
+          end
+        EOF
+      end
+    end.new
+  end
+
+  let(:project) do
+    Class.new do
+      def name
+        'blub'
+      end
+
+      def path
+        File.join(working_directory, name)
+      end
+    end.new
+  end
+
+  it "retrieves a layout by name" do
+
+    layout_manager = LayoutManager.new([layout_file], project)
+    layout = layout_manager.retrieve(:name)
+
+    expect(layout.name).to eq(:name)
+  end
+
+  it "raises an exception if requested layout was not found" do
+    layout_manager = LayoutManager.new([layout_file], project)
+    expect {
+      layout_manager.retrieve(:name_abc_def)
+    }.to raise_error Exceptions::LayoutNotFound
+  end
+end

data/spec/layout_storage_manager/layout_storage_manager_spec.rb

@@ -0,0 +1,58 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe LayoutStorageManager do
+  let(:layout_directory) { File.join(working_directory, 'layouts') }
+  let(:layout_file_klass) do 
+   Class.new do
+     attr_reader :path
+
+     def initialize(p)
+       @path = p
+     end
+
+     def content
+       File.read(@path)
+     end
+   end
+  end
+
+  before(:each) do
+    create_directory layout_directory
+  end
+
+  it "takes a path to look for layouts" do
+    LayoutStorageManager.new(layout_directory)
+  end
+
+  it "finds a specific template" do
+    file1 = 'layouts/new_layout1.layout'
+    file2 = 'layouts/new_layout2.layout'
+
+    create_file file1, "I'm content1"
+    create_file file2, "I'm content2"
+
+    mgr = LayoutStorageManager.new(layout_directory, layout_file_klass)
+    layout_file = File.join(working_directory, file1)
+
+    layout = mgr.retrieve(layout_file)
+    expect(layout.path).to eq(layout_file)
+  end
+
+  it "finds a specific template" do
+    file1 = 'layouts/new_layout1.layout'
+    file2 = 'layouts/new_layout2.layout'
+    file3 = 'layouts/new_layout3.layout'
+
+    create_file file1, "I'm content1"
+    create_file file2, "I'm content2"
+    create_file file3, "I'm content3"
+
+    mgr = LayoutStorageManager.new(layout_directory, layout_file_klass)
+    layout_file = File.join(working_directory, file1)
+
+    layouts = mgr.retrieve_all
+    expect(layouts.first.respond_to?(:content)).to eq(true)
+  end
+  
+end

data/spec/layout_tree/layout_tree_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Tree do
+  before(:each) do
+    @tree = LayoutTree.new('root_node')
+  end
+
+  it "takes a root node" do
+    LayoutTree.new('root_node')
+  end
+
+  it "adds a child node" do
+    @tree.add_node('child_node')
+
+    expect(@tree.tree.size).to eq(2)
+  end
+
+  it "is possible to serialize the whole tree (default action)" do
+    test_node = 'child_node'
+
+    @tree.add_node(test_node)
+    @tree.add_node('child_node')
+    @tree.add_node('child_node')
+    @tree.add_node('child_node')
+
+    serialized_tree = @tree.serialize
+
+    expect(serialized_tree[1]).to eq(test_node)
+  end
+
+  it "is possible to serialize the whole tree (customized action)" do
+    test_node = 'child_node'
+
+    @tree.add_node(test_node)
+    @tree.add_node('child_node')
+    @tree.add_node('child_node')
+    @tree.add_node('child_node')
+
+    serialized_tree = @tree.serialize do |node|
+      node.content
+    end
+
+    expect(serialized_tree[1]).to eq(test_node)
+  end
+
+  it "is possible to set the active node" do 
+    test_node = 'child_node'
+
+    @tree.add_node(test_node)
+    @tree.up
+    @tree.add_node('child_node')
+    @tree.up
+    @tree.add_node('child_node')
+
+    check = <<-EOF
+* node0
+|---> node1
+|---> node2
++---> node3
+    EOF
+    result = capture(:stdout) do
+      @tree.tree.print_tree
+    end
+    expect(result).to eq(check)
+  end
+
+  it "returns the active node in tree" do
+
+  end
+end