microstation 0.4.1

data/spec/enumerator_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+
+describe "Microstation::Enumerator" do
+
+  context "given a drawing scanned with a textual criteria" do
+
+    before(:all) do
+      @app = Microstation::App.new
+      @drawing = open_existing_drawing(@app)
+      @criteria = @app.create_scanner do |scan|
+        scan.include_textual
+      end
+      
+    end
+
+    after(:all) do
+      @app.close_active_drawing
+      @app.quit
+      # path = @drawing.full_path
+      #path.delete
+    end
+
+    let(:app) { @app}
+    let(:drawing){@drawing}
+
+    describe "app.scan" do
+      it "returns an Enumerator" do
+        pending
+        enum = app.scan(@criteria)
+        enum.should be_an_instance_of Microstation::Enumerator
+      end
+
+      it "should be a text node" do
+        enum = app.scan(@criteria).to_enum
+        first = enum.next
+        first.should be_an_instance_of Microstation::Text
+      end
+
+      it "should all be textual" do
+        pending
+        enum = app.scan(@criteria)
+        values = enum.map{|i| i}
+      end
+      
+      
+    end
+
+    
+
+    
+
+    
+
+  end
+
+end
+
+
+
+

data/spec/microstation_spec.rb

@@ -0,0 +1,36 @@
+#require File.join(File.dirname(__FILE__) ,  'spec_helper')
+require 'spec_helper.rb'
+
+
+describe Microstation do
+
+  context "#root" do
+
+    subject { Microstation.root}
+
+    it { should be_instance_of Pathname}
+    it "to_s" do
+      subject.to_s.should == Pathname.getwd.to_s
+    end
+
+  end
+
+
+  describe "#run" do
+    it "opens up and yields an app" do
+      Microstation.run do |app|
+        app.class.should == Microstation::App
+      end
+    end
+
+    it "can be called with implicit receiver" do
+      Microstation.run do
+        self.class.should == Microstation::App
+      end
+    end
+
+  end
+
+end
+
+

