atomy 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62af6cac78961b06d75c20c9dc3ae90f7fca1fdd
-  data.tar.gz: c0ac851cfa0bb9689b15f442767f9f0cdb8128ad
+  metadata.gz: eb2b96c8ce99460a0f0600c74786046f08607e3b
+  data.tar.gz: 275292c5f7ab03b089bcb7625b77f65e882db345
 SHA512:
-  metadata.gz: 7749e039df36ab97e64a173178d3822a44aa0fe91b5a3dd236d5ad66e754c894c07c3cc1a6538466d9b92093e142aa8cf9b0f89e5b07749080b1afdfca9c93e1
-  data.tar.gz: cdb16e0afc5cd0919b82679c5feb42706223e46d3534e3c5d7bdf779d35c1737f66020108d19806f5ee3eab4aabe2f37c40387001b7a9b1280d65b3a0b709621
+  metadata.gz: 8c56afef1d99fa1cb8e22c57dfe7a68520b09081a8699fac80293931a541ca751ab02cc852eef1e82dca3e5b8355cce4eaa2ce2deeb1fb30f30f47a50071f035
+  data.tar.gz: 6233206c5afa18e8aa828baa06fd8d9d5b96ecfb31a6aa66f74e6bd7c42dd28c2703aa435c44a2a292bd47ebc4ddbcd479899a3bc12bd69834d221ccc1d95dc8

data/kernel/format.ay

@@ -0,0 +1,14 @@
+use(require("core"))
+use(require("quotes"))
+use(require("file"))
+
+base = File expand-path("../", __FILE__)
+
+Atomy const-set(.Format, Module new)
+
+use(require(base + "/format/data"))
+use(require(base + "/format/formatter"))
+use(require(base + "/format/parser"))
+
+macro-quoter(f) [c]:
+  Atomy Format Parser parse(c)

data/kernel/format/data.ay

@@ -0,0 +1,56 @@
+use(require("core"))
+use(require("define"))
+use(require("array"))
+use(require("control-flow"))
+use(require("node"))
+use(require("cosmetics"))
+use(require("particles"))
+
+Atomy Format open:
+  ast:
+    Segment:
+      Chunk([.flags], @text)
+      String([.flags])
+      Decimal([.flags])
+      Hex([.flags])
+      Octal([.flags])
+      Binary([.flags])
+      Radix([.flags])
+      Float([.flags])
+      Exponent([.flags])
+      General([.flags])
+      Character([.flags])
+      Any([.flags])
+      Pluralize(.singular, [.flags], .plural?)
+      Lowercase(.content, [.flags])
+      Capitalize(.content, [.flags])
+      Uppercase(.content, [.flags])
+      Justify([.segments], [.flags])
+      Skip([.flags])
+      Indirection([.flags])
+      Iterate(.content, [.flags])
+      Break([.flags])
+      Conditional([.branches], [.flags], .default?)
+
+    Flag:
+      Number(@value?)
+      Symbol(@character)
+      ZeroPad
+      Precision(@value)
+
+    Formatter([.segments])
+
+  Segment symbol(m)? :=
+    @flags any? [f]:
+      f match:
+        Symbol -> f character == m
+        _ -> false
+
+  Segment precision :=
+    @flags find .is-a(Precision)? ?value()
+
+  Segment zero-pad? :=
+    @flags any? [f]:
+      f match:
+        ZeroPad -> true
+        _ -> false

data/kernel/format/formatter.ay

