liquidscript 0.0.1

data/lib/liquidscript/compiler/icr/literals.rb

@@ -0,0 +1,106 @@
+module Liquidscript
+  module Compiler
+    class ICR < Base
+      module Literals
+
+        def compile_number
+          code :number, pop.value
+        end
+
+        def compile_identifier(identifier)
+          default = action do
+            code :get, ref(identifier)
+          end
+
+          expect :equal  => action { compile_assignment(identifier) },
+                 :prop   => action { compile_property(identifier)   },
+                 :lparen => action { compile_call(identifier)       },
+                 :_      => default
+        end
+
+        def compile_dstring
+          code :dstring, pop.value[1..-2]
+        end
+
+        def compile_sstring
+          code :sstring, pop.value[1..-1]
+        end
+
+        def compile_keyword
+          code :keyword, shift(:keyword), compile_expression
+        end
+
+        def compile_object
+          shift :lbrack
+
+          objects = []
+          compile_object = action do
+            objects << [compile_object_key, compile_expression]
+          end
+
+          loop do
+            expect :rbrack => action.end_loop,
+            :comma         => action.shift,
+            [:identifier, :dstring] => compile_object
+          end
+
+          code :object, objects
+        end
+
+        def compile_array
+          shift :lbrace
+
+          parts = []
+          compile_part = action { parts << compile_expression }
+
+          loop do
+            expect :rbrace => action.end_loop,
+            :comma         => action.shift,
+            :_             => compile_part
+          end
+
+          code :array, parts
+        end
+
+        def compile_object_key
+          key = shift :identifier, :dstring
+          shift :colon
+
+          key
+        end
+
+        def compile_function
+          compile_function_with_parameters([])
+        end
+
+        def compile_function_with_parameters(parameter)
+          shift :arrow
+          shift :lbrack
+
+          expressions = Liquidscript::ICR::Set.new
+          expressions.context = Liquidscript::ICR::Context.new
+          expressions.context.parent = top.context
+          expressions[:arguments] = parameter
+          @set << expressions
+
+          parameter.each do |parameter|
+            set(parameter).parameter!
+          end
+
+
+          expression = action do
+            expressions << compile_expression
+          end
+
+          loop do
+            expect :rbrack => action.end_loop,
+              :_           => expression
+          end
+
+          code :function, @set.pop
+        end
+
+      end
+    end
+  end
+end

data/lib/liquidscript/errors.rb

@@ -0,0 +1,51 @@
+module Liquidscript
+
+  class Error < ::StandardError; end
+
+  class SyntaxError < Error; end
+  class CompileError < Error; end
+  class GeneratorError < Error; end
+
+  class UnexpectedEndError < CompileError; end
+  class InvalidReferenceError < CompileError
+
+    def initialize(name)
+      super "No variable named #{name}"
+    end
+  end
+  class UnexpectedError < CompileError
+    def initialize(expected, got)
+      @expected = expected
+      @got = got
+
+      super build_error_message
+    end
+
+    private
+
+    def build_error_message
+      str = "Expected one of %{expected}, got %{type}"
+      hash = {
+        :expected => @expected.map { |e| e.to_s.upcase }.join(', ')
+      }
+
+      if @got.is_a? Symbol
+        hash[:type] = @got.to_s.upcase
+      else
+        str << " (line %{line}, column %{column})"
+        hash.merge! :type   => @got.type.to_s.upcase,
+                    :line   => @got.line,
+                    :column => @got.column
+      end
+
+      sprintf(str, hash)
+    end
+  end
+
+  class InvalidCodeError < GeneratorError
+    def initialize(code)
+      super "Could not generate code for `#{code.to_s.upcase}`"
+    end
+  end
+
+end

data/lib/liquidscript/generator.rb

@@ -0,0 +1,11 @@
+require "hashie"
+require "liquidscript/generator/base"
+require "liquidscript/generator/context"
+require "liquidscript/generator/javascript"
+
+module Liquidscript
+
+  module Generator
+
+  end
+end

data/lib/liquidscript/generator/base.rb