data/spec/scanner_spec.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+
+
+describe Microstation::Scan::Criteria do
+
+  before(:all) do
+    @app = Microstation::App.new
+  end
+
+  after(:all) do
+    @app.quit
+  end
+
+  let(:app) { @app}
+
+  describe "#initialize" do
+
+    before(:each) do
+      @ole = double("scan_enum")
+      app.stub(:create_ole_scan_criteria).and_return(@ole)
+      app.stub(:load_constants)
+    end    
+
+    it "requires an app as argument" do
+      expect {
+        Microstation::Scan::Criteria.new()
+      }.to raise_error
+      
+    end
+
+    it "sets the ole_obj to the passed in ole_obj" do
+      scanner = Microstation::Scan::Criteria.new(app)
+      scanner.send(:app).should equal(app)
+    end
+
+    it "sets the ole_obj variable" do
+      scanner = Microstation::Scan::Criteria.new(app)
+      scanner.send(:ole_obj).should equal(@ole)
+    end
+
+  end
+  
+
+  describe "Microstation::Scan::Criteria" do
+    before(:each) do
+      @scanner = Microstation::Scan::Criteria.create(app)
+    end
+
+    after(:each) do
+      @scanner.close
+    end
+    
+
+    # after(:all) do
+    #   @scanner = nil
+    #   @app.quit
+    # end
+
+    let(:scanner){ @scanner}
+
+    it "removes the object from the scanner array on close" do
+      app.scanners.should have(1).item
+      app.scanners.find{|s| s == scanner}.should == scanner
+      scanner.close
+      app.scanners.should_not include(scanner)
+      scanner.ole_obj.should be_nil
+      scanner.app.should be_nil
+    end    
+
+    it "can be reset level" do
+      scanner.reset_levels
+    end
+
+    it "can reset types" do
+      scanner.reset_types
+    end
+
+    it "can reset classes" do
+      scanner.reset_classes
+    end
+
+    it "can reset all exclusions" do
+
+      %w(classes colors levels linestyles lineweights subtypes types).each do |method|
+        scanner.send("reset_#{method}")
+      end
+    end
+
+    describe 'the win32ole object' do
+      before(:each) do
+        @ole = double('ole')
+        @ole.stub('load_constants')
+        scanner.stub('ole_obj').and_return @ole
+      end
+
+      after(:each) do
+        @ole = nil
+      end
+      
+      let(:ole){@ole}      
+
+      it "can scan by type" do        
+        ole.should_receive('ExcludeAllTypes')          
+        ole.should_receive('IncludeType').with 37# Microstation::MSD::MsdElementTypeTag
+        scanner.include_tags
+        scanner.resolve        
+      end
+
+      it "can scan by color" do        
+        ole.should_receive('ExcludeAllColors')
+        ole.should_receive('IncludeColor').with(3)
+        scanner.include_color(3)
+        scanner.resolve        
+      end
+
+      it "can scan by linestyle" do        
+        ole.should_receive('ExcludeAllLineStyles')
+        ole.should_receive('IncludeLineStyle')
+        scanner.include_linestyle( scanner.linestyles[0])
+        scanner.resolve        
+      end
+
+      it "can scan by lineweight" do
+        ole.should_receive('ExcludeAllLineWeights')
+        ole.should_receive('IncludeLineWeight')
+        scanner.include_lineweight(3)
+        scanner.resolve
+      end
+
+      it "can scan by subtype" do
+        ole.should_receive('ExcludeAllSubtypes')
+        ole.should_receive('IncludeSubtype')
+        scanner.include_subtype( Microstation::MSD::MsdElementSubtypeAuxiliaryCoordinateSystem)
+        scanner.resolve
+      end
+
+      it "can scan by multiple" do
+        ole.should_receive('ExcludeAllColors')
+        ole.should_receive('IncludeColor').with(3)
+        ole.should_receive('ExcludeAllTypes')
+        ole.should_receive('IncludeType').with(37)
+        scanner.include_color(3)
+        scanner.include_tags
+        scanner.resolve
+      end
+      
+      
+      
+    end
+
+  end
+
+end
+
+

data/spec/spec_app.rb

@@ -0,0 +1,11 @@
+require_relative 'spec_helper'
+
+
+describe Microstation::App do
+  
+  it "should allow you to " do
+    app = Microstation::App.new
+    app.ole_object.class.should == WIN32OLE
+    end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+if RUBY_VERSION =~ /1\.8/
+  require 'rubygems'
+  require 'require_relative'
+  require 'ruby-debug'
+end
+require 'microstation'
+#
+DRAWING_DIR = File.join(File.dirname(__FILE__) , 'drawings')
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end
+
+def drawing_path(file)
+  drawing = File.join(DRAWING_DIR,file)
+  File.expand_path(drawing)
+end
+
+def open_existing_drawing(app)
+  app.open_drawing( drawing_path('test.dgn'))
+end
+
+

data/spec/tag_set_spec.rb

