microstation 0.8.5 → 0.8.7

data/lib/microstation/ts/instance.rb

@@ -1,25 +1,20 @@
 class Hash
-
-  def transform(&block)
-    reduce({}) do |result, (k,v)| 
-      new_k,new_v = yield k,v
+  def transform
+    each_with_object({}) do |(k, v), result|
+      new_k, new_v = yield k, v
       result[new_k] = new_v
-      result
     end
   end
 end
 
 module Microstation
-
   module TS
-
     class Instance
-
       include Enumerable
 
-      attr_reader :elements,:tagset,:microstation_id, :microstation_model
+      attr_reader :elements, :tagset, :microstation_id, :microstation_model
 
-      def initialize(ts,id, elements, model)
+      def initialize(ts, id, elements, model)
         @tagset = ts
         @microstation_id = id
         @elements = elements
@@ -35,7 +30,7 @@ module Microstation
       end
 
       def find_attribute(name)
-        @elements.find{|a| a.name == name.to_s}
+        @elements.find { |a| a.name == name.to_s }
       end
 
       def [](name)
@@ -43,15 +38,15 @@ module Microstation
       end
 
       def attributes
-        @elements.map{|e| e.name}
+        @elements.map { |e| e.name }
       end
 
-      def update_element(name,value)
+      def update_element(name, value)
         find_attribute(name).update(value)
       end
 
-      def []=(name,value)
-        update_element(name,value)
+      def []=(name, value)
+        update_element(name, value)
       end
 
       def element_value(name)
@@ -61,7 +56,7 @@ module Microstation
       def to_hash
         result = {}
         @elements.each do |ele|
-          result[ele.name] = ele.value unless (ele.value == "" || ele.value.nil?)
+          result[ele.name] = ele.value unless ele.value == "" || ele.value.nil?
         end
         result
       end
@@ -75,13 +70,12 @@ module Microstation
       end
 
       def to_h
-        result = {'tagset_name'=> tagset.name, 'microstation_id' => microstation_id,
-                  'microstation_model' => microstation_model, }
-        result['attributes'] = attribute_hash
+        result = {"tagset_name" => tagset.name, "microstation_id" => microstation_id,
+                  "microstation_model" => microstation_model}
+        result["attributes"] = attribute_hash
         result
       end
 
-
       def pair(el)
         [el.name, el.value]
       end
@@ -89,21 +83,19 @@ module Microstation
       def select
         result = []
         each do |el|
-          k,v = pair(el)
-          save = yield k,v
+          k, v = pair(el)
+          save = yield k, v
           result << find_attribute(k) if save
         end
-        self.class.new(tagset,result)
+        self.class.new(tagset, result)
       end
 
       def find(&block)
-        select(&block).first
+        find(&block)
       end
 
-      def each
-        @elements.each do |el|
-          yield el
-        end
+      def each(&block)
+        @elements.each(&block)
       end
 
       def each_pair
@@ -113,34 +105,32 @@ module Microstation
       end
 
       def map_v
-        each_pair do |k,v|
+        each_pair do |k, v|
           new_v = yield v
-          update_element(k,new_v)
+          update_element(k, new_v)
         end
       end
 
       def update(value_hash)
-        value_hash = value_hash.transform{|k,v| [k.to_s,v.to_s] }
+        value_hash = value_hash.transform { |k, v| [k.to_s, v.to_s] }
         valid_atts = attributes & value_hash.keys
         valid_atts.each do |att|
-          update_element(att,value_hash[att])
+          update_element(att, value_hash[att])
         end
       end
 
-      def method_missing(meth,*args,&block)
+      def method_missing(meth, *args, &block)
         base = meth.to_s.sub("=", "")
         if attributes.include?(base)
-          if meth.match /(=)/
-            update_element(base,*args)
+          if /(=)/.match?(meth)
+            update_element(base, *args)
           else
             element_value(base.to_s)
           end
         else
-          super(meth,*args,&block)
+          super(meth, *args, &block)
         end
       end
-
     end
-
   end
 end

data/lib/microstation/ts/tagset_trait.rb

@@ -1,27 +1,23 @@
 module Microstation
-
   module TS
-
-
     module TagSetTrait
-
       def tagsets
         @tagsets = TagSets.new(ole_obj_tagsets)
       end
 
       def tagset_names
-        tagsets.map{|ts| ts.name}
+        tagsets.map { |ts| ts.name }
       end
 
-      def create_tagset(name,&block)
+      def create_tagset(name, &block)
         ts = tagsets.create(name)
         block.call ts if block
         ts
       end
 
