microstation 0.8.6 → 0.8.7

data/lib/microstation/tagged_element.rb

@@ -1,20 +1,13 @@
 module Microstation
-
   class TaggedElement
-
     class Set
+      attr_reader :element, :name
 
-      attr_reader :element
-
-      def initialize(name,element)
+      def initialize(name, element)
         @name = name
         @element = element
       end
 
-      def name
-        @name
-      end
-
       def elements=(elements)
         elements.each do |ele|
           ele.base_element = @element
@@ -23,7 +16,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)
@@ -31,10 +24,10 @@ 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
 
@@ -45,14 +38,14 @@ 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
 
       def stringify_keys(hash)
         result = {}
-        hash.each do |key,value|
+        hash.each do |key, value|
           result[key.to_s] = value
         end
         result
@@ -62,44 +55,39 @@ module Microstation
         value_hash = stringify_keys(value_hash)
         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)
         # binding.pry
         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
 
-    def initialize(ole=nil)
+    def initialize(ole = nil)
       @ole_obj = ole
       @tag_sets = []
     end
 
-    def add_tagset(name,elements)
-      ts = TaggedElement::Set.new(name,self)
+    def add_tagset(name, elements)
+      ts = TaggedElement::Set.new(name, self)
       ts.elements = elements
       @tag_sets << ts
       ts
     end
 
     def get_tagset(name)
-      @tagsets.find{|ts| ts.name == name}
+      @tagsets.find { |ts| ts.name == name }
     end
-
-
   end
-
-
 end

data/lib/microstation/template.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'erb'
-require 'microstation'
-require 'liquid'
-require 'fileutils'
-require 'tmpdir'
-require_relative 'changer'
-require File.join(File.dirname(__FILE__), 'file_tests')
-require File.join(File.dirname(__FILE__), 'errors')
+require "erb"
+require "microstation"
+require "liquid"
+require "fileutils"
+require "tmpdir"
+require_relative "changer"
+require File.join(File.dirname(__FILE__), "file_tests")
+require File.join(File.dirname(__FILE__), "errors")
 
 module Microstation
   class Template
@@ -23,6 +23,7 @@ module Microstation
 
     def render(name: nil, output_dir: nil, locals: EMPTY_HASH, tagsets: EMPTY_ARRAY)
       return if locals == EMPTY_HASH && tagsets == EMPTY_ARRAY
+
       @changer.run(name: name, output_dir: output_dir) do |drawing|
         locals = normalize_hash(locals)
         update_text(drawing, locals)
@@ -46,14 +47,14 @@ module Microstation
     end
 
     def change_template_text_normal(drawing, locals = {})
-      drawing.scan_text do |text|
+      drawing.scan_text do |_model, text|
         new_text = update_liquid_text(text, locals)
         text.replace new_text if new_text != text.to_s
       end
     end
 
     def change_template_text_in_cells(drawing, locals = {})
-      drawing.scan_cells do |c|
+      drawing.scan_cells do |_model, c|
         c.text_elements do |text|
           new_text = update_liquid_text(text, locals)
           text.replace new_text if new_text != text.to_s
@@ -65,10 +66,10 @@ module Microstation
       update_hash = normalize_hash(locals)
       compiled = ::Liquid::Template.parse(text.to_s)
       new_text = begin
-                   compiled.render(update_hash)
-                 rescue StandardError
-                   text
-                 end
+        compiled.render(update_hash)
+      rescue
+        text
+      end
     end
 
     def normalize_hash(scope)

data/lib/microstation/template_info.rb

@@ -1,33 +1,27 @@
 module Microstation
-
   class TemplateInfo
-
     class TagSetMap
-
-      def initialize(filter,block)
+      def initialize(filter, block)
         @filter = filter
         @block = block
       end
 
       def call(tagsets)
         instances = tagsets.select(&filter)
-        instances.map{ |ti| block.call(ti)}
+        instances.map { |ti| block.call(ti) }
       end
     end
 
+    LIQUID_REGEXP = /{{([^}]+)}}/
 
-
-    LIQUID_REGEXP =  /{{([^}}]+)}}/
-
-
-    attr_reader :drawing,:placeholder_keys, :template, :tagsets,:locals,:drawing_path, :tagset_filter,:tagset_map
+    attr_reader :drawing, :placeholder_keys, :template, :tagsets, :locals, :drawing_path, :tagset_filter, :tagset_map
 
     def initialize(drawing, tagset_filter: nil, tagset_map: faa_map, visible: false)
       case drawing
       when ::Microstation::Drawing
         initialize_attributes(drawing)
         return
