tdrb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e92d32f3edc5319cab952f4777c42c97170325cd9e19c94558dd9f6cf36d965
+  data.tar.gz: 86954cb680c46b56814d95511d52a371fcfb2062fb715cdf8b7addc1d426e31e
+SHA512:
+  metadata.gz: 20e77bb2e93ddd65de9b9f72df08f19711152cdf47c38b9dc257b59b31508497bbb8b7ecec32259a62518929c489c67817e94d3115d7f40b274f33b77fd4739c
+  data.tar.gz: 13bbcf53226ef1afb1d2273c2ad4d8799fde2cea64f04d62b8d973477ed5bb4bf061c15a79be294048af58b25b0daba250035c2f5ef02b8683bef5779ddaf0b9

data/lib/tdrb/error.rb

@@ -0,0 +1,16 @@
+module TDRB
+  class Error < StandardError
+  end
+
+  class ParseError < Error
+  end
+
+  class TokenArgsError < Error
+  end
+
+  class TokenError < Error
+  end
+
+  class TokenTypeError < Error
+  end
+end

data/lib/tdrb/lexer.rb

@@ -0,0 +1,83 @@
+module TDRB
+  class Lexer
+    attr_reader :source, :tokens
+
+    def initialize(source:, state: -> (_) {})
+      @col    = 0
+      @line   = 0
+      @pos    = 0
+      @source = source
+      @stack  = []
+      @start  = 0
+      @state  = state
+      @tokens = []
+    end
+
+    def chars
+      @chars ||= source.grapheme_clusters
+    end
+
+    def current
+      chars[@start..]
+        .take(@pos - @start)
+        .join
+    end
+
+    def emit(token_type)
+      tokens << Token.new(literal: current, type: token_type)
+
+      @start = @pos
+      @stack = []
+    end
+
+    def ignore
+      @stack = []
+      @start = @pos
+    end
+
+    def next_char
+      return @stack << Token::EOF && Token::EOF if chars.count.pred == @pos
+
+      sub_source = source[@pos..]
+      @pos += 1
+
+      return @stack << Token::EOF && Token::EOF if sub_source.nil?
+
+      @stack << sub_source[0] && sub_source[0]
+    end
+
+    def peek
+      char = next_char
+      rewind
+
+      char
+    end
+
+    def pop_stack
+      @stack.pop || Token::EOF
+    end
+
+    def rewind
+      char = pop_stack
+      @pos -= 1 if char != Token::EOF
+      @pos = @start if (@pos < @start)
+    end
+
+    def run
+      while @state do
+        @state = @state.call(self)
+      end
+
+      true
+    end
+
+    def take(characters)
+      char = next_char
+      while characters.include?(char) do
+        char = next_char
+      end
+
+      rewind
+    end
+  end
+end

data/lib/tdrb/parse.rb

