microstation 0.8.5 → 0.8.7

data/lib/microstation/element.rb

@@ -1,21 +1,18 @@
-require 'microstation/property_handler'
+require "microstation/property_handler"
 
 class WIN32OLE
-
   def to_ole
     self
   end
-
 end
+
 module Microstation
 end
 
 module Microstation
-
   module ElementTrait
-
     #
-    # 
+    #
     #
     # @return [Boolean] true if ole type is Text
     #
@@ -25,7 +22,7 @@ module Microstation
 
     # @return [Boolean] true if ole type is TextNode
     def text_node?
-      ole_obj.Type  == ::Microstation::MSD::MsdElementTypeTextNode
+      ole_obj.Type == ::Microstation::MSD::MsdElementTypeTextNode
     end
 
     def has_tags?
@@ -49,9 +46,10 @@ module Microstation
       text? || text_node?
     end
 
-    def microstation_id()
+    def microstation_id
       id = ole_obj.Id || ole_obj.ID64
       return nil unless id
+
       id_from_record(id)
     end
 
@@ -67,18 +65,16 @@ module Microstation
     def parent
       parent_id = ole_obj.ParentID
       return nil unless parent_id
+
       id = id_from_record(parent_id)
       app.active_design_file.find_by_id(id)
     end
 
     def id_from_record(id)
-      if id.class == WIN32OLE_RECORD
-        if id.Low > id.High
-          return id.Low
-        else
-          return id.High
-        end
-      end
+      return unless id.instance_of?(WIN32OLE_RECORD)
+      return id.Low if id.Low > id.High
+
+      id.High
     end
 
     def select
@@ -93,55 +89,52 @@ module Microstation
       ole_obj.Type
     end
 
-
     def model
       Model.new(app, app.current_drawing, ole_obj.ModelReference)
     end
-
   end
 
   class Element
-
     include ElementTrait
 
-    def self.convert_item(ole,app, cell=nil)
-      return Point3d.from_ole(ole) if ole.class == WIN32OLE_RECORD && ole.typename == 'Point3d'
-      return ole unless ole.class == WIN32OLE
+    def self.convert_item(ole, app, cell = nil)
+      return Point3d.from_ole(ole) if ole.instance_of?(WIN32OLE_RECORD) && ole.typename == "Point3d"
+      return ole unless ole.instance_of?(WIN32OLE)
+
       case ole.Type
       when ::Microstation::MSD::MsdElementTypeText
-        ::Microstation::Text.new(ole,app,cell)
+        ::Microstation::Text.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeLine
-        ::Microstation::Line.new(ole,app,cell)
+        ::Microstation::Line.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeTextNode
-        ::Microstation::TextNode.new(ole,app,cell)
+        ::Microstation::TextNode.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeTag
-        ::Microstation::Tag.new(ole,app,cell)
+        ::Microstation::Tag.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeCellHeader
-        ::Microstation::Cell.new(ole,app,cell)
+        ::Microstation::Cell.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeSharedCell
-        ::Microstation::Cell.new(ole,app,cell)
+        ::Microstation::Cell.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeArc
-        ::Microstation::Arc.new(ole,app,cell)
+        ::Microstation::Arc.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeEllipse
-        ::Microstation::Ellipse.new(ole,app,cell)
+        ::Microstation::Ellipse.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeBsplineSurface
-        ::Microstation::BSplineSurface.new(ole,app,cell)
+        ::Microstation::BSplineSurface.new(ole, app, cell)
       when ::Microstation::MSD::MsdElementTypeBsplineCurve
-        ::Microstation::BSplineCurve.new(ole,app,cell)
+        ::Microstation::BSplineCurve.new(ole, app, cell)
 
       else
-        new(ole,app,cell)
+        new(ole, app, cell)
       end
     end
 
     def self.ole_object?
-      ole.class == WIN32OLE
+      ole.instance_of?(WIN32OLE)
     end
 
-
     attr_reader :ole_obj, :app, :original
 
-    def initialize(ole,app, cell = nil)
+    def initialize(ole, app, cell = nil)
       @ole_obj = ole
       @original = read_ole(ole)
       @app = app
@@ -153,23 +146,20 @@ module Microstation
     end
 
     def read_ole(ole)
-
     end
 
     def write_ole(value)
-
     end
 
-    def method_missing(meth,*args,&block)
-      if meth.to_s =~ /^[A-Z]/
-        result = ole_obj.send(meth,*args,&block)
-        Element.convert_item(result,app)
+    def method_missing(meth, *args, &block)
+      if /^[A-Z]/.match?(meth.to_s)
+        result = ole_obj.send(meth, *args, &block)
+        Element.convert_item(result, app)
       else