@@ -0,0 +1,346 @@
+use("core")
+use("define")
+use("control-flow")
+use("loop")
+use("regexp")
+use("particles")
+use("patterns")
+
+pretty = require("pretty")
+
+
+Atomy Format open:
+  peek-input() = @input [@position]
+
+  next-input() =
+    peek-input tap:
+      @position += 1
+
+  next-inputs() = @input drop(@position) or []
+
+  pluralize(s) =
+    condition:
+      s =~ r"o$"(i) ->
+        s + "es"
+
+      s =~ r"[aeiou]$"(i) ->
+        s + "s"
+
+      s =~ r"(?<root>.+[aeiou])y$"(i) ->
+        s + "s"
+
+      s =~ r"(lay-by|stand-by)$"(i) ->
+        s + "s"
+
+      s =~ r"(.+)y$"(i) ->
+        $1 + "es"
+
+      s =~ r"(.+)us$"(i) ->
+        $1 + ""
+
+      s =~ r"(.+)sis$"(i) ->
+        $1 + "es"
+
+      s =~ r"(.+)(ex|ix)$"(i) ->
+        $1 + "ces"
+
+      s =~ r"(.+)(ss|sh|ch|dge)$"(i) ->
+        s + "es"
+
+      otherwise ->
+        s + "s"
+
+  sub-format(sub) = do:
+    sub position = @position
+    out = sub scan(*@input)
+    @position = sub position
+    sub reset!
+    out
+
+  iterate(f) =
+    until(next-inputs empty? or @stop?):
+      @output << sub-format(f)
+
+  iterate-max(max, f) =
+    max times:
+      when(next-inputs empty? or @stop?):
+        break
+
+      @output << sub-format(f)
+
+  number(s, default = 1) =
+    if(num = s flags find .is-a(Number)?)
+      then: num value or next-inputs size
+      else: default
+
+  next-number(s) =
+    number(s, nil) or next-input
+
+  justified(j, s, left? = false) =
+    if(w = number(j, nil))
+      then:
+        padding = if(j zero-pad?) then: "0"; else: " "
+
+        condition:
+          j symbol("=")? or j symbol("<")? and j symbol(">")? ->
+            s center(w, padding)
+
+          left? and not j symbol(">")? or j symbol("<")? ->
+            s ljust(w, padding)
+
+          otherwise ->
+            s rjust(w, padding)
+      else:
+        s
+
+  char(c, n: Integer) = justified(c, n chr, true)
+  char(c, s) = justified(c, s to-s [0, 1], true)
+
+  integer(i, base) = justified(i, Integer(next-input) to-s(base))
+
+  float(f, x) = do:
+    format =
+      if(f precision)
+        then: "%." + f precision to-s + x
+        else: "%" + x
+
+    justified(f, sprintf(format, Float(next-input)))
+
+  spaced(_, _, _, []) = ""
+  spaced(j, _, left, [s]) =
+    if(j symbol(">")? or j symbol("=")?)
+      then: s + " " * left
+      else: " " * left + s
+  spaced(j, average, left, s . ss) =
+    [ s
+      " " * average
+      spaced(j, average, left - average, ss)
+    ] join
+
+  justify-to(_, _, []) = ""
+  justify-to(j, to, all: s . ss) = do:
+    needed = to - all collect .size inject .(+ _)
+
+    spacings =
+      condition:
+        j symbol("<")? and j symbol(">")? or j symbol("=")? ->
+          all size + 1
+
+        j symbol("<")? ->
+          all size
+
+        j symbol(">")? ->
+          all size
+
+        otherwise ->
+          all size - 1
+
+    naive-average = needed / spacings
+
+    average =
+      if(needed - naive-average * spacings >= spacings - 1)
+        then: naive-average + 1
+        else: naive-average
+
+    condition:
+      j symbol("<")? or j symbol("=")? ->
+        [ " " * naive-average
+          s
+          " " * average
+          spaced(j, average, needed - naive-average - average, ss)
+        ] join
+
+      otherwise ->
+        [ s
+          " " * naive-average
+          spaced(j, average, needed - naive-average, ss)
+        ] join
+
+  justify(j, [s]) = justified(j, s)
+  justify(j, ss) =
+    if(to = number(j, nil))
+      then: justify-to(j, to, ss)
+      else: ss join
+
+
+  process(c: Chunk) =
+    @output << c text
+
+  process(s: String) =
+    @output << justified(s, next-input to-s, true)
+
+  process(i: Decimal) =
+    @output << integer(i, 10)
+
+  process(i: Hex) =
+    @output << integer(i, 16)
+
+  process(i: Octal) =
+    @output << integer(i, 8)
+
+  process(i: Binary) =
+    @output << integer(i, 2)
+
+  process(i: Radix) =
+    @output << integer(i, i precision)
+
+  process(f: Float) =
+    @output << float(f, "f")
+
+  process(f: Exponent) =
+    @output << float(f, "e")
+
+  process(f: General) =
+    @output << float(f, "g")
+
+  process(c: Character) =
+    @output << char(c, next-input)
+
+  process(a: Any) =
+    @output << justified(a, pretty show(next-input), true)
+
+  process(p: Pluralize) = do:
+    num =
+      if(p symbol(">")?)
+        then: peek-input
+        else: next-input
+
+    @output <<
+      condition:
+        num == 1 ->
+          sub-format(p singular)
+
+        p plural ->
+          sub-format(p plural)
+
+        otherwise ->
+          pluralize(sub-format(p singular))
+
+  process(l: Lowercase) =
+    @output << sub-format(l content) downcase
+
+  process(c: Capitalize) = do:
+    words = sub-format(c content) split(" ")
+    number(c, words size) times [n]:
+      unless(n == 0):
+        @output << " "
+
+      @output << words shift capitalize
+
+    unless(words empty?):
+      @output << " " + words join(" ")
+
+  process(u: Uppercase) =
+    @output << sub-format(u content) upcase
+
+  process(s: Skip) =
+    if(s symbol("<")?)
+      then: @position -= number(s)
+      else: @position += number(s)
+
+  process(i: Indirection) =
+    @output <<
+      if(i symbol("*")?)
+        then: sub-format(next-input)
+        else: next-input format(*next-input)
+
+  process(i: Iterate) = do:
+    splat? = i symbol("*")?
+    sub? = i symbol(".")?
+    always-run? = i symbol("+")?
+    iterations = number(i, nil)
+
+    inputs =
+      if(splat?)
+        then: next-inputs
+        else: next-input
+
+    before = [@input, @position]
+
+    when(inputs empty? and always-run? and
+          iterations != 0):
+      @output << sub-format(i content)
+      return(nil)
+
+    condition:
+      iterations:
+        @input = inputs
+        @position = 0
+        iterate-max(iterations, i content)
+
+      sub?:
+        @iterating = inputs
+        inputs each [is]:
+          @output << i content format(*is)
+
+      otherwise:
+        @input = inputs
+        @position = 0
+        iterate(i content)
+
+    if(splat?)
+      then: @position = @input size
+      else: [@input, @position] = before
+
+  process(c: Conditional) =
+    [c symbol("?")?, c branches] match:
+      [true, t . (f . _)] ->
+        @output << sub-format(if(next-input) then: t; else: f)
+
+      [true, [t]] ->
+        when(next-input):
+          @output << sub-format(t)
+
+      _:
+        n = next-number(c)
+        if(n >= c branches size)
+          then:
+            when(c default):
+              @output << sub-format(c default)
+          else:
+            @output << sub-format(c branches [n])
+
+  process(j: Justify) =
+    @output <<
+      justify(j, j segments collect [s]: sub-format(s))
+
+  process(x) = raise("todo formatting: " + x inspect)
+
+  Formatter open:
+    attr-accessor(.position)
+
+    initialize(opts = nil) &blk := do:
+      super(opts) &blk
+      reset!
+
+    bytecode(g, mod) := do:
+      pos(g)
+      construct(g, mod)
+
+    reset! := do:
+      @input = []
+      @output = ""
+      @position = 0
+      @stop? = false
+      @iterating = []
+
+    scan(*@input) := do:
+      @segments each [s]:
+        s match:
+          Break ? symbol(".")? ->
+            when(@iterating empty?):
+              @stop? = true
+              break
+
+          Break ->
+            when(next-inputs empty?):
+              break
+
+          _ -> process(s)
+
+      @output
+
+    format(*inputs) :=
+      scan(*inputs) tap: reset!
+
+    alias-method(.[], .format)

