fancy 0.3.0

data/lib/package.fy

@@ -0,0 +1,61 @@
+require: "package/installer"
+require: "package/uninstaller"
+require: "package/dependency"
+require: "package/specification"
+
+class Fancy Package {
+  """
+
+  The Fancy Package System.
+
+  This class is used for installing and uninstalling fancy packages on
+  the system.
+
+  Example:
+      $ fancy install bakkdoor/mongo.fy
+
+  Will install the mongo.fy package from http://github.com/bakkdoor/mongo.fy
+  in the latest released version or get the current HEAD (master
+  branch) revision.
+
+  You can then load the package in your source file via
+      require: \"mongo.fy\"
+
+  """
+
+  ENV_PACKAGE_DIR_VAR = "FANCY_PACKAGE_DIR"
+
+  def self install: package_name {
+    """
+    Installs a package with a given name.
+    Expects package_name to be a string in the form of:
+        user/repo
+    Which would get the package code from github.com/user/repo
+    """
+
+    Installer new: package_name . run
+  }
+
+  def self uninstall: package_name {
+    Uninstaller new: package_name . run
+  }
+
+  def self package_root_dir {
+    if: (ENV[ENV_PACKAGE_DIR_VAR]) then: |path| {
+      return path
+    } else: {
+      return Fancy Package Installer DEFAULT_PACKAGES_PATH
+    }
+  }
+
+  def self add_to_loadpath {
+    """
+    Adds the Fancy Package install dir to the loadpath so you can
+    easily @require: packages into your code.
+    """
+
+    root = Fancy Package package_root_dir
+    Fancy CodeLoader push_loadpath: root
+    Fancy CodeLoader push_loadpath: (root ++ "/lib")
+  }
+}

data/lib/package/dependency.fy

@@ -0,0 +1,24 @@
+class Fancy Package {
+  class Dependency {
+    """
+    Package Dependency.
+    Represents a Dependency to another Package with a given version.
+    """
+
+    read_slots: ['name, 'version]
+
+    def initialize: @name version: @version ('latest) {
+    }
+  }
+
+  class RubyDependency {
+    """
+    Same as @Fancy::Package::Dependency@, just for rubygem packages.
+    """
+
+    read_slots: ['gem_name, 'version]
+
+    def initialize: @gem_name version: @version ('latest) {
+    }
+  }
+}

data/lib/package/installer.fy