@@ -0,0 +1,25 @@
+require "liquidscript/generator/base/dsl"
+require "liquidscript/generator/base/replacements"
+
+module Liquidscript
+  module Generator
+
+    class Base
+
+      include Replacements
+
+      def initialize(top)
+        @top = top
+      end
+
+      def generate
+        replace(@top, {}).to_s
+      end
+
+      def buffer
+        Buffer.new
+      end
+
+    end
+  end
+end

data/lib/liquidscript/generator/base/dsl.rb

@@ -0,0 +1,19 @@
+module Liquidscript
+  module Generator
+    class Base
+      module DSL
+        module ClassMethods
+
+          def to_generate(code, &block)
+            define_method(:"generate_#{code}", &block)
+            protected :"generate_#{code}"
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/liquidscript/generator/base/replacements.rb

@@ -0,0 +1,33 @@
+module Liquidscript
+  module Generator
+    class Base
+      module Replacements
+
+        # Replace a code with a string.  This uses the replacement
+        # definitions that are a part of the class.
+        #
+        # @param code [ICR::Code, #type]
+        # @param context [Hash]
+        def replace(code, context = {})
+          send(:"generate_#{code.type}",
+            code)
+
+        rescue NoMethodError => e
+          if e.name == :"_generate_code_#{code.type}"
+            raise InvalidCodeError.new(code.type)
+          else
+            raise
+          end
+        end
+
+        # Access to the replacements method on the class.
+        #
+        # @see [ClassMethods#replacements]
+        # @return [Hash]
+        def replacements
+          self.class.replacements
+        end
+      end
+    end
+  end
+end

data/lib/liquidscript/generator/context.rb

@@ -0,0 +1,7 @@
+module Liquidscript
+  module Generator
+    class Context < Hashie::Mash
+
+    end
+  end
+end

data/lib/liquidscript/generator/javascript.rb

@@ -0,0 +1,37 @@
+require "liquidscript/generator/javascript/literals"
+require "liquidscript/generator/javascript/metas"
+require "liquidscript/generator/javascript/objects"
+
+module Liquidscript
+  module Generator
+
+    # A list of all of the possible codes for javascript:
+    #
+    # - `:set`         ✔
+    # - `:get`         ✔
+    # - `:exec`        ✔
+    # - `:expression`  ✔
+    # - `:class`       ✔
+    # - `:module`      ✔
+    # - `:property`    ✔
+    # - `:call`        ✔
+    # - `:number`      ✔
+    # - `:sstring`     ✔
+    # - `:dstring`     ✔
+    # - `:object`      ✔
+    # - `:array`       ✔
+    # - `:function`    ✔
+    #
+    # Each one of these must have a generate function.
+    class Javascript < Base
+      include Literals
+      include Metas
+      include Objects
+
+      def initialize(top)
+        @modules = []
+        super
+      end
+    end
+  end
+end

data/lib/liquidscript/generator/javascript/literals.rb

@@ -0,0 +1,63 @@
+module Liquidscript
+  module Generator
+    class Javascript < Base
+      module Literals
+
+        def generate_number(code)
+
+          "#{code.first}"
+        end
+
+        def generate_dstring(code)
+
+          "\"#{code.first.gsub(/"/, '\\"')}\""
+        end
+
+        def generate_sstring(code)
+
+          "'#{code.first.gsub(/'/, "\\'")}'"
+        end
+
+        def generate_keyword(code)
+          " #{code[1].value} #{replace(code[2])}"
+        end
+
+        def generate_object(code)
+
+          object = buffer
+          object.set_join! ', '
+
+          code[1].inject(object) do |buf, part|
+            buf << "\"#{part[0].value}\": #{replace(part[1])}"
+          end
+
+          "{#{object}}"
+        end
+
+        def generate_array(code)
+
+          array = buffer
+          array.set_join! ', '
+
+          code[1].inject(array) do |a, p|
+            a << replace(p)
+          end
+
+          "[#{array}]"
+        end
+
+        def generate_function(code)
+
+          function = buffer
+
+          function                       <<
+            "function("                  <<
+            code[1].parameters.join(',') <<
+            ') {'                        <<
+            replace(code[1])             <<
+            '}'
+        end
+      end
+    end
+  end
+end

