dieses 0.0.1

data/lib/dieses/application/common.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Dieses
+  module Application
+    Error = Class.new Error
+
+    NotImplementedError = Class.new Error
+    NonApplicableError  = Class.new Error
+
+    struct = Class.new OpenStruct do
+      def self.call(**kwargs)
+        new(**kwargs)
+      end
+
+      def to_a
+        to_h.values
+      end
+    end
+
+    Style = Class.new struct
+    Param = Class.new struct
+
+    Orientation = Geometry::Rect::Orientation
+  end
+end

data/lib/dieses/application/mixins.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'mixins/lines'
+require_relative 'mixins/squares'
+require_relative 'mixins/scribes'

data/lib/dieses/application/mixins/lines.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Application
+    module Mixins
+      module Lines
+        module ClassMethods
+          Line = Struct.new :tag, :after, :style, :step, keyword_init: true
+
+          def hline(tag, after: Undefined, style: EMPTY_HASH)
+            (param.hlines ||= []) << Line.new(tag: tag, after: after, style: style)
+          end
+
+          def vline(tag, after: Undefined, style: EMPTY_HASH)
+            (param.vlines ||= []) << Line.new(tag: tag, after: after, style: style)
+          end
+
+          Cross = Struct.new :tag, :angle, :style, keyword_init: true
+
+          def cline(tag, angle:, style: EMPTY_HASH)
+            (param.clines ||= []) << Cross.new(tag: tag, angle: angle, style: style)
+          end
+        end
+
+        module InstanceMethods
+          def lines(unit: Undefined, multiple: Undefined)
+            step_lines(param)
+
+            unit     = Undefined.default(unit, param.unit)
+            multiple = Undefined.default(multiple, param.multiple || param.hlines&.map(&:step)&.sum)
+
+            draw_hlines unit: unit, multiple: multiple
+            draw_vlines unit: unit, multiple: multiple
+            draw_clines unit: unit, multiple: multiple
+          end
+
+          private
+
+          def step_lines(param)
+            [*param.hlines, *param.vlines].compact.each do |line|
+              line.step = case line.after
+                          when Proc                then param.instance_exec(&line.after)
+                          when Numeric             then line.after
+                          when Undefined, NilClass then 1
+                          else                          raise ArgumentError, "Wrong type for after: #{line.after.class}"
+                          end
+            end
+          end
+
+          def draw_hlines(unit:, multiple:)
+            return unless param.hlines
+
+            param = self.param
+
+            draw unit: unit, multiple: multiple do
+              repeat do
+                param.hlines.each do |line|
+                  hline line.tag, style: line.style
+                  down line.step
+                end
+              end
+            end
+          end
+
+          def draw_vlines(unit:, multiple:)
+            return unless param.vlines
+
+            param = self.param
+
+            draw unit: unit, multiple: multiple do
+              repeat do
+                param.vlines.each do |line|
+                  vline line.tag, style: line.style
+                  right line.step
+                end
+              end
+            end
+          end
+
+          def draw_clines(unit:, multiple:) # rubocop:disable Metrics/MethodLength
+            return unless param.clines
+
+            param = self.param
+
+            draw unit: unit, multiple: multiple do
+              repeat do
+                param.clines.each do |slant|
+                  repeat do
+                    cline slant.tag, angle: slant.angle, style: slant.style
+                    cross
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+        end
+      end
+    end
+  end
+end

