autocad 0.4.6 → 0.5

data/lib/autocad/selection_set.rb

@@ -1,61 +1,140 @@
-# require_relative "selection_filter"
-require_relative 'filter'
-
-module Autocad
-  class SelectionSet
-    attr_reader :filter_types, :filter_values, :name
-
-    def initialize(name)
-      @name = name
-      @filter_types = []
-      @filter_values = []
-    end
-
-    def has_filter?
-      filter_types && filter_types.any?
-    end
-
-    def filter_text(str = nil)
-      if str
-        filter_text_containing(str)
-      else
-        filter do |f|
-          f.or(f.type('TEXT'), f.type('MTEXT'))
-        end
-      end
-    end
-
-    # filter do |f|
-    #   st = f.type('Circle').or(f.type('Arc'))
-    #   st2 = f.layer('0').or(f.layer('1'))
-    #   f.and(st, st2)
-    # end
-    def filter
-      if block_given?
-        filter = Filter.new
-        result = yield filter
-        @filter_types, @filter_values = result.convert_clauses
-      end
-      self
-    end
-
-    # Helper methods for common operations
-    def filter_by_type(*types)
-      filter { |f| f.or(*types.map { |t| f.type(t) }) }
-    end
-
-    def filter_by_layer(*layers)
-      filter { |f| f.or(*layers.map { |l| f.layer(l) }) }
-    end
-
-    def filter_text_containing(text)
-      filter do |f|
-        f.and(f.has_text(text), f.or(f.type('TEXT'), f.type('MTEXT')))
-      end
-    end
-
-    def filter_block_references(name = nil)
-      filter { |f| f.block_reference(name) }
-    end
-  end
-end
+# require_relative "selection_filter"
+require_relative "filter"
+
+module Autocad
+  # Manages named selection criteria for AutoCAD entities
+  #
+  # Stores filter criteria for entity selection without executing the selection.
+  # Works with SelectionSetAdapter to apply filters and retrieve entities.
+  #
+  # @example Create a selection set with complex filters
+  #   ss = SelectionSet.new("walls")
+  #   ss.filter do |f|
+  #     f.and(f.layer("WALLS"), f.or(f.type("LINE"), f.type("POLYLINE")))
+  #   end
+  class SelectionSet
+    # @rbs attr_reader name: String -- Unique identifier for the selection set
+    # @rbs attr_reader filter_types: Array[Integer] -- AutoCAD group codes (DXF codes)
+    # @rbs attr_reader filter_values: Array[untyped] -- Filter values matching group codes
+    attr_reader :filter_types, :filter_values, :name
+
+    # Initialize a new selection set with a name
+    # @param name [String] Unique identifier for the selection set
+    # @rbs name: String
+    # @rbs return void
+    def initialize(name)
+      @name = name
+      @filter_types = []
+      @filter_values = []
+    end
+
+    # Check if set has active filters
+    # @return [Boolean] True if filters are defined
+    # @rbs return bool
+    def has_filter?
+      filter_types && filter_types.any?
+    end
+
+    # Filter for text entities with optional content matching
+    # @param str [String, nil] Optional text pattern to match
+    # @return [self] The selection set for chaining
+    # @example Filter all text entities
+    #   ss.filter_text
+    # @example Filter text with specific content
+    #   ss.filter_text("Revision")
+    # @rbs str: String? -- Optional text pattern to match
+    # @rbs return self
+    def filter_text(str = nil)
+      if str
+        filter_text_containing(str)
+      else
+        filter do |f|
+          f.or(f.type("TEXT"), f.type("MTEXT"))
+        end
+      end
+    end
+
+    # Configure complex filters through block
+    # @yield [Filter] Block for building filter criteria
+    # @return [self] The selection set for chaining
+    # @example Create a filter for red circles
+    #   ss.filter do |f|
+    #     f.and(f.type("CIRCLE"), f.color(1))
+    #   end
+    # @example Combine multiple conditions
+    #   ss.filter do |f|
+    #     st = f.type('Circle').or(f.type('Arc'))
+    #     st2 = f.layer('0').or(f.layer('1'))
+    #     f.and(st, st2)
+    #   end
+    # @rbs &: (Filter) -> Filter
+    # @rbs return self
+    def filter
+      if block_given?
+        filter = Filter.new
+        result = yield filter
+        @filter_types, @filter_values = result.convert_clauses
+      end
+      self
+    end
+
+    # Clear all filter criteria
+    # @return [self] The selection set for chaining
+    # @rbs return self
+    def clear_filter
+      @filter_types = []
+      @filter_values = []
+      self
+    end
+
+    # Helper methods for common operations
+    
+    # Filter by entity types
+    # @param types [Array<String>] Entity type names (e.g., "LINE", "CIRCLE")
+    # @return [self] The selection set for chaining
+    # @example Filter for lines and polylines
+    #   ss.filter_by_type("LINE", "POLYLINE")
+    # @rbs *types: Array[String]
+    # @rbs return self
+    def filter_by_type(*types)
+      filter { |f| f.or(*types.map { |t| f.type(t) }) }
+    end
+
+    # Filter by layer names
+    # @param layers [Array<String>] Layer names to filter
+    # @return [self] The selection set for chaining
+    # @example Filter for entities on specific layers
+    #   ss.filter_by_layer("WALLS", "DOORS")
+    # @rbs *layers: Array[String]
+    # @rbs return self
+    def filter_by_layer(*layers)
+      filter { |f| f.or(*layers.map { |l| f.layer(l) }) }
+    end
+
+    # Filter text entities containing specific text
+    # @param text [String] Text pattern to search for (supports wildcards)
+    # @return [self] The selection set for chaining
+    # @example Find text containing "NOTE"
+    #   ss.filter_text_containing("*NOTE*")
+    # @rbs text: String
+    # @rbs return self
+    def filter_text_containing(text)
+      filter do |f|
+        f.and(f.has_text(text), f.or(f.type("TEXT"), f.type("MTEXT")))
+      end
+    end
+
+    # Filter for block references with optional name
+    # @param name [String, nil] Optional block name to filter
+    # @return [self] The selection set for chaining
+    # @example Filter for any block reference
+    #   ss.filter_block_references
+    # @example Filter for specific block
+    #   ss.filter_block_references("DOOR")
+    # @rbs name: String?
+    # @rbs return self
+    def filter_block_references(name = nil)
+      filter { |f| f.block_reference(name) }
+    end
+  end
+end

