microstation 0.8.3 → 0.8.4

data/spec/microstation/functions_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+
+describe 'points by rectangle' do
+  include Minitest::Hooks
+
+  before(:all) do
+  @app = Microstation::App.new(visible: true)
+  config_app(@app)
+  end
+
+  after(:all) do
+    delete_current_drawing
+    @app.quit rescue nil
+  end
+
+  let(:app) { @app }
+
+  it 'should be a function on app' do
+    skip
+    require 'pry'; binding.pry
+    drawing = app.new_drawing('temp.dgn')
+    pts = app.get_points_by_rectangle
+    puts pts.value
+  end
+
+  describe '#points_by_line' do
+    it 'should not error' do
+      skip
+      drawing = app.new_drawing('temp.dgn')
+      require 'pry'; binding.pry
+      pts = app.get_points_by_line
+    end
+  end
+end

data/spec/microstation/tag_set_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+
+describe 'Lets start the Microstation once' do
+  include Minitest::Hooks
+  before(:all) do
+    @app = Microstation::App.new
+    config_app(@app)
+  end
+
+  after(:all) do
+    @app.quit rescue nil
+  end
+
+  describe 'a new drawing' do
+    let(:drawing) { new_drawing('temp.dgn', seedfile: 'seed2d') }
+
+    describe 'creating a new tag set' do
+      let(:tagsets) { drawing.tagsets }
+
+      it 'should have no initial tagsets' do
+        _(tagsets.size).must_equal 0
+      end
+
+      it 'should create a tagset' do
+        ts = tagsets.create('test')
+        _(ts).must_be_instance_of Microstation::TagSet
+      end
+
+      it 'should be the same as a found tagset' do
+        ts = tagsets.create('test')
+        _(tagsets['test']).must_equal ts
+      end
+
+      it 'should allow you to remove a tagset' do
+        tagsets.create('test')
+        _(tagsets.size).must_equal 1
+        tagsets.remove('test')
+        _(tagsets.size).must_equal 0
+      end
+    end
+
+    describe 'A TagSet' do
+      let(:drawing) { new_drawing('temp.dgn', seedfile: 'seed2d') }
+
+      describe '#create_tagset' do
+        it 'should allow you to create' do
+          ts = drawing.create_tagset('faatitle')
+          _(ts).must_be_instance_of Microstation::TagSet
+        end
+
+        it 'should yield to block if block_given' do
+          drawing.create_tagset('faatitle') do |ts|
+            _(ts).must_be_instance_of Microstation::TagSet
+          end
+        end
+
+        describe 'given a TagSet' do
+          let(:tagset) { drawing.create_tagset('faatitle') }
+
+          it 'should initially have no attributes' do
+            _(tagset.attributes).must_be_empty
+          end
+
+          it '#add_attribute adds TS::Attribute' do
+            _(tagset.attributes).must_be_empty
+            td = tagset.add_attribute('title', String, prompt: 'My title')
+            _(td.prompt).must_equal('My title')
+            _(tagset.attributes.size).must_equal 1
+            _(td).must_be_instance_of Microstation::TS::Attribute
+          end
+
+          it 'should exist and can be found in drawing' do
+            tagset_local = tagset
+            ts = drawing.find_tagset('faatitle')
+            _(ts.name).must_equal tagset_local.name
+          end
+        end
+
+        describe 'given a tagset with tag defintions' do
+          let(:tagset) { drawing.create_tagset('faatitle') }
+
+          before do
+            tagset.add_attribute('title', String)
+            tagset.add_attribute('city', String)
+          end
+
+          describe '#attributes' do
+            it 'should have the correct size' do
+              _(tagset.attributes.size).must_equal 2
+            end
+
+            it '#attributes should be Array of TS::Attributes' do
+              tagset.attributes.each do |ta|
+                _(ta).must_be_instance_of Microstation::TS::Attribute
+              end
+            end
+          end
+
+          describe '#attribute_names' do
+            it 'returns an array of the correct names' do
+              _(tagset.attribute_names).must_equal %w[title city]
+            end
+          end
+
+          describe '#[]' do
+            it 'should allow you to retrieve a tagset definition that exists' do
+              _(tagset['title']).must_be_instance_of Microstation::TS::Attribute
+            end
+
+            it "returns nil if attribute doesn't exist" do
+              _(tagset['bogus']).must_be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe 'a drawing with tagsets placed in drawing' do
+    let(:drawing) { open_existing_drawing('drawing_with_block.dgn') }
+    let(:tagsets) { drawing.tagsets }
+    let(:tset) { tagsets.first }
+
+    it 'has tagsets' do
+      _(tagsets).wont_be_empty
+    end
+
+    it 'has the correct tagsets' do
+      _(tagsets.size).must_equal 1
+      _(tset.name).must_equal 'electrical_panel_42'
+    end
+
+    it 'has tagset instances' do
+      _(tset.instances.size).must_equal 1
+      tagset_instance = tset.instances.first
+      _(tagset_instance.name).must_equal 'electrical_panel_42'
+      _(tagset_instance).must_be_instance_of Microstation::TS::Instance
+    end
+  end
+
+  describe 'a drawing with 3 instances of same tagset in drawing' do
+    let(:drawing) { open_existing_drawing('drawing_with_3_block.dgn') }
+    let(:tagsets) { drawing.tagsets }
+    let(:tset) { tagsets.first }
+
+    it 'has the correct number of tagsets' do
+      _(tagsets.size).must_equal 1
+      _(tagsets.names).must_equal %w[electrical_panel_42]
+      _(tset.name).must_equal 'electrical_panel_42'
+    end
+
+    it 'has the correct instances' do
+      _(tset.instances.size).must_equal 3
+      _(tset.instances.map(&:name)).must_equal %w[electrical_panel_42 electrical_panel_42 electrical_panel_42]
+    end
+  end
+end