@@ -0,0 +1,89 @@
+require "time"
+
+module TDRB
+  ## Returns Array<Result> to allow for multisession documents.
+  def self.parse(traindown:)
+    metakey_buf    = nil
+    movement_meta  = {}
+    movement_notes = []
+    result         = nil
+    performance    = nil
+
+    Parser
+      .new(traindown: traindown)
+      .tokens
+      .each_with_object([]) do |token, arr|
+        case token.type
+        when Token::DATETIME
+          arr << result if !result.nil?
+
+          occurred_at = safe_time(token.literal)
+          result      = Result.new(occurred_at: occurred_at)
+        when Token::FAIL
+          fails = safe_float(token.literal)
+
+          (performance || Performance.new).fails = fails
+        when Token::LOAD
+          if performance.nil? || performance.load
+            result.add_performance(performance) if performance&.load
+
+            performance =
+              Performance.new(
+                movement: performance&.movement,
+                load: safe_float(token.literal),
+              )
+          else
+            performance.load = safe_float(token.literal)
+          end
+        when Token::METAKEY
+          metakey_buf = token.literal
+          target = performance.nil? ? result.metadata : movement_meta
+          target[metakey_buf] = ""
+        when Token::METAVALUE
+          target = performance.nil? ? result.metadata : movement_meta
+          target[metakey_buf] = token.literal
+          metakey_buf = nil
+        when Token::MOVEMENT
+          if !performance.nil?
+            result
+              .add_performance(
+                performance,
+                metadata: movement_metadata,
+                notes: movement_notes,
+              )
+          end
+
+          performance = Performance.new(movement: token.literal)
+        when Token::NOTE
+          target = performance.nil? ? result.notes : movement_notes
+          target << token.literal
+        when Token::REP
+          reps = safe_float(token.literal)
+
+          (performance || Performance.new).reps = reps
+        when Token::SET
+          sets = safe_float(token.literal)
+
+          (performance || Performance.new).sets = sets
+        when Token::SUPERSET
+        end
+      end.tap do |results|
+        return results if result.nil?
+
+        result.add_performance(performance) if !performance.nil?
+        results << result
+      end
+  end
+
+  def self.safe_float(maybe_float_str)
+    Float(maybe_float_str)
+  rescue
+    0.0
+  end
+
+  def self.safe_time(maybe_time_str)
+    Time.parse(maybe_time_str)
+  rescue
+    Time.now
+  end
+end

data/lib/tdrb/parser.rb

@@ -0,0 +1,220 @@
+module TDRB
+  ##
+  # Parser is the thing that does STUFF to a Token stream. What stuff? Well,
+  # that is defined by the handler lambdas.
+
+  class Parser
+    attr_reader :lexer, :traindown
+
+    def initialize(traindown:)
+      @lexer     = Lexer.new(source: traindown, state: IDLE)
+      @traindown = traindown
+    end
+
+    def tokens
+      lexer.run
+      lexer.tokens
+    end
+
+    class << self
+      def colon_terminator?(char)
+        char == ":" || char == Token::EOF
+      end
+
+      def line_terminator?(char)
+        return true if char == Token::EOF
+
+        cp = char.codepoints;
+
+        return true if cp.empty?
+        return true if cp.count == 1 && [0, 10, 13, 59].include?(cp.first)
+        return true if cp.count == 2 && cp.first == 13 and cp.last == 10
+
+        false
+      end
+
+      def whitespace?(char)
+        char.strip.empty?
+      end
+    end
+
+    IDLE = lambda do |lexer|
+      char = lexer.peek
+      return if char == Token::EOF
+
+      if whitespace?(char) || line_terminator?(char)
+        lexer.next_char
+        lexer.ignore
+
+        return IDLE
+      end
+
+      case char
+      when "@" then DATETIME
+      when "#" then METAKEY
+      when "*" then NOTE
+      else
+        VALUE
+      end
+    end
+
+    DATETIME = lambda do |lexer|
+      lexer.take(["@", " "])
+      lexer.ignore
+
+      char = lexer.next_char
+
+      while !line_terminator?(char) do
+        char = lexer.next_char
+      end
+
+      lexer.rewind
+      lexer.emit(Token::DATETIME)
+
+      IDLE
+    end
+
+    METAKEY = lambda do |lexer|
+      lexer.take(["#", " "])
+      lexer.ignore
+
+      char = lexer.next_char
+
+      while !colon_terminator?(char) do
+        char = lexer.next_char
+      end
+
+      lexer.rewind
+      lexer.emit(Token::METAKEY)
+
+      METAVALUE
+    end
+
+    METAVALUE = lambda do |lexer|
+      lexer.take([":", " "])
+      lexer.ignore
+
+      char = lexer.next_char
+
+      while !line_terminator?(char) do
+        char = lexer.next_char
+      end
+
+      lexer.rewind
+      lexer.emit(Token::METAVALUE)
+
+      IDLE
+    end
+
+    # register_state :movement do
+    # end
+
+    MOVEMENT = lambda do |lexer|
+      superset = false;
+
+      char = lexer.next_char
+
+      return if char == Token::EOF
+
+      if char == "+"
+        superset = true
+        lexer.take([" "])
+        lexer.ignore
+        char = lexer.next_char
+      end
+
+      if char == "'"
+        lexer.ignore
+        char = lexer.next_char
+      end
+
+      while !colon_terminator?(char) do
+        char = lexer.next_char
+      end
+
+      lexer.rewind
+
+      if (superset)
+        lexer.emit(Token::SUPERSET)
+      else
+        lexer.emit(Token::MOVEMENT)
+      end
+
+      lexer.take([":"])
+      lexer.ignore
+
+      IDLE
+    end
+
+    NOTE = lambda do |lexer|
+      lexer.take(["*", " "])
+      lexer.ignore
+
+      char = lexer.next_char
+
+      while !line_terminator?(char) do
+        char = lexer.next_char
+      end
+
+      lexer.rewind
+      lexer.emit(Token::NOTE)
+
+      IDLE
+    end
+
+    NUMBER = lambda do |lexer|
+      lexer.take(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "."])
+
+      # TODO: Configurable chars
+      case lexer.peek
+      when "f", "F" then lexer.emit(Token::FAIL)
+      when "r", "R" then lexer.emit(Token::REP)
+      when "s", "S" then lexer.emit(TokenType::SET)
+      else
+        lexer.emit(Token::LOAD)
+      end
+
+      lexer.take(["f", "F", "r", "R", "s", "S"])
+      lexer.ignore
+
+      IDLE
+    end
+
+    VALUE = lambda do |lexer|
+      char = lexer.next_char
+
+      if char == "+" || char == "'"
+        lexer.rewind
+        return MOVEMENT
+      end
+
+      begin
+        !!Integer(char)
+        return NUMBER
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      if char != "b" && char != "B"
+        lexer.rewind
+        return MOVEMENT
+      end
+
+      peek = lexer.peek
+
+      if peek != "w" && peek != "W"
+        lexer.rewind
+        MOVEMENT
+      end
+
+      while !whitespace?(char)
+        char = lexer.next_char
+      end
+
+      lexer.rewind
+      lexer.emit(Token::LOAD)
+
+      IDLE
+    end
+  end
+end

