microstation 0.4.1

data/lib/microstation/template.rb

@@ -0,0 +1,84 @@
+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

data/lib/microstation/text.rb

@@ -0,0 +1,54 @@
+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

data/lib/microstation/text_node.rb

@@ -0,0 +1,74 @@
+module Microstation
+
+  class TextNode < Element
+
+    attr_reader :original_text, :ole_obj
+
+    def initialize(ole)
+      @ole_obj = ole
+      @original_text = ole_to_ruby(ole)
+    end
+
+    def empty?
+      ole_obj.TextLinesCount == 0
+    end
+
+    def text?
+      false
+    end
+
+    def size
+      ole_obj.TextLinesCount
+    end
+
+
+    def ole_to_ruby(ole)
+      count = ole.TextLinesCount
+      #    debugger if count > 0
+      str_array = []
+      1.upto(count) do |i|
+        str_array << ole.TextLine(i)
+      end
+      str_array.join("\n")
+    end
+
+    def _update(text)
+      update_ole(text)
+      @original_text = text
+    end
+
+    def update_ole(text)
+      ole_obj.DeleteAllTextLines
+      text.each_line do |line|
+        ole_obj.AddTextLine(line)
+      end
+      ole_obj.Redraw Microstation::MSD::MsdDrawingModeNormal
+      ole_obj.Rewrite
+    end
+
+    def to_s
+      @original_text.to_s
+    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 method_missing2(meth,*args,&block)
+      if meth.to_s =~ /^[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
+
+  end
+
+end

data/lib/microstation/ts/attribute.rb

@@ -0,0 +1,139 @@
+module Microstation
+  module TS
+
+    class Attribute
+
+      attr_reader :ole_obj
+
+      # msdTagTypeCharacter 1 (&H1)
+      # msdTagTypeShortInteger 2 (&H2)
+      # msdTagTypeLongInteger 3 (&H3)
+      # msdTagTypeDouble 4 (&H4)
+      # msdTagTypeBinary 5 (&H5)
+
+      TYPES = {
+        1 => String,
+        2 => Integer,
+        3 => Integer,
+        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
+        else
+          ruby_type = type
+        end
+
+        RUBY_TO_MS[ruby_type]
+      end
+
+      def att_type
+        TYPES[type]
+      end
+
+      def initialize(ole, options = {})
+        @ole_obj = ole
+        @definition = options[:definer]
+      end
+
+      def close
+        @ole_obj = nil
+      end
+
+      def tagset
+        @definition.tagset if definition
+      end
+
+      def name
+        @ole_obj.name
+      end
+
+      def name=(val)
+        @ole_obj.Name = val
+      end
+
+      def options_for_attribute
+        options = {}
+        options[:is_hidden] = true if hidden?
+        options[:prompt] = prompt if prompt
+        options[:default] = default_value
+        options[:readonly] = true if constant?
+      end
+
+      def to_s
+        "TagDefinition: #{name}"
+      end
+
+      def constant?
+        @ole_obj.IsConstant
+      end
+
+      def constant=(constant)
+        bool = constant ? true : false
+        @ole_obj.IsConstant = bool
+      end
+
+      def default
+        @ole_obj.DefaultValue
+      end
+
+      def default=(val)
+        @ole_obj.DefaultValue = val
+      end
+
+      def has_default?
+        !!default
+      end
+
+      def hidden?
+        @ole_obj.IsHidden
+      end
+
+      def hidden=(hidden)
+        bool =  hidden ? true :false
+        @ole_obj.IsHidden = bool
+      end
+      def prompt
+        @ole_obj.Prompt
+      end
+
+      def prompt=(val)
+        @ole_obj.Prompt = val
+      end
+
+      def type
+        TYPES[@ole_obj.TagType]
+      end
+
+      def attrib_options
+        options = {}
+        options[:default] = default_value if has_default?
+        options[:readonly] = true if constant?
+        options
+      end
+
+      def tagset_name
+        @ole_obj.TagSetName
+      end
+
+      def ==(other)
+        @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

data/lib/microstation/ts/instance.rb

@@ -0,0 +1,112 @@
+module Microstation
+  module TS
+
+    class Instance
+
+      include Enumerable
+
+      attr_reader :elements,:tagset
+
+      def initialize(ts, elements)
+        @tagset = ts
+        @elements = elements
+      end
+
+      def to_s
+        "TS:Instance #{tagset.name}"
+      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 []=(name,value)
+        update_element(name,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 pair(el)
+        [el.name, el.value]
+      end
+
+      def select
+        result = []
+        each do |el|
+          k,v = pair(el)
+          save = yield k,v
+          result << find_attribute(k) if save
+        end
+        self.class.new(tagset,result)
+      end
+
+      def find(&block)
+        select(&block).first
+      end
+
+      def each
+        @elements.each do |el|
+          yield el
+        end
+      end
+
+      def each_pair
+        @elements.each do |el|
+          yield el.name, el.value
+        end
+      end
+
+      def map_v
+        each_pair do |k,v|
+          new_v = yield v
+          update_element(k,new_v)
+        end
+      end
+
+      def update(value_hash)
+        value_hash = value_hash.map_kv{|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])
+        end
+      end
+
+      def method_missing(meth,*args,&block)
+        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
+
+  end
+end