liquidscript 0.0.1

data/spec/lib/liquidscript/compiler/icr_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "yaml"
+
+describe Compiler::ICR do
+
+  let(:scanner) do
+    iterator = double("iterator")
+    scanner = double("scanner")
+
+    expect(scanner).to receive(:each).once.and_return(iterator)
+    allow(iterator).to receive(:next).and_return([
+      Scanner::Token.new(:number, "32", 0, 0),
+      Scanner::Token.new(:number, "10", 0, 0)])
+    allow(iterator).to receive(:peek).and_return(
+      Scanner::Token.new(:number, "32", 0, 0))
+    allow(iterator).to receive(:rewind)
+    scanner
+  end
+
+  subject do
+    described_class.new(scanner)
+  end
+
+  describe "#peek" do
+    specify { expect(subject.peek).to be_a Scanner::Token }
+    specify { expect(subject.peek).to be_type :number }
+  end
+
+  describe "#expect" do
+
+    context "with one argument" do
+      before do
+        expect(subject).to receive(:compile_number).once
+      end
+
+      it "calls the corresponding method" do
+        subject.expect :number
+      end
+    end
+
+    context "with a mismatching argument" do
+      it "raises an error" do
+        expect {
+          subject.expect :string
+        }.to raise_error CompileError
+      end
+    end
+
+    context "with a hash argument" do
+      let :probe do
+        block = lambda {}
+
+        expect(block).to receive(:arity).once.and_return(0)
+        expect(block).to receive(:call).once.with(no_args)
+        block
+      end
+
+      let :bad_probe do
+        block = lambda {}
+
+        expect(block).to_not receive(:arity)
+        expect(block).to_not receive(:call)
+      end
+
+      context "and a symbol value" do
+        before do
+          expect(subject).to receive(:compile_something).once
+        end
+
+        it "calls the corresponding method" do
+          subject.expect :number => :something
+        end
+      end
+
+      context "and a block value" do
+
+        it "calls the corresponding block" do
+          subject.expect :number => probe
+        end
+      end
+
+      context "with no right action" do
+        it "raises an error" do
+          expect {
+            subject.expect :string => :foo
+          }.to raise_error CompileError
+        end
+
+        it "uses the catch all" do
+          subject.expect :string => bad_probe,
+            :_ => probe
+        end
+      end
+    end
+
+  end
+
+  describe "#compile" do
+    specify {
+      expect("hello = 3").to compile.and_produce([:exec,
+        [:_context, [:hello]], [:set, [:_variable, :hello], [:number, "3"]]
+      ])
+    }
+
+    specify {
+      expect("{hello: 'world}").to compile.and_produce([:exec,
+        [:_context, []], [:object, [[[:identifier, "hello"], [:sstring, "world"]]]]
+      ])
+    }
+
+    specify {
+      expect("(test)-> { 2 }").to compile.and_produce([:exec,
+        [:_context, []], [:function,
+          [:exec,
+            [:_context, [:test]],
+            [:_arguments, [[:identifier, "test"]]],
+            [:number, "2"]
+          ]
+      ]])
+    }
+
+    specify { expect("(2)").to compile         }
+    specify { expect("(2)->").to_not compile   }
+    specify { expect("()-> {}").to compile     }
+    specify { expect("(test)-> {}").to compile }
+    specify { expect("(test, foo)-> {}").to compile }
+  end
+
+  describe "with fixtures" do
+    Dir.glob("spec/fixtures/*.compile.yml") do |file|
+      content = YAML.load_file file
+      file =~ /spec\/fixtures\/(.*)\.compile\.yml/
+
+      it "compiles #{$1}" do
+        expect(content["data"]).to compile.and_produce content["compiled"]
+      end
+    end
+  end
+end

data/spec/lib/liquidscript/generator/javascript_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+require "yaml"
+
+describe Liquidscript::Generator::Javascript do
+  describe "with fixtures" do
+    Dir.glob("spec/fixtures/*.generate.yml") do |file|
+      content = YAML.load_file file
+      file =~ /spec\/fixtures\/(.*)\.generate\.yml/
+
+      it "generates #{$1}" do
+        expect(content["data"]).to generate(content["compiled"])
+      end
+    end
+  end
+end

data/spec/lib/liquidscript/icr/context_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+include Liquidscript
+
+describe ICR::Context do
+
+  it "creates a variable" do
+    expect(subject.set(:test)).to be_a ICR::Variable
+  end
+
+  it "gives an invalid reference" do
+    expect {
+      subject.get(:test)
+    }.to raise_error Liquidscript::InvalidReferenceError
+  end
+
+  context "with a parent" do
+
+    let(:parent) do
+      parent = double("parent")
+      expect(parent).to receive(:get).once.with(:foo).and_return(:test)
+      parent
+    end
+
+    subject do
+      context = ICR::Context.new
+      context.parent = parent
+      context
+    end
+
+    it "retrives the variable" do
+      expect(subject.get(:foo)).to be :test
+    end
+
+  end
+end

