autocad 0.4.6 → 0.5

data/sig/generated/autocad/filter.rbs

@@ -1,60 +1,388 @@
-# Generated from lib/autocad/filter.rb with RBS::Inline
-
-module Autocad
-  class Filter
-    attr_reader types: untyped
-
-    attr_reader values: untyped
-
-    attr_reader clauses: untyped
-
-    def initialize: (?clauses: untyped) -> untyped
-
-    def new_filter: (untyped clause, untyped value) -> untyped
-
-    def has_filters?: () -> untyped
-
-    # convert the clauses to the values and types needed for autocad filter
-    # rbs return Array[Array,Array] -- the types and values array
-    def convert_clauses: () -> untyped
-
-    # Logical Operators
-    def and: (*untyped conditions) -> untyped
-
-    def merge_conditions: (untyped existing, untyped new_condition) -> untyped
-
-    def or: (*untyped conditions) -> untyped
-
-    def xor: (untyped condition1, untyped condition2) -> untyped
-
-    def not: (untyped condition) -> untyped
-
-    # Relational Operators
-    #  f.type("Circle").greater_than(5)
-    def greater_than: (untyped value) -> untyped
-
-    def less_than: (untyped value) -> untyped
-
-    def equal_to: (untyped value) -> untyped
-
-    def not_equal_to: (untyped value) -> untyped
-
-    def block_reference: (?untyped name) -> untyped
-
-    def name: (untyped value) -> untyped
-
-    def type: (untyped kind) -> untyped
-
-    def layer: (untyped name) -> untyped
-
-    def visible: (?untyped vis) -> untyped
-
-    def color: (untyped num) -> untyped
-
-    def paper_space: () -> untyped
-
-    def model_space: () -> untyped
-
-    def contains: (untyped str) -> untyped
-  end
-end
+# Generated from lib/autocad/filter.rb with RBS::Inline
+
+module Autocad
+  # Builds complex filter expressions for AutoCAD entity selection
+  #
+  # This class provides a functional, immutable approach to building
+  # selection filters with a fluent interface. Each method returns a new
+  # Filter instance with the added condition.
+  #
+  # The Filter class is the core of the selection system, providing:
+  # - Logical operators (AND, OR, XOR, NOT)
+  # - Property filters (type, layer, color, etc.)
+  # - Numeric comparisons (greater than, less than, etc.)
+  # - Special entity filters (block references, text, etc.)
+  #
+  # @example Create a filter for red circles
+  #   filter = Filter.new
+  #     .type("CIRCLE")
+  #     .color(1)
+  #
+  # @example Combine filters with logical operators
+  #   text_filter = Filter.new.type("TEXT").or.type("MTEXT")
+  #   layer_filter = Filter.new.layer("NOTES")
+  #   combined = Filter.new.and(text_filter, layer_filter)
+  #
+  # @example Complex filter with nested conditions
+  #   filter = Filter.new.and(
+  #     Filter.new.or(
+  #       Filter.new.type("CIRCLE"),
+  #       Filter.new.type("ARC")
+  #     ),
+  #     Filter.new.not(
+  #       Filter.new.layer("HIDDEN")
+  #     )
+  #   )
+  class Filter
+    # @return [Array<Integer>] DXF group codes for filtering
+    # @return [Array<Object>] Values corresponding to types
+    # @return [Hash<Symbol, Object>] Internal representation of filter conditions
+    # @rbs attr_reader types: Array[Integer] -- DXF group codes for filtering
+    # @rbs attr_reader values: Array[untyped] -- Values corresponding to types
+    # @rbs attr_reader clauses: Hash[Symbol, untyped] -- Internal representation of filter conditions
+    attr_reader types: untyped
+
+    # @return [Array<Integer>] DXF group codes for filtering
+    # @return [Array<Object>] Values corresponding to types
+    # @return [Hash<Symbol, Object>] Internal representation of filter conditions
+    # @rbs attr_reader types: Array[Integer] -- DXF group codes for filtering
+    # @rbs attr_reader values: Array[untyped] -- Values corresponding to types
+    # @rbs attr_reader clauses: Hash[Symbol, untyped] -- Internal representation of filter conditions
+    attr_reader values: untyped
+
+    # @return [Array<Integer>] DXF group codes for filtering
+    # @return [Array<Object>] Values corresponding to types
+    # @return [Hash<Symbol, Object>] Internal representation of filter conditions
+    # @rbs attr_reader types: Array[Integer] -- DXF group codes for filtering
+    # @rbs attr_reader values: Array[untyped] -- Values corresponding to types
+    # @rbs attr_reader clauses: Hash[Symbol, untyped] -- Internal representation of filter conditions
+    attr_reader clauses: untyped
+
+    # Initialize a new filter with optional clauses
+    #
+    # @param clauses [Hash<Symbol, Object>] Initial filter clauses
+    # @return [void]
+    # @rbs clauses: Hash[Symbol, untyped] -- Initial filter clauses
+    # @rbs return void
+    def initialize: (?clauses: Hash[Symbol, untyped]) -> void
+
+    # Create a new filter with an additional clause
+    #
+    # This method implements the immutable pattern - instead of modifying
+    # the current filter, it returns a new filter with the added clause.
+    #
+    # @param clause [Symbol] The clause type
+    # @param value [Object] The clause value
+    # @return [Filter] A new filter instance
+    # @rbs clause: Symbol -- The clause type
+    # @rbs value: untyped -- The clause value
+    # @rbs return Filter -- A new filter instance
+    def new_filter: (Symbol clause, untyped value) -> Filter
+
+    # Check if filter has any conditions
+    #
+    # @return [Boolean] True if the filter has conditions
+    # @note This implementation always returns true and should be fixed
+    #       to check if clauses.any? instead
+    # @rbs return bool -- Always returns true (should check clauses.any?)
+    def has_filters?: () -> bool
+
+    # Convert the clauses to AutoCAD selection filter format
+    #
+    # Transforms the internal filter representation into the format
+    # expected by AutoCAD's selection API: arrays of group codes and values.
+    #
+    # @return [Array<Array<Integer>, Array<Object>>] The types and values arrays
+    # @rbs return [Array[Integer], Array[untyped]] -- The types and values arrays
+    def convert_clauses: () -> [ Array[Integer], Array[untyped] ]
+
+    # Logical AND combination of filters
+    #
+    # Creates a new filter that combines multiple conditions with AND logic.
+    # All conditions must be met for an entity to be selected.
+    #
+    # @param conditions [Array<Filter>] Filters to combine
+    # @return [Filter] A new filter with AND condition
+    # @example Combine type and layer filters
+    #   f.and(f.type("CIRCLE"), f.layer("WALLS"))
+    # @example Complex nested AND condition
+    #   f.and(
+    #     f.layer("ELECTRICAL"),
+    #     f.or(f.type("LINE"), f.type("POLYLINE"))
+    #   )
+    # @rbs *conditions: Array[Filter] -- Filters to combine
+    # @rbs return Filter -- A new filter with AND condition
+    def and: (*Array[Filter] conditions) -> Filter
+
+    # Placeholder for merging conditions (unimplemented)
+    #
+    # @note This method is a placeholder and not currently implemented
+    # @param existing [Filter] Existing filter
+    # @param new_condition [Filter] New filter to merge
+    # @return [void]
+    # @rbs existing: Filter -- Existing filter
+    # @rbs new_condition: Filter -- New filter to merge
+    # @rbs return void
+    def merge_conditions: (Filter existing, Filter new_condition) -> void
+
+    # Logical OR combination of filters
+    #
+    # Creates a new filter that combines multiple conditions with OR logic.
+    # Any condition can be met for an entity to be selected.
+    #
+    # @param conditions [Array<Filter>] Filters to combine
+    # @return [Filter] A new filter with OR condition
+    # @example Select circles or arcs
+    #   f.or(f.type("CIRCLE"), f.type("ARC"))
+    # @example Select entities on multiple layers
+    #   f.or(f.layer("WALLS"), f.layer("DOORS"), f.layer("WINDOWS"))
+    # @rbs *conditions: Array[Filter] -- Filters to combine
+    # @rbs return Filter -- A new filter with OR condition
+    def or: (*Array[Filter] conditions) -> Filter
+
+    # Logical XOR combination of two filters
+    #
+    # Creates a new filter that combines two conditions with XOR logic.
+    # Exactly one condition must be met for an entity to be selected.
+    #
+    # @param condition1 [Filter] First filter
+    # @param condition2 [Filter] Second filter
+    # @return [Filter] A new filter with XOR condition
+    # @example Select circles or red entities, but not red circles
+    #   f.xor(f.type("CIRCLE"), f.color(1))
+    # @rbs condition1: Filter -- First filter
+    # @rbs condition2: Filter -- Second filter
+    # @rbs return Filter -- A new filter with XOR condition
+    def xor: (Filter condition1, Filter condition2) -> Filter
+
+    # Logical NOT of a filter
+    #
+    # Creates a new filter that negates a condition.
+    # Entities that do NOT meet the condition will be selected.
+    #
+    # @param condition [Filter] Filter to negate
+    # @return [Filter] A new filter with NOT condition
+    # @example Select all entities except circles
+    #   f.not(f.type("CIRCLE"))
+    # @example Select entities not on the HIDDEN layer
+    #   f.not(f.layer("HIDDEN"))
+    # @rbs condition: Filter -- Filter to negate
+    # @rbs return Filter -- A new filter with NOT condition
+    def not: (Filter condition) -> Filter
+
+    # Filter for values greater than specified value
+    #
+    # Creates a new filter for numeric comparisons.
+    # Typically used for radius, length, or other dimensional properties.
+    #
+    # @param value [Numeric] Value to compare against
+    # @return [Filter] A new filter with greater than condition
+    # @example Filter for circles with radius > 5
+    #   f.type("CIRCLE").greater_than(5)
+    # @example Filter for lines longer than 10 units
+    #   f.type("LINE").greater_than(10)
+    # @rbs value: Numeric -- Value to compare against
+    # @rbs return Filter -- A new filter with greater than condition
+    def greater_than: (Numeric value) -> Filter
+
+    # Filter for values less than specified value
+    #
+    # Creates a new filter for numeric comparisons.
+    # Typically used for radius, length, or other dimensional properties.
+    #
+    # @param value [Numeric] Value to compare against
+    # @return [Filter] A new filter with less than condition
+    # @example Filter for circles with radius < 10
+    #   f.type("CIRCLE").less_than(10)
+    # @example Filter for text with height < 2.5
+    #   f.type("TEXT").less_than(2.5)
+    # @rbs value: Numeric -- Value to compare against
+    # @rbs return Filter -- A new filter with less than condition
+    def less_than: (Numeric value) -> Filter
+
+    # Filter for values equal to specified value
+    #
+    # Creates a new filter for exact numeric matches.
+    # Useful for standardized dimensions or properties.
+    #
+    # @param value [Numeric] Value to compare against
+    # @return [Filter] A new filter with equal to condition
+    # @example Filter for circles with radius = 7.5
+    #   f.type("CIRCLE").equal_to(7.5)
+    # @example Filter for text with exact height
+    #   f.type("TEXT").equal_to(3.0)
+    # @rbs value: Numeric -- Value to compare against
+    # @rbs return Filter -- A new filter with equal to condition
+    def equal_to: (Numeric value) -> Filter
+
+    # Filter for values not equal to specified value
+    #
+    # Creates a new filter that excludes entities with specific values.
+    #
+    # @param value [Numeric] Value to compare against
+    # @return [Filter] A new filter with not equal to condition
+    # @example Filter for circles with radius != 0
+    #   f.type("CIRCLE").not_equal_to(0)
+    # @example Filter for non-standard text heights
+    #   f.type("TEXT").not_equal_to(2.5)
+    # @rbs value: Numeric -- Value to compare against
+    # @rbs return Filter -- A new filter with not equal to condition
+    def not_equal_to: (Numeric value) -> Filter
+
+    # Filter for block references (optionally with specific name)
+    #
+    # Creates a new filter for block reference entities.
+    # Optionally filters for a specific block name pattern.
+    #
+    # @param name [String, nil] Block name pattern (e.g., "DOOR*")
+    # @return [Filter] A new filter for block references
+    # @example Filter for any block reference
+    #   f.block_reference
+    # @example Filter for door block references
+    #   f.block_reference("DOOR*")
+    # @example Filter for furniture with specific naming pattern
+    #   f.block_reference("FURN_*_CHAIR")
+    # @rbs name: String? -- Block name pattern (e.g., "DOOR*")
+    # @rbs return Filter -- A new filter for block references
+    def block_reference: (?String? name) -> Filter
+
+    # Filter by entity name
+    #
+    # Creates a new filter for entities with specific names.
+    # Useful for named objects like blocks, layers, etc.
+    #
+    # @param value [String] Entity name
+    # @return [Filter] A new filter for entity name
+    # @example Filter by specific entity name
+    #   f.name("A123")
+    # @example Filter by name pattern
+    #   f.name("DOOR_*")
+    # @rbs value: String -- Entity name
+    # @rbs return Filter -- A new filter for entity name
+    def name: (String value) -> Filter
+
+    # Filter by entity type
+    #
+    # Creates a new filter for entities of a specific type.
+    # This is one of the most common filters.
+    #
+    # @param kind [String] AutoCAD entity type (e.g., "LINE", "CIRCLE")
+    # @return [Filter] A new filter for entity type
+    # @example Filter for lines
+    #   f.type("LINE")
+    # @example Filter for circles
+    #   f.type("CIRCLE")
+    # @example Filter for multi-line text
+    #   f.type("MTEXT")
+    # @rbs kind: String -- AutoCAD entity type (e.g., "LINE", "CIRCLE")
+    # @rbs return Filter -- A new filter for entity type
+    def type: (String kind) -> Filter
+
+    # Filter by layer name
+    #
+    # Creates a new filter for entities on a specific layer.
+    # Supports exact layer names or wildcard patterns.
+    #
+    # @param name [String] Layer name
+    # @return [Filter] A new filter for layer
+    # @example Filter for entities on WALLS layer
+    #   f.layer("WALLS")
+    # @example Filter for entities on any layer starting with "A-"
+    #   f.layer("A-*")
+    # @rbs name: String -- Layer name
+    # @rbs return Filter -- A new filter for layer
+    def layer: (String name) -> Filter
+
+    # Filter by visibility
+    #
+    # Creates a new filter for entity visibility.
+    # By default, filters for visible entities.
+    #
+    # @param vis [Boolean] True for visible, false for invisible
+    # @return [Filter] A new filter for visibility
+    # @example Filter for visible entities
+    #   f.visible(true)
+    # @example Filter for hidden entities
+    #   f.visible(false)
+    # @rbs vis: bool -- True for visible, false for invisible
+    # @rbs return Filter -- A new filter for visibility
+    def visible: (?bool vis) -> Filter
+
+    # Filter by color index
+    #
+    # Creates a new filter for entities with a specific color.
+    # Accepts color index (1-255) or symbolic color names.
+    #
+    # @param num [Integer] AutoCAD color index (0-255)
+    # @return [Filter] A new filter for color
+    # @example Filter for red entities
+    #   f.color(1)  # Red
+    # @example Filter for blue entities
+    #   f.color(5)  # Blue
+    # @example Filter for entities with specific color
+    #   f.color(Autocad::Color::Green)
+    # @rbs num: Integer -- AutoCAD color index (0-255)
+    # @rbs return Filter -- A new filter for color
+    def color: (Integer num) -> Filter
+
+    # Filter for paper space entities
+    #
+    # Creates a new filter for entities in paper space (layouts).
+    #
+    # @return [Filter] A new filter for paper space
+    # @example Filter for paper space entities
+    #   f.paper_space
+    # @example Filter for title blocks in paper space
+    #   f.and(f.paper_space, f.block_reference("TITLE*"))
+    # @rbs return Filter -- A new filter for paper space
+    def paper_space: () -> Filter
+
+    # Filter for model space entities
+    #
+    # Creates a new filter for entities in model space.
+    #
+    # @return [Filter] A new filter for model space
+    # @example Filter for model space entities
+    #   f.model_space
+    # @example Filter for circles in model space
+    #   f.and(f.model_space, f.type("CIRCLE"))
+    # @rbs return Filter -- A new filter for model space
+    def model_space: () -> Filter
+
+    # Filter for text containing a string pattern
+    #
+    # Creates a new filter for text entities containing specific content.
+    # Works with both TEXT and MTEXT entities.
+    #
+    # @param str [String] Text pattern to search for
+    # @return [Filter] A new filter for text content
+    # @example Filter for text containing "REVISION"
+    #   f.has_text("REVISION")
+    # @example Filter for text containing a specific pattern
+    #   f.has_text("*REV*")
+    # @rbs str: String -- Text pattern to search for
+    # @rbs return Filter -- A new filter for text content
+    def has_text: (String str) -> Filter
+
+    # Filter for any text entity
+    #
+    # Creates a new filter for any text entity (TEXT or MTEXT).
+    #
+    # @return [Filter] A new filter for text entities
+    # @example Filter for any text entity
+    #   f.text
+    # @example Filter for text on a specific layer
+    #   f.and(f.text, f.layer("NOTES"))
+    def text: () -> untyped
+
+    # Filter for entities with specific linetype
+    #
+    # Creates a new filter for entities with a specific linetype.
+    #
+    # @param name [String] Linetype name
+    # @return [Filter] A new filter for linetype
+    # @example Filter for entities with DASHED linetype
+    #   f.linetype("DASHED")
+    def linetype: (untyped name) -> untyped
+  end
+end

