liquidscript 0.0.1

data/lib/liquidscript/scanner.rb

@@ -0,0 +1,40 @@
+require "liquidscript/scanner/token"
+require "liquidscript/scanner/lexer"
+
+module Liquidscript
+
+  # @todo Stream scanning.
+  # um...
+  class Scanner
+
+    include Enumerable
+
+    def initialize(source)
+      @tokenizer = Lexer.new
+      @source = source
+    end
+
+    def each
+      e = buffer.each
+
+      if block_given?
+        e.each(&Proc.new)
+      else
+        e
+      end
+    end
+
+    def inspect
+      "#<#{self.class.to_s}:#{'0x%08x' % self.object_id}>"
+    end
+
+    private
+
+    def buffer
+      @_parts ||= begin
+        @tokenizer.perform(@source)
+      end
+    end
+
+  end
+end

data/lib/liquidscript/scanner/lexer.rl

@@ -0,0 +1,106 @@
+%%{
+
+  machine lexer;
+
+  variable data @data;
+  variable p    @p;
+  variable pe   @pe;
+  variable eof  @eof;
+  access @;
+
+  number_integer = '-'? [0-9][1-9]*;
+  number_frac = '.' [0-9]+;
+  number_e = ('e' | 'E') ('+' | '-' | '');
+  number_exp = number_e [0-9]+;
+  number = number_integer number_frac? number_exp?;
+
+  string_double = '"' ( any -- '"' | '\\"' )* '"';
+  identifier = [A-Za-z_$][A-Za-z0-9_$]*;
+  string_single = "'" [A-Za-z0-9_$\-]+;
+
+  main := |*
+    number        => { emit :number      };
+    string_double => { emit :dstring     };
+    string_single => { emit :sstring     };
+    'class'       => { emit :class       };
+    'module'      => { emit :module      };
+    'new'         => { emit :keyword     };
+    'return'      => { emit :keyword     };
+    identifier    => { emit :identifier  };
+    '->'          => { emit :arrow       };
+    '='           => { emit :equal       };
+    '{'           => { emit :lbrack      };
+    '('           => { emit :lparen      };
+    '['           => { emit :lbrace      };
+    '}'           => { emit :rbrack      };
+    ')'           => { emit :rparen      };
+    ']'           => { emit :rbrace      };
+    ':'           => { emit :colon       };
+    '.'           => { emit :prop        };
+    ','           => { emit :comma       };
+    '\n'          => { line.call         };
+    space         => {                   };
+    any           => { error             };
+  *|;
+}%%
+
+module Liquidscript
+  class Scanner
+
+    # A lexer, built from ragel.
+    #
+    # @private
+    class Lexer
+
+      attr_reader :tokens
+
+      def initialize
+        %% write data;
+        # %% # fix
+        @tokens = []
+        clean!
+      end
+
+      def clean!
+        @p = nil
+        @pe = nil
+        @te = nil
+        @ts = nil
+        @act = nil
+        @eof = nil
+        @top = nil
+        @line = { :start => 0, :num => 0 }
+        @data = nil
+        @stack = nil
+      end
+
+      def emit(type)
+        @tokens << Token.new(type, @data[@ts..(@te - 1)],
+          @line[:num], @ts - @line[:start])
+      end
+
+      def error
+        raise SyntaxError, "Unexpected #{@data[@ts..(@te-1)].pack('c*')}"
+      end
+
+      def perform(data)
+        @data = data.unpack("c*") if data.is_a? String
+        @eof = data.length
+
+        @tokens = []
+
+        line = proc do
+          @line[:start] = @ts
+          @line[:num] += 1
+        end
+
+        %% write init;
+        %% write exec;
+
+        clean!
+
+        @tokens
+      end
+    end
+  end
+end

data/lib/liquidscript/scanner/token.rb

@@ -0,0 +1,37 @@
+require "liquidscript/icr/representable"
+
+module Liquidscript
+  class Scanner
+    class Token
+
+      attr_accessor :type
+      attr_accessor :value
+      attr_reader :line
+      attr_reader :column
+
+      include Enumerable
+      include ICR::Representable
+
+      def initialize(type, value, line, column)
+        @type   = type
+        @line   = line
+        @column = column
+        @value  = begin
+          value.pack("c*")
+        rescue NoMethodError, TypeError
+          value
+        end
+      end
+
+      def to_a
+        [@type, @value]
+      end
+
+      def type?(type)
+        @type == type
+      end
+
+    end
+
+  end
+end

data/lib/liquidscript/template.rb

@@ -0,0 +1,16 @@
+module Liquidscript
+  class Template
+
+    def initialize(data)
+      @data = data
+    end
+
+    def render
+      @_render ||= begin
+        compiler = Compiler::ICR.new(Scanner.new(@data))
+        compiler.compile
+        Generator::Javascript.new(compiler).generate
+      end
+    end
+  end
+end

data/lib/liquidscript/version.rb

@@ -0,0 +1,5 @@
+module Liquidscript
+
+  # The current version of liquidscript.
+  VERSION = "0.0.1".freeze
+end

