microstation 0.4.1 → 0.8.6

data/lib/microstation/tag_set_trait.rb

@@ -0,0 +1,51 @@
+module Microstation
+
+  module TagSetTrait
+
+    def tagsets
+      @tagsets ||= TagSets.new(self,ole_obj_tagsets)
+    end
+
+    def tagset_names
+      tagsets.map{|ts| ts.name}
+    end
+
+    def reset_tagsets
+      @tagsets = nil
+      tagsets
+    end
+
+    def create_tagset(name,&block)
+      ts = tagsets.create(name)
+      reset_tagsets
+      block.call ts if block
+      ts
+    end
+
+    def create_tagset!(name,&block)
+      remove_tagset(name)
+      create_tagset(name,&block)
+    end
+
+    def remove_tagset(name)
+      tagsets.remove(name)
+      reset_tagsets
+    end
+
+    def find_tagset(name)
+      tagsets[name]
+    end
+
+    protected
+
+    def ole_obj_tagsets
+      @ole_obj.TagSets
+    end
+
+    def ensure_tags(tags)
+      tags.map{|t| t.class == WIN32OLE ? app.ole_to_ruby(t) : t }
+    end
+
+  end
+
+end

data/lib/microstation/tagged_element.rb

@@ -0,0 +1,105 @@
+module Microstation
+
+  class TaggedElement
+
+    class Set
+
+      attr_reader :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
+        end
+        @elements = elements
+      end
+
+      def find_attribute(name)
+        @elements.find{|a| a.name == name.to_s}
+      end
+
+      def [](name)
+        find_attribute(name)
+      end
+
+      def attributes
+        @elements.map{|e| e.name}
+      end
+
+      def update_element(name,value)
+        find_attribute(name)._update(value)
+      end
+
+      def element_value(name)
+        find_attribute(name).value
+      end
+
+      def to_hash
+        result = {}
+        @elements.each do |ele|
+          result[ele.name] = ele.value unless (ele.value == "" || ele.value.nil?)
+        end
+        result
+      end
+
+      def stringify_keys(hash)
+        result = {}
+        hash.each do |key,value|
+          result[key.to_s] = value
+        end
+        result
+      end
+
+      def update(value_hash)
+        value_hash = stringify_keys(value_hash)
+        valid_atts = attributes & value_hash.keys
+        valid_atts.each do |att|
+          update_element(att,value_hash[att])
+        end
+      end
+
+      def method_missing(meth,*args,&block)
+        # binding.pry
+        base = meth.to_s.sub("=", "")
+        if attributes.include?(base)
+          if meth.match /(=)/
+            update_element(base,*args)
+          else
+            element_value(base.to_s)
+          end
+        else
+          super(meth,*args,&block)
+        end
+      end
+
+    end
+
+    def initialize(ole=nil)
+      @ole_obj = ole
+      @tag_sets = []
+    end
+
+    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}
+    end
+
+
+  end
+
+
+end

data/lib/microstation/template.rb

