RubyGems - hivemind - Versions diffs - 0.1 - Mend

hivemind 0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

checksums.yaml +7 -0
data/.gitignore +22 -0
data/Gemfile +7 -0
data/LICENSE +20 -0
data/README.md +42 -0
data/Rakefile +18 -0
data/bin/hivemind +52 -0
data/hivemind.gemspec +57 -0
data/lib/hivemind.rb +6 -0
data/lib/hivemind/code_viewer.rb +41 -0
data/lib/hivemind/combinators.rb +202 -0
data/lib/hivemind/environment.rb +32 -0
data/lib/hivemind/errors.rb +7 -0
data/lib/hivemind/renderer.rb +71 -0
data/lib/hivemind/runtime.rb +90 -0
data/lib/hivemind/syntax.rb +404 -0
data/lib/hivemind/universal_ast.rb +169 -0
data/lib/hivemind/vm.rb +186 -0
data/spec/hivemind/parser_spec.rb +0 -0
data/spec/hivemind/universal_ast_spec.rb +22 -0
data/spec/hivemind/vm_spec.rb +10 -0
data/spec/spec_helper.rb +7 -0
data/syntaxes/lolcode.syntax +34 -0
data/syntaxes/paren.syntax +34 -0
data/syntaxes/pythonic.syntax +36 -0
metadata +112 -0

data/lib/hivemind/universal_ast.rb ADDED Viewed

@@ -0,0 +1,169 @@
+module Hivemind
+  module UniversalAST
+    class Element
+      def self.fields(*labels)
+        define_method(:initialize) do |*args|
+          args.zip(labels).each do |arg, label|
+            instance_variable_set "@#{label}", arg
+          end
+        end
+        attr_reader *labels
+      end
+      def offset(depth)
+        '    ' * depth
+      end
+    end
+    class IfStatement < Element
+      # if <test>:
+      #   <<true-branch>>
+      # else:
+      #   <<else-branch>>
+      fields :test, :true_branch, :else_branch
+      def render(depth = 0)
+        "#{offset(depth)}If\n#{offset(depth + 1)}#{@test.render(depth + 1)}\n"
+        "#{@true_branch.render(depth + 1)}\n#{@else_branch.render(depth + 1)}\n"
+      end
+    end
+    class Assign < Element
+      # <left> = <right>
+      fields :left, :right
+      def render(depth = 0)
+        "#{offset(depth)}Assign left: #{@left.render} right: #{@right.render}"
+      end
+    end
+    class Attribute < Element
+      # <object>.<label>
+      fields :object, :label
+      def render(depth = 0)
+        "#{offset(depth)}Attribute : #{@object.render} #{@label.render}"
+      end
+    end
+    class AttributeAssign < Element
+      # <object>.<label> = <right>
+      fields :object, :label, :right
+      def render(depth = 0)
+        "#{offset(depth)}AttributeAssign : #{@object.render} #{@label.render} #{@right.render}"
+      end
+    end
+    class Call < Element
+      # <function>(<<args:', '>>)
+      fields :function, :args
+      def render(depth = 0)
+        "#{offset(depth)}Call\n#{@function.render(depth + 1)}\n#{offset(depth + 1)}#{@args.map(&:render).join(' ')}\n"
+      end
+    end
+    class List < Element
+      # [el1, el2..]
+      fields :elements
+      def render(depth = 0)
+        "#{offset(depth)}List\n#{@elements.map { |e| e.render(depth + 1) }.join("\n")}"
+      end
+    end
+    class Dictionary < Element
+      # {key1: val1, key2: val2..}
+      fields :pairs
+    end
+    class Binary < Element
+      # <left> <operation> <right>
+      fields :left, :operation, :right
+      def render(depth = 0)
+        "#{offset(depth)}Binary #{@left.render} #{@operation.value} #{@right.render}"
+      end
+    end
+    class MethodStatement < Element
+      # method <method-name>(<<args:', '):
+      #   <<body>>
+      fields :method_name, :args, :body
+      def render(depth = 0)
+        "#{offset(depth)}MethodStatement #{@method_name.value} #{@args.map(&:render).join(' ')}\n" +
+        "#{@body.map { |e| e.render(depth + 1) }.join("\n")}\n"
+      end
+    end
+    class ClassStatement < Element
+      # type <class-name>:
+      #   <<methods>>
+      fields :class_name, :methods
+      def render(depth = 0)
+        "#{offset(depth)}ClassStatement #{@class_name.value}\n" +
+        "#{@methods.map { |e| e.render(depth + 1) }.join("\n")}\n"
+      end
+    end
+    class Value < Element
+      fields :value
+      def render(depth = 0)
+        "#{offset(depth)}#{@value}"
+      end
+    end
+    class Name < Value
+    end
+    class String < Value
+    end
+    class Number < Value
+    end
+    class Int < Number
+    end
+    class Float < Number
+    end
+    class Operation < Value
+    end
+    class ModuleStatement < Element
+      # module <module-name>:
+      #   <<children>>
+      fields :module_name, :elements
+    end
+    class Pair < Element
+      # key => value
+      fields :key, :value
+    end
+    class Image < Element
+      fields :statements
+      def render(depth = 0)
+        @statements.map(&:render).join "\n"
+      end
+    end
+  end
+end

