liquidscript 0.0.1

data/lib/liquidscript/icr.rb

@@ -0,0 +1,18 @@
+require "liquidscript/icr/representable"
+require "liquidscript/icr/code"
+require "liquidscript/icr/set"
+require "liquidscript/icr/sexp"
+require "liquidscript/icr/context"
+require "liquidscript/icr/variable"
+
+module Liquidscript
+
+  # The ICR (rather, Intermediate Code Representation)
+  # is a method used to transform compiled code into
+  # the corresponding javascript code.  It can be used
+  # to optimize the code first, ensuring that the
+  # resultant code is fast.  The point here is to
+  # represent the code, and make it seem nice.
+  module ICR
+  end
+end

data/lib/liquidscript/icr/code.rb

@@ -0,0 +1,68 @@
+module Liquidscript
+  module ICR
+
+    # An individual code point.  This is normally in
+    # a set.  A code will have an action, and arguments
+    # that accompany that action.  The arguments list
+    # can be however long.
+    class Code
+
+      # The action that this code is associated with.
+      # This should be a symbol.
+      #
+      # @return [Symbol]
+      attr_reader :action
+
+      # The arguments that are used for this action.
+      # This is an array.
+      #
+      # @return [Array]
+      attr_reader :arguments
+
+      alias_method :type, :action
+
+      include Representable
+
+      # Initializes the code.  It takes an action and
+      # an argument as its arguments.  The action
+      # should not change from this point forward.
+      #
+      # @param action [Symbol]
+      # @param arguments [Array]
+      def initialize(action, *arguments)
+        @action = action
+        @arguments = arguments
+      end
+
+      # Turns the code into an array, containing the
+      # action and the arguments.  Note that changing
+      # this array will not change the code.
+      #
+      # @return [Array]
+      def to_a
+        [@action, *@arguments]
+      end
+
+      # If we don't respond to it, the @arguments array
+      # might.  Ask them if they do, and if they don't,
+      # respond accordingly.
+      #
+      # @param method [Symbol] the method to check.
+      # @param include_private [Boolean] whether or not to
+      #   include private methods.
+      # @return [Boolean]
+      def respond_to_missing?(method, include_private = false)
+        @arguments.respond_to?(method)
+      end
+
+      # Send the method to @arguments if it doesn't
+      # exist here.
+      #
+      # @return [Object]
+      def method_missing(method, *args, &block)
+        @arguments.public_send(method, *args, &block)
+      end
+
+    end
+  end
+end

data/lib/liquidscript/icr/context.rb

@@ -0,0 +1,94 @@
+module Liquidscript
+  module ICR
+
+    # Handles variables within blocks.  Each variable will get a
+    # reference in each context.  When retrieving the value of
+    # a variable, if the variable was not introduced in the scope,
+    # it will look to its parent for the value of the variable.
+    # When setting the value of a variable, a new variable is
+    # forcibly created.
+    class Context
+
+      # The variables that are allowed to be used as a global scope,
+      # i.e. used in a `get` context without a previous `set`.
+      DEFAULT_ALLOWED_VARIABLES = [
+        :window, :global, :exports, :console, :this
+      ]
+
+      # The parent of the current context.
+      #
+      # @return [Parent]
+      attr_accessor :parent
+
+      # The variables that are a part of this context.
+      #
+      # @return [Hash<Symbol, Variable>]
+      attr_reader :variables
+
+      # The variables that are allowed to be used as a global scope,
+      # i.e. used in a `get` context without a previous set.
+      #
+      # @see [DEFAULT_ALLOWED_VARIABLES]
+      # @return [Array<Symbol>]
+      attr_reader :allowed_variables
+
+      include Representable
+
+      # Initializes the context.
+      def initialize
+        @variables = {}
+        @allowed_variables = [DEFAULT_ALLOWED_VARIABLES].flatten
+      end
+
+      # Returns a variable reference.  If checks the local variables
+      # first; if it doesn't exist there, then if the type is `:get`,
+      # checks the parent; otherwise, sets the value of the variable.
+      # If there is no parent and the type is `:get`, it raises an
+      # {InvalidReferenceError}.
+      #
+      # @param name [Symbol] the name of the variable.
+      # @param type [Symbol] the type of use.  Should be `:get` or
+      #   `:set`.
+      # @return [Variable]
+      def variable(name, type)
+        @variables.fetch(name) do
+          if type == :set
+            @variables[name] = Variable.new(self, name)
+          elsif allowed_variables.include?(name)
+            Variable.new(self, name)
+          elsif type == :get && parent
+            parent.get(name)
+          else
+            raise InvalidReferenceError.new(name)
+          end
+        end
+      end
+
+      # All of the parameter variables.
+      #
+      # @return [Array<Variable>]
+      def parameters
+        @variables.values.select(&:parameter?)
+      end
+
+      # (see #variable).
+      #
+      # Passes `:get` as type.
+      def get(name)
+        variable(name, :get)
+      end
+
+      # (see #variable).
+      #
+      # Passes `:set` as type.
+      def set(name)
+        variable(name, :set)
+      end
+
+      def to_a
+        @variables.keys
+      end
+
+    end
+  end
+end