-      when String,Pathname
+      when String, Pathname
         drawing_path = drawing
       else
         drawing_path = drawing.to_path
@@ -40,7 +34,7 @@ module Microstation
       end
       @tagset_filter = tagset_filter
       @tagset_map = tagset_map
-      return self
+      self
     end
 
     def initialize_attributes(drawing)
@@ -54,7 +48,7 @@ module Microstation
     end
 
     def drawing_tagsets(drawing)
-      #drawing.tagsets_in_drawing_to_hash
+      # drawing.tagsets_in_drawing_to_hash
       drawing.tagsets_in_drawing_to_hash
     end
 
@@ -63,36 +57,35 @@ module Microstation
     end
 
     def to_h
-      if tagset_filter
-        filtered = tagsets.select{|ts| tagset_filter.call(ts)}
+      filtered = if tagset_filter
+        tagsets.select { |ts| tagset_filter.call(ts) }
       else
-        filtered = tagsets.dup
+        tagsets.dup
       end
-      mapped_tsets = filtered.map{|ts| tagset_map.call(ts)}
-      { template: template,
-        output_dir: output_dir,
-        name: drawing_name,
-        locals: locals,
-        tagsets: mapped_tsets
-      }
+      mapped_tsets = filtered.map { |ts| tagset_map.call(ts) }
+      {template: template,
+       output_dir: output_dir,
+       name: drawing_name,
+       locals: locals,
+       tagsets: mapped_tsets}
     end
 
     def default_filter
-      ->(ts){ ts.name == 'faatitle'}
+      ->(ts) { ts.name == "faatitle" }
     end
 
     def before_locals(locals)
       locals
     end
 
-    def map_tagset(mapname: , filter: tagset_name_filter, &block)
+    def map_tagset(mapname:, filter: tagset_name_filter, &block)
       @tagset_mappings[tname] = TagSetMap.new(filter, block)
     end
 
     def do_tagset_mappings
       @tagset_mappings.each do |ts_mapper|
         ts_mapper.call(tagsets)
-        ti_instances = tagsets.select{|ts| ts['tag_name'] == k}
+        ti_instances = tagsets.select { |ts| ts["tag_name"] == k }
         ti_instances.each do |ti|
           ti.attributes.map
         end
@@ -100,11 +93,11 @@ module Microstation
     end
 
     def faa_map
-      ->(ts){
-        if ts['tagset_name'] == 'faatitle'
-          atts = ts['attributes']
-          new_atts = atts.keep_if{|k,v| faa_title_keys.include? k}
-          ts['attributes']= new_atts
+      lambda { |ts|
+        if ts["tagset_name"] == "faatitle"
+          atts = ts["attributes"]
+          new_atts = atts.keep_if { |k, _v| faa_title_keys.include? k }
+          ts["attributes"] = new_atts
           ts
         else
           ts
@@ -113,21 +106,20 @@ module Microstation
     end
 
     def faa_title_keys
-      %w(microstation_id fac title1 title2 title3 subnam subttle appname appttl file dnnew jcnno city state)
+      %w[microstation_id fac title1 title2 title3 subnam subttle appname appttl file dnnew jcnno city state]
     end
 
-
     def drawing_name
       drawing_path.basename.to_s
     end
 
     def yaml_filename
-      drawing_path.basename.ext('yaml')
+      drawing_path.basename.ext("yaml")
     end
 
     def dump(dir = output_dir)
       dir = Pathname(dir)
-      File.open(dir + yaml_filename, 'w'){|f| f.puts self.to_yaml}
+      File.open(dir + yaml_filename, "w") { |f| f.puts to_yaml }
     end
 
     def to_yaml
@@ -136,37 +128,31 @@ module Microstation
 
     protected
 
-    def entry_points(drawing)
+    def entry_points(_drawing)
       @entry_points ||= get_entry_points
     end
 
     def get_entry_points(drawing)
       result = []
-      drawing.scan_all_text  do |m,text|
-        binding.pry if text =~ /txt1/ 
-
-        result << [m, text.to_s] if text.to_s  =~ /{{([^}}])+}}/
+      drawing.scan_text do |model, text|
+        result << [model, text.to_s] if /{{([^}])+}}/.match?(text.to_s)
       end
-      binding.pry
       result
     end
 
