xash 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ea6ec31fe55c1fad359d00416d8fa91a19067ee
+  data.tar.gz: b59f781bf66869db18f9920312793a7710c04381
+SHA512:
+  metadata.gz: b0c76d221977d272ccddc6243d2002a83b4d964c094dfc8395b747e8adcc6804d70c2cb9cc42058f1ed050af9a8772d4a36b68d46bbc00b39c0af41df6354944
+  data.tar.gz: a71041ae1493cc35a094d93582ab744d1299b90b07bdfc634e314834be6abbd1f5af961e4e3edf17966efd60986201cee47af03ffff69ee5c0e2f9188112edd6

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 xash.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 long-long-float
+
+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,42 @@
+# Xash
+
+## Installation
+
+    $ gem install xash
+
+## Usage
+
+    $ xash file.yml
+
+## Testing
+
+    $ rake test
+
+## Example
+
+samples/fizzbuzz.yml
+```ruby
+#FizzBuzz
+- for: [1..10,
+    do: [ ar: [i],
+        case: [
+            [$i, mod, 15, ==, 0], FizzBuzz,
+            [$i, mod, 3, ==, 0], Fizz,
+            [$i, mod, 5, ==, 0], Buzz,
+            do: [$i]
+        ]
+    ]
+]
+```
+
+## Document
+
+see [wiki](https://github.com/long-long-float/xash/wiki/Document)
+
+## 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 'rake/testtask'
+
+Rake::TestTask.new
+
+desc 'Run tests'
+task :default => :test

data/bin/xash

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'slop'
+require 'xash'
+require 'yaml'
+
+opts = Slop.parse do |o|
+  o.banner = "usage: xash [options] file"
+  o.separator 'YAML file can be only accepted'
+  o.on '-v', '--version', 'print the version' do
+    puts "Xash #{XASH::VERSION}"
+    exit
+  end
+  o.on '-h', '--help', 'print this help' do
+    puts o
+    exit
+  end
+end
+
+args = opts.arguments
+if args.empty?
+  puts opts
+else
+  puts XASH.eval(YAML.load(ARGF.read)).to_yaml
+end

data/lib/xash.rb

@@ -0,0 +1,9 @@
+require 'xash/version'
+require 'xash/evaluator'
+
+module XASH
+    def self.eval(code)
+        e = Evaluator.new
+        e.eval(code)
+    end
+end

data/lib/xash/context.rb

@@ -0,0 +1,58 @@
+module XASH
+    class Context
+        attr_accessor :name, :parent
+        attr_reader :lambda
+
+        def initialize(lambda, parent)
+            @variable_table = {}
+            @lambda = lambda['do']
+            @parent = parent
+            @name = '<anonymous>'
+        end
+
+        def exec(args)
+            exprs = @lambda
+            set_local_variable('it', args[0], false)
+            set_local_variable('args', args, false)
+            
+            yield(exprs)
+        end
+
+        def attach(context)
+            @attaching_context = context
+            ret = yield
+            @attaching_context = nil
+            ret
+        end
+
+        def attaching_context_call(name, *args)
+            @attaching_context && @attaching_context.send(name, *args)
+        end
+
+        def exist_variable?(name)
+            attaching_context_call(:exist_variable?, name) || @variable_table.include?(name) 
+        end
+
+        def variable(name)
+            attaching_context_call(:variable, name) || @variable_table[name] 
+        end
+
+        def variables
+            @variable_table.merge(attaching_context_call(:variables) || {})
+        end
+
+        def set_local_variable(name, val, with_warn)
+            if with_warn && @variable_table.key?(name)
+                warn "`#{name}` has been already assigned!"
+            end
+            @variable_table[name] = val
+        end
+
+        def reset_local_variable(name, val)
+            unless @variable_table.include? name
+                error UndefinedLocalVariableError, "undefined local variable `#{name}`"
+            end
+            @variable_table[name] = val
+        end
+    end
+end

data/lib/xash/context_stack.rb

@@ -0,0 +1,86 @@
+require 'xash/context'
+
+module XASH
+    class ContextStack
+        include Enumerable
+
+        def initialize(evaluator)
+            @evaluator = evaluator
+
+            @context_stack = []
+
+            #root context
+            root = Context.new({ 'do' => [] }, nil)
+            root.name = '<root>'
+            @context_stack.push(root)
+        end
+
+        def each
+            if block_given?
+                @context_stack.each{ |c| yield c }
+            else
+                @context_stack.each
+            end
+        end
+
+        def [](index)
+            @context_stack[index]
+        end
+
+        def current
+            @context_stack.last
+        end
+
+        def meta
+            @context_stack[-2]
+        end
+
+        def push(context)
+            @context_stack.push context
+            ret = yield
+            @context_stack.pop
+            ret
+        end
+
+        def get_variable(name)
+            #search order
+            #parents -> context_stack(attached -> local)
+            @context_stack.reverse_each do |context|
+                if context.exist_variable?(name)
+                    return context.variable(name)
+                end
+            end
+            
+            cur = current
+            while cur
+                if cur.exist_variable?(name)
+                    return cur.variable(name)
+                end
+                cur = cur.parent
+            end
+
+            raise UndefinedLocalVariableError, "undefined local variable `#{name}`"
+        end
+
+        def exist_variable?(name)
+            get_variable(name)
+        rescue
+            false
+        else
+            true
+        end
+
+        def variable(name)
+            get_variable(name)
+        rescue
+            @evaluator.error UndefinedLocalVariableError, "undefined local variable `#{name}`"
+        end
+
+        def meta_context
+            current = @context_stack.pop
+            ret = yield
+            @context_stack.push(current)
+            ret
+        end
+    end
+end

data/lib/xash/evaluator.rb

@@ -0,0 +1,386 @@
+require 'xash/context'
+require 'xash/context_stack'
+require 'xash/type'
+require 'xash/exception'
+
+require 'yaml'
+
+require 'pp'
+
+module XASH
+    class Evaluator
+
+        def error(klass, msg)
+            cc = @context_stack.current
+            variables = cc.variables.dup
+            if cc.name == '<root>'
+                variables = variables.each do |name, value|
+                    if @pseudo_functions.has_key? name
+                        variables[name] = '<internal>'
+                    end
+                end         
+            end
+            raise klass, {
+                current_name: cc.name || 'nil',
+                current_variables: variables,
+                current_lambda: cc.lambda,
+                parent_name: cc.parent ? cc.parent.name : 'nil',
+                message: msg
+            }.to_yaml
+        end
+
+        def warn(msg)
+            STDERR.puts msg
+        end
+
+        def call_function(name, args)
+            { name => args }
+        end
+
+        def make_lambda(args, exprs)
+            { 'do' => [ { 'ar' => args }, *exprs] }
+        end
+
+        def wrap_pseudo_function(args, realname)
+            make_lambda(args, [ call_function(realname, args.map{|arg| "$#{arg}"}) ])
+        end
+
+        def import_yaml(mod_name)
+            context = boot({ 'do' => YAML.load_file(mod_name) })
+            exec_context(context, [])
+        end
+
+        def initialize
+            @context_stack = ContextStack.new(self)
+
+            @pseudo_functions = {
+                'for' => wrap_pseudo_function(['collection', 'lambda'], '__for'),
+                'if' => wrap_pseudo_function(['condition', 'lambda'], '__if'),
+                'case' => wrap_pseudo_function([], '__case'),
+
+                'assign' => wrap_pseudo_function(['name', 'value'], '__assign'),
+                'reassign' => wrap_pseudo_function(['name', 'value'], '__reassign'),
+                'alias' => wrap_pseudo_function(['old', 'new'], '__alias'),
+
+                'import_yaml' => wrap_pseudo_function([], '__import_yaml'),
+                
+                'boot' => wrap_pseudo_function(['lambda'], '__boot'),
+                'method' => wrap_pseudo_function([], '__method'),
+                'get' => wrap_pseudo_function(['obj', 'name'], '__get'),
+
+                'ar' => { 'do' => [ call_function('__ar', '$args') ] },
+
+                #for arrays
+                'index' => wrap_pseudo_function(['ary', 'i'], '__index'),
+                'tail' => wrap_pseudo_function(['ary'], '__tail'),
+
+                'meta_context' => wrap_pseudo_function(%w(lambda_args lambda), '__meta_context'),
+                'expr' => wrap_pseudo_function([], '__expr')
+            }
+            @pseudo_functions.each do |name, val|
+                @context_stack.current.set_local_variable(name, val, true)
+            end
+
+            #とりあえず
+            import_yaml("#{File::dirname(__FILE__)}/kernel.yml")
+        end
+
+        def check_args(args, *types)
+            args.zip(types) do |arg, type|
+                next unless type
+                check_arg(arg, type)
+            end
+            nil
+        end
+
+        def check_arg(arg, type)
+            error TypeError, "`#{arg}` is not `#{type}`" unless Type.send("#{type}?", arg)
+            nil
+        end
+
+        OPERATORS = {
+            '==' => ->(l, r){ l.eql? r },
+            '/=' => ->(l, r){ !(l.eql? r) },
+
+            '>=' => ->(l, r){ l >= r },
+            '<=' => ->(l, r){ l <= r },
+            '>' => ->(l, r){ l > r },
+            '<' => ->(l, r){ l < r },
+
+            'or' => ->(l, r){ l || r },
+            'and' => ->(l, r){ l && r },
+            'xor' => ->(l, r){ l ^ r },
+
+            '+' => ->(l, r){ l + r },
+            '-' => ->(l, r){ l - r },
+
+            'mul' => ->(l, r){ l * r },
+            'div' => ->(l, r){ l / r },
+            'mod' => ->(l, r){ l % r }
+        }
+
+        #convert tokens to "Reverse Polish Notation"
+        def to_rpn(tokens, rpn)
+            (OPERATORS.keys + [/\\(\w+)/, /(^[-=^~|@`+;*:<.>?!%&_]+$)/]).each do |pattern|
+                idx, ope = if pattern.is_a? Regexp
+                            idx = tokens.index{|token| (token.is_a? String) && (m = pattern.match(token)) }
+                            [ idx, idx && $~[1] ]
+                        else
+                            [ tokens.index(pattern), pattern ]
+                        end
+                if idx
+                    to_rpn(tokens[0...idx], rpn)
+                    to_rpn(tokens[(idx + 1)...tokens.size], rpn)
+                    rpn << ope
+                    return 
+                end
+            end
+            rpn << tokens[0]
+        end
+
+        def condition(cond)
+            !(cond == false or cond == 0 or cond == nil)
+        end
+
+        def boot(executable)
+            case executable
+            when Context
+                executable
+            when ->(l) { Type.lambda?(l) }
+                Context.new(executable, @context_stack.current)
+            else
+                boot(make_lambda([], [ executable ]))
+            end
+        end
+
+        def exec_context(context, args)
+            context.exec(args) do |exprs|
+                ret = nil
+                exprs.each do |expr|
+                    ret = eval_expr(expr)
+                    if context.exist_variable?('next_value')
+                        ret = context.variable('next_value')
+                        break
+                    end
+                end
+                ret
+            end
+        end
+
+        def exec(executable, args, context_name = '<anonymous>')
+            case executable
+            when Context
+                executable.name = context_name
+
+                @context_stack.push(executable) do
+                    exec_context(executable, args)
+                end
+            else #lambda and mono expr
+                exec(boot(executable), args, context_name)
+            end
+        end
+
+        def eval_expr(expr)
+            case expr
+            when Array
+                expr.map{ |e| eval_expr(e) }
+            when Hash
+                k, v = expr.to_a[0]
+
+                no_eval = %w(do object if for)
+
+                k = eval_expr(k)
+                unless no_eval.index(k)
+                    v = eval_expr(v)
+                end
+
+                case k
+                #pseudo functions
+                when '__print'
+                    print v.join
+                when '__for'
+                    check_args(v, :collection)
+
+                    collection, lambda = v
+
+                    collection = Type.to_collection(eval_expr(collection))
+
+                    collection.map do |e|
+                        exec(lambda, [e])
+                    end
+                when '__if'
+                    check_args(v, :array)
+
+                    condition, lambda = v
+                    condition = eval_expr(call_function('expr', condition))
+
+                    if condition(condition)
+                        exec(lambda, [])
+                    else
+                        nil
+                    end
+
+                when '__case'
+                    args = @context_stack.variable('args')
+
+                    #0 2 4 ...
+                    0.step(args.size, 2).map do |i|
+                        unless Type.lambda?(args[i])
+                            if condition(eval_expr(call_function('expr', args[i])))
+                                break exec(args[i + 1], [])
+                            end
+                        else
+                            break exec(args[i], [])
+                        end
+                    end
+
+                when '__assign'
+                    check_args(v, :string)
+
+                    name, value = v
+
+                    @context_stack.meta.set_local_variable(name, value, true)
+                when '__reassign'
+                    check_args(v, :string)
+
+                    name, value = v
+
+                    @context_stack.meta.reset_local_variable(name, value)
+
+                when '__alias'
+                    check_args(v, :string, :string)
+
+                    old, new = v
+
+                    @context_stack.meta.set_local_variable(new, @context_stack.variable(old).dup, true)
+                when '__import_yaml'
+                    modules = @context_stack.variable('args')
+
+                    @context_stack.meta_context do
+                        modules.each do |mod|
+                            import_yaml(mod)
+                        end
+                    end
+
+                    true
+
+                when '__boot'
+                    check_args(v, :lambda)
+
+                    lambda = v[0]
+                    boot(lambda)
+
+                when '__method'
+                    seq = @context_stack.variable('args').dup
+
+                    obj = seq.shift
+                    until seq.empty?
+                        name, args = seq.shift, seq.shift
+                        obj = exec(obj.variable(name), args)
+                    end
+
+                    obj
+
+                when '__get'
+                    check_args(v, :context, :string)
+
+                    context, name = v
+
+                    context.variable(name)
+
+                when '__ar'
+                    names = v
+                    @context_stack.meta_context do
+                        args = @context_stack.variable('args')
+                    end
+                    names.zip(args) do |name, arg|
+                        @context_stack.meta.set_local_variable(name, arg, true)
+                    end
+
+                when '__index'
+                    check_args(v, :array, :integer)
+
+                    ary, i = v
+
+                    ary[i]
+
+                when '__tail'
+                    check_args(v, :array)
+                    ary = v[0]
+                    ary[1...ary.size]
+
+                when '__meta_context'
+                    check_args(v, :array, :executable)
+
+                    args, lambda = v
+
+                    #current
+                    @context_stack.meta_context do
+                        caller = @context_stack.current
+                        #caller
+                        @context_stack.meta_context do
+                            #meta context
+
+                            context = boot(lambda)
+                            #context.parent = current
+                            args.each do |arg|
+                                context.set_local_variable(arg, caller.variable(arg), true)
+                            end
+                            @context_stack.current.attach(context) do
+                                exec_context(context, args)
+                            end
+                        end
+                    end
+
+                when '__expr'
+                    
+                    tokens = @context_stack.variable('args')
+
+                    rpn = []
+                    to_rpn(tokens, rpn)
+
+                    stack = []
+                    rpn.each do |token|
+                        stack << if OPERATORS.key? token
+                                r, l = stack.pop, stack.pop
+                                OPERATORS[token][l, r]
+                            else
+                                if @context_stack.exist_variable?(token)
+                                    r, l = stack.pop, stack.pop
+                                    eval_expr(call_function(token, [l, r]))
+                                else
+                                    token
+                                end
+                            end
+                    end
+
+                    stack[0]
+
+                #for debug
+                when '__rb_inject'
+                    code = v[0]
+                    Kernel.eval(code, binding)
+
+                when 'do' #lambda
+                    expr #for lazy evaluation
+
+                #function call
+                else #others
+                    exec(@context_stack.variable(k), v, k)
+                end 
+            when /\$(\w+)/ #local variables
+                var_name = $1
+                @context_stack.variable(var_name)
+            when /(\d+)(\.\.\.|\.\.)(\d+)/ #range expr
+                { 'range' => [$1, $2, $3] }
+            else
+                #primitives
+                expr
+            end
+        end
+
+        def eval(code)
+            exec({ 'do' => code }, [])
+        end
+    end
+end

data/lib/xash/exception.rb

@@ -0,0 +1,13 @@
+module XASH
+    class UndefinedFunctionError < StandardError
+    end
+
+    class UndefinedLocalVariableError < StandardError
+    end
+
+    class TypeError < StandardError
+    end
+
+    class InvalidContextIDError < StandardError
+    end
+end

data/lib/xash/kernel.yml

@@ -0,0 +1,78 @@
+#kernel library
+
+- alias: [assign, def]
+
+- def: [print,
+    do: [
+        __print: [$args]
+    ]
+]
+
+- def: [puts,
+    do: [
+        print: [$args, "\n"]
+    ]
+]
+
+- def: [array,
+    do: [
+        $args
+    ]
+]
+
+- def:
+    - meta_assign
+    - do:
+        - meta_context: [$args, $assign]
+
+- def:
+    - expand
+    - do:
+        - ar: [context]
+        - assign: [names, tail: [$args]]
+        - for: [$names,
+            do: [ ar: [],
+                meta_assign: [$it, get: [$context, $it]]
+            ]
+        ]
+
+#escapes lambda
+- def: [next,
+    do: [[next_value],
+        meta_context: [[$next_value],
+            do: [
+                assign: [next_value, $it]
+            ]
+        ]
+    ]
+]
+
+#for class system
+- alias: [def, class]
+- alias: [reassign, override]
+
+- def: 
+    - new
+    - do:
+        - ar: [klass]
+        - assign: [new_args, tail: [$args]]
+        - assign: [context, boot: [$klass]]
+        - context: $new_args
+        - $context
+
+- def: [mdef,
+    do: [ ar: [name, lambda],
+        meta_context: [[name, lambda],#[$name, $lambda],
+            do: [ #ar: [name, lambda],
+                #__rb_inject: ["pp @context_stack.current.parent.name"],
+                def: [$name, boot: [$lambda] ]
+            ]
+        ]
+    ]
+]
+
+- def: [extends,
+    do: [ ar: [klass],
+        meta_context: [[], $klass]
+    ]
+]

data/lib/xash/type.rb

@@ -0,0 +1,43 @@
+module XASH
+    class Type
+        class << self
+
+            {
+                array: Array,
+                object: Hash,
+                string: String,
+                integer: Integer,
+                context: Context
+            }.each do |name, klass|
+                define_method "#{name}?" do |obj|
+                    obj.is_a? klass
+                end
+            end
+
+            def lambda?(lambda)
+                lambda.is_a? Hash and lambda.to_a[0][0] == 'do'
+            end
+
+            def collection?(collection)
+                collection.is_a? String or collection.respond_to? :to_a
+            end
+
+            def executable?(executable)
+                lambda?(executable) or context?(executable)
+            end
+
+            def to_collection(collection)
+                case collection
+                when String
+                    collection.each_char.to_a
+                when ->(c){ c.is_a? Hash and c.key? 'range' }
+                    f, e, l = collection['range']
+                    Range.new(f.to_i, l.to_i, e == '...').to_a
+                else
+                    raise TypeError, "`#{collection}` is not collection" unless collection? collection
+                    collection.to_a
+                end
+            end
+        end
+    end
+end

data/lib/xash/version.rb

@@ -0,0 +1,3 @@
+module XASH
+  VERSION = "0.0.2"
+end

data/samples/class.yml

@@ -0,0 +1,5 @@
+- import_yaml: ['samples/person.yml']
+
+- assign: [p, new: [$Person, long_long_float, '18']]
+
+- method: [$p, to_string, []]

data/samples/closure.yml

@@ -0,0 +1,13 @@
+- def: [make_get_name,
+    do: [ ar: [name],
+        boot: [
+            do: [
+                $name
+            ]
+        ]
+    ]
+]
+
+- assign: [get_name, { make_get_name: [long_long_float]}]
+
+- get_name: []

data/samples/context.yml

@@ -0,0 +1,10 @@
+- assign: [a, 10]
+- def:
+    - func
+    - do:
+        - assign: [a, 20]
+        - meta_context: [[],
+            do: [ $a ]
+        ]
+
+- func: []

data/samples/context_get.yml

@@ -0,0 +1,4 @@
+- import_yaml: ['samples/person.yml']
+
+- assign: [p, new: [$Person, long_long_float, 18]]
+- get: [$p, name]

data/samples/definition_operator.yml

@@ -0,0 +1,26 @@
+- def: ['!!',
+    do: [
+        ar: [ary, idx],
+        index: [$ary, $idx]
+    ]
+]
+
+- def: ['elem',
+    do: [
+        ar: [ary, e],
+        assign: [ret, false],
+        for: [$ary,
+            do: [
+                ar: [i],
+                puts: [$i, ' ', $e],
+                if: [[$i, ==, $e],
+                    do: [ reassign: [ret, true] ]
+                ]
+            ]
+        ],
+        $ret
+    ]
+]
+
+- assign: [ary, [1, 2, 3]]
+- expr: [$ary, '!!', 1]

data/samples/extend.yml

@@ -0,0 +1,15 @@
+- class:
+    - Base
+    - do:
+        - mdef: [func1, do: ['func1']]
+        - mdef: [func2, do: ['func2']]
+
+- class:
+    - Sub
+    - do:
+        - extends: [$Base]
+
+        - mdef: [func1, do: ['overridden']]
+
+- assign: [obj, new: [$Sub]]
+- [ method: [$obj, func1, []], method: [$obj, func2, []] ]

data/samples/fizzbuzz.yml

@@ -0,0 +1,11 @@
+#FizzBuzz
+- for: [1..10,
+    do: [ ar: [i],
+        case: [
+            [$i, mod, 15, ==, 0], FizzBuzz,
+            [$i, mod, 3, ==, 0], Fizz,
+            [$i, mod, 5, ==, 0], Buzz,
+            do: [$i]
+        ]
+    ]
+]

data/samples/for_array.yml

@@ -0,0 +1,3 @@
+- for: [[1, 9, 9, 5],
+    do: [$it]
+]

data/samples/for_range.yml

@@ -0,0 +1,3 @@
+- for: [1..10,
+    do: [$it]
+]

data/samples/object.yml

@@ -0,0 +1,6 @@
+- for:
+    - object: [{ name: long_long_float, age: 9999 }]
+    - do:
+        - [k, v]
+        - print: [$k, ' => ', $v]
+        - puts: []

data/samples/person.yml

@@ -0,0 +1,7 @@
+- class:
+    - Person
+    - do:
+        - ar: [name, age]
+
+        - mdef: [to_string, do: [expr: [ $name, +, ' : ', +, $age ] ]]
+        # - def: [to_string, boot: [ do: [expr: [ $name, +, " : ", +, $age ]]]]

data/samples/reassign.yml

@@ -0,0 +1,3 @@
+- assign: [a, 1]
+- reassign: [a, 10]
+- $a

data/samples/recursive.yml

@@ -0,0 +1,10 @@
+- def: [fact,
+    do: [[n],
+        case: [
+            [n, '>=', 1], 1,
+            expr: [{ self: [ expr: [$n, -, 1]] }, mul, $n]
+        ]
+    ]
+]
+
+- puts: [fact: [4]] #=> 24

data/test/test_basic.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+class BasicTest < Test::Unit::TestCase
+    def test_reassign
+        assert_equal 10, XASH_eval(:reassign)
+    end
+end

data/test/test_context.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+
+class ContextTest < Test::Unit::TestCase
+    def test_meta_context
+        assert_equal 10, XASH_eval(:context)
+    end
+
+    def test_closure
+        assert_equal 'long_long_float', XASH_eval(:closure)
+    end
+
+    def test_class
+        assert_equal 'long_long_float : 18', XASH_eval(:class)
+    end
+
+    def test_extend
+        assert_equal %w(overridden func2), XASH_eval(:extend)
+    end
+
+    def test_get
+        assert_equal 'long_long_float', XASH_eval(:context_get)
+    end
+end

data/test/test_expr.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+
+class ExprTest < Test::Unit::TestCase
+
+    def expr(*tokens)
+        XASH.eval [{ 'expr' => tokens }]
+    end
+
+    #+ - div mul
+    def test_basic_calc
+        assert_equal 6, expr(1, '+', 2, '+', 3)
+        assert_equal 26, expr(2, 'mul', 3, '+', 4, 'mul', 5)
+
+        assert_equal 1, expr(5, 'mod', 2)
+    end
+
+    #or and xor
+    def test_logical_calc
+        assert_equal true, expr(true, 'or', false)
+        assert_equal false, expr(true, 'and', false)
+        assert_equal true, expr(true, 'xor', false)
+    end
+
+    #== /=
+    def test_equivalent_calc
+        assert_equal true, expr(1, '+', 2, '==', 3)
+        assert_equal false, expr(1, '+', 2, '/=', 3)
+    end
+end

data/test/test_fizzbuzz.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+class FizzBuzzTest < Test::Unit::TestCase
+    def test_fizzbuzz
+        assert_equal [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz"], XASH_eval(:fizzbuzz)
+    end
+end

data/test/test_for.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+
+class ForTest < Test::Unit::TestCase
+    def test_range
+        assert_equal [*1..10], XASH_eval(:for_range)
+    end
+
+    def test_array
+        assert_equal [1, 9, 9, 5], XASH_eval(:for_array)
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require 'xash'
+require 'yaml'
+
+class Test::Unit::TestCase
+    def XASH_eval(name)
+        XASH.eval(YAML.load_file("samples/#{name}.yml"))
+    end
+end

data/test/test_if.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+
+class IfTest < Test::Unit::TestCase
+
+    def if_expr(cond, lambda)
+        XASH.eval [{ 'if' => [cond, lambda] }]
+    end
+
+    def test_basic
+        assert_equal 'ok', if_expr([true], 'ok')
+        assert_equal nil, if_expr([false], 'ok')
+
+        assert_equal 'ok', if_expr([5, 'mod', 2, '==', 1], 'ok')
+    end
+end

data/test/test_operator.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+class OperatorTest < Test::Unit::TestCase
+    def test_definition
+        assert_equal 2, XASH_eval(:definition_operator)
+    end
+end

data/xash.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "xash"
+  spec.version       = XASH::VERSION
+  spec.authors       = ["long-long-float"]
+  spec.email         = ["niinikazuki@yahoo.co.jp"]
+  spec.description   = %q{XASH is a external DSL which can be written in YAML!}
+  spec.summary       = %q{}
+  spec.homepage      = "https://github.com/long-long-float/xash"
+  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_dependency "slop", "~> 4.2"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: xash
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- long-long-float
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: XASH is a external DSL which can be written in YAML!
+email:
+- niinikazuki@yahoo.co.jp
+executables:
+- xash
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gemtest"
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/xash
+- lib/xash.rb
+- lib/xash/context.rb
+- lib/xash/context_stack.rb
+- lib/xash/evaluator.rb
+- lib/xash/exception.rb
+- lib/xash/kernel.yml
+- lib/xash/type.rb
+- lib/xash/version.rb
+- samples/class.yml
+- samples/closure.yml
+- samples/context.yml
+- samples/context_get.yml
+- samples/definition_operator.yml
+- samples/extend.yml
+- samples/fizzbuzz.yml
+- samples/for_array.yml
+- samples/for_range.yml
+- samples/object.yml
+- samples/person.yml
+- samples/reassign.yml
+- samples/recursive.yml
+- test/test_basic.rb
+- test/test_context.rb
+- test/test_expr.rb
+- test/test_fizzbuzz.rb
+- test/test_for.rb
+- test/test_helper.rb
+- test/test_if.rb
+- test/test_operator.rb
+- xash.gemspec
+homepage: https://github.com/long-long-float/xash
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- test/test_basic.rb
+- test/test_context.rb
+- test/test_expr.rb
+- test/test_fizzbuzz.rb
+- test/test_for.rb
+- test/test_helper.rb
+- test/test_if.rb
+- test/test_operator.rb