data/lib/liquidscript/icr/representable.rb

@@ -0,0 +1,39 @@
+module Liquidscript
+  module ICR
+
+    # Used to show that a specific element of the ICR is representable
+    # as an array.  It will forward the methods #to_s and #inspect to
+    # the #to_a method, expecting the including module to define it.
+    module Representable
+
+      extend Forwardable
+      include Comparable
+
+      def_delegators :to_a, :to_s, :inspect, :[], :each, :'<=>'
+
+
+      def to_ary
+        to_a
+      end
+
+      def to_yaml
+        to_a!.to_yaml
+      end
+
+      def to_a!
+        do_map = proc do |e|
+          if e.is_a?(Representable)
+            e.to_a!
+          elsif e.is_a? Array
+            e.map(&do_map)
+          else
+            e
+          end
+        end
+
+        to_a.map(&do_map)
+      end
+
+    end
+  end
+end

data/lib/liquidscript/icr/set.rb

@@ -0,0 +1,147 @@
+module Liquidscript
+  module ICR
+
+    # Represents a set of instruction codes.  Can contain
+    # metadata about the set, like whether or not it can
+    # be inlined, if a new context needs to be applied,
+    # etc.
+    class Set < Code
+
+      # The metadata that is applied to the set.
+      #
+      # @return [Hash]
+      attr_reader :metadata
+
+      include Representable
+
+      # Initialize the set.
+      def initialize
+        @metadata = {}
+        @code = []
+        @action = :exec
+      end
+
+      #
+      def context
+        @metadata.fetch(:context) do
+          @metadata.fetch(:parent).context
+        end
+      end
+
+      #
+      def context=(new_context)
+        @metadata[:context] = new_context
+      end
+
+      # Adds a code to the code list.  This is just a
+      # convienince method.
+      #
+      # @param action [Symbol] a symbol representing
+      #   the action.
+      # @param arguments the arguments for the code.
+      def add(action, *arguments)
+        @code << Code.new(action, arguments)
+      end
+
+      # A list of all the local variables in the
+      # current scope.  Local variables are defined
+      # as variables that were a) not passed in by
+      # function execution as arguments and b) are
+      # set within the current context.
+      #
+      # @return [Array<Symbol>]
+      def locals
+        variables - parameters
+      end
+
+      # A list of components (or arguments) that are
+      # in the current scope.  Defined as variables
+      # that were passed in by function execution as
+      # arguments.
+      #
+      # @return [Array<Symbol>]
+      def parameters
+        context.parameters.map(&:name)
+      end
+
+      # A list of _all_ variables in the current
+      # scope.
+      #
+      # @return [Array<Symbol>]
+      def variables
+        context.variables.keys - context.allowed_variables
+      end
+
+      # Turns the set into an array.  Includes the
+      # metadata information and the actual internal
+      # array.
+      # Note that this is _not_ the array used in
+      # {#method_missing} - that actually operates on
+      # the internal array.
+      #
+      # @return [Array]
+      def to_a
+        [
+          @action,
+          *@metadata.to_a.map { |(m, i)| [:"_#{m}", i] },
+          *@code
+        ]
+      end
+
+      # Outputs the codes in this set.
+      #
+      # @return [Array<Code>]
+      def codes
+        @code
+      end
+
+      # Access either the metadata or the codes.  If
+      # the accessor is a Symbol, it access the metadata;
+      # if it the accessor is a Numeric, it access the
+      # codes.
+      #
+      # @param key [Symbol, Numeric] the key.
+      # @return [Object]
+      def [](key)
+        if key.is_a? Numeric
+          @code[key]
+        else
+          @metadata[key]
+        end
+      end
+
+      # Sets something from the metadata.  Unlike the
+      # accessor, it does not distinguish between
+      # Numeric and Symbol keys.
+      #
+      # @param key [Object] the key.
+      # @param value [Object] the value.
+      # @return [Object]
+      def []=(key, value)
+        @metadata[key] = value
+      end
+
+      # Tells ruby that we respond to some methods.
+      # Passes the method name to the internal
+      # array, asking if it responds to it.
+      #
+      # @param method [Symbol] the method to check.
+      # @param include_private [Boolean] whether or not
+      #   to include private methods.
+      # @return [Boolean] whether or not we respond
+      #   to that method.
+      def respond_to_missing?(method, include_private = false)
+        @code.respond_to?(method, include_private)
+      end
+
+      # For methods that we don't respond to, send
+      # them to the interal array.
+      #
+      # @return [Object]
+      def method_missing(method, *args, &block)
+        @code.public_send(method, *args, &block)
+      end
+
+    end
+  end
+end