data/sig/generated/autocad/layer.rbs

@@ -1,19 +1,76 @@
-# Generated from lib/autocad/layer.rb with RBS::Inline
-
-module Autocad
-  class Layer < Element
-    def name: () -> untyped
-
-    def description: () -> untyped
-
-    def lock: (?untyped lk) -> untyped
-
-    def visible?: () -> untyped
-
-    def visible=: (untyped vis) -> untyped
-
-    def delete: () -> untyped
-
-    def linetype=: (untyped ltname) -> untyped
-  end
-end
+# Generated from lib/autocad/layer.rb with RBS::Inline
+
+module Autocad
+  class Layer < Element
+    # @rbs return String -- the name of the layer
+    def name: () -> String
+
+    # Get the color of the layer
+    # @rbs return Integer -- the color index of the layer
+    def color: () -> Integer
+
+    # Set the color of the layer
+    # @rbs color: Integer|Symbol -- the color to set (can be ACAD::COLOR constant, symbol, or integer)
+    # @rbs return void
+    def color=: (Integer | Symbol color) -> void
+
+    # Get the symbolic color name if available
+    # @rbs return Symbol|Integer -- the symbolic color name or integer if no name exists
+    def color_name: () -> (Symbol | Integer)
+
+    # set the name of the layer
+    # @rbs name: String
+    # @rbs return void
+    def name=: (String name) -> void
+
+    def description: () -> untyped
+
+    # is the layer the active layer
+    # @rbs return bool
+    def active?: () -> bool
+
+    # Activates the current layer by setting it as the active layer in the drawing.
+    # This method assigns the current layer's OLE object to the ActiveLayer property of the drawing's OLE object.
+    #
+    # @rbs return void
+    def activate: () -> void
+
+    # @rbs return bool
+    def frozen?: () -> bool
+
+    # freeze the layer - entities on layer are invisible and wont be
+    # regenerated
+    def freeze: () -> untyped
+
+    # unfreeze the layer
+    def unfreeze: () -> untyped
+
+    # @rbs return bool
+    def thawed?: () -> bool
+
+    # lock the layer - entities on layer can't be changed
+    def lock: () -> untyped
+
+    # unlock the layer
+    def unlock: () -> untyped
+
+    # @rbs return bool -- true if layer is locked
+    def locked?: () -> bool
+
+    def visible?: () -> untyped
+
+    def visible=: (untyped vis) -> untyped
+
+    # turn on the layer.
+    def turn_on: () -> untyped
+
+    def turn_off: () -> untyped
+
+    # @rbs return bool
+    def on?: () -> bool
+
+    def delete: () -> untyped
+
+    def linetype=: (untyped ltname) -> untyped
+  end
+end