data/kernel/format/parser.ay

@@ -0,0 +1,75 @@
+use("core")
+use("define")
+use("block")
+use("control-flow")
+use("grammar")
+use("init")
+
+Atomy Format open:
+  parser(Parser):
+    %atomy := Atomy Parser
+
+    text(e) := [
+      <(/"[^\\%#{Regexp quote(e)}]+"/)> { text }
+      "\\" <(/"[%\(\)\{\}\[\]]"/)> { text }
+      "\\" e=(%atomy(escape)) { e }
+    ]
+
+    nested(e) := c=(text(e)+) { init(Chunk, text: c join) }
+
+    chunk := nested("")
+
+    flagged := "%" fs=(flag*) s=(segment) { s flags = fs, s }
+
+    flag := [
+      "#" { Number new }
+      "0" &("." /"\d"/ | /"\d"/) { ZeroPad new }
+      "." <(/"\d+"/)> { init(Precision, value: text to-i) }
+      <(/"\d+"/)> { init(Number, value: text to-i) }
+      <(/"[\.\+\*=<>,\?]"/)> { init(Symbol, character: text) }
+    ]
+
+    segment := [
+      "p" "(" s=(sub(")")) ")" ("(" p=(sub(")")) ")")? {
+        Pluralize new [n]:
+          n singular = s
+          n plural = p
+      }
+      "l" "(" c=(sub(")")) ")" { init(Lowercase, content: c) }
+      "c" "(" c=(sub(")")) ")" { init(Capitalize, content: c) }
+      "u" "(" c=(sub(")")) ")" { init(Uppercase, content: c) }
+      "j" cs=(("(" c=(sub(")")) ")" { c })+) { init(Justify, segments: cs) }
+      "{" c=(sub("}")) "}" { init(Iterate, content: c) }
+      bs=(("[" c=(sub("]")) "]" { c })+) ("(" d=(sub(")")) ")")? {
+        init(Conditional, branches -> Array(bs), default -> d)
+      }
+      "_" { Skip new }
+      "^" { Break new }
+      "%" { Indirection new }
+      "s" { String new }
+      "d" { Decimal new }
+      "x" { Hex new }
+      "o" { Octal new }
+      "b" { Binary new }
+      "r" { Radix new }
+      "f" { Float new }
+      "e" { Exponent new }
+      "g" { General new }
+      "c" { Character new }
+      "v" { Any new }
+    ]
+
+    sub(e) := as=((flagged | nested(e))*) {
+      init(Formatter, segments -> Array(as))
+    }
+
+    root := x=(sub("")) !(/"."/) { x }
+
+
+  Parser singleton:
+    parse(source) :=
+      new(source) onto:
+        unless(parse):
+          raise-error
+
+        result

