shlisp_tools 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shlisp_tools.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 DaveSeidel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# ShlispTools
+
+Tools for shlisp/shnth developers. If you don't recognize both of words starting with "sh", this is probably not for you.
+
+Executables:
+* shlerb (a templating and uploading tool for txts; an ERB wrapper for shlisp)
+* shtool (a collection of little calculations)
+
+Classes/Modules:
+* ShlispTools::Ratio    # represents a pitch ratio
+* ShlispTools::Scales   # represents a scale (consisting of Ratios)
+* ShlispTools::Scales   # tiny collection of predefined scales
+* ShlispTools::Shnth    # useful constants and macros for Shnth things
+
+Shlerb code samples in examples directory.
+
+Shlisp & Shnth come from Sbobo - http://shbobo.net
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shlisp_tools'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shlisp_tools
+
+## Usage
+
+Shlerb usage:
+
+    shlerb FILENAME
+
+where FILENAME is something like cool_shnth_patches.txt.erb or cool_shnth_patches.shlerb. The contents of the file should be shlisp code with optional ERB sections containing Ruby code. (For more information on ERB, see https://en.wikipedia.org/wiki/ERuby). The Ruby code has access to the modules and classes mentioned above. More details soon.
+
+What shlerb does: it translates the input file into pure shlisp code and then uploads it to the attached Shnth using the "shlisp" command (from http://shbobo.net). If these are error translating the file, the error is displayed and nothing is uploaded.
+
+## Examples
+
+Here's an example of a shlerb file with a single situation. It plays a six-note meta-slendro scale on the keys in the order majora, majorb, majorc, majord, minord, minorc. The tones fade in slowly and will tend to (intentionally) distort as they reach full amplitude. The scale used is part of the collection of pre-defined scales that come with ShlispTools.
+
+    <%
+      Slew_mul = 5
+      Slew_add = 5
+      Modo_mul = 2
+    %>
+    <% s1 = Scales::MetaSlendro_1.scale(120) %> 
+    {
+      <%= Shnth::Situation_1 %>
+
+      ; 60Hz-ish
+      (srate (short 72 79))
+
+      (arab
+
+        (pan
+          (add
+            (modo (horna <%= s1[Shnth::Bar_A].n %> <%= s1[Shnth::Bar_A].d %> (slewa (majora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+            (modo (hornc <%= s1[Shnth::Bar_C].n %> <%= s1[Shnth::Bar_C].d %> (slewc (majorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+            (modo (horne <%= s1[Shnth::Bar_d].n %> <%= s1[Shnth::Bar_d].d %> (slewe (minord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          )
+          144
+        )
+
+        (pan
+          (add
+            (modo (hornb <%= s1[Shnth::Bar_B].n %> <%= s1[Shnth::Bar_B].d %> (slewb (majorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+            (modo (hornd <%= s1[Shnth::Bar_D].n %> <%= s1[Shnth::Bar_D].d %> (slewd (majord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+            (modo (hornf <%= s1[Shnth::Bar_c].n %> <%= s1[Shnth::Bar_c].d %> (slewf (minorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          )
+          80
+        )
+
+      )
+    }
+
+You can also define your own scales and add a scaling factor to bring them into the right range for your srate.
+
+    <%
+
+      # shortcuts for long names
+      S = ShlispTools::Scale
+      R = ShlispTools::Ratio
+
+      # define scale with 1/1 = 100 100
+      myMetaSlendro = S::Scale.new([
+        R::Ratio.new( 1,  1),
+        R::Ratio.new(37, 32),
+        R::Ratio.new(21, 16),
+        R::Ratio.new(49, 32),
+        R::Ratio.new( 7,  4),
+        R::Ratio.new( 2,  1)
+      ]).scale(100)
+
+      # get nume and deno for a given scale degree, using indexes 0 through 5 for a six-note scale
+      #   1/1:
+      #   myMetaSlendro[0].nume
+      #   myMetaSlendro[0].deno
+      #
+      #   37/32
+      #   myMetaSlendro[1].nume
+      #   myMetaSlendro[1].deno
+      #
+      #   ... 
+
+    %>
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/bin/shlerb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require 'erb'
+
+require 'shlisp_tools'
+
+# for the binding
+Scales = ShlispTools::Scales
+Shnth  = ShlispTools::Shnth
+
+def error(s)
+  puts s
+  exit 1
+end
+
+class Shlerb
+
+  TEMP_FILE = "_shlerb_temp"
+  
+  def self.perform(infile)
+    template_file = File.open(infile, 'r').read
+    out = nil
+
+    begin
+      out = herb(template_file)
+    rescue Exception => e
+      # do again and show verbos output
+      $VERBOSE = true
+      puts herb(template_file)
+      exit 1
+    end
+
+    if out
+      File.open(TEMP_FILE, 'w+') { |f| f.write(out) }
+      system("shlisp #{TEMP_FILE}")
+    end
+  end
+
+  private
+    def self.herb(tmpl)
+      ERB.new(tmpl, nil, ">").result(binding)
+    end
+
+end
+
+error "usage: shlerb FILENAME" if ARGV.length < 1
+Shlerb.perform(ARGV[0])

data/bin/shtool

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+
+#------------------------------------------------------------------------------
+# ops
+#------------------------------------------------------------------------------
+
+class OpResult
+  attr_reader :args, :result
+
+  def initialize(args=nil, result=nil)
+    @args = args
+    @result = result
+  end
+
+  def get
+    { :args => @args, :result => @result }
+  end
+end
+
+# base class for operations
+class Op
+  def self.name
+    ""
+  end
+  
+  def self.get(args)
+    OpResult.new.get
+  end
+  
+  def self.usage(err=nil)
+    puts "#{name} error: #{err}" if err
+  end
+
+  def self.description
+    ""
+  end
+
+  private
+    def self.parse_ratio(txt)
+      parsed = {}
+      matches = /(\d+)[\/\:](\d+)/.match(txt)
+      if matches && matches.captures.length >= 2
+        parsed[:nume] = matches[1].to_i
+        parsed[:deno] = matches[2].to_i
+      end
+      parsed
+    end
+end
+
+# operations
+
+class OpSr < Op
+  CLOCK = 72000000.0
+
+  def self.name
+    "sr"
+  end
+
+  def self.description
+    "given args for short to be passed to srate, computes resulting base pitch"
+  end
+
+  def self.get(args)
+    if args.length < 2
+      usage "too few args"
+    else
+      OpResult.new(args,
+        impl(args)
+      ).get
+    end
+  end
+
+  def self.usage(err=nil)
+    super err
+    puts "#{name} args: bigg smal"
+    puts description
+  end
+
+  private
+    def self.impl(args)
+      (CLOCK / ((args[0].to_i * 256) + args[1].to_i)).round(2)
+    end
+end
+
+class OpRatMul < Op
+  def self.name
+    "mul"
+  end
+
+  def self.description
+    "given a ratio in nume/deno form, applies a multiplier to both sides (for scaling)"
+  end
+
+  def self.get(args)
+    if ARGV.length < 2
+      usage "too few args"
+    else
+      parts = parse_ratio(ARGV[0])
+      if parts.empty?
+        usage "bad args"
+      else
+        OpResult.new(args,
+          impl(parts, args[1].to_i)
+        ).get
+      end
+    end
+  end
+
+  def self.usage(err=nil)
+    super err
+    puts "#{name} args: nume/deno mul"
+    puts description
+  end
+
+  private
+    def self.impl(parts, mul)
+      [parts[:nume] * mul, parts[:deno] * mul]
+    end
+end
+
+class OpRange < Op
+  Min = -128
+  Max = 128
+
+  def self.name
+    "range"
+  end
+
+  def self.description
+    "given a mul and an add, computes the resulting range as [low, nominal, high]"
+  end
+
+  def self.get(args)
+    if args.length < 2
+      usage "too few args"
+    else
+      OpResult.new(args,
+        impl(args[0].to_i, args[1].to_i)
+      ).get
+    end
+  end
+
+  def self.usage(err=nil)
+    super err
+    puts "#{name} args: nume deno"
+    puts description
+  end
+
+  private
+    def self.impl(mul, add)
+      lo = ((Min * mul) / Max) + add
+      hi = ((Max * mul) / Max) + add
+      [lo, add, hi]
+    end
+end
+
+class OpReduce < Op
+  def self.name
+    "reduce"
+  end
+
+  def self.description
+    "given a ratio in nume/deno form, computes the reduced version"
+  end
+
+  def self.get(args)
+    if args.length < 1
+      usage "too few args"
+    else
+      parts = parse_ratio(ARGV[0])
+      if parts.empty?
+        usage "bad args"
+      else
+        OpResult.new(args,
+          impl(parts)
+        ).get
+      end
+    end
+  end
+
+  def self.usage(err=nil)
+    super err
+    puts "#{name} args: nume/deno"
+    puts description
+  end
+
+  private
+    def self.impl(parts)
+      r = Rational(parts[:nume], parts[:deno])
+      [r.numerator, r.denominator]
+    end
+end
+
+# known operations
+Ops = [ OpSr, OpRatMul, OpRange, OpReduce ]
+
+#------------------------------------------------------------------------------
+# mainline code
+#------------------------------------------------------------------------------
+
+def usage
+  puts "usage: 'shtool OP [args ...]'"
+  puts "where OP is one of: #{Ops.collect{ |op| op.name}.join(" ") }"
+  puts "or try 'shtool help'"
+  exit 1
+end
+
+def main(argv)
+  if argv.length < 1
+    usage
+  else
+    op = argv.shift
+    case op
+      when "help"
+        Ops.each { |op| puts "#{op.name}: #{op.description}" }
+      when "sr"
+        sr = OpSr.get(argv)
+        puts "(srate (short #{sr[:args][0]} #{sr[:args][1]})) = #{sr[:result]}" if sr
+      when "mul"
+        mul = OpRatMul.get(argv)
+        puts "#{mul[:args][0]} * #{mul[:args][1]} -> #{mul[:result][0]}/#{mul[:result][1]}" if mul
+      when "range"
+        range = OpRange.get(argv)
+        puts "#{range[:args][0]} #{range[:args][1]} -> [#{range[:result].join(",")}]" if range
+      when "reduce"
+        reduce = OpReduce.get(argv)
+        puts "#{reduce[:args][0]} -> #{reduce[:result][0]}/#{reduce[:result][1]}" if reduce
+      else
+        puts "Unrecognized operation #{op}"
+        usage
+    end
+  end
+end
+
+main(ARGV)

data/examples/hexanies.txt.erb

@@ -0,0 +1,103 @@
+<%
+  Slew_mul = 5
+  Slew_add = 5
+  Modo_mul = 2
+%>
+<% s = Scales::Hexany1357.scale(127) %>
+{
+  <%= Shnth::Situation_1 %>
+
+  ; 60Hz-ish
+  (srate (short 36 79))
+
+  (arab
+
+    (pan
+      (add
+        (modo (horna <%= s[Shnth::Bar_A].n %> <%= s[Shnth::Bar_A].d %> (slewa (majora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornc <%= s[Shnth::Bar_C].n %> <%= s[Shnth::Bar_C].d %> (slewc (majorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (horne <%= s[Shnth::Bar_d].n %> <%= s[Shnth::Bar_d].d %> (slewe (minord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (horng <%= s[Shnth::Bar_b].n %> <%= s[Shnth::Bar_b].d %> (slewg (minorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+      )
+      80
+    )
+
+    (pan
+      (add
+        (modo (hornb <%= s[Shnth::Bar_B].n %> <%= s[Shnth::Bar_B].d %> (slewb (majorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornd <%= s[Shnth::Bar_D].n %> <%= s[Shnth::Bar_D].d %> (slewd (majord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornf <%= s[Shnth::Bar_c].n %> <%= s[Shnth::Bar_c].d %> (slewf (minorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornh <%= s[Shnth::Bar_a].n %> <%= s[Shnth::Bar_a].d %> (slewh (minora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+      )
+      144
+    )
+
+  )
+}
+
+{
+  <%= Shnth::Situation_2 %>
+
+  ; 60Hz-ish
+  (srate (short 72 79))
+
+  (arab
+
+    (corpb 60 60)
+
+    (pan
+      (comba
+        (add
+          (modo (sawa  <%= s[Shnth::Bar_A].n %> <%= s[Shnth::Bar_A].d %> (slewa (majora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          (modo (sawc  <%= s[Shnth::Bar_C].n %> <%= s[Shnth::Bar_C].d %> (slewc (majorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          (modo (sawe  <%= s[Shnth::Bar_d].n %> <%= s[Shnth::Bar_d].d %> (slewe (minord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          (modo (sawg  <%= s[Shnth::Bar_b].n %> <%= s[Shnth::Bar_b].d %> (slewg (minorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        )
+        120 (corpb) 100
+      )
+      80
+    )
+
+    (pan
+      (combb
+        (add
+          (modo (sawb <%= s[Shnth::Bar_B].n %> <%= s[Shnth::Bar_B].d %> (slewb (majorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          (modo (sawd <%= s[Shnth::Bar_D].n %> <%= s[Shnth::Bar_D].d %> (slewd (majord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          (modo (sawf <%= s[Shnth::Bar_c].n %> <%= s[Shnth::Bar_c].d %> (slewf (minorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+          (modo (sawh <%= s[Shnth::Bar_a].n %> <%= s[Shnth::Bar_a].d %> (slewh (minora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        )
+        120 (corpb) 100
+      )
+      144
+    )
+
+  )
+
+}
+
+{
+  <%= Shnth::Situation_3 %>
+
+  (left
+    (waveb
+      (add
+        (modo (sawa 20 60 (saucec 56 (slewa (bara) 8 24))) 2)
+        (modo (sawb 30 60 (sauced 60 (slewb (barb) 8 24))) 2)
+      )
+      24
+      (corp 10 60)
+    )
+  )
+
+  (right
+    (wavec
+      (add
+        (modo (sawc 40 60 (saucee 70 (slewc (barc) 8 24))) 2)
+        (modo (sawd 80 60 (saucef 64 (slewd (bard) 8 24))) 2)
+      )
+      24
+      (corpb 10 60)
+    )
+  )
+
+}

data/examples/metaslendro.txt.erb

@@ -0,0 +1,63 @@
+<%
+  Slew_mul = 5
+  Slew_add = 5
+  Modo_mul = 2
+%>
+<% s1 = Scales::MetaSlendro_1.scale(120) %> 
+{
+  <%= Shnth::Situation_1 %>
+
+  ; 60Hz-ish
+  (srate (short 72 79))
+
+  (arab
+
+    (pan
+      (add
+        (modo (horna <%= s1[Shnth::Bar_A].n %> <%= s1[Shnth::Bar_A].d %> (slewa (majora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornc <%= s1[Shnth::Bar_C].n %> <%= s1[Shnth::Bar_C].d %> (slewc (majorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (horne <%= s1[Shnth::Bar_d].n %> <%= s1[Shnth::Bar_d].d %> (slewe (minord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+      )
+      144
+    )
+
+    (pan
+      (add
+        (modo (hornb <%= s1[Shnth::Bar_B].n %> <%= s1[Shnth::Bar_B].d %> (slewb (majorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornd <%= s1[Shnth::Bar_D].n %> <%= s1[Shnth::Bar_D].d %> (slewd (majord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornf <%= s1[Shnth::Bar_c].n %> <%= s1[Shnth::Bar_c].d %> (slewf (minorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+      )
+      80
+    )
+
+  )
+}
+<% s2 = Scales::MetaSlendro_2.scale(120) %>
+{
+  <%= Shnth::Situation_2 %>
+
+  ; 60Hz-ish
+  (srate (short 72 79))
+
+  (arab
+
+    (pan
+      (add
+        (modo (horna <%= s2[Shnth::Bar_A].n %> <%= s2[Shnth::Bar_A].d %> (slewa (majora) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornc <%= s2[Shnth::Bar_C].n %> <%= s2[Shnth::Bar_C].d %> (slewc (majorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (horne <%= s2[Shnth::Bar_d].n %> <%= s2[Shnth::Bar_d].d %> (slewe (minord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+      )
+      144
+    )
+
+    (pan
+      (add
+        (modo (hornb <%= s2[Shnth::Bar_B].n %> <%= s2[Shnth::Bar_B].d %> (slewb (majorb) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornd <%= s2[Shnth::Bar_D].n %> <%= s2[Shnth::Bar_D].d %> (slewd (majord) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+        (modo (hornf <%= s2[Shnth::Bar_c].n %> <%= s2[Shnth::Bar_c].d %> (slewf (minorc) <%= Slew_mul %> <%= Slew_add %>)) <%= Modo_mul %>)
+      )
+      80
+    )
+
+  )
+}

data/lib/shlisp_tools/ratio.rb

@@ -0,0 +1,81 @@
+module ShlispTools
+  class Ratio
+    include Enumerable
+
+    attr_reader :nume, :deno, :rat
+
+    def initialize(nume, deno, scale=nil)
+      @nume = nume
+      @deno = deno
+      _set_rat
+      scale(scale)
+    end
+
+    # pos: scale up (multiply)
+    # neg: scale down (divide)
+    def scale(mul)
+      if mul
+        if mul >= 0
+          @nume *= mul
+          @deno *= mul
+          @nume = 255 if @nume > 255
+          @deno = 255 if @deno > 255
+        else
+          mul = mul.abs
+          @nume /= mul
+          @deno /= mul
+          @nume = 1 if @nume <= 0
+          @deno = 1 if @deno <= 0
+        end
+      end
+    end
+
+    def n
+      @nume
+    end
+
+    def n=(nume)
+      @nume = nume
+      _set_rat
+    end
+
+    def d
+      @deno
+    end
+
+    def d=(deno)
+      @deno = deno
+      _set_rat
+    end
+
+    def reduce
+      Ratio.new(@rat.numerator, @rat.denominator)
+    end
+
+    def reduce!
+      @nume = @rat.numerator
+      @deno = @rat.denominator
+    end
+
+    def to_s
+      "#{@nume}/#{@deno}"
+    end
+
+    def to_r
+      @rat
+    end
+
+    def each
+      yield @rat
+    end
+
+    def <=>(other)
+      @rat <=> other.rat
+    end
+
+    private
+      def _set_rat
+        @rat = Rational(@nume, @deno)
+      end
+  end
+end

data/lib/shlisp_tools/scale.rb

@@ -0,0 +1,83 @@
+module ShlispTools
+  class Scale
+    include Enumerable
+
+    DEF_SEP = ' '
+
+    def initialize(degrees=nil)
+      @degrees = []
+      if degrees && !degrees.empty?
+        degrees.each { |n| @degrees << n }
+        _sort
+      end
+    end
+
+    def add(degree)
+      @degrees << degree
+      _sort
+    end
+
+    def remove(idx)
+      @degrees.delete_at(idx) rescue nil
+    end
+
+    def scale(mul)
+      unless empty?
+        @degrees.each_with_index do |note,i|
+          if i == 0
+            note.scale(mul)
+          else
+            tmp = ((mul > note.deno) ? mul : mul*2)
+            note.scale((tmp / note.deno).to_i)
+          end
+        end
+      end
+      self
+    end
+
+    def [](idx)
+      @degrees[idx] rescue nil
+    end
+
+    def length
+      @degrees.length
+    end
+
+    def empty?
+      @degrees.empty?
+    end
+
+    def <<(degree)
+      add(degree)
+    end
+
+    def each(&block)
+      @degrees.each(&block)
+    end
+
+    def to_s
+      scaled
+    end
+
+    def scaled(sep=DEF_SEP)
+      @degrees.inject([]) { |out,d| out << d.to_s; out }.join(sep)
+    end
+
+    def reduced(sep=DEF_SEP)
+      @degrees.inject([]) { |out,d| out << d.to_r.to_s; out }.join(sep)
+    end
+
+    def numes(sep=DEF_SEP)
+      @degrees.inject([]) { |out,d| out << d.n; out }.join(sep)
+    end
+
+    def denos(sep=DEF_SEP)
+      @degrees.inject([]) { |out,d| out << d.d; out }.join(sep)
+    end
+
+    private
+      def _sort
+        @degrees.sort!
+      end
+  end
+end

data/lib/shlisp_tools/scales.rb

@@ -0,0 +1,47 @@
+require 'shlisp_tools/scale'
+
+module ShlispTools
+  module Scales
+
+    # 1-3-5-7 hexany, utonal stellated
+    # second degree (49/48) and 2/1 removed to fit eight buttons
+    Hexany1357 = Scale.new([
+      Ratio.new( 1,  1),
+      Ratio.new(25, 24),
+      Ratio.new( 7,  6),
+      Ratio.new( 5,  4),
+      Ratio.new(35, 24),
+      Ratio.new( 3,  2),
+      Ratio.new( 5,  3),
+      Ratio.new( 7,  4)
+    ])
+
+    MetaSlendro_1 = Scale.new([
+      Ratio.new( 1,  1),
+      Ratio.new(37, 32),
+      Ratio.new(21, 16),
+      Ratio.new(49, 32),
+      Ratio.new( 7,  4),
+      Ratio.new( 2,  1)
+    ])
+
+    MetaSlendro_2 = Scale.new([
+      Ratio.new(  1,   1),
+      Ratio.new(  9,   8),
+      Ratio.new(151, 128),
+      Ratio.new(  3,   2),
+      Ratio.new( 25,  16),
+      Ratio.new(  2,   1)
+    ])
+
+    CentaurPelog = Scale.new([
+      Ratio.new( 1,   1),
+      Ratio.new(21,  20),
+      Ratio.new( 7,   6),
+      Ratio.new( 3,   2),
+      Ratio.new(14,   9),
+      Ratio.new( 2,   1)
+    ])
+
+  end
+end

data/lib/shlisp_tools/shnth.rb

@@ -0,0 +1,31 @@
+module ShlispTools
+  module Shnth
+    Light_1 = 1
+    Light_2 = Light_1 * 4
+    Light_3 = Light_2 * 4
+    Light_4 = Light_3 * 4
+    Light_5 = Light_4 * 4
+    Light_6 = Light_5 * 4
+    Light_7 = Light_6 * 4
+    Light_8 = Light_7 * 4
+
+    Situation_1 = "(jump (tar 1)) (lights #{Light_1})"
+    Situation_2 = "(jump (tar 1)) (lights #{Light_2})"
+    Situation_3 = "(jump (tar 1)) (lights #{Light_3})"
+    Situation_4 = "(jump (tar 1)) (lights #{Light_4})"
+    Situation_5 = "(jump (tar 1)) (lights #{Light_5})"
+    Situation_6 = "(jump (tar 1)) (lights #{Light_6})"
+    Situation_7 = "(jump (tar 1)) (lights #{Light_7})"
+    Situation_8 = "(jump (tar 1)) (lights #{Light_8})"
+
+    # scale indexes by bar (A=major, a=minora), using stevek's arrangement
+    Bar_A = 0
+    Bar_B = 1
+    Bar_C = 2
+    Bar_D = 3
+    Bar_d = 4
+    Bar_c = 5
+    Bar_b = 6
+    Bar_a = 7
+  end
+end

data/lib/shlisp_tools/version.rb

@@ -0,0 +1,3 @@
+module ShlispTools
+  VERSION = "0.0.1"
+end

data/lib/shlisp_tools.rb

@@ -0,0 +1,5 @@
+require 'shlisp_tools/version'
+require 'shlisp_tools/ratio'
+require 'shlisp_tools/scale'
+require 'shlisp_tools/scales'
+require 'shlisp_tools/shnth'

data/shlisp_tools.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shlisp_tools/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shlisp_tools"
+  spec.version       = ShlispTools::VERSION
+  spec.authors       = ["Dave Seidel"]
+  spec.email         = ["dave.seidel@gmail.com"]
+  spec.description   = %q{shtool, shlerb, the Scale and Ratio classes, and the Scales and Shnth modules}
+  spec.summary       = %q{Tools for shlisp/shnth users.}
+  spec.homepage      = "http://gthub.com/DaveSeidel"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: shlisp_tools
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dave Seidel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: shtool, shlerb, the Scale and Ratio classes, and the Scales and Shnth
+  modules
+email:
+- dave.seidel@gmail.com
+executables:
+- shlerb
+- shtool
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/shlerb
+- bin/shtool
+- examples/hexanies.txt.erb
+- examples/metaslendro.txt.erb
+- lib/shlisp_tools.rb
+- lib/shlisp_tools/ratio.rb
+- lib/shlisp_tools/scale.rb
+- lib/shlisp_tools/scales.rb
+- lib/shlisp_tools/shnth.rb
+- lib/shlisp_tools/version.rb
+- shlisp_tools.gemspec
+homepage: http://gthub.com/DaveSeidel
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Tools for shlisp/shnth users.
+test_files: []