microstation 0.4.1

data/spec/app_spec.rb

@@ -0,0 +1,267 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+
+describe "Microstation::App" do
+
+  before(:all) do
+    @app = Microstation::App.new
+    @existing_drawing_path = drawing_path('test.dgn')
+    @new_drawing_path = drawing_path('my_new_drawing.dgn')
+  end
+
+  before(:each) do
+    File.delete(@new_drawing_path) if File.exist?(@new_drawing_path)
+  end
+
+
+  after(:all) do
+    @app.quit if @app
+    @app = nil
+  end
+
+  let(:app){@app}
+
+  describe "#initialize" do
+    it "with no options visible is true" do
+      app = Microstation::App.new
+      app.should be_visible
+    end
+
+    it "works with options" do
+      app = Microstation::App.new(:visible => false)
+      app.should_not be_visible
+    end
+
+  end
+
+  describe "#can_open?" do
+
+
+    it "can open a dwg file" do
+      app.can_open?('test.dwg').should be_true
+    end
+
+    it "can open a dgn file" do
+      app.can_open?('test.dgn').should be_true
+    end
+
+    it "can't open any other type of files" do
+      %w(xls doc txt png tiff odf).each do |format|
+        app.can_open?("test.#{format}").should be_false
+      end
+    end
+  end
+
+  describe "#open_drawing" do
+
+    after(:each) do
+      app.close_active_drawing
+    end
+
+
+    let (:valid_file){ @existing_drawing_path }
+    let (:invalid_file) {"bogus file"}
+
+    it "returns a drawing if drawing exists" do
+      drawing = app.open_drawing(valid_file)
+      drawing.class.should == Microstation::Drawing
+      app.active_design_file.should.eql? drawing.ole_obj
+    end
+
+    it "raises error if drawing does not exist" do
+      expect {
+        app.open_drawing(invalid_file)
+      }.to raise_error
+    end
+
+    describe "when given a block" do
+
+      it "yields the drawing to a block if a block is given" do
+        app.open_drawing(valid_file) do |drawing|
+          drawing.class.should == Microstation::Drawing
+          app.active_design_file.should.eql? drawing.ole_obj
+        end
+      end
+
+
+      it "closes drawing after block returns" do
+        app.active_design_file.should == nil
+        app.open_drawing(valid_file) do |drawing|
+          app.active_design_file.should.eql? drawing.ole_obj
+        end
+        app.active_design_file.should == nil
+      end
+
+    end
+
+  end
+
+  it "has an ole_object" do
+    app.ole_obj.class.should == ::WIN32OLE
+  end
+
+  describe "load constants" do
+    it "should load the constants" do
+      app.load_constants
+      Microstation::MSD::MsdElementTypeTag.should == 37
+    end
+  end
+
+  describe "create_scanner" do
+    it "should yield a scanner object" do
+      app.create_scanner do |scan|
+        scan.should be_instance_of Microstation::Scan::Criteria
+        scan.include_tags
+        scan.include_color(3)
+      end
+
+    end
+  end
+
+
+
+
+  describe "#create_ole_scanner" do
+    it "returns an ole scanner" do
+      pending
+      scanner = app.create_ole_scan_criteria
+      scanner.ole_type.to_s.should =~ /_ElementScanCriteria/
+    end
+  end
+
+  describe "#normalize_name(name)" do
+
+    it "returns the name if the name is absolute" do
+      app.normalize_name("c:/my_drawings/cool.dng").to_s.should == "c:/my_drawings/cool.dgn"
+    end
+
+    context "when given a relative path and project dir is set" do
+      it "returns the name joined with the project_dir" do
+        app.project_dir = "c:/projects/new"
+        app.normalize_name('cool_beans.dng').to_s.should == "c:/projects/new/cool_beans.dgn"
+      end
+
+    end
+
+    context "when project_dir is nil" do
+      it "returns name relative to the calling process" do
+        app.project_dir = nil
+        app.normalize_name('cool_beans.dng').to_s.should == (Pathname.getwd + 'cool_beans.dgn').to_s
+      end
+    end
+  end
+
+  it "#windows path  method" do
+    pending
+    app.windows_path( drawing_path("")).should == "c:\\test"
+  end
+
+
+  it "should have a #username" do
+    app.username.should == ENV["USERNAME"]
+  end
+
+  describe "#new_drawing" do
+    # before(:each) do
+    #   @new_name = "my_new_drawing.dgn"
+    #   @new_drawing_path = drawing_path(@new_name)
+    #   @existing_drawing_path = drawing_path('test.dgn')
+    # end
+
+    after(:each) do
+      app.close_active_drawing
+     # File.delete(@new_drawing_path) if File.exist?(@new_drawing_path)
+    end
+
+    let(:existing_drawing){ @existing_drawing_path }
+    let(:new_drawing) { @new_drawing_path }
+
+
+    it "needs a filename" do
+      expect{ app.new_drawing()}.to raise_error
+    end
+
+    it "raises an error if drawing exists" do
+      expect {
+        app.new_drawing(existing_drawing).to raise_error
+      }
+    end
+
+    it "creates a drawing if it's a new drawing_name" do
+      drawing = app.new_drawing(new_drawing)
+      drawing.should be_an_instance_of Microstation::Drawing
+    end
+
+    describe "when given a block" do
+
+      it "yields the drawing to a block if a block is given" do
+        app.new_drawing(new_drawing) do |drawing|
+          drawing.class.should == Microstation::Drawing
+          app.active_design_file.should.eql? drawing.ole_obj
+        end
+      end
+
+
+      it "closes drawing after block returns" do
+        app.active_design_file.should == nil
+        app.new_drawing(new_drawing) do |drawing|
+          app.active_design_file.should.eql? drawing.ole_obj
+        end
+        app.active_design_file.should == nil
+      end
+
+    end
+
+  end
+
+  describe "an app with an open drawing" do
+    before(:each) do
+      @drawing = app.new_drawing(@new_drawing_path)
+    end
+
+    after(:each) do
+      app.close_active_drawing
+    #  File.delete(@new_drawing_path) if File.exist? (@new_drawing_path)
+    end
+
+    describe "#scan" do
+      it "defaults to all objects without a scan criteria" do
+        pending
+        expect{app.scan}.to_not raise_error
+      end
+
+      it "resolves the scan criteria" do
+        scanner = app.create_scanner do |scan|
+          scan.include_textual
+        end
+        scanner.should_receive("resolve")
+        app.scan(scanner)
+      end
+
+
+
+    end
+
+    # describe "#current_drawing" do
+    #   it "returns the current drawing" do
+    #     binding.pry
+    #     app.current_drawing.should == @drawing
+    #   end
+
+    # end
+
+
+
+
+  end
+
+  # it "forwards method missing" do
+
+  #   @app.ole_obj.should_receive("Open")
+  #   @app.Open("this is a drawing")
+
+
+  # end
+
+
+end
+