data/spec/microstation/template_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+require 'fileutils'
+require 'digest/md5'
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'microstation/template'
+
+module TestHelper
+  def digest_for_path(file)
+    Digest::MD5.hexdigest(File.read(file))
+  end
+
+  def file_same?(p, p2)
+    digest_path(p) == digest_path(p2)
+  end
+end
+
+describe Microstation::Template do
+  include TestHelper
+
+  describe 'initialization' do
+    it 'needs a drawing argument' do
+      assert_raises { Microstation::Template.new }
+    end
+
+    it 'requires a valid and existing  microstation file' do
+      %w[draw.dgn file://adoc.doc file://anexcel.xls file://autocad.dwg].each do |ftype|
+        assert_raises { Microstation::Template.new(ftype) }
+      end
+    end
+
+    describe 'given a good dgn file and file exists' do
+      let(:file) { 'file.dgn' }
+
+      it 'does not error' do
+        mock = Minitest::Mock.new
+        mock.expect(:file?, true)
+        File.stub :file?, true do
+          Microstation::Template.new(file)
+        end
+      end
+
+      it 'sets the template' do
+        mock = Minitest::Mock.new
+        mock.expect(:file?, true)
+        File.stub :file?, true do
+          temp = Microstation::Template.new(file)
+          _(temp.template).must_equal(file)
+        end
+      end
+    end
+  end
+
+  describe 'a drawing with tags' do
+    before do
+      @dgn_name = 'drawing_with_block.dgn'
+      @dgn_file = drawing_path('drawing_with_block.dgn')
+      @template = Microstation::Template.new(@dgn_file)
+    end
+
+    subject { @template }
+
+    describe '.render' do
+      let(:dgn_name) { @dgn_name }
+      let(:template) { @template }
+      let(:dgn_file) { @dgn_file }
+      let(:copied_file) { drawing_path('copied_file.dgn') }
+      let(:output_file) { output_path(dgn_name) }
+      let(:changed_name) { 'changed_name.dgn' }
+      let(:locals) do
+        { 'a1' => 'change 1', 'a2' => 'change 2',
+          'a3' => 'c3', 'a4' => 'c4' }
+      end
+
+      before do
+        FileUtils.rm(copied_file) if File.exist? copied_file
+        FileUtils.cp(dgn_file, copied_file)
+        FileUtils.rm(output_file) if File.exist? output_file
+        FileUtils.rm(output_path(changed_name)) if File.exist?(output_path(changed_name))
+      end
+
+      after do
+        FileUtils.rm(output_file) if File.exist? output_file
+        FileUtils.rm(output_path(changed_name)) if File.exist?(output_path(changed_name))
+      end 
+
+      it "it doesn't error" do
+        template.render(output_dir: OUTPUT_DIR)
+      end
+
+      describe 'when locals or tagsets not input' do
+        it 'does nothing unless either locals or tagsets' do
+          template.render(output_dir: OUTPUT_DIR)
+          _(File.file?(output_file)).must_equal false
+        end
+      end
+
+      describe 'when locals or tagset is set' do
+        it 'creates a file' do
+          template.render(output_dir: OUTPUT_DIR, locals: locals)
+          _(File.file?(output_file)).must_equal true
+        end
+
+        it 'changes text' do
+          template.render(output_dir: OUTPUT_DIR,
+                          locals: { 'a1' => 'change 1', 'a2' => 'change 2', 'a3' => 'c3', 'a4' => 'c4' })
+          text = Microstation.get_text(output_file)
+          ['text1 change 1', 'text2 change 2', 'text3 c3', "node1 c4\nnode1 ", "node2 \nnode2 ",
+           'text a1 again change 1'].each do |t|
+            _(text).must_include(t)
+          end
+        end
+
+        it "doesn't change input file" do
+          template.render(output_dir: OUTPUT_DIR, locals: locals)
+          _(FileUtils.compare_file(dgn_file, copied_file)).must_equal true
+        end
+
+        it 'changes the output' do
+          template.render(output_dir: OUTPUT_DIR, locals: locals)
+          _(FileUtils.compare_file(output_file, copied_file)).must_equal false
+        end
+      end
+
+      describe 'a drawing with multiple blocks of the same block' do
+        # before :all do
+        #   @dgn_file = drawing_path('drawing_with_block.dgn')
+        #   @template = Microstation::Template.new(@dgn_file)
+        # end
+
+        let(:filename) { 'drawing_with_3_block.dgn' }
+        let(:drawing_file) { drawing_path(filename) }
+        let(:template) { Microstation::Template.new(drawing_file) }
+        let(:output_file) { output_path(filename) }
+
+        before do
+          FileUtils.rm(output_file) if File.exist? output_file
+        end
+
+        it 'updates the drawing_blocks' do
+          panel = { 'brk_1_service' => 'OUTLETS',
+                    'brk_2_service' => 'AIR CONDITIONER',
+                    'microstation_id' => 324 }
+          template.render(output_dir: OUTPUT_DIR, tagsets: [{ 'electrical_panel_42' => panel }])
+          Microstation.run do |app| 
+            drawing = app.open_drawing(output_file)
+            ts = drawing.find_tagset_instance_by_name_and_id('electrical_panel_42', 324)
+            _(ts.brk_2_service).must_equal('AIR CONDITIONER')
+          end
+        end
+      end
+      
+    end
+  end
+end

data/spec/microstation/text_node_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+
+describe 'Microstation::TextNode' do
+  include Minitest::Hooks
+  before(:all) do
+    @app = Microstation::App.new
+    config_app(@app)
+  end
+
+  after(:all) do
+    @app.quit rescue nil
+  end
+
+  describe 'given a TextNode' do
+    let(:app) { @app }
+    let(:scanner) { app.create_scanner(:text, &:include_text_nodes) }
+    let(:drawing) { open_existing_drawing('drawing_with_text.dgn') }
+    let(:text_node) { drawing.scan_model(scanner).find { |t| !t.empty? } }
+
+    it 'should forward Capitalized methods to @ole_obj' do
+      ole = Minitest::Mock.new
+      ole.expect(:Type, 'A ole type')
+      text_node.stub(:ole_obj, ole) do
+        _(text_node.Type).must_equal 'A ole type'
+      end
+      ole.verify
+    end
+
+    describe 'ruby string methods' do
+      describe "calling with methods that don't change the string" do
+        it 'should not call the update method' do
+          skip
+          ole = Minitest::Mock.new
+          mock.expect(:update, true)
+          text_node.stub(:upcase, true)
+
+          ole = Minitest::Mock.new
+          text_node.reverse
+          text_node.downcase
+        end
+
+        it 'should give the correct value' do
+          value = text_node.to_s
+          _(text_node.reverse.to_s).must_equal(value.reverse)
+        end
+
+        it 'should retain the same value' do
+          value = text_node.to_s
+          result = text_node.reverse
+          _(text_node.to_s).must_equal(value)
+          _(text_node.to_s).wont_equal result
+        end
+      end
+
+      describe 'calling with methods that change the string' do
+        it 'should change the value' do
+          value = text_node.to_s
+          result = text_node.reverse!
+          _(text_node.to_s).must_equal(result)
+          _(text_node.to_s).wont_equal(value)
+        end
+      end
+    end
+  end
+end

data/spec/microstation/text_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+
+describe 'Microstation:Text and Microstation::TextNode' do
+  include Minitest::Hooks
+  before(:all) do
+    @app = Microstation::App.new
+    config_app(@app)
+  end
+  after(:all) do
+    @app.quit rescue nil
+  end
+
+  describe 'given a text node initialized by a scan' do
+    let(:drawing) { open_existing_drawing('drawing_with_text.dgn') }
+    let(:criteria) { @app.create_scanner(&:include_textual) }
+
+    before do
+      text_array = drawing.scan_model(criteria).to_a
+      @text = text_array.find { |t| t.instance_of?(Microstation::Text) }
+    end
+
+    let(:text) { @text }
+
+    it 'should be an instance of text' do
+      _(text).must_be_instance_of Microstation::Text
+    end
+
+    it 'should forward all the Microstation commands to ole_obj' do
+      _(text.IsTextElement).must_equal true
+    end
+
+    it 'should update the drawing if the text is changed' do
+      id = text.microstation_id
+      val = text.to_s
+      text.reverse!
+      drawing_text = drawing.find_by_id(id)
+      _(drawing_text.to_s).must_equal(val.reverse)
+    end
+  end
+end