hivemind 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2764d5a862cc3857083c1477149d9371a287b5e
+  data.tar.gz: c77dec53e2a89d414049b1a8ee27012b447f10ca
+SHA512:
+  metadata.gz: afaea2fd77b4ed39da1da4e29026fff23731cfe1ff0c57ba04351ae3f62a8b2398210c7eb947c082443c12d4bf7b2128a1f7ef2b7c634c6d5c09480136ad6637
+  data.tar.gz: 36c436652012e46864ceb2665d5006113c21c0137c0a4628744a9d84a7070a59c5fceaa31c80037664b72eb16dc82fdc403ab6e1035b88909e16bc5bd2569f1a

data/.gitignore

@@ -0,0 +1,22 @@
+#Logs
+application/logs/*.php
+
+# Content types
+/application/xml/types/*.xml
+
+# Custom builds and generated php files
+/core/documentation/build
+/core/views/admin/content/translations.php
+
+# Attachs and cache files #
+*.tmp
+/attach/cache/
+/attach/
+/application/cache/_bancha/*.css
+/application/cache/_bancha/*.js
+
+Gemfile.lock
+*.pyc
+*.doc
+*.txt
+

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'bundler'
+  gem 'rspec'
+  gem 'skeptic'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Alexander Ivanov
+
+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 @@
+[![Build Status](https://travis-ci.org/alehander42/hivemind.svg?branch=master)](https://travis-ci.org/alehander42/hivemind)
+[![MIT License](http://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+# hivemind
+
+A programming language for HackFMI 5
+
+A compiler for hivemind
+
+# Usage
+
+Run a file
+
+```bash
+hivemind <filename>
+```
+
+Translate a file into another syntax representation
+
+```bash
+hivemind render a.hm pythonic a2.hm
+```
+
+# Language
+
+The language is just a simple python/ruby-like language for now.
+
+# Features(language & env)
+
+
+# Future development
+
+* fluid folder/file structure representations
+* editor plugins
+* more syntaxes
+
+## License
+
+Copyright 2016 [Alexander Ivanov](https://twitter.com/alehander42)
+
+Distributed under the MIT License.
+

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/bin/hivemind

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'hivemind'
+
+SYNTAXES_PATH = File.join(File.expand_path(File.join(File.dirname(__FILE__), '..')), 'syntaxes')
+
+def astify(source, syntax)
+  parser, refs = Hivemind::Syntax.generate_syntax(syntax)
+  success, tree, _ = parser.parse(source, refs)
+  tree
+end
+
+def syntax_file(f)
+  File.read(File.join(SYNTAXES_PATH, "#{f}.syntax"))
+end
+
+if ARGV.length == 1
+  filename = ARGV[0]
+  source = File.read(filename)
+  syntax_line, _, source = source.partition("\n")
+  if !syntax_line.start_with? 'syntax: '
+    puts "file doesn't specify a syntax"
+    exit 1
+  end
+  syntax = syntax_file(syntax_line.partition(': ').last)
+  tree = astify(source.lstrip, syntax)
+  vm = Hivemind::VM.new(tree)
+  result = vm.run Hivemind::Runtime::HivemindEnv
+elsif ARGV.length == 4
+  filename, second_syntax_name, save = ARGV[1..-1]
+  source = File.read(filename)
+  syntax_line, _, source = source.partition("\n")
+  if !syntax_line.start_with? 'syntax: '
+    puts "first line of file doesn't specify a syntax"
+    exit 1
+  end
+  first  = syntax_file(syntax_line.partition(': ').last)
+  second = syntax_file(second_syntax_name)
+  tree = astify(source.lstrip, first)
+  result = Hivemind::Renderer.new(tree, second).render
+  File.write(save, "syntax: #{second_syntax_name}\n\n#{result}")
+else
+  puts <<-USAGE
+    hivemind <filename>
+      runs the file
+    hivemind render <filename> <syntax> <new_filename>
+      renders the source with <syntax>
+  USAGE
+end
+

data/hivemind.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: skeptic 0.0.16 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "hivemind"
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Alexander Ivanov"]
+  s.date = "2016-03-12"
+  s.description = "A multi-syntax programming language"
+  s.email = "alehande42@gmail.com"
+  s.executables = ["hivemind"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "bin/hivemind",
+    "lib/hivemind.rb",
+    ".gitignore",
+    "Gemfile",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "hivemind.gemspec",
+    "lib/hivemind/code_viewer.rb",
+    "lib/hivemind/combinators.rb",
+    "lib/hivemind/environment.rb",
+    "lib/hivemind/errors.rb",
+    "lib/hivemind/renderer.rb",
+    "lib/hivemind/runtime.rb",
+    "lib/hivemind/syntax.rb",
+    "lib/hivemind/universal_ast.rb",
+    "lib/hivemind/vm.rb",
+    "spec/spec_helper.rb",
+    "spec/hivemind/parser_spec.rb",
+    "spec/hivemind/vm_spec.rb",
+    "spec/hivemind/universal_ast_spec.rb",
+    "syntaxes/pythonic.syntax",
+    "syntaxes/lolcode.syntax",
+    "syntaxes/paren.syntax"
+  ]
+  s.homepage = "http://github.com/alehander42/hivemind"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.4.8"
+  s.summary = "A multi-syntax language"
+
+  s.add_development_dependency(%q<rspec>, ["= 2.14.1"])
+  s.add_development_dependency(%q<bundler>, [">= 0"])
+  s.add_development_dependency(%q<skeptic>, [">= 0"])
+end
+

data/lib/hivemind.rb

@@ -0,0 +1,6 @@
+require_relative 'hivemind/universal_ast'
+require_relative 'hivemind/environment'
+require_relative 'hivemind/vm'
+require_relative 'hivemind/runtime'
+require_relative 'hivemind/syntax'
+require_relative 'hivemind/renderer'

data/lib/hivemind/code_viewer.rb

@@ -0,0 +1,41 @@
+#  'universal_ast'
+
+# module Hivemind
+#   class CodeViewer
+#     def initialize(tree)
+#       @tree = tree
+#     end
+
+#     def view_as(query)
+#       hierarchy = QueryAnalyzer.parse(query)
+#       rebuild_tree(hierarchy)
+#     end
+
+#     def rebuild_tree(hierarchy)
+#       if hierarchy[0].type == @code_view.hierarchy[0].type
+#         # only sorting maybe
+#         # and sorting still not supported
+#         @tree
+#       else
+#         # method > code
+#         new_tree = UniversalAST::Image.new([])
+#         top = {}
+#         if hierarchy[0].type == :method
+#           @tree.statements.each do |statement|
+#             statement.methods.each do |method|
+#               top[method.method_name.value] ||= {}
+#               top[method.method_name.value][statement.class_name.value] = [args, method.body]
+#             end
+#           end
+#         else
+#            @tree.statements.each do |statement|
+#              statement.body.each do |method|
+#                top[method.class_name.value] ||= {}
+#                top[method.class_name.value][statement.method_name.value] = [args, method.body]
+#              end
+#            end
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/hivemind/combinators.rb

@@ -0,0 +1,202 @@
+require_relative 'universal_ast'
+
+class Combinator
+  def &(other)
+    And.new(self, other)
+  end
+
+  def |(other)
+    Or.new(self, other)
+  end
+end
+
+class Lit < Combinator
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def parse(input, refs)
+    if input.start_with?(@value)
+      [true, @value, input[@value.length.. -1]]
+    else
+      [false, '', input]
+    end
+  end
+end
+
+class Mat < Combinator
+  attr_reader :regex
+
+  def initialize(regex)
+    @regex = /\A#{regex}/
+  end
+
+  def parse(input, refs)
+    match = @regex.match(input)
+    if match
+      [true, input[0..match.to_s.size - 1], input[match.to_s.size.. -1]]
+    else
+      [false, '', input]
+    end
+  end
+end
+
+class Binary < Combinator
+  attr_accessor :first, :second
+
+  def initialize(first, second)
+    @first, @second = first, second
+  end
+end
+
+class And < Binary
+  def parse(input, refs)
+    first_success, first_result, remaining = @first.parse(input, refs)
+    if first_success
+      second_success, second_result, remaining  = @second.parse(remaining, refs)
+      if second_success
+        return [true, combine(first_result, second_result), remaining]
+      end
+    end
+    [false, [], input]
+  end
+
+  def combine(first_result, second_result)
+    if @first.is_a?(And)
+      first_result + [second_result]
+    else
+      [first_result, second_result]
+    end
+  end
+end
+
+class Or < Binary
+  def parse(input, refs)
+    [@first, @second].each do |combinator|
+      success, result, remaining = combinator.parse(input, refs)
+      return [true, result, remaining] if success
+    end
+    [false, '', input]
+  end
+end
+
+class Many < Combinator
+  attr_accessor :parser
+
+  def initialize(parser, as: nil)
+    @parser = parser
+  end
+
+  def parse(input, refs)
+    success = true
+    remaining = input
+    results = []
+    while success
+      success, result, remaining = @parser.parse(remaining, refs)
+      results.push(result) if success
+    end
+    [true, results, remaining]
+  end
+end
+
+class Join < Combinator
+  attr_accessor :parser, :as
+
+  def initialize(parser, separator, as: nil)
+    @parser = parser
+    @separator = separator
+    @as = as.to_sym
+    @separator_parser = Lit.new(@separator) & Mat.new(/ */) #workaround hivemind
+    @@depth ||= 0
+  end
+
+  def parse(input, refs)
+    success = true
+    remaining = input
+    results = []
+    while success
+      # puts "#{'  ' * @@depth}BEFORE " + @parser.label.to_s
+      # p ["  " * @@depth, remaining]
+
+      # @@depth += 1
+      success, result, remaining = @parser.parse(remaining, refs)
+      # @@depth -= 1
+      # puts "#{'  ' * @@depth}AFTER " + @parser.label.to_s
+      # p ["  " * @@depth, success, remaining, results.length]
+      # puts
+
+      results.push(result) if success
+      if success
+        if remaining.start_with? '    (' # fix later
+          remaining = "\n#{remaining}"
+        end
+        success, result, remaining = @separator_parser.parse(remaining, refs)
+      end
+    end
+    [true, results, remaining]
+  end
+end
+
+class Ref < Combinator
+  attr_accessor :label
+
+  def initialize(label, as: nil)
+    @label = label
+    @as = as
+  end
+
+  def parse(input, refs)
+    ref_parser = refs[@label.to_sym]
+    ref_parser.parse(input, refs)
+  end
+end
+
+class Maybe < Combinator
+  attr_accessor :parser
+
+  def initialize(parser)
+    @parser = parser
+  end
+
+  def parse(input, refs)
+    _, result, remaining = @parser.parse(input, refs)
+    [true, result, remaining]
+  end
+end
+
+class Apply < Combinator
+  attr_accessor :parser
+  attr_reader :transformation
+
+  def initialize(parser, &transformation)
+    @parser, @transformation = parser, transformation
+  end
+
+  def parse(input, refs)
+    success, result, remaining = @parser.parse(input, refs)
+    result = @transformation.call(result) if success
+    [success, result, remaining]
+  end
+end
+
+def literal(value)
+  Literal.new(value)
+end
+
+def many(combinator)
+  Many.new(combinator)
+end
+
+def maybe(combinator)
+  Maybe.new(combinator)
+end
+
+def apply(combinator, &transformation)
+  Apply.new(combinator, &transformation)
+end
+
+def match(regex)
+  Match.new(regex)
+end