data/lib/liquidscript/generator/javascript/metas.rb

@@ -0,0 +1,41 @@
+module Liquidscript
+  module Generator
+    class Javascript
+      module Metas
+
+        def generate_exec(code)
+
+          exec = buffer
+          exec << _exec_context(code)
+          code.codes.inject(exec) do |m, c|
+            m << replace(c)
+            m
+          end
+        end
+
+        def generate_set(code)
+          case code[1].type
+          when :variable
+            "#{code[1].name} = #{replace code[2]};"
+          when :property
+            "#{replace code[1]} = #{replace code[2]};"
+          end
+        end
+
+        def generate_get(code)
+
+          "#{code[1].name}"
+        end
+
+        protected
+
+        def _exec_context(code)
+
+          unless code.locals.empty?
+            "var #{code.locals.join(',')}; "
+          end
+        end
+      end
+    end
+  end
+end

data/lib/liquidscript/generator/javascript/objects.rb

@@ -0,0 +1,137 @@
+module Liquidscript
+  module Generator
+    class Javascript
+      module Objects
+
+        def generate_expression(code)
+          "(#{replace(code[1].first)})"
+        end
+
+        def generate_call(code)
+          call = buffer
+          args = buffer
+          args.set_join! ','
+
+          case code[1].type
+          when :identifier
+            call << "#{code[1].value}"
+          else
+            call << "#{replace(code[1])}"
+          end
+
+          code[2..-1].inject(args) do |b, arg|
+            b << replace(arg)
+          end
+
+          call << "(" << args << ")"
+        end
+
+        def generate_property(code)
+          prop = buffer
+
+          case code[1].type
+          when :identifier
+            prop << code[1].value
+          when :variable
+            prop << code[1].name
+          else
+            prop << replace(code[1])
+          end
+
+          prop << "." << code[2].value
+        end
+
+        def generate_class(code)
+          body       = buffer
+          class_name = code[1].value
+
+          in_module(class_name) do |last_module|
+            body                                          <<
+              "#{class_name} = function #{class_name}(){" <<
+              "if(this.initialize) {"                     <<
+              "this.initialize.apply(this, arguments);"   <<
+              "}};"
+
+            code[2].each do |(k, v)|
+              case k.type
+              when :identifier
+                body                                      <<
+                  "#{class_name}.prototype.#{k.value} ="  <<
+                  replace(v) << ";"
+              when :dstring
+                body                                      <<
+                  "#{class_name}.prototype[#{k.value}] =" <<
+                  replace(v) << ";"
+              when :prop
+                if k[1].name != :this
+                  raise InvalidCodeError.new(v[1].name)
+                end
+
+                body                                      <<
+                  "#{class_name}.#{k[2].value} = "        <<
+                  replace(v) << ";"
+              end
+            end
+
+            if last_module
+              body                                        <<
+                "#{last_module}.#{class_name} = "         <<
+                "#{class_name};"
+            end
+
+          end
+
+          body
+        end
+
+        def generate_module(code)
+          body = buffer
+          module_name = code[1].value
+
+          in_module(module_name) do |last_module|
+            body << "#{module_name} = {};"
+
+            code[2].each do |part|
+              k = part[0]
+              v = part[1]
+              case k
+              when :identifier
+                body                                      <<
+                  "#{module_name}.#{k.value} = "          <<
+                  replace(v) << ";"
+              when :dstring
+                body                                      <<
+                  "#{module_name}[#{k.value}] = "         <<
+                  replace(v)  << ";"
+              when :class
+                body << generate_class(part)
+              end
+            end
+
+            if last_module
+              body                                        <<
+                "#{last_module}.#{module_name} = "        <<
+                "#{module_name};"
+            end
+          end
+
+          body
+        end
+
+        protected
+
+        def current_module
+          @modules.last
+        end
+
+        def in_module(module_name)
+          @modules << module_name
+          out = yield @modules[-2]
+          @modules.pop
+          out
+        end
+
+      end
+    end
+  end
+end