-      def create_tagset!(name,&block)
+      def create_tagset!(name, &block)
         remove_tagset(name)
-        create_tagset(name,&block)
+        create_tagset(name, &block)
       end
 
       def remove_tagset(name)
@@ -39,11 +35,8 @@ module Microstation
       end
 
       def ensure_tags(tags)
-        tags.map{|t| t.class == WIN32OLE ? app.wrap(t) : t }
+        tags.map { |t| t.instance_of?(WIN32OLE) ? app.wrap(t) : t }
       end
-
     end
-
   end
-
 end

data/lib/microstation/types.rb

@@ -30,9 +30,6 @@ module Microstation
     Text: 17,
   }
 
-
-
-
 end
 
 msdElementTypeCellLibraryHeader 1 (&H1)

data/lib/microstation/version.rb

@@ -1,5 +1,3 @@
 module Microstation
-
-  VERSION = '0.8.5'
-
+  VERSION = "0.8.7"
 end

data/lib/microstation/wrap.rb

@@ -1,17 +1,12 @@
 module Microstation
-
   def self.needs_extending?(ole)
-    ole.class == WIN32OLE && (not ole.respond_to? :text?)
+    ole.instance_of?(WIN32OLE) && (!ole.respond_to? :text?)
   end
 
-
   module Microstation
-
     module Wrap
-
-
-      def self.wrap(item,app,cell=nil)
-        Element.convert_item(item,app, cell)
+      def self.wrap(item, app, cell = nil)
+        Element.convert_item(item, app, cell)
       end
 
       # def text?(item)
@@ -21,8 +16,6 @@ module Microstation
       #  def text_node?(item)
       #   item.Type == Microstation::MSD::MsdElementTypeTextNode
       # end
-
     end
   end
-
 end

data/lib/microstation.rb

@@ -1,34 +1,32 @@
-require 'microstation/version'
-require 'win32ole'
-require 'microstation/file_tests'
-require 'microstation/app'
-require 'microstation/drawing'
-require 'microstation/configuration'
-require 'microstation/ext/pathname'
-require 'microstation/cad_input_queue'
-require 'microstation/scan/criteria'
-require 'microstation/enumerator'
-require 'microstation/line'
-require 'microstation/text'
-require 'microstation/text_node'
-require 'microstation/template'
-require 'microstation/tag_set'
-require 'microstation/cell'
-require 'microstation/tag'
-require 'microstation/dir'
-require 'microstation/ext/win32ole'
-require 'microstation/template_info'
-require 'microstation/template_runner'
-require 'erb'
+require "microstation/version"
+require "win32ole"
+require "microstation/file_tests"
+require "microstation/app"
+require "microstation/drawing"
+require "microstation/configuration"
+require "microstation/ext/pathname"
+require "microstation/cad_input_queue"
+require "microstation/scan/criteria"
+require "microstation/enumerator"
+require "microstation/line"
+require "microstation/text"
+require "microstation/text_node"
+require "microstation/template"
+require "microstation/tag_set"
+require "microstation/cell"
+require "microstation/tag"
+require "microstation/dir"
+require "microstation/ext/win32ole"
+require "microstation/template_info"
+require "microstation/template_runner"
+require "erb"
 
 module Microstation
-
   ROOT = Pathname(__dir__).parent
 
-  TEMPLATES_PATH = ROOT + 'templates'
-  
-  class << self
+  TEMPLATES_PATH = ROOT + "templates"
 
+  class << self
     def save_as_pdf(d)
       run do |app|
         drawing = app.current_drawing
@@ -38,43 +36,37 @@ module Microstation
     end
 
     def default_error_proc
-      @default_error_proc ||= ->(e,f){ puts "Couldn't open drawing #{f}" }
+      @default_error_proc ||= ->(e, f) { puts "Couldn't open drawing #{f}" }
     end
 
     def default_drawing_options
       {read_only: true, error_proc: default_error_proc}
     end
 
-    def default_error_proc=(p)
-      @default_error_proc = p
-    end
+    attr_writer :default_error_proc
 
-    def default_app_options
-       @default_app_options
-    end
+    attr_reader :default_app_options
 
-    def default_app_options=(opts)
-      @default_app_options = opts 
-    end
+    attr_writer :default_app_options
 
     default_app_options = {visible: false}
 
     def root
-      ROOT 
+      ROOT
     end
 
     def plot_driver_directory
       root + "plot"
     end
 
-    def use_template(template,context, options ={} )
+    def use_template(template, context, options = {})
       def context.binding
         binding
       end
       options = {readonly: true}
       App.run do |app|