data/lib/dieses/application/mixins/scribes.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Application
+    module Mixins
+      class Scribes < Module
+        def self.[](type)
+          raise ArgumentError, "No such Scribes type available: #{type}" unless Bundle.method_defined? type
+
+          new(type)
+        end
+
+        def initialize(type)
+          super()
+          @type = type.to_sym
+        end
+
+        def with(unit:, ratio: [1/1r], gap: [0])
+          tap do
+            @unit  = unit
+            @ratio = ratio
+            @gap   = gap
+          end
+        end
+
+        module ClassMethods
+          def variate_scribes(unit:, ratio: [1/1r], gap: [0])
+            variate(unit: unit, ratio: ratio, gap: gap) do
+              self.name = :"#{self.unit}#{self.ratio.to_s.delete('/')}#{self.gap}"
+              self.desc = "#{self.unit} mm x-height with #{self.ratio} ratio and #{self.gap} mm gap"
+            end
+          end
+        end
+
+        module InstanceMethods
+          def scribes
+            param.x_height = 1.0
+            param.height   = param.hlines.size > 2 ? 2 * param.ratio / (param.hlines.size - 2) : 1
+
+            lines
+          end
+        end
+
+        module Bundle
+          def quartet
+            hline :ascender,  after: proc { height },
+                              style: Style.(stroke: 'blue', 'stroke-width': '0.2')
+            hline :waist,     after: proc { x_height },
+                              style: Style.(stroke: 'grey', 'stroke-width': '0.1', 'stroke-dasharray': '2, 2')
+            hline :base,      after: proc { height },
+                              style: Style.(stroke: 'red',  'stroke-width': '0.1', 'stroke-dasharray': '2, 2')
+            hline :descender, after: proc { gap },
+                              style: Style.(stroke: 'blue', 'stroke-width': '0.2')
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          # codebeat:disable[ABC]
+          def sextet
+            hline :ascender2,  after: proc { height },
+                               style: Style.(stroke: 'blue', 'stroke-width': '0.2')
+            hline :ascender1,  after: proc { height },
+                               style: Style.(stroke: 'grey', 'stroke-width': '0.1', 'stroke-dasharray': '2, 2')
+            hline :waist,      after: proc { x_height },
+                               style: Style.(stroke: 'grey', 'stroke-width': '0.1')
+            hline :base,       after: proc { height },
+                               style: Style.(stroke: 'red',  'stroke-width': '0.1')
+            hline :descender1, after: proc { height },
+                               style: Style.(stroke: 'grey', 'stroke-width': '0.1', 'stroke-dasharray': '2, 2')
+            hline :descender2, after: proc { gap },
+                               style: Style.(stroke: 'blue', 'stroke-width': '0.2')
+          end
+          # codebeat:enable[ABC]
+          # rubocop:enable Metrics/MethodLength
+        end
+
+        def included(base)
+          base.include Lines
+
+          base.extend ClassMethods
+          base.include InstanceMethods
+
+          base.extend Bundle
+
+          base.variate_scribes(unit: @unit, ratio: @ratio, gap: @gap) if @unit
+
+          base.send(@type)
+        end
+      end
+    end
+  end
+end

