davafons / eggtended-js Goto Github PK

 describe("run", function() {
    let originalLog;
    beforeEach(function() {
      originalLog = console.log;
      console.log = function (...args) { 
        ...
      };
    });
    // test code here
    afterEach(function() {
      ...
    });
    it("testing one.egg with mocking of console.log", function() {
      ...
    }
}

do(
  try(
    do {  # Try
      throw(42)
    },
    do {  # Catch
      print(+("Caught error! ", __error__))
    }
  ),
  try(
    do {  # Try
      print(20)
    },
    do {  # Catch
      print(+("Caught error! ", __error__))
    },
    do {  # Finally
      print("Finally called")
    }
  )
)

do(
  def(x, map{a: 1, b: 4, c: map{d: 5, e: 3}}),
  print(x["sub", "a"]),     # 1
  print(x["sub", "c"]),     # Map { d: 5, e: 3 }
  print(x["sub", "c", "e"]) # 3
)

do(
  def(x, array[1,4,5]),
  def(s, x.join("-")),                 # The same as x("join", "-")
  print(s),                            # 1-4-5
  print(array[1,4,5].join("-").length) # 5
)

do (
  def(x, object ( 
    c:   0,
    gc:  ->{this.c},
    sc:  ->{value, =(this, "c", value)},
    inc: ->{=(this, "c", +(this.c, 1))}
  )),
  print(x),
  print(x["c"]),
  print(x.c),
  print(x.gc),             # calls the function!
  print(element(x, "gc")), # [Function: bound ]
  print(x("sub", "gc")),   # [Function: bound ]
  print(x.sub("gc")),      # [Function: bound ]
  print(x.sc(5)),
  print(x("sc", 5)),
  print(x.gc)
)

do{
  print(4.toFixed(2)),
  def(x, 4),
  print(x("toFixed", 2)),
  def(z, x.toFixed(2)),
  print(z),
}

do(
  define(num(x), 3), # OK
  define(str(y), 5), # This should fail
  define(myfun, fun(int(x), print(x))), # Add type to function parameters
  myfun(4.3)
) 

# module. Exports z
do {
  print("inside module"),
  :=(z, map{inc: ->{x, 
                     +(x,1)
                   } # end fun
           } # end map
  ), # end of :=
  z  # el último valor será exportado
}

do {
  def(x, map["x", 4, "y", map["z", 3]]),
  print(x),                               # { x: 4, y: { z: 3 } }
  print(element(x, "x")),                 # 4
  print(element(x, "y")),                 # { z: 3 }
  print(element(x, "y", "z"))             # 3
}

do (
  def(x, object ( 
    "c", 0,
    "gc", ->{element[this, "c"]},
    "sc", ->{value, =(this, "c", value)},
    "inc", ->{=(this, "c", +(element[this, "c"],1))}
  )),
  print(x),
  print(x("gc")),
  x("sc", 4),
  print(x("gc")),
  x("inc"),
  print(x("gc")),
)

do(
  def(x, array[1,2,3, array[9,8,7]]),
  set(x, 2, 9),
  print(x),             # [ 1, 2, 9, [ 9, 8, 7 ] ]
  set(x, 3, 1, 1000),
  print(x)              # [ 1, 2, 9, [ 9, 1000, 7 ] ]
)

do(
  def(x, array[1, array[2,3]]),
  print(element(x,0)),          # 1
  print(element(x,1)),          # [ 2, 3 ]
  print(element(x,1,1)),        # 3
  print(element(x,-1,-1)),      # 3
  print(element(x,-1,0))        # 2
 )

do(
  print(4("undefined-method", 2, 3)) # 9. Called 'missing', aliased to '+'
)

do( # test properties in egg
  def(x, array[1,array[3,2,5]]),
  print(x("length")),          # 2
  print(x["sub", 1]("length")) # 3
)

do(
  def(x, object ( 
    "c", 0,
    "gc", ->{element[this, "c"]},
    "sc", ->{value, =(this, "c", value)},
    "inc", ->{=(this, "c", +(element[this, "c"],1))}
  )),
  def(y, child(x)),
  print(y.sc(5)),
  print(y.c)
)

do {
  print("hello"("length")),
  print(4("toFixed", 2))
}

do {
  :=(d, r/
         (?<year>  \d{4} ) -?  # year 
         (?<month> \d{2} ) -?  # month 
         (?<day>   \d{2} )     # day
        /x),
  print(d.test("1987-07-14")),  # true
  :=(m, d.exec("1987-07-14")),  
  print(m), #  [ '1987-07-14', '1987', '07', '14', index: 0, input: '1987-07-14' ]
  print(m.index), # 0
    
  :=(x, RegExp.exec("2015-02-22", d)), 
                  /*
                  [ '2015-02-22',
                    '2015',
                    '02',
                    '22',
                    index: 0,
                    input: '2015-02-22',
                    year: '2015',
                    month: '02',
                    day: '22' ]
                  */
  print(x),
  print(x.year), # 2015
  print(x.month) # 02
}

obj("meth", args)

print(x("join", "-")("toUpperCase"))

  do {
    def(sum,  ; function
      -> { nums, 
        do {
           := (i, 0), # Creates a local variable i and sets to 0
           := (s, 0), # Creates local var s and sets to 0
           while { <(i, length(nums)),
             do { =(s, +(s, <-(nums, i))),
                =(i, +(i, 1))
             }
           },
           s
        }
     )
   },
   print(+("sum(array[1, 2, 3]) := ", sum(array[1, 2, 3])))
  }

  do( 
    set(x,9),
    print(x) # ReferenceError: Tried setting an undefined variable: x
  )

do {
  use('command-line'),
  :=(optionDefinition, arr [
    map { name: 'verbose', alias: 'v', type: Boolean },
    map { name: 'src', type: String, multiple: true, defaultOption: true },
    map { name: 'timeout', alias: 't', type: Number },
    map { name: 'help', alias: 'h', type: Boolean },
  ]),
  :=(options, parseArgs(optionDefinitions)),
  print(options)
    /* options es un map como este:
        {
          src: [
            'one.js',
            'two.js'
          ],
          verbose: true,
          timeout: 1000
        }
    */
}

  do(
    define(x, 4),
    define(setx, fun(val, 
        set(x, val)
      )
    ),
    setx(50),
    print(x)
  )