-        tmpfile = Tempfile.new('drawing')
-        app.new_drawing(tmpfile,template) do |drawing|
+        tmpfile = Tempfile.new("drawing")
+        app.new_drawing(tmpfile, template) do |drawing|
           drawing.scan_text do |text|
             compiled_template = ERB.new(text)
             new_text = compiled_template.result(context.binding)
@@ -97,34 +89,34 @@ module Microstation
     end
 
     # gets all dwg and dgn dfiles in a directory
-    # @param dir 
+    # @param dir
     def drawings_in_dir(dir)
       dirpath = Pathname.new(dir).expand_path
-      drawings = dirpath.glob("*.d{gn,wg,xf}").sort_by{ _1.basename('.*').to_s.downcase }
+      drawings = dirpath.glob("*.d{gn,wg,xf}").sort_by { _1.basename(".*").to_s.downcase }
     end
 
-    def dump_template_info_for_dir(dir, options={})
+    def dump_template_info_for_dir(dir, **options)
       drawings = drawings_in_dir(dir)
       raise "no drawings in dir #{dir}" if drawings.empty?
       with_drawings(drawings) do |drawing|
-        template = TemplateInfo.new(drawing,options)
+        template = TemplateInfo.new(drawing, **options)
         template.dump(dir)
       end
     end
 
-    def dump_template_info(dgn, dir: nil,  tagset_filter: nil, visible: false)
+    def dump_template_info(dgn, dir: nil, tagset_filter: nil, visible: false)
       drawing = Pathname(dgn).expand_path
       output_dir = dir || drawing.parent
-      template = TemplateInfo.new(drawing,tagset_filter: tagset_filter, visible: visible)
+      template = TemplateInfo.new(drawing, tagset_filter: tagset_filter, visible: visible)
       template.dump(output_dir)
     end
 
     # @param dir [String] the directory of drawing [dgn,dwg] to convert
     # @param outdir [String] the output dir for converted pdf files
-    def dgn2pdf(dir,outdir = dir)
+    def dgn2pdf(dir, outdir = dir)
       drawings = drawings_in_dir(dir)
       with_drawings(drawings) do |drawing|
-        drawing.save_as_pdf(name: drawing.name,dir: outdir)
+        drawing.save_as_pdf(name: drawing.name, dir: outdir)
       end
     end
 
@@ -141,30 +133,29 @@ module Microstation
 
     # opens all the drawings in a drawing
     # by calling open drawing
-    def with_drawings_in_dir(dir,...)
+    def with_drawings_in_dir(dir, ...)
       drawings = drawings_in_dir(dir)
-      with_drawings(drawings,...)
+      with_drawings(drawings, ...)
     end
 
-    
     def with_drawings(...)
-      App.with_drawings(...) 
+      App.with_drawings(...)
     end
 
-    def scan_text(file,&block)
-      ::App.open_drawing(file) do |d|
+    def scan_text(file, &block)
+      App.open_drawing(file) do |d|
         d.scan_text(&block)
       end
     end
 
     def get_text(file, &block)
-      ::App.open_drawing(file) do |d|
-         d.get_text(&block)
+      App.open_drawing(file) do |d|
+        d.get_text(&block)
       end
     end
 
     def get_all_text(file)
-      ::App.open_drawing(file) do |d|
+      App.open_drawing(file) do |d|
         d.get_all_text
       end
     end
@@ -193,34 +184,28 @@ module Microstation
         drawing.close
       end
     end
- 
-    def run(options={}, &block)
-      App.run(...)
-    end
 
+    def run(options = {}, &block)
+      App.run(options, &block)
+    end
   end
-
 end
 
 if $0 == __FILE__
 
-  require 'pry'
+  require "pry"
 
   app = Microstation::App.new
-  require 'microstation/ole_helper'
+  require "microstation/ole_helper"
 
-  File.open('app_methods.txt','w') do |f|
-    f.write app.ole_obj.ole_methods_detail
-  end
+  File.write("app_methods.txt", app.ole_obj.ole_methods_detail)
 
-  tlib = app.ole_obj.ole_typelib 
-  File.open('microstation_classes.txt','w') do |f|
-    f.write app.ole_obj.ole_classes_detail
-  end
+  tlib = app.ole_obj.ole_typelib
+  File.write("microstation_classes.txt", app.ole_obj.ole_classes_detail)
 
   ole_obj = app.ole_obj
 
-  event_classes = ole_obj.select_ole_type('event')
+  event_classes = ole_obj.select_ole_type("event")
   puts event_classes