-    def keys_from_entry_points(entry_points= get_entry_points)
-      entry_points.reduce([]) do |result,(m,text)|
-        text.scan(LIQUID_REGEXP).flatten.map{|t| t.strip}.each do |a|
+    def keys_from_entry_points(entry_points = get_entry_points)
+      entry_points.reduce([]) do |result, (_m, text)|
+        text.scan(LIQUID_REGEXP).flatten.map { |t| t.strip }.each do |a|
           result << a
         end
         result.uniq
       end
     end
 
-    def keys_to_h(keys= @placeholder_keys)
-      keys.each_with_object({}) do |k,h|
+    def keys_to_h(keys = @placeholder_keys)
+      keys.each_with_object({}) do |k, h|
         h[k] = ""
       end
     end
-
-
   end
-
 end

data/lib/microstation/template_runner.rb

@@ -1,7 +1,5 @@
 module Microstation
-
   class TemplateRunner
-
     attr_reader :file, :template_hash
 
     def initialize(file)
@@ -11,18 +9,16 @@ module Microstation
     end
 
     def load(file)
-      begin
-        File.open(file) do |f|
-          YAML.load(f)
-        end
-      rescue => e
-        binding.pry
-        puts "Could not parse YAML: #{e.message}"
+      File.open(file) do |f|
+        YAML.load(f)
       end
+    rescue => e
+      binding.pry
+      puts "Could not parse YAML: #{e.message}"
     end
 
     def name
-      template_hash[:name] || Pathname(template).basename.ext('.dgn')
+      template_hash[:name] || Pathname(template).basename.ext(".dgn")
     end
 
     def locals
@@ -41,25 +37,21 @@ module Microstation
       template_hash[:template]
     end
 
-    def run_with_app(app,options = {})
-      run_options = { app: app}.merge(options)
+    def run_with_app(app, options = {})
+      run_options = {app: app}.merge(options)
       run(run_options)
     end
 
     def run(options = {})
-      begin
       the_template = Template.new(template)
-      template_options = { output_dir: output_dir,
-        locals: locals,
-        name: name,
-        tagsets: tagsets
-                         }
+      template_options = {output_dir: output_dir,
+                          locals: locals,
+                          name: name,
+                          tagsets: tagsets}
       run_options = template_options.merge(options)
       the_template.render(run_options)
-      rescue
-        binding.pry
-      end
+    rescue
+      binding.pry
     end
-
   end
 end

data/lib/microstation/text.rb

@@ -1,11 +1,8 @@
-require 'microstation/element'
+require "microstation/element"
 
 module Microstation
-
   class Text < Element
-
-
-    def read_ole(ole)
+    def read_ole(_ole)
       ole_obj.Text
     end
 
@@ -21,7 +18,6 @@ module Microstation
       @original =~ reg
     end
 
-
     # def microstation_id
     #   @ole_obj.Id || @ole_obj.ID64
     # end
@@ -40,27 +36,31 @@ module Microstation
     def bounds
       binding.pry
       rotation = ole_obj.Rotation
-      inverse_rotation = app_ole_obj.Matrix3dInverse(rotation) rescue pry
-      transform = app_ole_obj.Transform3dFromMatrix3dandFixedPoint3d(app_ole_obj.Matrix3dInverse(rotation), ole_obj.origin)
+      inverse_rotation = begin
+        app_ole_obj.Matrix3dInverse(rotation)
+      rescue
+        pry
+      end
+      transform = app_ole_obj.Transform3dFromMatrix3dandFixedPoint3d(app_ole_obj.Matrix3dInverse(rotation),
+        ole_obj.origin)
       ole_obj.transform transform
       pts = []
 
-      0.upto(4)  do |i|
+      0.upto(4) do |i|
         points[i] = ole_obj.Boundary.Low
       end
       points[2] = self.Boundary.High
       points[1].X = points[2].x
       points[3].y = points[2].Y
-
     end
 
-    def method_missing(meth,*args, &block)
-      if meth =~ /^[A-Z]/
-        ole_obj.send(meth,*args)
+    def method_missing(meth, *args, &block)
+      if /^[A-Z]/.match?(meth)
+        ole_obj.send(meth, *args)
       else
         dup = @original.dup
-        result = dup.send(meth,*args, &block)
-        update(result) 
+        result = dup.send(meth, *args, &block)
+        update(result)
         result
       end
     end
@@ -71,9 +71,5 @@ module Microstation
     #     _update(dup) unless dup == @original_text
     #   result
     # end