data/kernel/therie.ay

@@ -0,0 +1,193 @@
+use(require("atomy"))
+
+io = require("io")
+
+nesting-level = dynamic(0)
+running-stats = dynamic
+
+data(Stats(@passed = 0, @failed = 0))
+
+fn(indented(s)): (" " * (^nesting-level * 2)) + s
+
+fn(colored(color, s)):
+  unless(^(io OutputPort) tty?):
+    return(s)
+
+  codes = [
+    .black
+    .red
+    .green
+    .yellow
+    .blue
+    .magenta
+    .cyan
+    .white
+  ]
+
+  i"\e[3#{codes index(color)}m#{s}\e[0m"
+
+fn(in-own-module &action):
+  ctx = Atomy Module new
+  ctx use(self)
+  ctx module-exec &action
+
+
+def(theorize &tests):
+  with(running-stats = Stats new):
+    tests call
+    puts("")
+
+    stats = ^running-stats
+
+    puts(
+      f"total of %d tests (%s passed, %s failed)" [
+        stats failed + stats passed
+        colored(.green, stats passed)
+        if(stats failed == 0)
+          then: "0"
+          else: colored(.red, stats failed)
+      ])
+
+    stats
+
+
+def(describe(what) &body):
+  puts(indented(f"- %s" [what]))
+
+  with(nesting-level = (^nesting-level + 1)):
+    in-own-module &body
+
+  nil
+
+alias-method(.context, .describe)
+
+
+def(let(name) &body):
+  define-method(name):
+    res = instance-exec &body
+
+    singleton:
+      define-method(name): res
+
+    res
+
+def(subject &body): def(.subject) &body
+
+
+def(it(description) &tests):
+  do {
+    in-own-module &tests
+    puts(indented(colored(.green, f"✓ %s" [description])))
+  } rescue {
+    e:
+      when(^running-stats):
+        ^running-stats failed += 1
+
+      puts(indented(colored(.red, f"✗ %s" [description])))
+      puts(
+        indented(
+          colored(
+            .yellow
+            f"  ` %s: %s" [
+              e class name
+              e message
+            ])))
+
+      e backtrace first((ENV["THERIE_BT_LIMIT"] or 5) to-i) each [l]:
+        puts(indented(f"    %s" [colored(.cyan, l)]))
+  } else:
+    when(^running-stats):
+      ^running-stats passed += 1
+
+  nil
+
+
+data(Actuality(@value = nil, @action = nil))
+
+def(expect(value)): Actuality new(value)
+def(expect &action): Actuality new(nil, action)
+
+def(Actuality to): ExpectTo new(self)
+def(Actuality to-not): ExpectTo new(self, true)
+
+
+data(ExpectTo(@actual, @negated? = false))
+
+def(ExpectTo(actual, negated) match(matcher)):
+  matched = matcher matches?(actual)
+
+  condition:
+    negated && matched:
+      /raise(matcher negative-failure-message(actual))
+
+    negated && !matched:
+      true
+
+    !matched:
+      /raise(matcher failure-message(actual))
+
+    negated:
+      true
+
+
+data(Matcher)
+
+def(Matcher matches?(actual)): /error(.not-implemented)
+def(Matcher failure-message(actual)): /error(.not-implemented)
+def(Matcher negative-failure-message(actual)): /error(.not-implemented)
+
+Matcher data: EqualityMatcher(@value)
+def(ExpectTo be(value)): match(EqualityMatcher new(value))
+def(EqualityMatcher(value) matches?(actual)): actual value == value
+def(EqualityMatcher(value) failure-message(actual)):
+  i"expected #{actual value} to be #{value}"
+def(EqualityMatcher(value) negative-failure-message(actual)):
+  i"expected #{actual value} to not be #{value}, but it was"
+
+
+Matcher data: RaiseMatcher(@exception, @message = nil)
+def(ExpectTo raise(exception, message = nil)):
+  match(RaiseMatcher new(exception, message))
+def(RaiseMatcher matches?(actual)):
+  actual action rescue {
+    e:
+      @raised = e
+      @raised is-a?(@exception)
+  } else: false
+def(RaiseMatcher failure-message(actual)):
+  if(@raised)
+    then: i"expected #{@exception}, got #{@raised class}: #{@raised}"
+    else: i"expected #{@exception} but nothing was raised"
+def(RaiseMatcher negative-failure-message(actual)):
+  i"expected #{@exception} to not be raised, but it was"
+
+
+Matcher data: ErrorMatcher(@error)
+def(ExpectTo error(error)): match(ErrorMatcher new(error))
+def(ErrorMatcher matches?(actual)):
+  with-restarts(errored(matched?) -> matched?) {
+    actual action call
+    false
+  } bind {
+    (e: ExceptionError):
+      raise(e exception)
+
+    (e: Error):
+      @errored = e
+      /restart(.errored, e kind-of?(@error))
+  }
+def(ErrorMatcher failure-message(actual)):
+  if(@errored)
+    then: i"expected #{@error}, got #{@errored class}: #{@errored}"
+    else: i"expected #{@error} but nothing was signalled"
+def(ErrorMatcher negative-failure-message(actual)):
+  i"expected #{@error} to not be signalled, but it was"
+
+
+Matcher data: KindMatcher(@class)
+def(ExpectTo be-a(class)): match(KindMatcher new(class))
+def(KindMatcher matches?(actual)): actual value is-a?(@class)
+def(KindMatcher failure-message(actual)):
+  i"expected #{actual value} (#{actual value class}) to be a #{@class}"
+def(KindMatcher negative-failure-message(actual)):
+  i"expected #{actual value} (#{actual value class}) to not be a #{@class}, but it was"