data/spec/configuration_spec.rb

@@ -0,0 +1,122 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+require 'pry'
+
+describe Microstation::Configuration do
+
+  before(:all) do
+    @app = Microstation::App.new
+    @configuration = Microstation::Configuration.new(@app)
+    @defined_variable = "new_variable"
+    @defined_variable_value = "variable_value"
+    @configuration[@defined_variable] = @defined_variable_value
+    @undefined_variable = 'undefined'
+    @configuration.remove_variable('undefined')
+  end
+
+  after(:all) do
+    @configuration.remove_variable(@defined_variable)
+    @app.quit
+  end
+
+
+  describe "#exists" do
+    let(:variable){ @defined_variable}
+    let(:undefined){ @undefined_variable}
+    subject { @configuration}
+
+    it "should return true if config variable is exists" do
+      subject.exists?(variable).should be_true
+    end
+
+    it "should return false if config variable doesn't exist" do
+      subject.exists?(undefined).should be_false
+    end
+
+  end
+
+  describe "#[]" do
+    let(:undefined){ @undefined_variable}
+    let(:variable){ @defined_variable}
+    subject{@configuration}
+
+    it "should check if value exists" do
+      subject.should_receive(:exists?).with('undefined')
+      expect(subject[undefined]).to be_nil
+    end
+
+    it "should return the configuration variable if exists" do
+      expect(subject[variable]).to eq 'variable_value'
+    end
+
+    it "should return nil if not exists" do
+      expect(@configuration[undefined]).to equal nil
+    end
+
+
+  end
+
+  describe "#should update" do
+
+    let(:undefined){@undefined}
+    let(:variable){@defined_variable}
+
+    it "should return true if key doesn't exist" do
+      @configuration.should_update?(undefined).should be_true
+    end
+
+    it "should return false if key exists? and options[:force] is false or nil" do
+      @configuration.should_update?(variable).should be_false
+    end
+
+    it "should return true if key exists? and options[:force] is true" do
+      @configuration.should_update?(variable, {:force => true}).should be_true
+    end
+
+  end
+
+  describe "setting variables" do
+
+    before(:each) do
+      @variable = "TEST_VARIABLE"
+      @configuration.remove_variable(@variable)
+    end
+
+    context "value not existing yet" do
+
+      it "should set the variable" do
+        @configuration[@variable].should == nil
+        @configuration[@variable] = "a new variable"
+        @configuration[@variable].should == "a new variable"
+      end
+
+    end
+
+    context "value existing" do
+
+      let(:variable){@defined_variable}
+      subject{ @configuration}
+
+      it "should raise variable defined if force option is false" do
+        @configuration[variable].should == 'variable_value'
+        expect{ @configuration[variable]= "my new value"}.to raise_error  Microstation::VariableDefined
+        @configuration[variable].should == "variable_value"
+      end
+
+      it "should change the variable if force is true"  do
+        @configuration[variable].should == "variable_value"
+        @configuration.set(variable, "my new value", :force => true)
+        @configuration[variable].should == "my new value"
+      end
+
+    end
+
+    describe "#expand" do
+      it "should be able to expand string" do
+        @configuration.expand( "$(_USTN_USER)$(_USTN_USERNAME).txt").should_not be_nil
+
+      end
+
+    end
+
+  end
+end