data/lib/autocad/selection_set_adapter.rb

@@ -1,71 +1,208 @@
 module Autocad
+  # Manages AutoCAD selection set operations and OLE integration
+  #
+  # Executes selections using stored criteria and provides access to selected entities.
+  # Bridges between Ruby selection criteria and AutoCAD's native selection mechanisms.
+  #
+  # Key Features:
+  # - Multiple selection methods (window, crossing, fence, point)
+  # - Filter-based entity selection
+  # - Enumeration of selected entities
+  # - OLE integration with AutoCAD
+  #
+  # @example Create and use a selection set
+  #   ss = drawing.create_selection_set("walls")
+  #   ss.filter { |f| f.layer("WALLS") }
+  #   ss.select(mode: :all)
+  #   ss.each { |wall| wall.color = 1 }
   class SelectionSetAdapter
+    # Initialize from OLE object
+    # @param drawing [Drawing] Parent drawing document
+    # @param ole [WIN32OLE] AutoCAD OLE selection set object
+    # @return [SelectionSetAdapter] New adapter instance
+    # @rbs drawing: Drawing
+    # @rbs ole: WIN32OLE
+    # @rbs return SelectionSetAdapter
     def self.from_ole_obj(drawing, ole)
       ss = SelectionSet.new(ole.Name)
       new(drawing, ss, ole)
     end
 
+    # @rbs attr_reader ole_obj: WIN32OLE -- Underlying OLE selection set
+    # @rbs attr_reader drawing: Drawing -- Parent drawing document
+    # @rbs attr_reader selection_set: SelectionSet -- Configured selection criteria
     attr_reader :ole_obj, :drawing, :selection_set
 
+    # Initialize new adapter
+    # @param drawing [Drawing] Parent drawing document
+    # @param selection_set [SelectionSet] Selection criteria container
+    # @param ole [WIN32OLE, nil] Optional existing OLE selection set
+    # @rbs drawing: Drawing
+    # @rbs selection_set: SelectionSet
+    # @rbs ole: WIN32OLE?
+    # @rbs return void
     def initialize(drawing, selection_set, ole = nil)
       @drawing = drawing
       @selection_set = selection_set
       @ole_obj = ole || create_selection_set
     end
 
+    # Delete the selection set from AutoCAD
+    # @return [void]
+    # @example Remove selection set when no longer needed
+    #   ss.delete if ss.count == 0
+    # @rbs return void
     def delete
       @ole_obj.Delete
       @selection_set = nil
     end
 