@@ -1,84 +1,90 @@
-require 'erb'
-require 'liquid'
-require 'fileutils'
-require File.join(File.dirname(__FILE__), 'extensions/hash')
-module Microstation
-
-  class Template
-
-    def initialize(template,app = nil)
-   #   @app = app || Microstation::App.new
-      @template = template
-    end
-
-    def close
-      @app.quit
-    end
-
-    def render(context,locals={}, output)
-      temp = Tempfile.new('working')
-      temp.close
-      __run__(context,locals,temp.path)
-      FileUtils.mv(temp,output)
-      puts "Printed drawing #{output}"
-    end
-
-    def add_binding(scope,locals={},&block)
-      tagsets = locals.delete(:tagsets)
-      nlocals = normalize_hash(locals)
-      nscope = normalize_hash(scope)
-      nlocals = locals.merge(nscope)
-      nlocals['yield'] = block.nil? ? '' : yield
-      nlocals['content'] = nlocals['yield']
-      [nlocals,tagsets]
-    end
-
-    def normalize_hash(scope)
-       scope = scope.to_h if scope.respond_to?(:to_h)
-      if scope.kind_of? Hash
-        scope = scope.map_k{|k| k.to_s}
-      end
-      scope
-    end
-
-    def update_tagset(drawing,name,values)
-      tagset = drawing.find_tagset(name)
-      tagset.update(values)
-    end
-
-    def add_binding_erb(object)
-      class << object
-        def get_binding
-          binding
-        end
-      end
-    end
-
-    def __run__(context,locals={},file)
-
-      Microstation.run do |app|
-        app.new_drawing(file,@template) do |drawing|
-          scope,tagsets = add_binding(context,locals)
-          tagsets.each do |tagset_name,values|
-            tagset = drawing.find_tagset(tagset_name.to_s).first
-            require 'pry'
-            binding.pry
-            tagset.update(values) if tagset
-          end
-          drawing.scan_text do |text|
-            #   binding.pry if text =~ /usi_west|usi_east/
-            compiled = ::Liquid::Template.parse(text.to_s)
-            new_text = compiled.render(scope) rescue text #binding.pry
-            if new_text != text.to_s
-              text.replace(new_text)
-            end
-
-          end
-        end
-        #file
-      end
-    end
-
-  end
-
-end
+# 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')
+
+module Microstation
+  class Template
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
+    def initialize(template, output_dir: nil, app: nil, name: nil)
+      @changer = Changer.new(template, output_dir: output_dir, app: app, name: name)
+    end
+
+    def template
+      @changer.template
+    end
+
+    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)
+        update_tagsets(drawing, tagsets)
+      end
+    end
+
+    def run(update = {})
+      @changer.run do |drawing|
+        locals = normalize_hash(update)
+        return if locals == {}
+
+        update_text(drawing, locals)
+        update_tagsets(drawing, tagsets)
+      end
+    end
+
+    def update_text(drawing, locals = {})
+      change_template_text_normal(drawing, locals)
+      change_template_text_in_cells(drawing, locals)
+    end
+
+    def change_template_text_normal(drawing, locals = {})
+      drawing.scan_text do |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|
+        c.text_elements do |text|
+          new_text = update_liquid_text(text, locals)
+          text.replace new_text if new_text != text.to_s
+        end
+      end
+    end
+
+    def update_liquid_text(text, locals)
+      update_hash = normalize_hash(locals)
+      compiled = ::Liquid::Template.parse(text.to_s)
+      new_text = begin
+                   compiled.render(update_hash)
+                 rescue StandardError
+                   text
+                 end
+    end
+
+    def normalize_hash(scope)
+      scope = scope.to_h if scope.respond_to?(:to_h)
+      scope = scope.transform_keys(&:to_s) if scope.is_a? Hash
+      scope
+    end
+
+    def update_tagsets(drawing, ts_arg)
+      return if ts_arg == []
+      return if ts_arg == {}
+
+      ts_arg = [ts_arg] if ts_arg.instance_of?(Hash)
+      ts_arg.each do |hash_pair|
+        drawing.update_tagset(hash_pair.keys[0], hash_pair.values[0])
+      end
+    end
+  end
+end

data/lib/microstation/template_info.rb

@@ -0,0 +1,172 @@
+module Microstation
+
+  class TemplateInfo
+
+    class TagSetMap
+
+      def initialize(filter,block)
+        @filter = filter
+        @block = block
+      end
+
+      def call(tagsets)
+        instances = tagsets.select(&filter)
+        instances.map{ |ti| block.call(ti)}
+      end
+    end
+
+
+
+    LIQUID_REGEXP =  /{{([^}}]+)}}/
+
+
+    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
+        drawing_path = drawing
+      else
+        drawing_path = drawing.to_path
+      end
+      binding.pry
+      ::Microstation::App.run(visible: visible) do |app|
+        app.open_drawing(drawing_path) do |d|
+          initialize_attributes(d)
+        end
+      end
+      @tagset_filter = tagset_filter
+      @tagset_map = tagset_map
+      return self
+    end
+
+    def initialize_attributes(drawing)
+      @drawing_path = drawing.path
+      entry_points = get_entry_points(drawing)
+      @placeholder_keys = keys_from_entry_points(entry_points)
+      @locals = keys_to_h(@placeholder_keys)
+      @template = @drawing_path.to_s
+      @tagsets = drawing_tagsets(drawing)
+      @output_dir = output_dir(@drawing_path)
+    end
+
+    def drawing_tagsets(drawing)
+      #drawing.tagsets_in_drawing_to_hash
+      drawing.tagsets_in_drawing_to_hash
+    end
+
+    def output_dir(l_drawing_path = @drawing_path)
+      l_drawing_path.parent.to_s
+    end
+
+    def to_h
+      if tagset_filter
+        filtered = tagsets.select{|ts| tagset_filter.call(ts)}
+      else
+        filtered = 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
+      }
+    end
+
+    def default_filter
+      ->(ts){ ts.name == 'faatitle'}
+    end
+
+    def before_locals(locals)
+      locals
+    end
+
+    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.each do |ti|
+          ti.attributes.map
+        end
+      end
+    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
+          ts
+        else
+          ts
+        end
+      }
+    end
+
+    def faa_title_keys
+      %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')
+    end
+
+    def dump(dir = output_dir)
+      dir = Pathname(dir)
+      File.open(dir + yaml_filename, 'w'){|f| f.puts self.to_yaml}
+    end
+
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    protected
+
+    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  =~ /{{([^}}])+}}/
+      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|
+          result << a
+        end
+        result.uniq
+      end
+    end
+
+    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