data/lib/atomy/codeloader.rb

@@ -1,8 +1,13 @@
+require "fileutils"
+
 require "atomy/bootstrap"
 require "atomy/compiler"
 require "atomy/parser"
 require "atomy/module"
 
+require "rubinius/compiler"
+require "rubinius/compiler/compiled_file"
+
 module Atomy
   module CodeLoader
     LOADED_MODULES = {}
@@ -143,24 +148,55 @@ module Atomy
       mod = Atomy::Module.new { use(Atomy::Bootstrap) }
       mod.file = file.to_sym
 
+      compiled_file_name = CodeTools::Compiler.compiled_name(file)
+      if should_load_compiled_file(compiled_file_name, file)
+        code_loader = Rubinius::CodeLoader.new(compiled_file_name)
+        code = code_loader.load_compiled_file(compiled_file_name, 0, 0)
+
+        Rubinius.attach_method(
+          :__script__,
+          code,
+          mod.compile_context.constant_scope,
+          mod)
+
+        res = mod.__script__
+
+        return [res, mod]
+      end
+
       node = Atomy::Parser.parse_file(file)
 
-      res = evaluate_sequences(node, mod)
+      res = nil
+      code =
+        Atomy::Compiler.package(mod.file) do |gen|
+          res = evaluate_sequences(gen, node, mod)
+        end
+
+      if ENV["DEBUG"]
+        printer = CodeTools::Compiler::MethodPrinter.new
+        printer.bytecode = true
+        printer.print_method(code)
+      end
+
+      write_compiled_file(compiled_file_name, mod, code) if compiled_file_name
 
       [res, mod]
     end
 
