fiber_pattern 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2975f472d7c4d0d21ffe8a6a6eb918d145b8cc37a7191e141c4aa167bd09e136
-  data.tar.gz: 723d930af45c9e963001a0c678e50db9da2fe75690c9297bbf524f898cb5bb32
+  metadata.gz: d0ed0351785dcc4a977f481938aecf3b3d787b91752558bc307cf2b72ad962e8
+  data.tar.gz: c16dbb1de69fa26de99bc7dc12504db55c1707bf5a9e7388973fdf1954998e18
 SHA512:
-  metadata.gz: 332c10d1d8a7cd0cf594ac22d597e0b6dc589155094157ecb7f7ca26552347ae1d8917ea63fcadce24158661ec668919a91b07cd2231e13f1f0a34532c2c2b42
-  data.tar.gz: de8c48b9c34681594201c7443e478bda797d432af8d2b3a1d66767cb94f4dfd84b44e30554c87b0b9d62743dd9cf236e04e11e26a7f90d4d5c87e858c9b243fd
+  metadata.gz: d9fc5ede7f7838208da2e8382414bebf621af83d557df70d5222531b8087b389dda3d213608149d4f478c146ef803b676c93925d4c0749e2cd889bd71132ba3e
+  data.tar.gz: '0090202feec59f5190da9296132831e0ffaa12389cf0fed5a66c4222662c5700aec07a42ef2b0b1fa0c748261a801eccf6bc63baf8130be985f7b98a4d882699'

data/lib/fiber_pattern/body_measurements.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Value object representing key body dimensions.
+  #
+  # Accepts any set of named measurements as keyword arguments.
+  # Each value should be a FiberUnits::Length.
+  #
+  # @example
+  #   body = FiberPattern::BodyMeasurements.new(
+  #     bust: 36.inches,
+  #     waist: 30.inches,
+  #     hip: 38.inches,
+  #     arm_length: 24.inches
+  #   )
+  #   body.bust       # => 36.inches
+  #   body[:waist]    # => 30.inches
+  #   body.measurements # => [:bust, :waist, :hip, :arm_length]
+  class BodyMeasurements
+    # @return [Hash<Symbol, FiberUnits::Length>] all measurements
+    attr_reader :data
+
+    # @param measurements [Hash<Symbol, FiberUnits::Length>] named body measurements
+    def initialize(**measurements)
+      raise ArgumentError, "at least one measurement is required" if measurements.empty?
+
+      @data = measurements.freeze
+      define_accessors!
+    end
+
+    # Returns the measurement names.
+    #
+    # @return [Array<Symbol>]
+    def measurements
+      data.keys
+    end
+
+    # Hash-style access to a measurement.
+    #
+    # @param name [Symbol]
+    # @return [FiberUnits::Length, nil]
+    def [](name)
+      data[name]
+    end
+
+    # Returns measurements as a plain hash.
+    #
+    # @return [Hash<Symbol, FiberUnits::Length>]
+    def to_h
+      data.dup
+    end
+
+    private
+
+    def define_accessors!
+      data.each_key do |name|
+        define_singleton_method(name) { data[name] }
+      end
+    end
+  end
+end