@@ -0,0 +1,65 @@
+module Microstation
+
+  class TemplateRunner
+
+    attr_reader :file, :template_hash
+
+    def initialize(file)
+      puts "running #{file}"
+      @file = file
+      @template_hash = load(file)
+    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}"
+      end
+    end
+
+    def name
+      template_hash[:name] || Pathname(template).basename.ext('.dgn')
+    end
+
+    def locals
+      template_hash[:locals]
+    end
+
+    def tagsets
+      template_hash[:tagsets]
+    end
+
+    def output_dir
+      template_hash[:output_dir]
+    end
+
+    def template
+      template_hash[:template]
+    end
+
+    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
+                         }
+      run_options = template_options.merge(options)
+      the_template.render(run_options)
+      rescue
+        binding.pry
+      end
+    end
+
+  end
+end

data/lib/microstation/text.rb

@@ -1,54 +1,79 @@
-module Microstation
-
-  class Text < Element
-
-    def initialize(ole)
-      @ole_obj = ole
-      @original_text = @ole_obj.Text
-    end
-
-    # def microstation_id
-    #   @ole_obj.Id || @ole_obj.ID64
-    # end
-    # def text?
-    #   true
-    # end
-
-    # def text_node?
-    #   false
-    # end
-
-    def to_s
-      @original_text.to_s
-    end
-
-    def method_missing2(meth,*args, &block)
-      if meth =~ /^[A-Z]/
-        @ole_obj.send(meth,*args)
-      else
-        dup = @original_text.dup
-        result = dup.send(meth,*args, &block)
-        _update(dup) unless dup == @original_text
-        result
-      end
-    end
-
-    def method_missing(meth,*args,&block)
-      dup = @original_text.dup
-        result = dup.send(meth,*args, &block)
-        _update(dup) unless dup == @original_text
-      result
-    end
-
-
-    def _update(text)
-      @ole_obj.Text = text
-      @original_text = text
-      @ole_obj.Redraw Microstation::MSD::MsdDrawingModeNormal
-      @ole_obj.Rewrite
-      @original_text = text
-    end
-
-  end
-
-end
+require 'microstation/element'
+
+module Microstation
+
+  class Text < Element
+
+
+    def read_ole(ole)
+      ole_obj.Text
+    end
+
+    def write_ole(text)
+      ole_obj.Text = text
+    end
+
+    def to_regexp
+      Regexp.new(read_ole.to_s)
+    end
+
+    def =~(reg)
+      @original =~ reg
+    end
+
+
+    # def microstation_id
+    #   @ole_obj.Id || @ole_obj.ID64
+    # end
+    # def text?
+    #   true
+    # end
+
+    # def text_node?
+    #   false
+    # end
+
+    def to_s
+      original.to_s
+    end
+
+    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)
+      ole_obj.transform transform
+      pts = []
+
+      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)
+      else
+        dup = @original.dup
+        result = dup.send(meth,*args, &block)
+        update(result) 
+        result
+      end
+    end
+
+    # def method_missing(meth,*args,&block)
+    #   dup = @original_text.dup
+    #     result = dup.send(meth,*args, &block)
+    #     _update(dup) unless dup == @original_text
+    #   result
+    # end
+
+
+
+  end
+
+end