data/spec/lib/liquidscript/icr/set_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+include Liquidscript
+
+describe ICR::Set do
+
+  its(:metadata) { should be_a Hash }
+
+  describe "#to_a" do
+    specify { expect(subject.to_a).to be_an Array }
+    specify { expect(subject.to_a).to have(1).item }
+
+    context "with metadata" do
+      subject do
+        set = ICR::Set.new
+        set.metadata.merge! :hello => "world"
+        set
+      end
+
+      specify { expect(subject.to_a).to have(2).items }
+      specify { expect(subject.to_a).to eq [:exec, [:_hello, "world"]] }
+
+    end
+
+    context "with codes" do
+      subject do
+        set = ICR::Set.new
+        set << "test"
+        set
+      end
+
+      specify { expect(subject.to_a).to have(2).item }
+      specify { expect(subject.to_a).to eq [:exec, "test"] }
+
+    end
+
+    context "with both" do
+      subject do
+        set = ICR::Set.new
+        set.metadata.merge! :hello => "world"
+        set << "test"
+        set
+      end
+
+      specify { expect(subject.to_a).to have(3).items }
+      specify { expect(subject.to_a).to eq [:exec, [:_hello, "world"], "test"] }
+
+    end
+  end
+
+  describe "#add" do
+    it "adds a code to the set" do
+      subject.add(:number, "32")
+
+      expect(subject.to_a).to have(2).items
+      expect(subject.to_a.last).to be_a ICR::Code
+    end
+  end
+end

data/spec/lib/liquidscript/scanner/lexer_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Liquidscript::Scanner::Lexer, :lexer_helper do
+  subject { described_class.new }
+  describe "#emit" do
+    it "pushes a token" do
+      subject.instance_exec { @data = "hello"; @ts = 0; @te = 6 }
+      subject.emit(:test)
+      expect(subject.tokens.first).to be_token(:test, "hello")
+    end
+  end
+
+  describe "#perform" do
+    it "scans a number" do
+      expect(scan("43")).to eq [
+        [:number, "43"]
+      ]
+    end
+
+    it "scans a string" do
+      scan('"hello world" ').should eq [
+        [:dstring, '"hello world"']
+      ]
+
+      scan(" 'foobar").should eq [
+        [:sstring, "'foobar"]
+      ]
+    end
+
+    it "scans an identifier" do
+      scan('test = 4').should eq [
+        [:identifier, "test"],
+        [:equal, "="],
+        [:number, "4"]
+      ]
+    end
+
+    it "scans brackets" do
+      scan("{ test = 3 }").should eq [
+        [:lbrack, "{"],
+        [:identifier, "test"],
+        [:equal, "="],
+        [:number, "3"],
+        [:rbrack, "}"]
+      ]
+    end
+
+    it "scans keywords" do
+      scan("return test = new foo").should eq [
+        [:keyword, "return"],
+        [:identifier, "test"],
+        [:equal, "="],
+        [:keyword, "new"],
+        [:identifier, "foo"]
+      ]
+    end
+  end
+end

data/spec/lib/liquidscript/scanner_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Liquidscript::Scanner do
+  subject { described_class.new("42") }
+  it { should be_a Enumerable }
+
+  describe "#each" do
+    specify { expect(subject.each).to be_a Enumerator }
+    specify { expect { |y| subject.each(&y) }.to yield_control.once }
+  end
+
+  context "with invalid input" do
+    subject { described_class.new("'test'") }
+
+    it "raises an error" do
+      expect {
+        subject.each
+      }.to raise_error Liquidscript::SyntaxError
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require "bundler/setup"
+Bundler.setup
+
+require "coveralls"
+Coveralls.wear!
+
+require "liquidscript"
+
+include Liquidscript
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.include LexerHelper, :lexer_helper
+end

data/spec/support/helpers/lexer_helper.rb

@@ -0,0 +1,5 @@
+module LexerHelper
+  def scan(source)
+    subject.perform(source)
+  end
+end

data/spec/support/matchers/be_token.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :be_token do |type, value|
+  match do |data|
+    data == Liquidscript::Scanner::Token.new(type, value, 0, 0)
+  end
+
+  description do
+    "be token #{[type, value].inspect}"
+  end
+end

data/spec/support/matchers/compile.rb

@@ -0,0 +1,41 @@
+RSpec::Matchers.define :compile do
+  include Liquidscript
+
+  chain :and_produce do |prod|
+    @prod = prod
+  end
+
+  match do |data|
+    if @prod
+      (@_out = compiler(data).compile) == @prod
+    else
+      @_out = compiler(data).compile?
+    end
+  end
+
+  failure_message_for_should do |data|
+    "expected #{data} to compile correctly"
+  end
+
+  failure_message_for_should_not do |data|
+    "expected #{data} not to compile (compiled anyway, got: #{@_out})"
+  end
+
+  description do |data|
+    "compile #{data}"
+  end
+
+  diffable
+
+  def expected
+    @prod
+  end
+
+  def actual
+    @_out || []
+  end
+
+  def compiler(data)
+    Compiler::ICR.new(Scanner.new(data))
+  end
+end

data/spec/support/matchers/generate.rb

@@ -0,0 +1,46 @@
+RSpec::Matchers.define :generate do |v|
+  include Liquidscript
+
+  match do |data|
+    (@_out = for_match(generator(data).generate)) ==
+    (@_expected = for_match(v))
+  end
+
+  description do |data|
+    "generate #{v}"
+  end
+
+  failure_message_for_should do |data|
+    sprintf "expected %{source} to generate %{dest} (got: %{actual}) - %{tree}",
+      :source => data.inspect,
+      :dest   => for_match(v).inspect,
+      :actual => actual.inspect,
+      :tree   => tree(data)
+  end
+
+  def actual
+    @_out
+  end
+
+  def expected
+    @_expected
+  end
+
+  diffable
+
+  def generator(data)
+    compiler = Compiler::ICR.new(Scanner.new(data))
+    compiler.compile
+    Generator::Javascript.new(compiler.top)
+  end
+
+  def tree(data)
+    compiler = Compiler::ICR.new(Scanner.new(data))
+    compiler.compile
+    compiler.top.to_sexp
+  end
+
+  def for_match(str)
+    str.to_s.gsub(/[\s\n\t]+/, '')
+  end
+end