-    # checks if the selection set has any items
-    # @ rbs return bool
+    # Checks if the selection set has any items
+    # @return [Boolean] True if selection contains entities
+    # @example Skip processing if selection is empty
+    #   next unless ss.has_items?
+    # @rbs return bool
     def has_items?
       ole_obj.Count > 0
     end
 
+    # Get item count in selection set
+    # @return [Integer] Number of selected entities
+    # @example Report selection count
+    #   puts "Selected #{ss.count} entities"
+    # @rbs return Integer
     def count
       ole_obj.Count
     end
 
+    # Clear selection set contents
+    # @return [void]
+    # @example Clear before new selection
+    #   ss.clear
+    #   ss.select_on_screen
+    # @rbs return void
     def clear
       ole_obj.Clear
     end
 
+    # Clear filter criteria
+    # @return [void]
+    # @example Reset filters for new selection
+    #   ss.clear_filter
+    #   ss.filter { |f| f.type("LINE") }
+    # @rbs return void
+    def clear_filter
+      selection_set.clear_filter
+    end
+
+    # Set text content filter
+    # @param str [String] Text pattern to match
+    # @return [void]
+    # @example Filter for text with specific content
+    #   ss.filter_text("Revision")
+    # @rbs str: String -- Text pattern to match
+    # @rbs return void
     def filter_text(str)
       @selection_set.filter_text(str)
     end
 
+    # Filter text containing substring
+    # @param str [String] Substring to match
+    # @return [void]
+    # @example Find text containing "NOTE"
+    #   ss.filter_text_containing("NOTE")
+    # @rbs str: String -- Substring to match
+    # @rbs return void
     def filter_text_containing(str)
       @selection_set.filter_text_containing(str)
     end
 
+    # Get the application instance
+    # @return [Autocad::App] The application instance
+    # @private
     def app
       @drawing.app
     end
 
+    # Iterate through selected entities
+    # @yield [Element] Block to process each entity
+    # @return [Enumerator<Element>] Enumerator of selected entities if no block given
+    # @example Process each selected entity
+    #   ss.each { |entity| entity.color = 1 }
+    # @example Convert to array
+    #   entities = ss.each.to_a
+    # @rbs &: (Element) -> void
+    # @rbs return Enumerator[Element]
     def each
       return to_enum(__callee__) unless block_given?
 
       ole_obj.each { |o| yield app.wrap(o) }
     end
 
+    # Get the name of the selection set
+    # @return [String] The selection set name
+    # @example Get selection set identifier
+    #   puts "Working with selection set: #{ss.name}"
+    # @rbs return String
     def name
       @ole_obj.Name
     end
 
+    # Get filter types from selection set
+    # @return [Array<Integer>] Array of DXF group codes
+    # @example Access raw filter data
+    #   puts "Using filter types: #{ss.filter_types.join(', ')}"
+    # @rbs return Array[Integer]
     def filter_types
       @selection_set.filter_types
     end
 
+    # Get filter values from selection set
+    # @return [Array<Object>] Array of filter values
+    # @example Access raw filter data
+    #   puts "Using filter values: #{ss.filter_values.inspect}"
+    # @rbs return Array[untyped]
     def filter_values
       @selection_set.filter_values
     end
 
+    # Select entities interactively on screen
+    # @param ft [WIN32OLE::Variant, nil] Optional filter types variant
+    # @param fv [WIN32OLE::Variant, nil] Optional filter values variant
+    # @return [void]
+    # @example Select entities with user interaction
+    #   ss.select_on_screen
+    # @example Select with predefined filters
+    #   ss.filter { |f| f.type("CIRCLE") }
+    #   ss.select_on_screen
+    # @rbs ft: WIN32OLE::Variant? -- Filter types variant
+    # @rbs fv: WIN32OLE::Variant? -- Filter values variant
+    # @rbs return void
     def select_on_screen(ft = ole_filter_types, fv = ole_filter_values)
-      @ole_obj.SelectOnScreen(ft, fv)
+      if filter_types.empty? && filter_values.empty?
+        @ole_obj.SelectOnScreen(nil, nil)
+      else
+        @ole_obj.SelectOnScreen(ft, fv)
+      end
     end
 