data/lib/tdrb/performance.rb

@@ -0,0 +1,57 @@
+module TDRB
+  class Performance
+    attr_accessor :fails,
+      :load,
+      :metadata,
+      :movement,
+      :notes,
+      :sequence,
+      :sets,
+      :reps
+
+    def initialize(
+      fails: 0,
+      load: nil,
+      movement: "Unidentified Movement",
+      metadata: {},
+      notes: [],
+      reps: 1,
+      sequence: 0,
+      sets: 1
+    )
+      @fails    = 0
+      @load     = load
+      @movement = movement
+      @metadata = metadata
+      @notes    = notes
+      @reps     = 1
+      @sequence = 0
+      @sets     = 1
+    end
+
+    def ==(p)
+      raise TypeError.new("Not a Performance") if !p.is_a? Performance
+
+      p.movement == movement &&
+        p.reps == reps &&
+        p.sets == sets &&
+        p.fails == fails &&
+        p.load == load
+    end
+
+    def to_h
+      @hash ||=
+        instance_variables.each_with_object({}) do |iv, h|
+          h[iv[1..].to_sym] = instance_variable_get(iv)
+        end
+    end
+
+    def to_json
+      @json ||= to_h.to_json
+    end
+
+    def volume
+      (load || 0.0) * sets * (reps - fails)
+    end
+  end
+end

data/lib/tdrb/result.rb