-    def evaluate_sequences(n, mod)
+    def evaluate_sequences(gen, n, mod)
       if n.is_a?(Atomy::Grammar::AST::Sequence)
         res = nil
 
-        n.nodes.each do |sub|
-          res = evaluate_sequences(sub, mod)
+        n.nodes.each.with_index do |sub, i|
+          gen.pop unless i == 0
+          res = evaluate_sequences(gen, sub, mod)
         end
 
         res
       else
-        mod.evaluate(n, mod.compile_context)
+        res = mod.evaluate(n, mod.compile_context)
+        mod.compile(gen, n)
+        res
       end
     end
 
@@ -191,6 +227,40 @@ module Atomy
       ".ay"
     end
 
+    def should_load_compiled_file(compiled_file, source_file)
+      return false unless compiled_file
+      return false unless File.exists?(compiled_file)
+
+      compiled_mtime = File.mtime(compiled_file)
+      return false if File.mtime(source_file) > compiled_mtime
+
+      module_list_file_name = compiled_file + ".modules"
+      if File.exists?(module_list_file_name)
+        File.open(module_list_file_name, "r") do |io|
+          io.each_line do |line|
+            mod_file = line.rstrip
+            return false if File.mtime(mod_file) > compiled_mtime
+          end
+        end
+      end
+
+      true
+    end
+
+    def write_compiled_file(compiled_file_name, mod, code)
+      FileUtils.mkdir_p(File.expand_path("../", compiled_file_name))
+      CodeTools::CompiledFile.dump(code, compiled_file_name, Rubinius::Signature, 0)
+
+      module_list_file_name = compiled_file_name + ".modules"
+      File.open(module_list_file_name, "w") do |io|
+        mod.singleton_class.included_modules.each do |used_module|
+          next if used_module == mod
+          next unless used_module.is_a?(Atomy::Module) && used_module.file
+          io.puts(used_module.file.to_s)
+        end
+      end
+    end
+
     def search_path(path, load_paths)
       load_paths.each do |load_path|
         if found = find_source("#{load_path}/#{path}")

data/lib/atomy/version.rb

@@ -1,3 +1,3 @@
 module Atomy
-  VERSION = "0.6.4"
+  VERSION = "0.6.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atomy
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.5
 platform: ruby
 authors:
 - Alex Suraci
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-09 00:00:00.000000000 Z
+date: 2015-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kpeg
@@ -101,6 +101,10 @@ files:
 - kernel/doc.ay
 - kernel/dynamic.ay
 - kernel/file.ay
+- kernel/format.ay
+- kernel/format/data.ay
+- kernel/format/formatter.ay
+- kernel/format/parser.ay
 - kernel/grammar.ay
 - kernel/hash.ay
 - kernel/interpolation.ay
@@ -117,6 +121,7 @@ files:
 - kernel/regexp.ay
 - kernel/repl.ay
 - kernel/stack-local.ay
+- kernel/therie.ay
 - lib/atomy.rb
 - lib/atomy/bootstrap.rb
 - lib/atomy/code/assign.rb