data/sig/generated/autocad/layout.rbs

@@ -0,0 +1,64 @@
+# Generated from lib/autocad/layout.rb with RBS::Inline
+
+module Autocad
+  class Layout < PlotConfiguration
+    # Inserts a block into the layout
+    # @rbs block: Block
+    # @rbs pt: Point3d?
+    # @rbs return void
+    def insert_block: (Block block, ?pt: Point3d?) -> void
+
+    # Get the layout name
+    # @rbs return String
+    def name: () -> String
+
+    # Set the layout name
+    # @rbs str: String
+    # @rbs return void
+    def name=: (String str) -> void
+
+    # Copy plot settings from another configuration
+    # @rbs pc: PlotConfiguration
+    # @rbs return void
+    def copy_plot_configuration: (PlotConfiguration pc) -> void
+
+    # Insert a block reference into the layout
+    # @rbs name: String
+    # @rbs pt: Point3d
+    # @rbs rotation: Float
+    # @rbs scale: Float
+    # @rbs return BlockReference?
+    # @raise [StandardError] On insertion failure
+    def add_block_reference: (String name, pt: Point3d, ?rotation: Float, ?scale: Float) -> BlockReference?
+
+    # Get layout tab order position
+    # @rbs return Integer
+    def tab_order: () -> Integer
+
+    # Set layout tab order position
+    # @rbs n: Integer
+    # @rbs return void
+    def tab_order=: (Integer n) -> void
+
+    # Get paper dimensions in millimeters
+    # @rbs return [Float, Float]
+    def paper_size: () -> [ Float, Float ]
+
+    # Calculate usable area bounds with margins
+    # @rbs return BoundingBox
+    def bounds: () -> BoundingBox
+
+    # Get paper size in inches
+    # @rbs return [Float, Float]
+    def paper_size_inches: () -> [ Float, Float ]
+
+    # Add a paper space viewport
+    # @rbs scale: Symbol
+    # @rbs return PViewport
+    def add_pviewport: (?Symbol scale) -> PViewport
+
+    # Get page margins
+    # @rbs return [[Float, Float], [Float, Float]]
+    def paper_margins: () -> [ [ Float, Float ], [ Float, Float ] ]
+  end
+end