data/lib/hivemind/vm.rb ADDED Viewed

@@ -0,0 +1,186 @@
+require_relative 'runtime'
+require_relative 'universal_ast'
+module Hivemind
+  class VM
+    def initialize(ast)
+      @ast = ast
+    end
+    def run(env)
+      @ast.run env
+    end
+  end
+  class Runtime::HivemindObject
+    def call(function, args, env)
+      if function.is_a?(UniversalAST::MethodStatement)
+        args_values = {:self => self}
+        function.args[1..-1].zip(args) do |label, arg|
+          args_values[label.value.to_sym] = arg
+        end
+        body_env = Environment.new(env, **args_values)
+        function.body.map { |expr| expr.run(body_env) }[-1] || env.top[:@nil]
+      else
+        function.call self, *args, env
+      end
+    end
+  end
+  class Runtime::HivemindClass
+    def call(function, args, env)
+      h = Runtime::HivemindObject.new({}, self)
+      function = dispatch_method(:init)
+      if function.is_a?(UniversalAST::MethodStatement)
+        args_values = {:self => h}
+        function.args[1..-1].zip(args) do |label, arg|
+          args_values[label.value.to_sym] = arg
+        end
+        body_env = Environment.new(env, **args_values)
+        function.body.map { |expr| expr.run(body_env) }[-1] || env.top[:@nil]
+      else
+        function.call h, *args, env
+      end
+      h
+    end
+  end
+  module UniversalAST
+    class Image
+      def run(env)
+        @statements.each do |statement|
+          statement.run(env)
+        end
+        # puts env.top[:Object].methods.keys
+        if env.top[:Object].methods.key? :start
+          weird_object = Runtime::hivemind_object({})
+          weird_object.call(env.top[:Object].methods[:start], [], env)
+        else
+          env.top[:@nil]
+        end
+      end
+    end
+    class ModuleStatement
+      def run(env)
+        module_statement = Runtime::HivemindModule.new(@module_name)
+        @statements.each do |statement|
+          module_statement.elements[@statement.is_a?(ModuleStatement) ? @statement.module_name : @statement.class_name] =
+            statement.run(env)
+        end
+        env
+      end
+    end
+    class If
+      def run(env)
+        if @test.run(env) == env.top[:@true]
+          @true_branch.run env
+        else
+          @else_branch.run env
+        end
+      end
+    end
+    class Assign
+      def run(env)
+        env[@left.value.to_sym] = @right.run(env)
+      end
+    end
+    class Attribute
+      def run(env)
+        obj = @object.run(env)
+        env.current_self = obj
+        if obj.respond_to?(:data)
+          if obj.data.key? @label.value
+            obj.data[@label.value]
+          else
+            method = obj.klass.dispatch_method(@label.value)
+            if method
+              method
+            else
+              raise HivemindAccessError.new("No #{@label.value} in obj")
+            end
+          end
+        else
+          obj.methods[@label.value]
+        end
+      end
+    end
+    class AttributeAssign
+      def run(env)
+        @object.run(env).data[@label.value] = @right.run(env)
+      end
+    end
+    class Call
+      def run(env)
+        if !@function.is_a?(Attribute)
+          function = @function.run(env)
+          env.current_self.call(function, @args.map { |arg| arg.run(env) }, env)
+        elsif @function.label.value != :new
+          obj = @function.object.run(env)
+          function = obj.klass.dispatch_method(@function.label.value)
+          obj.call(function, @args.map { |arg| arg.run(env) }, env)
+        else
+          obj = @function.object.run(env)
+          function == obj.dispatch_method(:init)
+          obj.call(function, @args.map { |arg| arg.run(env) }, env)
+        end
+      end
+    end
+    class Binary
+      def run(env)
+        Runtime::hivemind_numbr(@left.run(env).data[:_value].send(@operation.value, @right.run(env).data[:_value]))
+      end
+    end
+    class List
+      def run(env)
+        Runtime::HivemindObject.new({_elements: @elements.map { |elem| elem.run(env) }}, env.top[:List])
+      end
+    end
+    class Dictionary
+      def run(env)
+        dict = {}
+        @pairs.each do |pair|
+          dict[pair.key.value.to_sym] = pair.value.run(env)
+        end
+        Runtime::HivemindObject.new({_dict: dict}, env.top[:Dict])
+      end
+    end
+    class Value
+      def run(env)
+        Runtime::HivemindObject.new({_value: @value}, env.top[self.class.name.split('::').last.to_sym])
+      end
+    end
+    class ClassStatement
+      def run(env)
+        definition = env.fetch(@class_name.value) || Runtime::HivemindClass.new(@class_name.value, env.top[:Object], {})
+        @methods.each do |method|
+          definition.methods[method.method_name.value] = method
+        end
+        env[@class_name.value] = definition
+      end
+    end
+    class MethodStatement
+      def run(env)
+        self
+      end
+    end
+    class Name
+      def run(env)
+        env[@value]
+      end
+    end
+  end
+end