-        super(meth,*args,&block)
+        super(meth, *args, &block)
       end
     end
 
-
     def get_property_handler
       ph_ole = app_ole_obj.CreatePropertyHandler(ole_obj)
       PropertyHandler.new(ph_ole)
@@ -183,15 +173,14 @@ module Microstation
       property_handler[name]
     end
 
-
     def do_update(value)
       return false if value == original
+
       saved_original = original
       begin
         write_ole(value)
         @original = read_ole(ole_obj)
-        return true
-
+        true
       rescue => e
         @original = saved_original
         false
@@ -231,65 +220,63 @@ module Microstation
       ole.IsCellElement || ole.IsSharedCellElement
     end
 
-    def each_cell(ole,&block)
+    def each_cell(ole, &block)
       cell = ole if ole_cell(ole)
-      ole.ResetElementEnumeration rescue binding.pry
+      begin
+        ole.ResetElementEnumeration
+      rescue
+        binding.pry
+      end
       while ole.MoveToNextElement
         component = ole.CopyCurrentElement
         if component.IsTextNodeElement
-          yield Microstation::Wrap.wrap(component.AsTextNodeElement,app,cell)
+          yield Microstation::Wrap.wrap(component.AsTextNodeElement, app, cell)
         elsif component.IsTextElement
-          yield  Microstation::Wrap.wrap(component.AsTextElement,app,cell)
+          yield Microstation::Wrap.wrap(component.AsTextElement, app, cell)
         elsif component.IsComplexElement
           each(component)
         else
-          yield  Microstation::Wrap.wrap(component,app,cell)
+          yield Microstation::Wrap.wrap(component, app, cell)
         end
       end
     end
 
-    def each(ole = ole_obj,&block)
+    def each(ole = ole_obj, &block)
       return unless ole.IsComplexElement
-      return to_enum(:each) unless block_given?
+      return to_enum(:each) unless block
+
       if ole.IsCellElement
-        each_cell(ole,&block)
+        each_cell(ole, &block)
       else
-        each_complex(ole,&block)
+        each_complex(ole, &block)
       end
     end
 
-    def each_complex(ole,&block)
+    def each_complex(ole, &block)
       cell = nil
       components = ole.GetSubElements
       while components.MoveNext
         component = components.Current
         if component.IsTextNodeElement
-          yield Microstation::Wrap.wrap(component.AsTextNodeElement,app,cell)
+          yield Microstation::Wrap.wrap(component.AsTextNodeElement, app, cell)
         elsif component.IsTextElement
-          yield  Microstation::Wrap.wrap(component.AsTextElement,app,cell)
+          yield Microstation::Wrap.wrap(component.AsTextElement, app, cell)
         elsif component.IsComplexElement
-          each(component,&block)
+          each(component, &block)
         else
-          yield  Microstation::Wrap.wrap(component,app,cell)
+          yield Microstation::Wrap.wrap(component, app, cell)
         end
       end
     end
-
   end
 
-
   class App
-
     def ole_to_ruby(ole)
-      Element.convert_item(ole,self)
+      Element.convert_item(ole, self)
     end
-
   end
-
 end
 
-
-
 module Microstation
   class Arc < Element
   end

data/lib/microstation/enumerator.rb

@@ -1,32 +1,27 @@
-require_relative 'wrap'
+require_relative "wrap"
 
 module Microstation
-
   class Enumerator
-
     include Enumerable
 
     attr_reader :app
 
-    def initialize(ole,app)
+    def initialize(ole, app)
       @ole_obj = ole
       @app = app
     end
 
     def each
       return enum_for(:each) unless block_given?
+
       while @ole_obj.MoveNext
         item = @ole_obj.Current
-        yield Microstation::Wrap.wrap(item,app)
+        yield Microstation::Wrap.wrap(item, app)
       end
     end
 
     def reset
       @ole_obj.reset
     end
-
-
-
   end
-
 end

data/lib/microstation/errors.rb

@@ -1,17 +1,12 @@
 module Microstation
-
   Error = Class.new(::RuntimeError)
   NonDGNFile = Class.new(Error)
   FileNotFound = Class.new(Error)
   MultipleUpdateError = Class.new(Error)
   class ExistingFile < Error
-
     def initialize(path)
       msg = "File at path #{path} already exists"
       super(msg)
     end
   end
-
-
-
 end

data/lib/microstation/event_handler.rb

@@ -1,14 +1,11 @@
 module Microstation
-
   class EventHandler
     def initialize
       @handlers = {}
     end
 
     def add_handler(event, &block)