data/lib/fiber_pattern/ease.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Value object representing ease preferences per measurement.
+  #
+  # Ease is the difference between body measurements and finished garment
+  # measurements. Positive ease creates a looser fit; negative ease creates
+  # a tighter fit.
+  #
+  # @example
+  #   ease = FiberPattern::Ease.new(
+  #     bust: 4.inches,
+  #     waist: 2.inches,
+  #     hip: 2.inches
+  #   )
+  #   ease.bust        # => 4.inches
+  #   ease[:waist]     # => 2.inches
+  #   ease.for(:bust)  # => 4.inches
+  class Ease
+    # @return [Hash<Symbol, FiberUnits::Length>] all ease values
+    attr_reader :data
+
+    # @param ease_values [Hash<Symbol, FiberUnits::Length>] named ease values
+    def initialize(**ease_values)
+      raise ArgumentError, "at least one ease value is required" if ease_values.empty?
+
+      @data = ease_values.freeze
+      define_accessors!
+    end
+
+    # Returns the ease value for a given measurement.
+    #
+    # @param name [Symbol]
+    # @return [FiberUnits::Length]
+    # @raise [ArgumentError] if no ease is defined for the measurement
+    def for(name)
+      raise ArgumentError, "no ease defined for #{name.inspect}" unless data.key?(name)
+
+      data[name]
+    end
+
+    # Hash-style access to an ease value.
+    #
+    # @param name [Symbol]
+    # @return [FiberUnits::Length, nil]
+    def [](name)
+      data[name]
+    end
+
+    # Returns all measurement names that have ease defined.
+    #
+    # @return [Array<Symbol>]
+    def measurements
+      data.keys
+    end
+
+    # Returns ease values as a plain hash.
+    #
+    # @return [Hash<Symbol, FiberUnits::Length>]
+    def to_h
+      data.dup
+    end
+
+    private
+
+    def define_accessors!
+      data.each_key do |name|
+        next if name == :for # avoid overriding #for
+
+        define_singleton_method(name) { data[name] }
+      end
+    end
+  end
+end

data/lib/fiber_pattern/garment_sizing.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Combines body measurements with ease to produce finished garment dimensions.
+  #
+  # @example
+  #   body = FiberPattern::BodyMeasurements.new(bust: 36.inches, waist: 30.inches)
+  #   ease = FiberPattern::Ease.new(bust: 4.inches, waist: 2.inches)
+  #   garment = FiberPattern::GarmentSizing.new(body: body, ease: ease)
+  #   garment.bust   # => 40.inches
+  #   garment.waist  # => 32.inches
+  class GarmentSizing
+    # @return [FiberPattern::BodyMeasurements]
+    attr_reader :body
+
+    # @return [FiberPattern::Ease]
+    attr_reader :ease
+
+    # @param body [FiberPattern::BodyMeasurements] body measurements
+    # @param ease [FiberPattern::Ease] ease preferences
+    def initialize(body:, ease:)
+      validate!(body, ease)
+      @body = body
+      @ease = ease
+      define_accessors!
+    end
+
+    # Returns the finished garment dimension for a given measurement.
+    #
+    # @param name [Symbol]
+    # @return [FiberUnits::Length] body measurement + ease
+    # @raise [ArgumentError] if the measurement is not defined
+    def dimension(name)
+      raise ArgumentError, "unknown measurement #{name.inspect}" unless body.data.key?(name)
+
+      body[name] + (ease[name] || zero_length(body[name]))
+    end
+
+    # Hash-style access to finished dimensions.
+    #
+    # @param name [Symbol]
+    # @return [FiberUnits::Length]
+    def [](name)
+      dimension(name)
+    end
+
+    # Returns all finished garment dimensions.
+    #
+    # @return [Hash<Symbol, FiberUnits::Length>]
+    def dimensions
+      body.measurements.each_with_object({}) do |name, result|
+        result[name] = dimension(name)
+      end
+    end
+
+    private
+
+    def validate!(body, ease)
+      ease.measurements.each do |name|
+        unless body.measurements.include?(name)
+          raise ArgumentError, "ease defines #{name.inspect} but body measurements does not"
+        end
+      end
+    end
+
+    def define_accessors!
+      body.measurements.each do |name|
+        define_singleton_method(name) { dimension(name) }
+      end
+    end
+
+    def zero_length(reference)
+      reference * 0
+    end
+  end
+end

