ramekin 0.0.5b

data/lib/ramekin/tokenizer.rb

@@ -0,0 +1,287 @@
+require 'strscan'
+
+module Ramekin
+  class Location
+    attr_reader :pos, :line, :col
+    def initialize(pos, line, col)
+      @pos = pos
+      @line = line
+      @col = col
+    end
+
+    def linecol
+      "#{@line}:#{@col}"
+    end
+
+    def start
+      self
+    end
+
+    def fin
+      self
+    end
+  end
+
+  class LocRange
+    def self.between(a, b)
+      new(a.start, b.fin)
+    end
+
+    attr_reader :start, :fin
+    def initialize(start, fin)
+      @start = start
+      @fin = fin
+    end
+
+    def pos_range
+      (@start.pos...@fin.pos)
+    end
+  end
+
+  class Token < Element
+    def initialize(type, *values)
+      @type = type
+      @values = values
+      @meta = {}
+    end
+
+    def components
+      [self]
+    end
+
+    def value
+      @values[0]
+    end
+
+    def dup
+      Token.new(type, *values).tap { |t| t.loc_range = loc_range }
+    end
+
+    attr_reader :type, :values, :meta
+    attr_accessor :loc_range
+
+    def start
+      loc_range.start
+    end
+
+    def fin
+      loc_range.fin
+    end
+
+    def repr_basic
+      return @type if @values.empty?
+
+      "#{@type}(#{@values.join(',')})"
+    end
+
+    def repr
+      return repr_basic if macro_stack.empty?
+
+      "#{repr_basic}[#{macro_stack.map(&:value).join(',')}]"
+    end
+
+    def inspect
+      "t:#{repr}"
+    end
+  end
+
+  class Tokenizer
+    def self.tokenize(str, &b)
+      new(str).tokenize(&b)
+    end
+
+    def initialize(str)
+      @scanner = StringScanner.new(str)
+      @macros = []
+      @last_match = nil
+      @last_captures = []
+      @line = 0
+      @col = 0
+      @in_macro = false
+    end
+
+    include Error::Helpers
+    # @override
+    def default_error_location
+      @last_token
+    end
+
+    def skip_whitespace_and_comments
+      match %r(
+        (?: \s+
+          | ;.*?$
+        )+
+      )mx
+    end
+
+    def match(regexp)
+      matched = @scanner.scan(regexp)
+      return false unless matched
+
+      update_linecol(matched)
+      true
+    end
+
+    def match_exact(string)
+      return false unless @scanner.peek(string.size) == string
+      @scanner.pos += string.size
+      update_linecol(string)
+      true
+    end
+
+    def update_linecol(matched)
+      @index += matched.size
+
+      newlines = matched.count("\n")
+      @line += newlines
+      if newlines > 0
+        @col = find_colno(matched[0])
+      else
+        @col += find_colno(matched[0])
+      end
+    end
+
+    def find_colno(str)
+      str.rpartition("\n").last.size
+    end
+
+    def location
+      Location.new(@scanner.pos, @line, @col)
+    end
+
+    def tokenize(&b)
+      return enum_for(:tokenize) unless block_given?
+
+      @index = 0
+      @lineno = 1
+      @colno = 1
+      skip_whitespace_and_comments
+
+      until @scanner.eos?
+        start = self.location
+        category, *values = self.scan
+        t = Token.new(category, *values)
+        # t.source_name = @source_name
+        # t.original = @input
+        t.loc_range = LocRange.between(start, self.location)
+
+        @last_token = t
+        yield t
+        skip_whitespace_and_comments
+      end
+    end
+
+    def scan
+      if @is_note
+        @is_note = false
+        return [:length, m] if match /\d+[.]?|=\d+/
+      end
+
+      if @is_remote
+      end
+
+      @macros.each do |pattern|
+        return [:macrocall, pattern] if match_exact(pattern)
+      end
+
+      if !@in_macro and match /"([^="]+?)=/
+        @macros << m(1)
+
+        @macros.sort_by! { |m| -m.size }
+        @macros.uniq!
+
+        @in_macro = true
+
+        return [:macro, m(1)]
+      end
+
+      if @in_macro and match /"/
+        @in_macro = false
+        return [:endmacro]
+      end
+
+      return [:string, unescape(m(1))] if match /"((?:\\.|[^"])*)"/
+
+      return [:define, m(1)] if match /#define\s*(.*?)\n/
+      return [:ifdef, m(1)] if match /#ifdef\s*(.*?)\n/
+      return [:ifndef, m(1)] if match /#ifndef\s*(.*?)\n/
+      return [:endif, m(1)] if match /#endif/
+
+      return [:adsr, m(1)] if match /#adsr:(\h+(?:,\h+)*)/
+      return [:tuning, m(1)] if match /#tuning:(\h\h\h\h)/
+      return [:bpm, m(1)] if match /#bpm:(\d+)/
+      return [:legato_tie] if match /~/
+
+      return [:transpose, m(1)] if match /_([+-]\d+)/
+      return [:transpose, '0'] if match /_0/
+      return [:amk, m(1)] if match /#amk\s*(\d+)/
+      return [:option, m(1)] if match /#option (\w+)/
+      return [:channel, m(1)] if match /#(\d+)/
+      return [:directive, m(1)] if match /#([\w-]+)/
+      return [:lbrace] if match /[{]/
+      return [:rbrace] if match /[}]/
+      return [:v, m(1), m(2)] if match /v(\d+)(?:,(\d+))?/
+      return [:relv, m(1), m(2)] if match /v([+-]\d+)(?:,(\d+))?/
+      return [:instrument, m(1)] if match /@(\d+)/
+      return [:instrument, m(1)] if match /@(\w+)/
+      return [:hex, m(1)] if match /[$](\h\h)/
+      return [:t, m(1)] if match /t(\d+)/
+
+      return note(:note, m) if match /[abcdefg][+-]?/
+      return note(:r) if match /r/
+      return note(:native_tie, m(1)) if match /\^\^/
+      return note(:tie, m(1)) if match /\^/
+      return [:slash] if match /\//
+
+      return [:octave, m] if match /[<>]/
+      return [:o, m(1)] if match /o(\d+)/
+      return [:p, m(1)] if match /p(\d+,\d+(?:,\d+)?)/
+
+      return [:superloop] if match /\[\[/
+      return [:superloop_end, m(1)] if match /\]\](\d*)/
+
+      return [:remote_def, m(1)] if match /[(]!(\d+)[)]\[/
+      return [:loop, m(1)] if match /(?:[(](\d+)[)])?\[/
+      return [:loop_end, m(1)] if match /\](\d*)/
+      return [:loop_call, m(1), m(2)] if match /[(](\d+)[)](\d+)?/
+
+      # this needs a reparse
+      return remote(:remote_call, m(1)) if match /[(]!(\d*)/
+
+      return [:star, m(1)] if match /\*(\d*)/
+      return [:y, m(1)] if match /y(\d+)/
+      return [:rely, m(1)] if match /y([LR]\d+)/
+      return [:rely, 'C'] if match /yC/
+      return [:w, m(1)] if match /w(\d+)/
+      return [:l, m(1)] if match /l(\d+)/
+      return [:amp] if match /[&]/
+      return [:q, m(1)] if match /q(\h\h)/
+      return [:n, m(1)] if match /n(\h\h?)/
+
+      error! "unknown token near: #{@scanner.peek(10)}"
+
+      return [:unknown, m] if match /./
+    end
+
+    def note(*a)
+      @is_note = true
+      a
+    end
+
+    def remote(*a)
+      @is_remote = true
+      a
+    end
+
+    def unescape(str)
+      str.gsub /\\(.)/ do
+        next $1 if $1 == '"'
+        error! "invalid escape - only double quote allowed: #{$1.inspect}"
+      end
+    end
+
+    def m(i=0)
+      @scanner[i]
+    end
+  end
+end

data/lib/ramekin/util.rb

@@ -0,0 +1,120 @@
+require 'zip'
+
+module Ramekin
+  module Util
+    extend self
+
+  private
+    def clear_dir(dir, force: false, remake: true)
+      if Dir.exist?(dir) && !Dir.empty?(dir)
+        unless @force
+          $stderr.print "#{dir} already exists. delete? [y/n] "
+          input = $stdin.gets.strip
+          if input.downcase != 'y'
+            $stderr.puts 'skipping...'
+            return false
+          end
+        end
+
+        FileUtils.remove_entry_secure(dir) if Dir.exist?(dir)
+      end
+
+      FileUtils.mkdir_p(dir) if remake
+      true
+    end
+
+    def unpack_zip_here(zip, &b)
+      Zip::File.open_buffer(zip).each do |entry|
+        next if entry.directory?
+        # chop off the first directory
+        name = entry.name.split('/', 2).last
+        next if name.empty?
+        next if name.start_with?('.github')
+        next if name =~ /__MACOSX/
+        yield name if block_given?
+
+        next unless File.expand_path(name).start_with?(File.expand_path('.'))
+
+        FileUtils.mkdir_p(File.dirname(name))
+        entry.extract(name)
+      end
+    end
+
+    def sys(*a, **kw)
+      env = {}
+      kw.each { |k, v| env[k.to_s] = v }
+
+      system(env, *a)
+    rescue Interrupt
+      # allow interrupt out of the subprocess but capture it for ramekin itself
+    end
+
+    def executable?(path)
+      stat = File.stat(path)
+      stat.file? && stat.executable?
+    rescue SystemCallError
+      false
+    end
+
+    def config_string(key)
+      s = RbConfig::MAKEFILE_CONFIG[key]
+      if block_given?
+        yield s
+      else
+        s
+      end
+    end
+
+    def find_executable(bin, path=ENV['PATH'])
+      executable_file = proc do |name|
+        begin
+        rescue SystemCallError
+        else
+          next name if stat.file? and stat.executable?
+        end
+      end
+
+      exts = config_string('EXECUTABLE_EXTS')&.split || config_string('EXEEXT') {|s| [s]}
+      if File.expand_path(bin) == bin
+        return bin if executable?(bin)
+        if exts
+          exts.each {|ext| executable?(file = bin + ext) and return file}
+        end
+        return nil
+      end
+
+      if path
+        path = path.split(File::PATH_SEPARATOR)
+      else
+        path = %w[/usr/local/bin /usr/ucb /usr/bin /bin]
+      end
+
+      path.each do |dir|
+        dir.sub!(/\A"(.*)"\z/m, '\1') if $mswin or $mingw
+        file = File.join(dir, bin)
+        return file if executable?(file)
+
+        (exts || []).each do |ext|
+          fname = file + ext
+          return fname if executable?(fname)
+        end
+      end
+      nil
+    end
+
+    def cmake
+      @cmake ||= find_executable('cmake') \
+        or error! 'please install cmake to set up addmusick/asar.'
+    end
+
+    def make
+      @make ||= find_executable('make') \
+        or error! 'please install make to set up addmusick/asar.'
+    end
+
+    def git
+      @git ||= find_executable('git') \
+        or error! 'please install git to set up spct'
+    end
+  end
+end

data/lib/ramekin/volume.rb

@@ -0,0 +1,16 @@
+module Ramekin
+  module Volume
+    extend self
+
+    BASE = Math.log(2) / 6
+    INF = 1.0/0
+    def volume_to_db(vol)
+      return -INF if vol == 0
+      Math.log((vol+1) / 256.0) / BASE
+    end
+
+    def db_to_volume(db)
+      (256.0 * Math.exp(BASE * db) - 1).clamp(0..)
+    end
+  end
+end

data/lib/ramekin.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require_relative 'ramekin/util'
+require_relative 'ramekin/config'
+require_relative 'ramekin/amk_setup'
+require_relative 'ramekin/spc_player'
+require_relative 'ramekin/errors'
+require_relative 'ramekin/element'
+require_relative 'ramekin/tokenizer'
+require_relative 'ramekin/processor'
+require_relative 'ramekin/macros'
+require_relative 'ramekin/note_aggregator'
+require_relative 'ramekin/legato'
+require_relative 'ramekin/meta'
+require_relative 'ramekin/channel_separator'
+require_relative 'ramekin/volume'
+require_relative 'ramekin/renderer'
+require_relative 'ramekin/amk_runner'
+require_relative 'ramekin/sample_pack'

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: ramekin
+version: !ruby/object:Gem::Version
+  version: 0.0.5b
+platform: ruby
+authors:
+- jneen
+autorequire:
+bindir: gembin
+cert_chain: []
+date: 2025-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: strscan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description:
+email: jneen@jneen.net
+executables:
+- ramekin
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- gembin/ramekin
+- lib/ramekin.rb
+- lib/ramekin/amk_runner.rb
+- lib/ramekin/amk_runner/sample_groups.rb
+- lib/ramekin/amk_setup.rb
+- lib/ramekin/channel_separator.rb
+- lib/ramekin/cli.rb
+- lib/ramekin/config.rb
+- lib/ramekin/element.rb
+- lib/ramekin/errors.rb
+- lib/ramekin/legato.rb
+- lib/ramekin/macros.rb
+- lib/ramekin/meta.rb
+- lib/ramekin/note_aggregator.rb
+- lib/ramekin/processor.rb
+- lib/ramekin/renderer.rb
+- lib/ramekin/sample_pack.rb
+- lib/ramekin/spc_player.rb
+- lib/ramekin/tokenizer.rb
+- lib/ramekin/util.rb
+- lib/ramekin/volume.rb
+homepage: https://codeberg.org/jneen/ramekin
+licenses:
+- GPL-3.0-only
+metadata:
+  source_code_uri: https://codeberg.org/jneen/ramekin
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A tool for making SMW music with AddmusicK
+test_files: []