@@ -0,0 +1,180 @@
+require("yaml")
+require("open-uri")
+
+class Fancy Package {
+  class Installer {
+    """
+
+    @Fancy::Package@ installer.
+
+    Downloads packages from Github (usually the latest tagged version,
+    if no version is specified, or the latest HEAD revision in the
+    master branch) and install it to the @FANCY_PACKAGE_DIR.
+
+    """
+
+    DEFAULT_FANCY_ROOT = ENV["HOME"] ++ "/.fancy"
+    DEFAULT_PACKAGES_PATH = DEFAULT_FANCY_ROOT ++ "/packages"
+    DEFAULT_PACKAGES_LIB_PATH = DEFAULT_PACKAGES_PATH ++ "/lib"
+
+    def initialize: @package_name version: @version ("latest") install_path: @install_path (ENV["FANCY_PACKAGE_DIR"]) {
+      """
+      Creates a new @Package Installer@ for a given package name, an
+      optional version (default is 'latest') and an optional
+      installation path (default is the standard installation path for
+      Fancy packages).
+      """
+
+      splitted = @package_name split: "/"
+      @user = splitted first
+      @repository = splitted second
+
+      @install_path if_nil: {
+        @install_path = DEFAULT_PACKAGES_PATH
+        Directory create!: DEFAULT_FANCY_ROOT
+        Directory create!: DEFAULT_PACKAGES_PATH
+        Directory create!: DEFAULT_PACKAGES_LIB_PATH
+        Directory create!: $ DEFAULT_PACKAGES_PATH ++ "/downloads"
+      }
+
+      @download_path = @install_path ++ "/downloads"
+    }
+
+    def run {
+      """
+      Runs the installer & installs the package into
+      @$FANCY_PACKAGE_DIR.
+      """
+
+      filename = nil
+      if: (@version == "latest") then: {
+        if: (self latest_tag) then: |tag| {
+          @version = tag
+        } else: {
+          @version = "master"
+        }
+        filename = self download_tgz: @version
+      }
+
+      # now unpack & check for dependencies
+      unpack_dir = unpack_file: filename
+      rename_dir: unpack_dir
+      self load_fancypack
+    }
+
+    def latest_tag {
+      "Returns the latest tag (sorted alphabetically)."
+
+      tags = self tags
+      if: (tags size > 0) then: {
+        tags keys sort last
+      }
+    }
+
+    def tags {
+      "Returns a list of tags the repository has on Github."
+
+      url = "http://github.com/api/v2/yaml/repos/show/" ++ @package_name ++ "/tags/"
+      YAML load_stream(open(url)) documents() first at: "tags"
+    }
+
+    def download_url: version {
+      """
+      Returns the download url for a given version of the package
+      to be installed.
+      """
+
+      "https://github.com/" ++ @package_name ++ "/tarball/" ++ version
+    }
+
+    def download_tgz: version {
+      """
+      Downloads the .tar.gz file from Github with the given version
+      (tag or branch name) and saves it to the specified @install_path.
+
+
+      The Default install_path is ~/.fancy/packages/.
+      If an environment variable @FANCY_PACKAGE_DIR is defined, it
+      will get used.
+      """
+
+      download_url = download_url: version
+      ["Downloading ", @package_name, " version ", version, " from: ", download_url] join println
+
+      filename = [@user, "_", @repository, "-", version, ".tar.gz"] join
+
+      # run curl to get the .tar.gz file
+      cmd = ["curl -o ", @download_path, "/", filename, " -L -O ", download_url] join
+      System do: cmd
+
+      filename
+    }
+
+    def unpack_file: filename {
+      "Unpacking " ++ filename println
+      System do: $ ["tar xf ", @download_path, "/", filename, " -C ", @install_path, "/"] join
+      output = System pipe: $ ["tar tf ", @download_path, "/", filename] join
+      dirname = output readlines first chomp
+    }
+
+    def installed_path {
+      @install_path + "/" + @user + "_" + @repository + "-" + @version
+    }
+
+    def lib_path {
+      @install_path + "/lib"
+    }
+
+    def rename_dir: dirname {
+      """
+      Renames a given directory to a common way within the install path.
+      => It will rename the given dirname to $user/$repo-$version.
+      """
+
+      System do: $ ["mv ", @install_path, "/", dirname, " ", self installed_path] join
+    }
+
+    def load_fancypack {
+      """
+      Loads the @.fancypack file within the downloaded package directory.
+      If no @.fancypack file is found, raise an error.
+      """
+
+      Dir glob(self installed_path ++ "/*.fancypack") first if_do: |fpackfile| {
+        require: fpackfile
+      }
+
+      if: (Specification[@repository]) then: |spec| {
+        fulfill_spec: spec
+      } else: {
+        "Something wen't wrong. Did not find a fancypack specification for package: " ++ @repository . raise!
+      }
+    }
+
+    def fulfill_spec: spec {
+      unless: (spec include_files empty?) do: {
+        File open: (self lib_path + "/" + (spec package_name)) modes: ['write] with: |f| {
+          spec include_files each: |if| {
+            f write: "require: \""
+            f write: (self installed_path)
+            f write: "/"
+            f write: if
+            f writeln: "\""
+          }
+        }
+      }
+
+      spec dependencies each: |dep| {
+        Package install: dep
+      }
+
+      spec rubygem_dependencies each: |dep| {
+        if: (dep version == 'latest) then: {
+          System do: $ "rbx gem install " ++ (dep gem_name)
+        } else: {
+          System do: $ "rbx gem install -v=" ++ (dep version) ++ " " ++ (dep gem_name)
+        }
+      }
+    }
+  }
+}

data/lib/package/specification.fy