data/lib/fiber_pattern/grade_rules.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Defines per-measurement step values used to grade a pattern across sizes.
+  #
+  # Each rule maps a measurement name to a step value (a FiberUnits::Length)
+  # that represents how much that measurement changes between adjacent sizes.
+  #
+  # @example
+  #   rules = FiberPattern::GradeRules.new(
+  #     bust: { step: 2.inches },
+  #     waist: { step: 2.inches },
+  #     sleeve_length: { step: 0.5.inches }
+  #   )
+  #   rules.step_for(:bust) # => 2.inches
+  class GradeRules
+    # @return [Hash<Symbol, Hash>] raw rules keyed by measurement name
+    attr_reader :rules
+
+    # @param rules [Hash<Symbol, Hash>] measurement rules, each with a :step key
+    def initialize(**rules)
+      validate!(rules)
+      @rules = rules.freeze
+    end
+
+    # Returns the step value for a given measurement.
+    #
+    # @param measurement [Symbol] measurement name
+    # @return [FiberUnits::Length] step between adjacent sizes
+    # @raise [ArgumentError] if the measurement has no rule defined
+    def step_for(measurement)
+      raise ArgumentError, "no rule defined for #{measurement.inspect}" unless rules.key?(measurement)
+
+      rules[measurement][:step]
+    end
+
+    # Returns all measurement names that have rules defined.
+    #
+    # @return [Array<Symbol>]
+    def measurements
+      rules.keys
+    end
+
+    private
+
+    def validate!(rules)
+      rules.each do |name, config|
+        unless config.is_a?(Hash) && config.key?(:step)
+          raise ArgumentError, "rule for #{name.inspect} must be a Hash with a :step key"
+        end
+      end
+    end
+  end
+end

data/lib/fiber_pattern/grader.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Applies grade rules to a base size's measurements to produce a full size range.
+  #
+  # @example
+  #   grader = FiberPattern::Grader.new(
+  #     base_size: :m,
+  #     measurements: { bust: 36.inches, waist: 30.inches },
+  #     rules: grade_rules
+  #   )
+  #   grader.size(:l)     # => { bust: 38.inches, waist: 32.inches }
+  #   grader.all_sizes    # => { xs: {...}, s: {...}, ... }
+  class Grader
+    # Standard size progression from smallest to largest.
+    SIZES = %i[xs s m l xl xxl xxxl xxxxl xxxxxl].freeze
+
+    # @return [Symbol] the base size used as the grading anchor
+    # @return [Hash<Symbol, FiberUnits::Length>] base measurements
+    # @return [FiberPattern::GradeRules] grading rules
+    attr_reader :base_size, :measurements, :rules
+
+    # @param base_size [Symbol] one of the standard SIZES
+    # @param measurements [Hash<Symbol, FiberUnits::Length>] base size measurements
+    # @param rules [FiberPattern::GradeRules] grade rules to apply
+    # @param sizes [Array<Symbol>] optional custom size list (defaults to SIZES)
+    def initialize(base_size:, measurements:, rules:, sizes: SIZES)
+      @sizes = sizes
+      validate!(base_size, measurements, rules)
+      @base_size = base_size
+      @measurements = measurements.freeze
+      @rules = rules
+    end
+
+    # Returns graded measurements for a single size.
+    #
+    # @param target [Symbol] the size to compute
+    # @return [Hash<Symbol, FiberUnits::Length>]
+    # @raise [ArgumentError] if the target size is not in the size list
+    def size(target)
+      raise ArgumentError, "unknown size #{target.inspect}" unless @sizes.include?(target)
+
+      offset = @sizes.index(target) - @sizes.index(base_size)
+
+      measurements.each_with_object({}) do |(name, base_value), result|
+        step = rules.step_for(name)
+        result[name] = base_value + (step * offset)
+      end
+    end
+
+    # Returns graded measurements for all sizes.
+    #
+    # @return [Hash<Symbol, Hash<Symbol, FiberUnits::Length>>]
+    def all_sizes
+      @sizes.each_with_object({}) do |size_name, result|
+        result[size_name] = size(size_name)
+      end
+    end
+
+    private
+
+    def validate!(base_size, measurements, rules)
+      unless @sizes.include?(base_size)
+        raise ArgumentError, "base_size #{base_size.inspect} is not in the size list"
+      end
+
+      measurements.each_key do |name|
+        unless rules.measurements.include?(name)
+          raise ArgumentError, "no grade rule for measurement #{name.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/fiber_pattern/shaping.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Calculates evenly distributed shaping (increases or decreases) across a span of rows.
+  #
+  # @example Decreasing from 60 to 40 stitches over 30 rows
+  #   shaping = FiberPattern::Shaping.new(
+  #     from: 60.stitches,
+  #     to: 40.stitches,
+  #     over: 30.rows,
+  #     method: :decrease
+  #   )
+  #   shaping.total_changes      # => 10
+  #   shaping.every_n_rows       # => 3
+  #   shaping.schedule           # => [{row: 1, action: :dec}, {row: 4, action: :dec}, ...]
+  class Shaping
+    # @return [FiberUnits::Stitches] starting stitch count
+    # @return [FiberUnits::Stitches] ending stitch count
+    # @return [FiberUnits::Rows] total rows available for shaping
+    # @return [Symbol] shaping method (:increase or :decrease)
+    # @return [Integer] stitches changed per shaping row (default 2 for paired shaping)
+    attr_reader :from, :to, :over, :method, :stitches_per_event
+
+    # @param from [FiberUnits::Stitches] starting stitch count
+    # @param to [FiberUnits::Stitches] target stitch count
+    # @param over [FiberUnits::Rows] number of rows available for shaping
+    # @param method [Symbol] :increase or :decrease
+    # @param stitches_per_event [Integer] stitches changed per shaping row (default 2 for paired shaping)
+    def initialize(from:, to:, over:, method:, stitches_per_event: 2)
+      validate!(from, to, over, method)
+      @from = from
+      @to = to
+      @over = over
+      @method = method
+      @stitches_per_event = stitches_per_event
+    end
+
+    # Total number of shaping events needed.
+    #
+    # @return [Integer]
+    def total_changes
+      stitch_difference / stitches_per_event
+    end
+
+    # Base interval between shaping rows.
+    #
+    # @return [Integer]
+    def every_n_rows
+      return 0 if total_changes.zero?
+
+      over.value / total_changes
+    end
+
+    # Row-by-row schedule of shaping events, distributing any remainder rows
+    # evenly across the span.
+    #
+    # @return [Array<Hash>] each entry has :row and :action keys
+    def schedule
+      return [] if total_changes.zero?
+
+      changes = total_changes
+      rows_available = over.value
+      action = (method == :decrease) ? :dec : :inc
+
+      base_interval = rows_available / changes
+      remainder = rows_available % changes
+
+      schedule = []
+      current_row = 0
+
+      changes.times do |i|
+        # Spread remainder evenly: the first `remainder` intervals get +1 row
+        interval = base_interval + ((i < remainder) ? 1 : 0)
+        current_row += interval
+        schedule << {row: current_row, action: action}
+      end
+
+      schedule
+    end
+
+    private
+
+    def stitch_difference
+      (from.value - to.value).abs
+    end
+
+    def validate!(from, to, over, method)
+      unless %i[increase decrease].include?(method)
+        raise ArgumentError, "method must be :increase or :decrease, got #{method.inspect}"
+      end
+
+      if method == :decrease && from.value < to.value
+        raise ArgumentError, "from must be greater than to for :decrease shaping"
+      end
+
+      if method == :increase && from.value > to.value
+        raise ArgumentError, "from must be less than to for :increase shaping"
+      end
+
+      if over.value <= 0
+        raise ArgumentError, "over must be a positive row count"
+      end
+    end
+  end
+end