-      if block_given?
-        @handlers[event] = block
-      end
+      @handlers[event] = block if block
     end
 
     def get_handler(event)
@@ -24,5 +21,4 @@ module Microstation
       end
     end
   end
-
 end

data/lib/microstation/ext/pathname.rb

@@ -1,23 +1,21 @@
-require 'pathname'
+require "pathname"
 
-  
- class Pathname
+class Pathname
+  def ext(newext = "")
+    str = to_s
+    return dup if [".", ".."].include? str
 
-   def ext(newext = '')
-     str = self.to_s
-    return self.dup if ['.', '..'].include? str
-    if newext != ''
+    if newext != ""
       newext = (newext =~ /^\./) ? newext : ("." + newext)
     end
-    Pathname.new(str.dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || str + newext)
-   end
+    Pathname.new(str.dup.sub!(%r{([^/\\])\.[^./\\]*$}) { ::Regexp.last_match(1) + newext } || str + newext)
+  end
 
-  def extstr(newext='')
-    Pathname.new( self.to_s.ext(newext))
+  def extstr(newext = "")
+    Pathname.new(to_s.ext(newext))
   end
-  
+
   def glob(pattern)
-    self.class.glob("#{self.to_s}/#{pattern}")
+    self.class.glob("#{self}/#{pattern}")
   end
-
 end

data/lib/microstation/ext/win32ole.rb

@@ -1,7 +1,5 @@
 class WIN32OLE
-
   def ole_obj
     self
   end
-
 end

data/lib/microstation/extensions/faa.rb

@@ -5,29 +5,21 @@ module Microstation
   end
 end
 
-
 module Microstation
-
-
   class Drawing
-
-
-
     def number
       binding.pry
-      Drawing::Number.from_string(self.basename)
+      Drawing::Number.from_string(basename)
     end
 
     class Number
-
       DRAWING_RE = /(.+)-.+-(.+)-(.+).dgn/
 
       def self.from_string(drawing_name)
         md = DRAWING_RE.match(drawing_name.to_s)
-        new(md[1],md[2],md[3])
+        new(md[1], md[2], md[3])
       end
 
-
       def Index(str)
         return str if str == Drawing::Index
         Drawing::Index.new(str.to_s)
@@ -37,37 +29,30 @@ module Microstation
 
       attr_reader :locid, :factype, :index
 
-      def initialize(locid,factype, index)
+      def initialize(locid, factype, index)
         @locid = locid.to_s.upcase
         @factype = factype.to_s.upcase
         @index = Index(index)
       end
 
-
-
       def to_s
-        [locid,'D',factype,index.to_s].join("-")
+        [locid, "D", factype, index.to_s].join("-")
       end
 
       def discipline
         index.discipline
       end
 
-      def +(n)
-        self.class.new(locid,factype,index.+(n))
+      def +(other)
+        self.class.new(locid, factype, index.+(other))
       end
 
-      def -(n)
-        self.class.new(locid,factype,index.-(n))
+      def -(other)
+        self.class.new(locid, factype, index.-(other))
       end
-
     end
 
-
     class Index
-
-
-
       def initialize(str)
         return str if str === Index
         @nbr = str
@@ -97,14 +82,12 @@ module Microstation
         "#{discipline}#{dstring}"
       end
 
-      def +(n)
-        self.class.new( combined_string( digits_string(as_int + n)))
+      def +(other)
+        self.class.new(combined_string(digits_string(as_int + other)))
       end
 
-
-      def -(n)
-        self.class.new( combined_string( digits_string(as_int - n)))
-
+      def -(other)
+        self.class.new(combined_string(digits_string(as_int - other)))
       end
 
       def succ
@@ -114,11 +97,6 @@ module Microstation
       def pred
         self.-(1)
       end
-
-
-
     end
-
   end
-
 end

data/lib/microstation/file_tests.rb

@@ -1,68 +1,33 @@
 module Microstation
-
   module FileTests
+    def microstation_drawing?(f)
+      return true if drawing_dgn?(f)
 
+      f = f&.to_path&.to_str
+      drawing_dgn?(f)
+    end
 
-    def microstation_drawing?(f)
-      f = f.to_path if f.respond_to? :to_path
-      f = f.to_str
-      File.file?(f) && File.extname(f) == '.dgn'
+    def drawing_dgn?(f)
+      File.file?(f) && File.extname(f) == ".dgn"
     end
 
     def drawing?(f)
-      f = f.to_path if f.respond_to? :to_path
-      f = f.to_str
-      File.file?(f) && drawing_type?(f)
-    end
+      return true if drawing_type?(f)
 