+    # Select entities using various methods
+    # @param mode [Symbol] Selection mode (:all, :window, :crossing, :previous, :last)
+    # @param pt1 [Point3d, nil] First point for window selection
+    # @param pt2 [Point3d, nil] Second point for window selection
+    # @param ft [WIN32OLE::Variant, nil] Optional filter types variant
+    # @param fv [WIN32OLE::Variant, nil] Optional filter values variant
+    # @return [void]
+    # @example Select all entities matching filter
+    #   ss.select(mode: :all)
+    # @example Window selection
+    #   ss.select(mode: :window, pt1: [0,0,0], pt2: [10,10,0])
+    # @rbs mode: Symbol -- Selection mode (:all, :window, :crossing, :previous, :last)
+    # @rbs pt1: Point3d? -- First point for window selection
+    # @rbs pt2: Point3d? -- Second point for window selection
+    # @rbs ft: WIN32OLE::Variant? -- Filter types variant
+    # @rbs fv: WIN32OLE::Variant? -- Filter values variant
+    # @rbs return void
     def select(mode: :all, pt1: nil, pt2: nil, ft: ole_filter_types, fv: ole_filter_values)
       acad_mode = case mode
       when :all
@@ -82,9 +219,21 @@ module Autocad
         Acad::AcSelectionSetAll
       end
       @ole_obj.Select(acad_mode, nil, nil, ft, fv)
+    rescue => ex
+      binding.irb
     end
 
-    # accepts Point3d | [x,y] | (x,y)
+    # Select entities at specific point
+    # @param x [Numeric, Point3d, Array<Numeric>] X coordinate or point object
+    # @param y [Numeric, nil] Y coordinate (if using separate coordinates)
+    # @return [void]
+    # @example Select at specific point
+    #   ss.select_at_point(10, 20)
+    # @example Select at point object
+    #   ss.select_at_point(Point3d.new(10, 20, 0))
+    # @rbs x: Numeric | Point3d | Array[Numeric] -- X coordinate or point object
+    # @rbs y: Numeric? -- Y coordinate (if using separate coordinates)
+    # @rbs return void
     def select_at_point(x, y)
       point = if x.respond_to?(:x) && x.respond_to?(:y)
         # Handle Point3d object
@@ -100,11 +249,21 @@ module Autocad
       @ole_obj.SelectAtPoint(point, filter_types, filter_values)
     end
 
-    # @param points [Array<Point3d>] Array of points defining the polygon
-    # @param mode [:fence, :window, :crossing] Selection mode
+    # Select entities using polygonal fence
+    # @param points [Array<Point3d>] Polygon vertices
+    # @param mode [Symbol] Selection mode (:fence, :window, :crossing)
+    # @return [void]
+    # @raise [ArgumentError] For invalid mode
+    # @example Select using fence
+    #   points = [[0,0], [10,0], [10,10], [0,10]]
+    #   ss.select_by_polygon(points: points, mode: :fence)
+    # @rbs points: Array[Point3d] -- Polygon vertices
+    # @rbs mode: Symbol -- Selection mode (:fence, :window, :crossing)
+    # @rbs return void
+    # @raise [ArgumentError] For invalid mode
     def select_by_polygon(points: [], mode: :fence)
       # Convert points to arrays of coordinates
-      point_coords = points.map { |p| [p.x, p.y] }
+      point_coords = points.map { |p| Point3d(p) }.map { |p| [p.x, p.y, p.z] }.flatten
 
       mode_code = case mode
       when :fence then 5
@@ -113,24 +272,44 @@ module Autocad
       else
         raise ArgumentError, "Invalid selection mode: #{mode}. Must be :fence, :window, or :crossing"
       end
+      ole_point_coords = WIN32OLE::Variant.new(point_coords, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_R8)
 
-      @ole_obj.SelectByPolygon(mode_code, point_coords, filter_types, filter_values)
+      binding.irb
+      @ole_obj.SelectByPolygon(mode_code, ole_point_coords, filter_types, filter_values)
     end
 
+    # Configure filter through block
+    # @yield [Filter] Block for building filter criteria
+    # @return [void]
+    # @example Create complex filter
+    #   ss.filter do |f|
+    #     f.and(f.layer("WALLS"), f.or(f.type("LINE"), f.type("POLYLINE")))
+    #   end
+    # @rbs &: (Filter) -> Filter
+    # @rbs return void
     def filter(&)
       @selection_set.filter(&)
     end
 
     private
 
+    # Create new OLE selection set
+    # @return [WIN32OLE] The created OLE selection set
+    # @rbs return WIN32OLE
     def create_selection_set
       @drawing.ole_obj.SelectionSets.Add(@selection_set.name)
     end
 
+    # Convert filter types to OLE variant
+    # @return [WIN32OLE::Variant] OLE variant for filter types
+    # @rbs return WIN32OLE::Variant
     def ole_filter_types
       WIN32OLE::Variant.new(filter_types, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_I2)
     end
 