@@ -0,0 +1,50 @@
+require "json"
+require "set"
+
+module TDRB
+  class Result
+    attr_reader :metadata,
+      :notes,
+      :movements,
+      :occurred_at,
+      :performances,
+      :source
+
+    def initialize(
+      movements: ::Set.new,
+      occurred_at: nil,
+      performances: [],
+      source: ""
+    )
+      @metadata     = {}
+      @movements    = movements
+      @notes        = []
+      @occurred_at  = occurred_at
+      @performances = performances
+      @source       = source
+    end
+
+    def add_performance(performance, metadata: {}, notes: [])
+      raise TypeError.new("Not a performance") if !performance.is_a? Performance
+
+      movements.add(performance.movement)
+
+      performance.metadata = metadata
+      performance.notes    = notes
+      performance.sequence = performances.count
+
+      performances << performance
+    end
+
+    def to_h
+      @hash ||=
+        instance_variables.each_with_object({}) do |iv, h|
+          h[iv[1..].to_sym] = instance_variable_get(iv)
+        end
+    end
+
+    def to_json
+      @json ||= to_h.to_json
+    end
+  end
+end

data/lib/tdrb/token.rb

@@ -0,0 +1,63 @@
+module TDRB
+  class Token
+    attr_reader :literal, :type
+
+    DATETIME  = "Date / Time".freeze
+    FAIL      = "Fails".freeze
+    LOAD      = "Load".freeze
+    METAKEY   = "Metadata Key".freeze
+    METAVALUE = "Metadata Value".freeze
+    MOVEMENT  = "Movement".freeze
+    NOTE      = "Note".freeze
+    REP       = "Reps".freeze
+    SET       = "Sets".freeze
+    SUPERSET  = "Superset Movement".freeze
+
+    TOKEN_SYMBOLS = %i[
+      datetime fail load metakey metavalue movement note rep set superset
+    ]
+
+    ALLOWED_TYPES = TOKEN_SYMBOLS.map { |ts| const_get(ts.upcase) }.freeze
+
+    EOF = "\x00".freeze
+
+    class << self
+      TOKEN_SYMBOLS.each do |method|
+        define_method(method) do |literal|
+          new(literal: literal, type: const_get(method.upcase))
+        end
+      end
+    end
+
+    def initialize(literal:, type:)
+      raise TokenTypeError if !ALLOWED_TYPES.include?(type)
+
+      @literal = literal
+      @type    = type
+    end
+
+    def ==(t)
+      raise TokenArgsError.new("Invalid comparison") if !t.is_a? Token
+
+      literal == t.literal && type == t.type
+    end
+
+    def ===(t)
+      raise TokenTypeError if !ALLOWED_TYPES.include?(t)
+
+      type == t
+    end
+
+    def movement?
+      @movement ||= [MOVEMENT, SUPERSET].include?(type)
+    end
+
+    def performance?
+      @performance ||= [FAIL, LOAD, REP, SET].include?(type)
+    end
+
+    def to_s
+      "[#{type}] #{literal}"
+    end
+  end
+end

data/lib/tdrb/version.rb

@@ -0,0 +1,3 @@
+module TDRB
+  VERSION = "1.0.0".freeze
+end

data/lib/tdrb.rb

@@ -0,0 +1,4 @@
+Dir[File.join(__dir__, 'tdrb', '*.rb')].each { |f| require f }
+
+module TDRB
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: tdrb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tyler Scott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-12-14 00:00:00.000000000 Z
+dependencies: []
+description: A fun little gem chockful of Traindown tchotchkies
+email: tyler@greaterscott.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tdrb.rb
+- lib/tdrb/error.rb
+- lib/tdrb/lexer.rb
+- lib/tdrb/parse.rb
+- lib/tdrb/parser.rb
+- lib/tdrb/performance.rb
+- lib/tdrb/result.rb
+- lib/tdrb/token.rb
+- lib/tdrb/version.rb
+homepage: https://traindown.com
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://traindown.com
+  source_code_uri: https://traindown.com
+  changelog_uri: https://traindown.com
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Ruby + Traindown = TDRB
+test_files: []