@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+require 'tempfile'
+
+
+module Helper
+
+  def create_temp_drawing
+    file = Tempfile.new('drawing.dgn')
+    file.close
+    @app.new_drawing(file.path)
+  end
+end
+
+
+
+describe Microstation::TagSet do
+
+  include Helper
+
+  before(:all) do
+    @app = Microstation::App.new
+  end
+
+  after(:all) do
+    @app.close_active_drawing if @app
+    @app.quit
+  end
+
+  describe 'a new drawing' do
+    let(:new_drawing){ create_temp_drawing}
+
+
+    context 'creating a new tag set' do
+      let(:tagsets){ new_drawing.tagsets}
+
+      it 'should have no initial tagsets' do
+        tagsets['test'].should be_nil
+      end
+
+      it 'should return a tagset' do
+        ts = tagsets.create('test')
+        ts.should be_instance_of Microstation::TagSet
+      end
+
+      it 'should be the same as a found tagset' do
+        ts = tagsets.create('test')
+        tagsets['test'].should == ts
+      end
+
+      it 'should allow you to remove a tagset' do
+        tagsets.create('test')
+        tagsets.size.should == 1
+        tagsets.remove('test')
+        tagsets.should be_empty
+      end
+
+    end
+  end
+
+  describe 'A Tag Set' do
+    let(:app) { @app}
+    let(:new_drawing){ create_temp_drawing}
+
+    describe "#create_tagset" do
+
+      it 'should allow you to create' do
+        ts = new_drawing.create_tagset('faatitle')
+        ts.should be_instance_of Microstation::TagSet
+      end
+
+      it 'should yield to block if given a block' do
+        new_drawing.create_tagset('faatitle') do |ts|
+          ts.should be_an_instance_of Microstation::TagSet
+        end
+      end
+
+      context 'given a new TagSet' do
+        let(:tagset){ new_drawing.create_tagset('faatitle')}
+
+        it 'should have no attributes' do
+          tagset.attributes.should be_empty
+        end
+
+        it 'should allow you to add new definitions' do
+          tagset.attributes.should be_empty
+          td = tagset.add_attribute('title', String, :prompt => 'My title')
+
+          td.prompt.should == 'My title'
+          tagset.attributes.size.should == 1
+        end
+
+      end
+
+
+      context 'given a tagset with tag definitions' do
+        let(:tagset){ new_drawing.create_tagset('faatitle')}
+      #  let(:td1){ tagset.definition('title',String)}
+       # let(:td2){ tagset.definition('city', String)}
+
+        it 'should have correct size' do
+          tagset.attributes.size.should == 0
+          tagset.add_attribute('title', String)
+          tagset.attributes.size.should == 1
+          tagset.add_attribute('city',String)
+          tagset.attributes.size.should == 2
+        end
+
+        it 'should allow you to retrieve a td' do
+          td = tagset.add_attribute('title', String)
+          tagset['title'].should == td
+        end
+      end
+    end
+
+  end
+
+end
+
+
+
+
+
+

data/spec/text_node_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__) ,  'spec_helper')
+
+module NodeHelper
+
+  def text_node_scanner(app)
+    app.create_scanner do |scan|
+      scan.include_text_nodes
+    end
+  end
+end
+
+
+
+
+describe "Microstation::TextNode" do
+
+  include NodeHelper
+
+  context "given a TextNode" do
+
+    before(:all) do
+      @app = Microstation::App.new
+      @scanner = text_node_scanner(app)
+    end
+    after(:all) do
+      @app.quit
+    end
+    
+
+    let(:app){ @app }
+    let(:drawing) { open_existing_drawing(app) }
+    let(:text_node) { drawing.scan(@scanner).find{|t|  !(t.empty?)  }}
+
+    it "should forward Capitalized methods to @ole_obj" do
+      ole = double('ole')
+      text_node.stub(:ole_obj).and_return(ole)
+      ole.should_receive('Type').and_return
+      text_node.Type      
+    end
+
+    describe "ruby string methods" do
+
+      context "calling with methods that don't change the string" do
+
+        it "should not call the update method" do
+          ole = double('ole')
+          text_node.stub(:ole_obj).and_return(ole)
+          text_node.should_not_receive('update_ole')
+          ole.should_not_receive("Rewrite")
+          text_node.reverse
+          text_node.downcase
+        end
+
+        it "should give the correct value" do
+          value = text_node.to_s
+          text_node.reverse.to_s.should == value.reverse
+        end
+
+        it "should retain the same value" do
+          value = text_node.to_s
+          text_node.reverse
+          text_node.to_s.should == value
+        end
+      end
+
+      context "calling with methods that change the string" do
+
+        it "should call the update method" do
+          value = text_node.to_s
+          reversed = value.reverse
+          text_node.should_receive('update_ole').with(reversed)
+          text_node.reverse!
+        end
+
+        it "should change to value" do
+          value = text_node.to_s
+          reversed = value.reverse
+          text_node.reverse!
+          text_node.to_s.should == reversed
+        end
+
+      end
+
+    end
+
+  end
+end
+
+        
+        
+        
+