data/spec/drawing_spec.rb

@@ -0,0 +1,247 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+
+module DrawingHelpers
+
+  def create_new_drawing_path(name)
+    path = drawing_path(name)
+    File.delete(path) if File.exist? path
+    return path
+  end
+
+end
+
+describe Microstation::Drawing do
+  include DrawingHelpers
+
+  context "a drawing created with app.new_drawing" do
+
+    before(:all) do
+      @app = Microstation::App.new
+      #     debugger
+      @drawing_name = 'my_new_drawing.dgn'
+      @new_drawing_path = create_new_drawing_path('my_new_drawing.dgn')
+      @new_drawing = @app.new_drawing(@new_drawing_path)
+    end
+
+    after(:all) do
+      @app.close_active_drawing if @app
+      @app.quit if @app
+      File.delete(@new_drawing_path) if File.exist?(@new_drawing_path || "")
+    end
+
+    let(:new_drawing) { @new_drawing}
+    let(:new_drawing_path) { @new_drawing_path }
+    let(:new_drawing_name) {@drawing_name}
+
+    # describe "#name and path" do
+
+
+
+
+    #   context "when given a relative name and no project_dir" do
+    #     before(:each) do
+    #       @app.project_dir = nil
+    #       @drawing_name = "my drawing.dgn"
+    #       @path = @app.normalize_name(@drawing_name)
+
+    #     end
+
+    #     after(:each) do
+    #       @path.unlink
+    #     end
+
+    #     subject{@app.new_drawing(@drawing_name) }
+
+
+    #     it "#name should be set to the name of the drawing with .dgn extension" do
+    #       subject.name.should =~ "my drawing.dgn"
+    #     end
+
+    #     it "#path should be the working path" do
+    #       subject.path.should == Pathname.getwd
+    #     end
+
+    #   end
+
+    #   context "when given a relative name and a project_dir" do
+
+    #     before(:each) do
+    #       @app.project_dir = "c:/my_projects/"
+    #       @new_drawing = @app.new_drawing('my drawing')
+    #     end
+
+    #     after(:each) do
+    #       File.delete(@new_drawing.full_path)
+    #     end
+
+
+    #     it "name should be the name of the drawing" do
+    #       @new_drawing.name.should == 'my drawing.dng'
+    #     end
+
+    #     it "path should == the project_dir" do
+    #       drawing.path.should == "c:\\my_projects"
+    #     end
+
+    #   end
+    # end
+
+    it "should be the active drawing" do
+      new_drawing.should be_active
+    end
+
+    describe "#author" do
+
+      it "should be '' to start" do
+         pending
+        new_drawing.author.should == ""
+      end
+
+      it "should set author if given a new author" do
+        new_drawing.author = "A newer author"
+        new_drawing.author.should == "A newer author"
+      end
+
+    end
+
+    describe "#title" do
+      it "should be '' to start" do
+        new_drawing.title.should == ""
+      end
+
+      it "should set title if given a new title" do
+        new_drawing.title = "a new title"
+        new_drawing.title.should == "a new title"
+      end
+
+    end
+
+    describe "#keywords" do
+      it "should be empty to start" do
+        new_drawing.keywords.should == ""
+      end
+
+      it "should set keywords if given a string of words" do
+        new_drawing.keywords = "project, rcl, new"
+        new_drawing.keywords.should == "project, rcl, new"
+      end
+    end
+
+
+    it "should have a #comments method" do
+      new_drawing.comments.should == ""
+      new_drawing.comments = "these are the comments"
+      new_drawing.comments.should == "these are the comments"
+    end
+
+
+
+
+    it "should have a two_d? method" do
+      new_drawing.should be_two_d
+    end
+
+    it "should be able to save as pdf" do
+      new_drawing.save_as_pdf
+    end
+
+    describe "revision count" do
+      it "should have a revision_count" do
+        new_drawing.should respond_to "revision_count"
+      end
+
+      it "should forward method" do
+        new_drawing.ole_obj.should_receive("DesignRevisionCount").and_return(0)
+        new_drawing.revision_count
+      end
+    end
+
+    describe "pdf_name" do
+      it "should be the passed in dirname + name with pdf changed for ext" do
+        new_drawing.pdf_name("my_name","output").to_s.should == File.expand_path(File.join('output', "my_name.pdf"))
+      end
+
+      it "should == the name of the drawing file #basename with pdf ext with no args" do
+        new_drawing.stub(:basename).and_return "Drawing Name"
+        File.extname(new_drawing.pdf_name).should == '.pdf'
+        File.basename(new_drawing.pdf_name, '.pdf').should == "Drawing Name"
+      end
+
+    end
+
+
+    context "save_as_pdf" do
+      it "should use the filename if given in args" do
+        new_drawing.save_as_pdf("testfile")
+      end
+    end
+
+    describe "scanning" do
+
+    it "should have a #create_scanner" do
+      scanner = new_drawing.create_scanner
+      scanner.include_textual
+      end
+
+      it "should scan the drawing" do
+        scanner = new_drawing.create_scanner do |scan|
+          scan.include_textual
+        end
+        new_drawing.scan(scanner)
+      end
+    end
+
+
+    describe "#scan_text" do
+
+      it "only yields textual items" do
+
+        new_drawing.scan_text do |item|
+          item.class.should == (Microstation::Text || Microstation::TextNode)
+        end
+      end
+    end
+
+
+
+  end
+end
+
+
+
+
+
+
+    # describe "#new_drawing" do
+    #   before(:each) do
+    #     ENV["USERNAME"] = "test person"
+    #   end
+
+    #   after(:each) do
+    #     @drawing.close
+    #     @drawing =  nil
+    #   end
+
+    #   it "should set author" do
+    #     @app.should_receive(:username).and_return("test person")
+    #     @drawing = @app.new_drawing(new_drawing_path)
+    #     @drawing.author.should == "test person"
+    #   end
+
+    # end
+
+    # describe "creating  a new drawing" do
+    #   before(:each) do
+    #     @drawing = @app.new_drawing(new_drawing_path)
+    #   end
+
+    #   after(:each) do
+    #     @drawing.close
+    #     @drawing = nil
+    #   end
+
+
+
+
+
+