-
-
-
   end
-
 end

data/lib/microstation/text_node.rb

@@ -1,15 +1,11 @@
 module Microstation
-
   class TextNode < Element
-
     attr_reader :original, :ole_obj
 
-
     def to_regexp
       Regexp.new(original.to_s)
     end
 
-
     def empty?
       ole_obj.TextLinesCount == 0
     end
@@ -22,7 +18,6 @@ module Microstation
       ole_obj.TextLinesCount
     end
 
-
     def read_ole(ole)
       count = ole.TextLinesCount
       #    debugger if count > 0
@@ -54,17 +49,15 @@ module Microstation
     end
 
     def write_ole_in_cell(text)
-      begin
-        orig_ole = ole_obj
-        new_text_ole = ole_obj.Clone
-        new_text_ole.DeleteAllTextLines
-        text.each_line do |line|
-          new_text_ole.AddTextLine(line)
-        end
-        @ole_obj = new_text_ole
-      rescue => e
-        @ole_obj = orig_ole
+      orig_ole = ole_obj
+      new_text_ole = ole_obj.Clone
+      new_text_ole.DeleteAllTextLines
+      text.each_line do |line|
+        new_text_ole.AddTextLine(line)
       end
+      @ole_obj = new_text_ole
+    rescue => e
+      @ole_obj = orig_ole
     end
 
     def update_ole!(text)
@@ -81,33 +74,33 @@ module Microstation
     end
 
     def =~(reg)
-      @original =~ reg 
+      @original =~ reg
     end
 
     def template?
       !!(@original =~ /{{.+}}/)
     end
 
-    def render(h={})
-      return self unless  template?
-      template = Liquid::Template.parse(self.to_s)
+    def render(h = {})
+      return self unless template?
+
+      template = Liquid::Template.parse(to_s)
       result = template.render(h)
       update(result) unless result == @original
       self
     end
 
-    def method_missing(meth,*args,&block)
-      if meth =~ /^[A-Z]/
-        ole_obj.send(meth,*args)
+    def method_missing(meth, *args, &block)
+      if /^[A-Z]/.match?(meth)
+        ole_obj.send(meth, *args)
       else
         copy = @original.dup
-        result = copy.send(meth,*args,&block)
+        result = copy.send(meth, *args, &block)
         update(result) unless copy == @original
         result
       end
     end
 
-
     # def method_missing2(meth,*args,&block)
     #   if meth.to_s =~ /^[A-Z]/
     #     ole_obj.send(meth,*args)
@@ -118,7 +111,5 @@ module Microstation
     #     result
     #   end
     # end
-
   end
-
 end

data/lib/microstation/ts/attribute.rb

@@ -1,9 +1,6 @@
 module Microstation
-
   module TS
-
     class Attribute
-
       attr_reader :ole_obj
 
       # msdTagTypeCharacter 1 (&H1)
@@ -16,26 +13,26 @@ module Microstation
         1 => String,
         2 => Integer,
         3 => Integer,
-        4 => Float,
+        4 => Float
         #   5 => Binary
       }
 
       RUBY_TO_MS = TYPES.invert
 
       def self.tag_type(type)
-        if type.class == Symbol
-          ruby_type = case type
-                      when :char
-                        String
-                      when :int
-                        Integer
-                      when :float
-                        Float
-                      else
-                        :char
-                      end
+        ruby_type = if type.instance_of?(Symbol)
+          case type
+          when :char
+            String
+          when :int
+            Integer
+          when :float
+            Float
+          else
+            :char
+          end
         else
-          ruby_type = type
+          type
         end
 
         RUBY_TO_MS[ruby_type]
@@ -104,9 +101,10 @@ module Microstation
       end
 
       def hidden=(hidden)
-        bool =  hidden ? true :false
+        bool = hidden ? true : false
         @ole_obj.IsHidden = bool
       end
+
       def prompt
         @ole_obj.Prompt
       end
@@ -131,10 +129,8 @@ module Microstation
       end
 
       def ==(other)
-        @ole_obj.Name == other.ole_obj.Name  && @ole_obj.TagSetName == other.ole_obj.TagSetName && @ole_obj.TagType == other.ole_obj.TagType
+        @ole_obj.Name == other.ole_obj.Name && @ole_obj.TagSetName == other.ole_obj.TagSetName && @ole_obj.TagType == other.ole_obj.TagType
       end
-
     end
-
   end
 end