data/liquidscript.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'liquidscript/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "liquidscript"
+  spec.version       = Liquidscript::VERSION
+  spec.authors       = ["Jeremy Rodi"]
+  spec.email         = ["redjazz96@gmail.com"]
+  spec.summary       = %q{A javascript-based language that compiles to javascript.}
+  spec.description   = %q{A javascript-based language that compiles to javascript.}
+  spec.homepage      = "https://github.com/redjazz96/liquidscript"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
+
+  spec.add_dependency "hashie", "~> 2.0"
+end

data/spec/fixtures/class.compile.yml

@@ -0,0 +1,26 @@
+data: |
+  module Something {
+    class SomeClass {
+      test: -> {}
+    }
+  }
+
+compiled:
+  - :exec
+  - - :_context
+    - - :SomeClass
+      - :Something
+  - - :module
+    - - :identifier
+      - Something
+    - - - :class
+        - - :identifier
+          - SomeClass
+        - - - - :identifier
+              - test
+            - - :function
+              - - :exec
+                - - :_context
+                  - []
+                - - :_arguments
+                  - []

data/spec/fixtures/class.generate.yml

@@ -0,0 +1,31 @@
+data: |
+  module Something {
+    class Test {
+      wee: -> {
+        console.log(2)
+      }
+
+      initialize: -> {
+        "this should be init"
+      }
+    }
+  }
+
+compiled: |
+  var Test, Something;
+
+  Something = {};
+  Test = function Test() {
+    if(this.initialize) {
+      this.initialize.apply(this, arguments);
+    }
+  };
+
+  Test.prototype.wee = function() {
+    console.log(2)
+  };
+
+  Test.prototype.initialize = function() {
+    "this should be init"
+  };
+  Something.Test = Test;

data/spec/fixtures/combination.generate.yml

@@ -0,0 +1,33 @@
+data: |
+  Test = require("some_module/test")
+
+  module SomeModule {
+    class Thing {
+      initialize: -> {
+        this.test = new Test()
+      }
+
+      do: (thing)-> {
+        return this.test.do(thing)
+      }
+    }
+  }
+
+compiled: |
+  var Test, Thing, SomeModule;
+  Test = require("some_module/test");
+  SomeModule = {};
+  Thing = function Thing() {
+    if(this.initialize) {
+      this.initialize.apply(this, arguments);
+    }
+  };
+
+  Thing.prototype.initialize = function() {
+    this.test = new Test();
+  };
+
+  Thing.prototype.do = function(thing) {
+    return this.test.do(thing)
+  };
+  SomeModule.Thing = Thing;

data/spec/fixtures/complex.generate.yml

@@ -0,0 +1,20 @@
+data: |
+  thing = {
+    test: -> {
+      "hello"
+    }
+  }
+
+  thing.test()
+
+compiled: |
+  var thing;
+
+  thing = {
+    "test": function() {
+      "hello"
+    }
+  };
+
+  thing.test()
+

data/spec/fixtures/expression.generate.yml

@@ -0,0 +1,4 @@
+data: |
+  (2)
+
+compiled: "(2)"

data/spec/fixtures/function.generate.yml

@@ -0,0 +1,11 @@
+data: |
+  console = 2
+  some_function = ()-> {
+    console = 3
+  }
+
+compiled: |
+  var some_function;
+  console = 2;
+
+  some_function = function() { console = 3; };

data/spec/fixtures/get.generate.yml

@@ -0,0 +1,5 @@
+data: |
+  something = 2
+  test = something
+
+compiled: "var something,test; something = 2; test = something;"

data/spec/fixtures/literals.generate.yml

@@ -0,0 +1,8 @@
+data: |
+  object = { hello: "world" }
+  test = [1, 2]
+
+compiled: |
+  var object, test;
+  object = { "hello": "world" };
+  test = [1, 2];

data/spec/fixtures/main.compile.yml

@@ -0,0 +1,32 @@
+data: |
+  console = 2
+  func = ()-> {
+    console.log("hello world")
+  }
+compiled:
+  - :exec
+  - - :_context
+    - - :console
+      - :func
+  - - :set
+    - - :_variable
+      - :console
+    - - :number
+      - "2"
+  - - :set
+    - - :_variable
+      - :func
+    - - :function
+      - - :exec
+        - - :_context
+          - []
+        - - :_arguments
+          - []
+        - - :call
+          - - :property
+            - - :_variable
+              - :console
+            - - :identifier
+              - log
+          - - :dstring
+            - hello world

data/spec/fixtures/set.generate.yml

@@ -0,0 +1,4 @@
+data: |
+  something = 2
+
+compiled: "var something; something = 2;"

data/spec/fixtures/string.generate.yml

@@ -0,0 +1,6 @@
+data: |
+  test = "hello"
+  foo  = 'world
+
+compiled: |
+  var test,foo; test = "hello"; foo = 'world';

data/spec/lib/liquidscript/buffer_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Liquidscript::Buffer do
+
+  subject { described_class.new "hello ", "world" }
+
+  its(:to_s) { should eq "hello world" }
+  its(:inspect) { should eq '"hello world"' }
+
+  it "appends a value" do
+    subject.append(", test")
+    expect(subject.to_s).to eq "hello world, test"
+  end
+end