data/lib/fiber_pattern/size_chart.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module FiberPattern
+  # Standard size chart based on Craft Yarn Council (CYC) guidelines.
+  #
+  # Provides lookup of standard body measurements by size, and a closest-size
+  # finder that matches body measurements to the nearest standard size.
+  #
+  # @example
+  #   chart = FiberPattern::SizeChart.new
+  #   chart.size(:m)          # => { bust: 36.inches, waist: 28.inches, hip: 38.inches }
+  #   chart.closest_size(bust: 37.inches, waist: 29.inches, hip: 39.inches) # => :m
+  class SizeChart
+    # CYC standard women's body measurements (inches).
+    # Source: Craft Yarn Council Standards & Guidelines
+    CYC_WOMEN = {
+      xs: {bust: 28, waist: 20, hip: 30},
+      s: {bust: 32, waist: 24, hip: 34},
+      m: {bust: 36, waist: 28, hip: 38},
+      l: {bust: 40, waist: 32, hip: 42},
+      xl: {bust: 44, waist: 36, hip: 46},
+      xxl: {bust: 48, waist: 40, hip: 50},
+      xxxl: {bust: 52, waist: 44, hip: 54},
+      xxxxl: {bust: 56, waist: 48, hip: 58},
+      xxxxxl: {bust: 60, waist: 52, hip: 62}
+    }.freeze
+
+    # @return [Hash<Symbol, Hash<Symbol, FiberUnits::Length>>] size chart data
+    attr_reader :chart
+
+    # @return [Array<Symbol>] ordered size names
+    attr_reader :sizes
+
+    # Creates a new size chart.
+    #
+    # @param chart [Hash<Symbol, Hash<Symbol, Numeric>>] raw chart data mapping size names
+    #   to measurement hashes. Values are converted to inches. Defaults to CYC_WOMEN.
+    def initialize(chart: CYC_WOMEN)
+      @chart = chart.each_with_object({}) do |(size_name, measurements), result|
+        result[size_name] = measurements.transform_values { |v| v.is_a?(Numeric) ? v.inches : v }
+      end.freeze
+      @sizes = @chart.keys.freeze
+    end
+
+    # Returns body measurements for a standard size.
+    #
+    # @param name [Symbol] size name
+    # @return [Hash<Symbol, FiberUnits::Length>]
+    # @raise [ArgumentError] if the size is not in the chart
+    def size(name)
+      raise ArgumentError, "unknown size #{name.inspect}" unless chart.key?(name)
+
+      chart[name]
+    end
+
+    # Finds the closest standard size to the given body measurements.
+    #
+    # Compares using the sum of squared differences across all provided
+    # measurements. Only measurements present in both the query and the
+    # chart are compared.
+    #
+    # @param measurements [Hash<Symbol, FiberUnits::Length>] body measurements to match
+    # @return [Symbol] the closest size name
+    # @raise [ArgumentError] if no measurements overlap with the chart
+    def closest_size(**measurements)
+      comparable_keys = measurements.keys & chart.values.first.keys
+      raise ArgumentError, "no comparable measurements provided" if comparable_keys.empty?
+
+      sizes.min_by do |size_name|
+        size_data = chart[size_name]
+        comparable_keys.sum do |key|
+          diff = measurements[key].value - size_data[key].value
+          diff * diff
+        end
+      end
+    end
+
+    # Returns a BodyMeasurements object for a standard size.
+    #
+    # @param name [Symbol] size name
+    # @return [FiberPattern::BodyMeasurements]
+    def body_measurements_for(name)
+      BodyMeasurements.new(**size(name))
+    end
+  end
+end