data/spec/hivemind/parser_spec.rb ADDED Viewed

File without changes

data/spec/hivemind/universal_ast_spec.rb ADDED Viewed

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Hivemind
+  module UniversalAST
+    describe Element do
+      it 'fields initializes a class with given labels' do
+        class A < Element
+          fields :a
+        end
+        expect(A.new(2).a).to eq(2)
+      end
+    end
+    describe ModuleStatement do
+      it 'is initialized with an elements attribute' do
+        mod = ModuleStatement.new('ha', [])
+        expect(mod.elements).to eq([])
+      end
+    end
+  end
+end

data/spec/hivemind/vm_spec.rb ADDED Viewed

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Hivemind
+  describe VM do
+    it 'should work for a program with a single number' do
+      vm = VM.new UniversalAST::Number.new(44)
+      expect(vm.run(Runtime::HivemindEnv).data[:_value]).to eq 44
+    end
+  end
+end

data/spec/spec_helper.rb ADDED Viewed

@@ -0,0 +1,7 @@
+# well, really, no time for a lot of tests now
+# dirty fast prototyping
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'hivemind'

data/syntaxes/lolcode.syntax ADDED Viewed

@@ -0,0 +1,34 @@
+#if_statement
+<test> O RLY
+    YA RLY
+    <<true_branch>>
+    NO WAI
+    <<else_branch>>
+#assign
+DO <left> <right>
+#method_statement
+HOW DUZ I <method_name>(<<args:' '>>)
+    <<body>>
+IF U SAY SO
+#attribute
+<object> HEY <label>
+#attribute_assign
+<object> BE <label> <right>
+#call
+GIMME <function> (<<args:' '>>)
+#class_statement
+TOM SAYS <class_name>
+    <<methods>>
+LOVE
+#module_statement
+HAI <module_name>
+    <<elements>>
+KTHXBYE

data/syntaxes/paren.syntax ADDED Viewed

@@ -0,0 +1,34 @@
+#if_statement
+(if <test>
+    <true_branch>
+    <else_branch>)
+#assign
+(define <left> <right>)
+#method_statement
+(method <method_name> (<<args:' '>>)
+    <<body>>)
+#attribute
+<object>.<label>
+#attribute_assign
+(update <object>.<label> <right>)
+#binary
+(<operation> <left> <right>)
+#call
+(! <function> <<args:' '>>)
+#list
+_(<<elements:' '>>)
+#class_statement
+(class <class_name>
+    <<methods>>)
+#module_statement
+(module <module_name>
+    <<elements>>)