+    # Convert filter values to OLE variant
+    # @return [WIN32OLE::Variant] OLE variant for filter values
+    # @rbs return WIN32OLE::Variant
     def ole_filter_values
       WIN32OLE::Variant.new(filter_values, WIN32OLE::VARIANT::VT_ARRAY | WIN32OLE::VARIANT::VT_VARIANT)
     end

data/lib/autocad/spline.rb

@@ -0,0 +1,27 @@
+module Autocad
+  class Spline < Element
+    # @rbs return float -- The area of the arc
+    def area
+      @ole_obj.Area
+    end
+
+    # whether the spline is closed
+    def closed? # : bool
+      @ole_obj.Closed
+    end
+
+    # ole obj Variant (array of doubles)
+    # 3D WCS Control Points for the spline
+    # @rbs return Array(Point3d)
+    def control_points
+    end
+
+    # set the control points for the spline
+    # @rbs pts Array(Point3d) | Array(Array[Double,Double,Double?])
+    def control_points=(pts)
+    end
+
+    def degree
+    end
+  end
+end

data/lib/autocad/text.rb

@@ -1,38 +1,86 @@
+# rbs_inline: enabled
+
 require_relative "element"
 
 module Autocad
+  # Single-line text annotation element in AutoCAD
+  #
+  # Represents a simple text entity with a single line of content.
+  # Provides methods for reading, writing, and manipulating text properties.
+  #
+  # @example Create and modify text
+  #   text = drawing.model.add_text("Label", [10,5,0])
+  #   text.height = 2.5
+  #   text.update("New Label")
   class Text < Element
+    # Read text content from OLE object
+    #
+    # @param _ole [WIN32OLE] The OLE object to read from (unused parameter)
+    # @return [String] The text content
+    # @rbs (_ole: WIN32OLE) -> String
     def read_ole(_ole)
       ole_obj.TextString
     end
 
+    # Confirm this is a text element (always true)
+    #
+    # @return [Boolean] Always returns true for Text objects
+    # @rbs return bool
+    def text?
+      true
+    end
+
+    # Update text content in AutoCAD
+    #
+    # @param text [String] The new text content
+    # @return [void]
+    # @rbs text: String -> void
     def write_ole(text)
       ole_obj.TextString = text
     end
 
+    # Convert text content to regex pattern
+    #
+    # @return [Regexp] A regular expression based on the text content
+    # @rbs return Regexp
     def to_regexp
       Regexp.new(read_ole.to_s)
     end
 
+    # Toggle text highlighting in the drawing
+    #
+    # @param flag [Boolean] Whether to highlight (true) or unhighlight (false)
+    # @return [void]
+    # @example Highlight selected text
+    #   selected_text.each { |t| t.highlight }
+    # @rbs flag: bool -> void
+    def highlight(flag = true)
+      ole_obj.Highlight(flag)
+      ole_obj.Update
+    end
+
+    # Regex pattern matching against text content
+    #
+    # @param reg [Regexp] The regular expression to match against
+    # @return [Integer, nil] Match position or nil if no match
+    # @rbs reg: Regexp -> Integer?
     def =~(reg)
       @original =~ reg
     end
 
-    # de_relativef tocad_id
-    #   @ole_obj.Id || @ole_obj.ID64
-    # end
-    # def text?
-    #   true
-    # end
-
-    # def text_node?
-    #   false
-    # end
-
+    # Get text content as string
+    #
+    # @return [String] The text content
+    # @rbs return String
     def to_s
       original.to_s
     end
 
+    # Experimental bounding box calculation
+    #
+    # @return [BoundingBox] The text's bounding box
+    # @note Contains debug code - use with caution
+    # @rbs return BoundingBox
     def bounds
       binding.break
       rotation = ole_obj.Rotation
@@ -53,6 +101,13 @@ module Autocad
       points[3].y = points[2].Y
     end
 
+    # Delegate uppercase methods to OLE object, lowercase to string methods
+    #
+    # @param meth [Symbol] The method name
+    # @param * [Array] Method arguments
+    # @param & [Proc] Optional block
+    # @return [Object] Result of the method call
+    # @rbs (Symbol, *untyped) -> untyped
     def method_missing(meth, *, &)
       if /^[A-Z]/.match?(meth)
         ole_obj.send(meth, *)

data/lib/autocad/text_style.rb

@@ -0,0 +1,4 @@
+module Autocad
+  class TextStyle < Element
+  end
+end

data/lib/autocad/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Autocad
-  VERSION = '0.4.6'
+  VERSION = "0.5"
 end