data/lib/fiber_pattern/version.rb

@@ -3,6 +3,6 @@
 # :nocov:
 module FiberPattern
   # Current gem version.
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end
 # :nocov:

data/lib/fiber_pattern.rb

@@ -6,6 +6,13 @@ require_relative "fiber_pattern/version"
 require_relative "fiber_pattern/sizing"
 require_relative "fiber_pattern/repeat"
 require_relative "fiber_pattern/scaling"
+require_relative "fiber_pattern/shaping"
+require_relative "fiber_pattern/grade_rules"
+require_relative "fiber_pattern/grader"
+require_relative "fiber_pattern/body_measurements"
+require_relative "fiber_pattern/ease"
+require_relative "fiber_pattern/garment_sizing"
+require_relative "fiber_pattern/size_chart"
 
 # Utilities for generating fiber pattern measurements from gauge data.
 module FiberPattern

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fiber_pattern
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Meagan Waller
@@ -37,6 +37,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A Ruby gem for calculating pattern sizes and stitch counts for knitting
   and crochet projects.
 email:
@@ -48,8 +76,15 @@ files:
 - LICENSE.txt
 - README.md
 - lib/fiber_pattern.rb
+- lib/fiber_pattern/body_measurements.rb
+- lib/fiber_pattern/ease.rb
+- lib/fiber_pattern/garment_sizing.rb
+- lib/fiber_pattern/grade_rules.rb
+- lib/fiber_pattern/grader.rb
 - lib/fiber_pattern/repeat.rb
 - lib/fiber_pattern/scaling.rb
+- lib/fiber_pattern/shaping.rb
+- lib/fiber_pattern/size_chart.rb
 - lib/fiber_pattern/sizing.rb
 - lib/fiber_pattern/version.rb
 - sig/fiber_pattern.rbs