atomy 0.6.5 → 0.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb2b96c8ce99460a0f0600c74786046f08607e3b
-  data.tar.gz: 275292c5f7ab03b089bcb7625b77f65e882db345
+  metadata.gz: bb9fbe912f398f02739a10a44f50918a01fe3ac4
+  data.tar.gz: 4728cd82f1aa5171babf677f74e6f07561815ad7
 SHA512:
-  metadata.gz: 8c56afef1d99fa1cb8e22c57dfe7a68520b09081a8699fac80293931a541ca751ab02cc852eef1e82dca3e5b8355cce4eaa2ce2deeb1fb30f30f47a50071f035
-  data.tar.gz: 6233206c5afa18e8aa828baa06fd8d9d5b96ecfb31a6aa66f74e6bd7c42dd28c2703aa435c44a2a292bd47ebc4ddbcd479899a3bc12bd69834d221ccc1d95dc8
+  metadata.gz: 74f797b2806e1069d7077e97d6e0ea8e15afc0a69fcdc564bbe50b6e0ff903aa7b1e9d9d479d7f64b070a5fc049107f7bf597208f842e02bf24788ca144ef1e4
+  data.tar.gz: 37770a5407e8de8082ac690b90fa4823feccc37e0960c0715575c072f1398e379569d98e27957e62f61607961260d088f2eea862dabb5b5aa891943659f9dd37

data/lib/atomy/pattern.rb

@@ -1,5 +1,5 @@
 require "atomy/node/constructable"
-require "rubinius/ast"
+require "rubinius/code/ast"
 
 module Atomy
   class Pattern

data/lib/atomy/version.rb

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

metadata

@@ -1,24 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: atomy
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.6.6
 platform: ruby
 authors:
 - Alex Suraci
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-11 00:00:00.000000000 Z
+date: 2016-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kpeg
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -26,13 +26,13 @@ dependencies:
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rubinius-compiler
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -40,27 +40,27 @@ dependencies:
         version: '2.3'
 - !ruby/object:Gem::Dependency
   name: rubinius-ast
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.4'
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -68,13 +68,13 @@ dependencies:
         version: '10.4'
 - !ruby/object:Gem::Dependency
   name: rspec-its
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -101,10 +101,6 @@ 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
@@ -121,7 +117,6 @@ 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
@@ -197,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: the Atomy programming language

data/kernel/format/data.ay

@@ -1,56 +0,0 @@
-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

@@ -1,346 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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/format.ay

@@ -1,14 +0,0 @@
-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/therie.ay

@@ -1,193 +0,0 @@
-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"