data/lib/dieses/application/mixins/squares.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Application
+    module Mixins
+      module Squares
+        def squares(unit: Undefined, multiple: Undefined)
+          param = self.param
+
+          draw unit: Undefined.default(unit, param.unit), multiple: Undefined.default(multiple, param.multiple) do
+            repeat do
+              repeat do
+                square :square, width: multiple, style: Style.(stroke: 'blue', 'stroke-width': '0.2', fill: 'none')
+                right multiple
+              end
+              down multiple
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dieses/application/paper.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Dieses
+  module Application
+    module Paper
+      Dim = Struct.new(*%i[width height], keyword_init: true) do
+        def self.call(width, height)
+          new width: width, height: height
+        end
+
+        def short
+          values.min
+        end
+
+        def long
+          values.max
+        end
+      end
+
+      Margin = Struct.new(*%i[top right bottom left], keyword_init: true) do # in CSS margin order
+        def self.call(*args)
+          values = case args.size
+                   when 1            then Array.new(members.size, *args)
+                   when members.size then args
+                   else                   raise ArgumentError, "Incorrect number of arguments: #{args}"
+                   end
+
+          new(Hash[*members.zip(values).flatten])
+        end
+
+        def self.build(dim, short:, long:)
+          kwargs = if dim.height > dim.width
+                     { top: long, right: short, bottom: long, left: short }
+                   else
+                     { top: short, right: long, bottom: short, left: long }
+                   end
+
+          new(**kwargs)
+        end
+      end
+
+      Variant = Struct.new :type, :name, :width, :height, :floor, :scale, keyword_init: true do
+        def build # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+          dim = Dim.(width, height)
+
+          if scale.nil? || (short = Support.approx(dim.short * scale)) < floor
+            short = floor
+            scale = floor / dim.short
+          end
+
+          long   = Support.approx(dim.long * scale)
+          margin = Margin.build(dim, short: short, long: long)
+
+          variant = self
+
+          Paper.define_singleton_method(name) do |**kwargs|
+            klass = Class.new(Instance)
+
+            klass.type    variant.type
+            klass.variant variant.name
+
+            klass.new(*dim.values, **margin.to_h.merge(**kwargs))
+          end
+        end
+      end
+
+      module DSL
+        VARIANTS = [
+          { suffix: 'n', floor: 7.0  }, # Narrow margins (default)
+          { suffix: 'm', floor: 12.0 }, # Medium margins: bare minimum margin to accommodate ISO 838 filing holes
+          { suffix: 'w', floor: 20.0 }  # Wide margins: safe minimum margin to accommodate ISO 838 filing holes
+        ].freeze
+
+        def family(type, width:, height:, scale: nil)
+          VARIANTS.map do |hash|
+            name  = :"#{type}#{hash[:suffix]}"
+            floor = hash[:floor]
+            Variant.new(type: type, name: name, width: width, height: height, floor: floor, scale: scale).tap(&:build)
+          end.first.tap do |variant| # rubocop:disable Style/MultilineBlockChain
+            # set the first variant as the default paper
+            (class << self; self; end).alias_method type, variant.name
+          end
+        end
+      end
+
+      class Instance < DelegateClass(Geometry::Rect)
+        extend Support::ClassAttribute
+
+        define :type,    instance_reader: true
+        define :variant, instance_reader: true
+
+        extend Forwardable
+        def_delegators :@margin, *Margin.members
+
+        def initialize(width, height, **margin)
+          @margin = Margin.new(**margin)
+          super(Geometry::Rect.new(width, height))
+        end
+
+        def inner
+          @inner ||= shrink(width: left + right, height: top + bottom)
+        end
+
+        def orient(orientation)
+          self.class.new((rect = super).width, rect.height, **margin.to_h)
+        end
+
+        def to_h
+          super.merge(margin.to_h)
+        end
+
+        protected
+
+        attr_reader :margin
+      end
+
+      extend DSL
+
+      A4 = Dim.new width: 210.0, height: 297.0
+      B4 = Dim.new width: 250.0, height: 353.0
+      US = Dim.new width: 215.9, height: 279.4
+
+      family :a3, width: A4.height,     height: A4.width * 2
+      family :a4, width: A4.width,      height: A4.height
+      family :a5, width: A4.height / 2, height: A4.width
+      family :a6, width: A4.width  / 2, height: A4.height / 2
+
+      family :b3, width: B4.height,     height: B4.width * 2
+      family :b4, width: B4.width,      height: B4.height
+      family :b5, width: B4.height / 2, height: B4.width
+      family :b6, width: B4.width  / 2, height: B4.height / 2
+
+      family :us, width: US.width,      height: US.height
+
+      class << self
+        alias letter us
+
+        def default
+          :a4
+        end
+      end
+    end
+  end
+end