@@ -0,0 +1,55 @@
+class Fancy Package {
+  class Specification {
+    @@specs = <[]>
+
+    read_write_slots: ['author, 'email, 'include_files, 'bin_files,
+                       'description, 'homepage, 'version]
+
+    read_slots: ['package_name, 'dependencies, 'rubygem_dependencies]
+
+    def initialize: @package_name with: block {
+      @dependencies = []
+      @rubygem_dependencies = []
+      @include_files = []
+      @bin_files = []
+
+      block call_with_receiver: self
+
+      @@specs at: @package_name put: self
+    }
+
+    def dependencies: dependencies {
+      dependencies each: |d| {
+        name = d first
+        version = d second
+        { version = 'latest } unless: version
+        dep = Dependency new: name version: version
+        @dependencies << dep
+      }
+    }
+
+    def ruby_dependencies: dependencies {
+      dependencies each: |d| {
+        gem_name = d first
+        version = d second
+        { version = 'latest } unless: version
+        dep = RubyDependency new: gem_name version: version
+        @rubygem_dependencies << dep
+      }
+    }
+
+    def add_dependency: name version: version ('latest) {
+      dep = Dependency new: name version: version
+      @dependencies << dep
+    }
+
+    def add_ruby_dependency: gem_name version: version ('latest) {
+      dep = RubyDependency new: gem_name version: version
+      @rubygem_dependencies << dep
+    }
+
+    def self [] package_name {
+      @@specs[package_name]
+    }
+  }
+}

data/lib/package/uninstaller.fy

@@ -0,0 +1,15 @@
+class Fancy Package {
+  class Uninstaller {
+    """
+
+    @Fancy Package@ Uninstaller.
+
+    """
+
+    def initialize: @package_name {
+    }
+
+    def run {
+    }
+  }
+}

data/lib/parser.fy

@@ -0,0 +1,4 @@
+
+require: "parser/methods"
+require(File.expand_path("parser/ext/fancy_parser", File.dirname(__FILE__)))
+

data/lib/parser/ext/README

@@ -0,0 +1,15 @@
+This directory contains all the code that deals with parsing Fancy
+source files (.fy) and creating an object-oriented representation (a
+so-called AST - Abstract Syntax Tree) from it to be used in the
+compiler for further processing (mostly to .fyc bytecode files).
+
+The parser.y file contains the grammar rules in GNU Bison (YACC
+compatible) syntax, which make up the parser. The parser actions are
+written in C and call out to Ruby methods defined in parser.rb via
+rbx's C-extension interface to build the actual AST objects.
+
+The lexer.y contains the lexer rules in GNU Flex syntax for scanning a
+source file for tokens.
+
+The parser.rb file contains all the methods used by the parser to
+create AST objects.

data/lib/parser/ext/ext.c

@@ -0,0 +1,42 @@
+#include "ext.h"
+#include "ruby.h"
+#include "lexer.h"
+
+static VALUE
+fancy_parse_string(VALUE self, VALUE code) {
+  VALUE filename = rb_funcall(self, rb_intern(":filename"), 0);
+  VALUE lineno = rb_funcall(self, rb_intern(":line"), 0);
+  char *str = StringValueCStr(code);
+  YY_BUFFER_STATE buffstate = yy_scan_string(str);
+  yy_switch_to_buffer(buffstate);
+  yylineno = NUM2INT(lineno);
+  yyparse(self);
+  yy_delete_buffer(buffstate);
+  return self;
+}
+
+static VALUE
+fancy_parse_file(VALUE self) {
+  VALUE filename = rb_funcall(self, rb_intern(":filename"), 0);
+  VALUE lineno = rb_funcall(self, rb_intern(":line"), 0);
+  char *str = StringValueCStr(filename);
+  FILE *f = fopen(str, "r");
+  if(!f) {
+    rb_funcall(self, rb_intern("ast:file_error:"), 2, INT2NUM(0), rb_str_new2("Could not open file"));
+    return Qnil;
+  }
+  YY_BUFFER_STATE buffstate = yy_create_buffer(f, YY_BUF_SIZE);
+  yy_switch_to_buffer(buffstate);
+  yylineno = NUM2INT(lineno);
+  yyparse(self);
+  yy_delete_buffer(buffstate);
+  return self;
+}
+
+void
+Init_fancy_parser() {
+  VALUE fancy = rb_const_get(rb_cObject, rb_intern("Fancy"));
+  VALUE parser = rb_const_get(fancy, rb_intern("Parser"));
+  rb_define_method(parser, "parse_string:", fancy_parse_string, 1);
+  rb_define_method(parser, ":parse_file", fancy_parse_file, 0);
+}

data/lib/parser/ext/ext.h

@@ -0,0 +1,8 @@
+#ifndef _FANCY_PARSER_EXT_H_
+#define _FANCY_PARSER_EXT_H_
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+
+#endif /* _FANCY_PARSER_EXT_H_ */

data/lib/parser/ext/extconf.rb

@@ -0,0 +1,3 @@
+require('mkmf')
+have_library("fl")
+create_makefile('fancy_parser')

data/lib/parser/ext/lexer.lex

@@ -0,0 +1,187 @@
+%{
+#include "ruby.h"
+#include "parser.h"
+
+int yyerror(char *s);
+%}
+
+%option yylineno
+
+digit		[0-9]
+octdigit	[0-7]
+hexdigit        [0-9a-fA-F]
+bindigit        [01]
+capital         [A-Z]
+lower           [a-z]
+letter          [A-Za-z]
+special         [-+?!=*/^><%&~]
+special_under   ({special}|"_")
+operator        ({special}+|"||"{special_under}*)
+int_lit 	[-+]?{digit}({digit}|_{digit})*
+double_lit      {int_lit}\.{digit}+
+hex_lit         0[xX]{hexdigit}+
+bin_lit         0[bB]{bindigit}+
+oct_lit         0[oO]{octdigit}+
+string_lit      L?\"(\\.|[^\\"])*\"
+multiline_string L?\"\"\"(\\.|[^\\"])*\"\"\"
+lparen          \(
+rparen          \)
+at_lcurly       "@{"
+lcurly          "{"
+rcurly          "}"
+lbracket        "["
+rbracket        "]"
+lhash           "<["
+rhash           "]>"
+stab            "|"
+arrow           "=>"
+thin_arrow      "->"
+delimiter       [ \n\r\t\(\)]
+return_local    "return_local"
+return          "return"
+require         "require:"
+try             "try"
+catch           "catch"
+finally         "finally"
+retry           "retry"
+super           "super"
+private         "private"
+protected       "protected"
+self            "self"
+match           "match"
+case            "case"
+identifier      @?@?({lower}|[_&*])({letter}|{digit}|{special_under})*
+selector        ({letter}|[_&*])({letter}|{digit}|{special_under})*":"
+constant        {capital}({letter}|{digit}|{special_under})*
+nested_constant ({constant}::)+{constant}
+symbol_lit      \'({identifier}|{operator}|:|"[]")+
+ruby_send_open  {identifier}{lparen}
+ruby_oper_open  {operator}{lparen}
+regexp_lit      "/".*"/"
+comma           ,
+
+semi            ;
+equals          =
+colon           :
+class           "class"
+def             "def"
+dot             "."
+dollar          "$"
+comment         #[^\n]*
+escaped_newline "\\".*\n
+
+%%
+
+{class}         { return CLASS; }
+{def}           { return DEF; }
+{hex_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return HEX_LITERAL;
+                }
+{oct_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return OCT_LITERAL;
+                }
+{bin_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return BIN_LITERAL;
+                }
+{int_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return INTEGER_LITERAL;
+                }
+{double_lit}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return DOUBLE_LITERAL;
+                }
+{string_lit}	{
+                  yylval.object = rb_str_new2(yytext);
+                  return STRING_LITERAL;
+                }
+{multiline_string} {
+                  yylval.object = rb_str_new2(yytext);
+                  return MULTI_STRING_LITERAL;
+                }
+{lparen}        { return LPAREN; }
+{rparen}        { return RPAREN; }
+{at_lcurly}     { return AT_LCURLY; }
+{lcurly}        { return LCURLY; }
+{rcurly}        { return RCURLY; }
+{lbracket}      { return LBRACKET; }
+{rbracket}      { return RBRACKET; }
+{lhash}         { return LHASH; }
+{rhash}         { return RHASH; }
+{stab}          { return STAB; }
+{arrow}         { return ARROW; }
+{thin_arrow}    { return THIN_ARROW; }
+{equals}        { return EQUALS; }
+{operator}      {
+                  yylval.object = rb_str_new2(yytext);
+                  return OPERATOR;
+                }
+{return_local}  { return RETURN_LOCAL; }
+{return}        { return RETURN; }
+{require}       { return REQUIRE; }
+{try}           { return TRY; }
+{catch}         { return CATCH; }
+{finally}       { return FINALLY; }
+{retry}         { return RETRY; }
+{super}         { return SUPER; }
+{private}       { return PRIVATE; }
+{protected}     { return PROTECTED; }
+{self}          {
+                  yylval.object = rb_str_new2(yytext);
+                  return IDENTIFIER;
+                }
+{match}         {
+                  return MATCH;
+                }
+{case}          {
+                  return CASE;
+                }
+{identifier}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return IDENTIFIER;
+                }
+{selector}      {
+                  yylval.object = rb_str_new2(yytext);
+                  return SELECTOR;
+                }
+{ruby_send_open} {
+                  yylval.object = rb_str_new2(yytext);
+                  return RUBY_SEND_OPEN;
+                }
+{ruby_oper_open} {
+                  yylval.object = rb_str_new2(yytext);
+                  return RUBY_OPER_OPEN;
+                }
+{constant}      {
+                  yylval.object = rb_str_new2(yytext);
+                  return CONSTANT;
+                }
+{nested_constant} {
+                  yylval.object = rb_str_new2(yytext);
+                  return CONSTANT;
+                }
+{symbol_lit}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return SYMBOL_LITERAL;
+                }
+{regexp_lit}    {
+                  yylval.object = rb_str_new2(yytext);
+                  return REGEX_LITERAL;
+                }
+{comma}         { return COMMA; }
+{semi}          { return SEMI; }
+{colon}         { return COLON; }
+{dot}           { return DOT; }
+{dollar}        { return DOLLAR; }
+
+{comment}       {}
+
+[ \t]*		{}
+{escaped_newline} {}
+[\n]		{ return NL; }
+
+.		{ fprintf(stderr, "SCANNER %d", yyerror("")); exit(1);	}
+