data/lib/liquidscript/icr/sexp.rb

@@ -0,0 +1,41 @@
+module Liquidscript
+  module ICR
+
+    class ::Array; def to_sexp; Sexp.new(self).output; end; end
+
+    # @private
+    class Sexp
+
+      def initialize(compiler)
+        @compiler = compiler
+        @depth = 0
+      end
+
+      def output
+        out(@compiler).strip
+      end
+
+      private
+
+      def out(v)
+        if v.is_a?(Representable) || v.is_a?(Array)
+          @depth += 1
+          body = ["\n", " " * @depth, "(",
+            v.to_a.map {|d| out d }.join(' '),
+            ")"].join
+          @depth -= 1
+          body
+        else
+          body = v.to_s.gsub(/\"/, "\\\"")
+
+          if body.include? " "
+            "\"#{body}\""
+          else
+            body
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/liquidscript/icr/variable.rb

@@ -0,0 +1,68 @@
+module Liquidscript
+  module ICR
+
+    # Represents a variable.  It can hold a value, but it will not
+    # be used to reconstruct the variable itself.
+    class Variable
+
+      # The context in which this variable exists.  The variable
+      # should exist in one and only one context, but can be used
+      # in contexts other than its own.
+      #
+      # @return [Context]
+      attr_reader :context
+
+      # The name of the variable that this represents.  This will
+      # be used in both ICR and in the final output.
+      #
+      # @return [Symbol]
+      attr_reader :name
+
+      # The set that describes the value of this variable.  The
+      # set just so happens to describe the value of the variable;
+      # it is not used to define the variable's value.
+      #
+      # @return [Code]
+      attr_accessor :value
+
+      include Representable
+
+      def initialize(context, name)
+        @context = context
+        @name = name
+        @value = nil
+      end
+
+      # Make this class compatible with the #type based system.
+      #
+      # @return [Symbol]
+      def type
+        :variable
+      end
+
+      # Marks this variable as an argument to a function.  This is to
+      # let the context know not to show it in certain cases.
+      #
+      # @return [self]
+      def parameter!
+        @parameter = true
+        self
+      end
+
+      # Whether or not the variable is an argument to a function.
+      #
+      # @see {#parameter!}
+      # @return [Boolean]
+      def parameter?
+        @parameter
+      end
+
+      # Turns the variable into an array.
+      #
+      # @return [Array<(Symbol, Symbol)>]
+      def to_a
+        [:_variable, @name]
+      end
+    end
+  end
+end