data/lib/dieses/application/pen.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Application
+    class Pen
+      attr_reader :canvas
+
+      def initialize(canvas)
+        @canvas = canvas
+      end
+
+      def draw(unit:, multiple: nil, &block)
+        Draw.(self, Ruler.(unit, multiple), &block)
+      end
+
+      Ruler = Struct.new :unit, :multiple do
+        def self.call(unit, multiple = nil)
+          new unit, (multiple || 1)
+        end
+
+        def major
+          @major ||= multiple * unit
+        end
+
+        def even(length)
+          major * (length / major).to_i
+        end
+
+        def measure(n)
+          n * unit
+        end
+      end
+
+      class Draw
+        extend Forwardable
+
+        def_delegators :@pen, :canvas
+        def_delegators :@buffer, :<<
+        def_delegators :@ruler, :unit, :multiple
+
+        def self.call(pen, ruler, &block)
+          Draw.new(pen, ruler).(&block)
+        end
+
+        def initialize(pen, ruler, pos: Undefined)
+          @pen    = pen
+          @pos    = Undefined.default(pos, Geometry::Point::Mutable.cast(canvas.position))
+          @ruler  = ruler
+          @buffer = Set.new
+        end
+
+        def repeat(count = nil, &block)
+          self.class.new(pen, ruler, pos: pos.dup).instance_exec do
+            1.step(count) do
+              prev = pos.dup
+              instance_exec(&block)
+              put
+
+              break if pos == prev || perfect.outside?(pos)
+            rescue Offsite
+              break
+            end
+          end
+        end
+
+        def call(&block)
+          instance_exec(&block)
+          put
+        end
+
+        private
+
+        attr_reader :pen, :pos, :ruler, :buffer
+
+        def perfect
+          @perfect ||= Geometry::Rect.new(ruler.even(canvas.width), ruler.even(canvas.height))
+        end
+
+        Offsite = Class.new StopIteration
+
+        module Elements
+          def hline(tag = Undefined, length: Undefined, style: Undefined)
+            length = Undefined.equal?(length) ? perfect.width : ruler.measure(length)
+            add Geometry::Line.new(pos, pos.translate(x: length)), tag, style
+          end
+
+          def vline(tag = Undefined, length: Undefined, style: Undefined)
+            length = Undefined.equal?(length) ? perfect.height : ruler.measure(length)
+            add Geometry::Line.new(pos, pos.translate(y: length)), tag, style
+          end
+
+          def cline(tag = Undefined, angle:, style: Undefined)
+            add perfect.intersect(Geometry::Equation.slant_from_direction(point: pos, angle: -angle)), tag, style
+          end
+
+          def rect(tag = Undefined, width:, height:, style: Undefined)
+            width, height = ruler.measure(width), ruler.measure(height)
+            add Geometry::Rect.new(width, height, position: pos), tag, style
+          end
+
+          def square(tag = Undefined, width:, style: Undefined)
+            rect(tag, width: width, height: width, style: style)
+          end
+
+          private
+
+          BASE_STYLE = { stroke: 'black', 'stroke-width': '0.1' }.freeze
+
+          def add(element, tag, style)
+            raise Offsite unless element && perfect.cover?(element)
+
+            tag = Undefined.default(tag, caller_locations(1, 1).first.label.to_sym)
+
+            element.tap do
+              buffer << element.classify(tag, **BASE_STYLE.merge(Undefined.default(style, EMPTY_HASH).to_h))
+            end
+          end
+
+          def put
+            canvas.tap do
+              buffer.each { |element| canvas << element }
+            end
+          end
+        end
+
+        module Movements
+          def move(x: Undefined, y: Undefined)
+            tap do
+              pos.translate!(x: x * ruler.unit) unless Undefined.equal?(x)
+              pos.translate!(y: y * ruler.unit) unless Undefined.equal?(y)
+            end
+          end
+
+          def up(y = 1)
+            move y: -y
+          end
+
+          def down(y = 1)
+            move y: y
+          end
+
+          def left(x = 1)
+            move x: -x
+          end
+
+          def right(x = 1)
+            move x: x
+          end
+
+          def cross(distance = 1, angle: Undefined)
+            radian = Undefined.equal?(angle) ? perfect.angle : Support.to_radian(angle)
+            move x: distance * Math.cos(radian), y: distance * Math.sin(radian)
+          end
+        end
+
+        include Elements
+        include Movements
+      end
+    end
+  end
+end