+      f = f&.to_path&.to_str
+      drawing_type(f)
+    end
 
     def drawing_type?(f)
-      f = f.to_path if f.respond_to? :to_path
-      f = f.to_str
-      ext = File.extname(f)
-      ext == '.dwg' || ext == '.dgn'
+      File.file?(f) && (File.extname(f) == ".dgn" || File.extname(f) == ".dwg")
     end
 
     def check_is_drawing(f)
-      raise ArgumentError, 'File must be a dgn or dwg file' unless drawing?(f)
-    end
-    def check_is_dgn(f)
-      raise ArgumentError, 'File must be a dgn file' unless microstation_drawing?(f)
+      raise ArgumentError, "File must be a dgn or dwg file" unless drawing?(f)
     end
-  end
-
-end
-
-
-if $0 == __FILE__
-
-  class Test
-
-    include Microstation::FileChecks
-
-
-  end
-
-  module Microstation
-
-    class Test2
-
-      include FileChecks
 
+    def check_is_dgn(f)
+      raise ArgumentError, "File must be a dgn file" unless microstation_drawing?(f)
     end
-
-  end
-
-  t = Test.new
-  t2 = Microstation::Test2.new
-
-  def check_type(c,c2,f)
-    puts "c.drawing_type?(#{f}) == #{c.drawing_type?(f)}"
-    puts "c2.drawing_type?(#{f}) == #{c2.drawing_type?(f)}"
   end
-
-  %w( doc.pdf doc.doc doc.rtf doc.dgn doc.dwg doc.rb).each do |f|
-    check_type(t,t2,f)
-  end
-
 end

data/lib/microstation/functions.rb

@@ -1,27 +1,23 @@
-require 'dry/monads'
+require "dry/monads"
 module Microstation
-
   class App
     include Dry::Monads[:result]
   end
 
   module Functions
-
     extend Dry::Monads[:result]
 
     def get_points_by_rectangle
       queue = cad_input_queue
-      queue.show_command('Get points by block')
+      queue.show_command("Get points by block")
       start_point = queue.get_point
-      if start_point.failure?
-        return Failure(:point1_reset)
-      end
+      return Failure(:point1_reset) if start_point.failure?
+
       queue.send_command "PLACE BLOCK"
       queue.send_data_point start_point.value!
       end_point = queue.get_point
-      if end_point.failure?
-        return Failure(:point2_reset)
-      end
+      return Failure(:point2_reset) if end_point.failure?
+
       Success([start_point.value!, end_point.value!])
     end
 
@@ -29,15 +25,13 @@ module Microstation
       queue = cad_input_queue
       queue.show_command("Get points by line")
       start_point = queue.get_point
-      if start_point.failure?
-        return Failure(:point1_reset)
-      end
+      return Failure(:point1_reset) if start_point.failure?
+
       queue.send_command "PLACE LINE"
       queue.send_data_point start_point.value!
       end_point = queue.get_point("Enter next vertex")
-      if end_point.failure?
-        return Failure(:point2_reset)
-      end
+      return Failure(:point2_reset) if end_point.failure?
+
       Success([start_point.value!, end_point.value!])
     end
 
@@ -48,13 +42,9 @@ module Microstation
     def get_point
       cad_input_queue.get_point
     end
-
-
   end
 
-
   class App
     include Functions
   end
 end
-

data/lib/microstation/graphics.rb

@@ -1,35 +1,28 @@
 module Microstation
-
   module Graphics
-
-
-    def line(p1,p2,el = WIN32OLE_VARIANT::Nothing)
+    def line(p1, p2, el = WIN32OLE_VARIANT::Nothing)
       pt1 = app.to_ole_point3d(p1)
       pt2 = app.to_ole_point3d(p2)
       begin
-        ole = app.ole_obj.CreateLineElement2(el,pt1,pt2)
-      rescue Exception => ex
+        ole = app.ole_obj.CreateLineElement2(el, pt1, pt2)
+      rescue Exception => e
         binding.pry
         return nil
       end
       add_element(ole) if ole
     end
 
-
     def line_from_pts(pts, el = WIN32OLE_VARIANT::Nothing)
-      ole_points = pts.map{ |pt| app.to_ole_point3d(pt) }
+      ole_points = pts.map { |pt| app.to_ole_point3d(pt) }
       ole = app.ole_obj.CreateLineElement1(el, ole_points)
       if ole
-        add_element(ole) 
+        add_element(ole)
       else
         binding.pry
       end
     rescue Exception => e
       binding.pry
-      return nil
+      nil
     end
   end
-
-
 end
-