microstation 0.4.1 → 0.8.6

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

data/spec/microstation_spec.rb

@@ -1,36 +1,47 @@
-#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
-
-
+# frozen_string_literal: true
+
+require_relative 'spec_helper'
+
+
+describe Microstation do
+  describe '#root' do
+    subject { Microstation.root }
+
+    it 'to_s' do
+      _(subject.to_s).must_equal(Pathname.getwd.to_s)
+    end
+  end
+
+  describe '#run' do
+    it 'opens up and yields an app' do
+      result = nil
+      Microstation.run do |app|
+        _(app).must_be_instance_of(Microstation::App)
+      end
+    end
+  end
+
+  describe '#get_text' do
+    let(:drawing_with_text) { drawing_path('drawing_with_text.dgn') }
+    let(:drawing_no_text) { drawing_path('drawing_no_block.dgn') }
+    let(:text_for_drawing_with_text){ [
+                                        "Four score and seven years ago our fathers brought forth",
+                                        "Out out brief candle\nLifes but a walking shadow",
+                                        "It is my lady, it is my love\nOh that she knew she were"
+                                      ]
+    }
+
+    describe 'when drawing has text' do
+      it 'returns the text' do
+        text = Microstation.get_text(drawing_with_text)
+        _(text.sort).must_equal(text_for_drawing_with_text.sort)
+      end
+    end
+
+    describe 'when drawing has no text' do
+      it 'returns an empty array' do
+        _(Microstation.get_text(drawing_no_text)).must_equal([])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,31 +1,97 @@
-# 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
-
-
+# frozen_string_literal: true
+
+require 'pathname'
+SPEC_DIR = Pathname(__dir__).expand_path
+ROOT_DIR = SPEC_DIR.parent
+DRAWING_DIR = ROOT_DIR +  'cad_files'
+OUTPUT_DIR = ROOT_DIR + 'test_outdir'
+TEMP_DIR = ROOT_DIR + 'tmp'
+
+require 'bundler/setup'
+$LOAD_PATH.unshift( ROOT_DIR + 'lib')
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/hooks/default'
+require 'microstation'
+require 'pry'
+def drawing_path(file)
+  (DRAWING_DIR + file).expand_path
+end
+
+def output_path(file = nil)
+  if file
+    (OUTPUT_DIR + file).expand_path.to_s
+  else
+    OUTPUT_DIR
+  end
+end
+
+def seedfile_path(file)
+  drawing_path(file)
+end
+
+def normalize_path(p)
+  p.to_s.sub(/[c,C]:/, 'C:')
+end
+
+def config_app(app)
+  conf = app.configuration
+  conf.prepend('MS_SEEDFILES', DRAWING_DIR)
+  # conf.set!('MS_DESIGNSEED','seed2d')
+end
+
+def open_existing_drawing(name)
+  path = drawing_path(name)
+  raise "drawing #{name} doesn't exist" unless File.file?(path)
+
+  @app.open_drawing(path)
+end
+
+def new_drawing(name, seedfile: 'seed2d' )
+  seed_path = (drawing_path(seedfile) if seedfile)
+  begin
+    @app.close_active_drawing
+  rescue StandardError
+    nil
+  end
+  @path = output_path(name)
+  File.delete(@path) if File.exist? @path
+  @app.new_drawing(@path, seedfile: seed_path)
+end
+
+def non_existent_path(name)
+  path = drawing_path(name)
+  File.delete(path) if File.exist? path
+  path
+end
+
+def delete_current_drawing
+  if drawing = @app.current_drawing
+    path = drawing.path
+    begin
+      @app.close_active_drawing
+    rescue StandardError
+      nil
+    end
+    begin
+      File.delete path
+    rescue StandardError
+      nil
+    end
+  end
+end
+
+def before_new_drawing
+  @app.close_active_drawing
+  begin
+    File.delete(@path)
+  rescue StandardError
+    nil
+  end
+end
+
+# def before_new_drawing
+#   @app.close_active_drawing
+#   File.delete(@drawing_path) if (@drawing_path && File.exist? @drawing_path)
+# end