liquor 0.1.1 → 0.9.1

data/spec/context_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Liquor::Context do
+  before do
+    @compiler = Liquor::Compiler.new
+    @context  = Liquor::Context.new(@compiler, ['ext', 'ext2'])
+  end
+
+  it "declares variables" do
+    @context.type('a').should == :free
+    @context.declare 'a'
+    @context.type('a').should == :variable
+  end
+
+  it "verifies variable names" do
+    expect { @context.declare 'null' }.to raise_error(Liquor::NameError)
+    expect { @context.declare 'a' }.not_to raise_error
+    expect { @context.declare 'a' }.not_to raise_error
+    expect { @context.declare 'ext' }.not_to raise_error
+  end
+
+  it "mangles names" do
+    @context.declare '_env'
+    @context.access('_env').should_not be_nil
+    @context.access('_env').should_not == '_env'
+  end
+
+  it "supports nesting" do
+    @context.nest do
+      @context.declare 'test'
+    end
+    expect { @context.access 'test' }.to raise_error(Liquor::NameError)
+  end
+
+  it "shadows variables" do
+    @context.declare 'test'
+    var_a = @context.access 'test'
+
+    var_b = @context.nest do
+      @context.declare 'test'
+      @context.access 'test'
+    end
+
+    var_c = @context.access 'test'
+
+    var_a.should_not == var_b
+    var_a.should == var_c
+  end
+end

data/spec/drop_delegation_spec.rb

@@ -0,0 +1,21 @@
+require 'liquor/drop/drop'
+
+describe Liquor::DropDelegation do
+  before :all do
+    class TestModel
+      include Liquor::Dropable
+    end
+
+    class TestModelDrop < Liquor::Drop
+    end
+  end
+
+  after :all do
+    Object.send :remove_const, :TestModel
+    Object.send :remove_const, :TestModelDrop
+  end
+
+  it "should correctly unwrap drop classes" do
+    Liquor::DropDelegation.unwrap_drop_class(TestModelDrop).should == TestModel
+  end
+end

data/spec/drop_spec.rb

@@ -0,0 +1,222 @@
+require "spec_helper"
+
+require "sqlite3"
+require "liquor/drop/drop"
+
+ActiveRecord::Base.establish_connection(
+  adapter:  'sqlite3',
+  database: ':memory:',
+)
+
+ActiveRecord::Schema.define force: true do
+  create_table "users", force: true do |t|
+    t.string "login"
+    t.string "email"
+    t.string "occupation"
+  end
+
+  create_table "articles", force: true do |t|
+    t.integer "user_id"
+    t.string  "name"
+    t.boolean "published"
+  end
+end
+
+# Models
+
+class User < ActiveRecord::Base
+  include Liquor::Dropable
+
+  has_many :articles
+
+  scope :with_login, ->(login) { where('login = ?', login) }
+  scope :with_id,    ->(id)    { where('id = ?', id) }
+end
+
+class Article < ActiveRecord::Base
+  include Liquor::Dropable
+
+  belongs_to :user
+
+  scope :published, -> { where('published = ?', true) }
+end
+
+dhh = User.create login: 'dhh', email: 'dhh@loudthinking.org', occupation: 'developer'
+dhh.articles.create name: 'java sucks',  published: false
+dhh.articles.create name: 'rails rules', published: true
+
+me = User.create login: 'me', email: 'vassily@poupkin.org', occupation: 'developer'
+me.articles.create name: 'hello world', published: true
+
+nate = User.create login: 'xnutsive', email: 'nat@evl.ms', occupation: 'manager'
+
+# Drops
+
+class UserDrop < Liquor::Drop
+  attributes :id, :login, :email
+  scopes :with_login, :with_id
+
+  has_many :articles, scope: [ :published ]
+end
+
+class ArticleDrop < Liquor::Drop
+  attributes :name, :published
+  scopes :published
+
+  belongs_to :user
+end
+
+describe Liquor::Drop do
+  before do
+    @me = User.find_by_login 'me'
+    @dhh = User.find_by_login 'dhh'
+  end
+
+  it "should export attributes" do
+    strukt = Struct.new(:a, :b)
+    klass = Class.new(Liquor::Drop) do
+      attributes :a, :b
+    end
+
+    datum = strukt.new(1, "hello")
+    drop  = klass.new(datum)
+
+    exec('{{ drop.a }} {{ drop.b }}', drop: drop).should == '1 hello'
+    expect { exec('{{ drop.c }}') }.to raise_error
+  end
+
+  it "should allow iterating" do
+    expect {
+      exec(%|{% for user in: users do: %}{{ user.id }}{% end for %}|, users: User.to_drop)
+    }.not_to raise_error
+  end
+
+  it "should walk relations and stuff" do
+    exec('{{ user.login }}', user: @dhh.to_drop).should == 'dhh'
+    exec(%|{% for article in: user.articles do: %}{{ article.name }}, {% end for %}|,
+         user: @dhh.to_drop).strip.should == 'rails rules,'
+    exec(%|{{ size(articles) }}|, articles: Article.to_drop).should == '3'
+    exec(%|{{ size(articles.published) }}|, articles: Article.to_drop).should == '2'
+    exec(%|{{ size(users.with_login('dhh')) }}|, users: User.to_drop).should == '1'
+    exec(%|{% if article.user == null then: %}ok{% end if %}|, article: Article.new.to_drop).should == 'ok'
+  end
+
+  it "should support generic find_by" do
+    exec(%|{{ users.find_by(login: "dhh").email }}|, users: User.to_drop).should == 'dhh@loudthinking.org'
+    exec(%|{{ users.find_by(email: "vassily@poupkin.org").login }}|, users: User.to_drop).should == 'me'
+    exec(%|{{ users.find_by(id: user).email }}|, users: User.to_drop, user: @dhh.to_drop).should == 'dhh@loudthinking.org'
+  end
+
+  it "should return null from find_by" do
+    exec(%|{% if users.find_by(login: "123") == null then: %}ok{% end if %}|, users: User.to_drop).should == 'ok'
+  end
+
+  it "should support generic find_all_by and return a tuple" do
+    exec(%|{{ size(users.find_all_by(occupation: "developer")) }}|, users: User.to_drop).should == '2'
+    exec(%|{{ size(users.find_all_by(occupation: "manager")) }}|, users: User.to_drop).should == '1'
+  end
+
+  it "should support reversing" do
+    ltr = exec(%|{% for user in: users do: %}{{ user.id }}{% end for %}|, users: User.to_drop)
+    rtl = exec(%|{% for user in: users.reverse do: %}{{ user.id }}{% end for %}|, users: User.to_drop)
+    ltr.should == rtl.reverse
+  end
+
+  it "should support except" do
+    res = exec(%|{% for user in: users.except(users.find_by(login: 'xnutsive')) do: %}{{ user.login }},{% end for %}|, users: User.to_drop)
+    res.split(',').sort.should == %w(me dhh).sort
+  end
+
+  it "should support find_except_by" do
+    res = exec(%|{% for user in: users.find_except_by(login: 'xnutsive') do: %}{{ user.login }},{% end for %}|, users: User.to_drop)
+    res.split(',').sort.should == %w(me dhh).sort
+  end
+
+  it "should not fail if the [] argument is out of range" do
+    exec(%|{% if users[5] == null then: %}ok{% end if %}|, users: User.to_drop).should == 'ok'
+  end
+
+  it "should provide [] access to the elements, returned by find_all_by function" do
+    exec(%|
+      {% assign found_users = users.find_all_by(occupation: "developer") %}
+      {{ found_users[0].login }}
+    |, users: User.to_drop).strip.should == 'dhh'
+  end
+
+  it "should accept scope returned by find_all_by in for statements" do
+    exec(%|
+      {% for user in: users.find_all_by(occupation: "developer") do: %}
+        {{ user.login }}
+      {% end for %}
+    |, users: User.to_drop).split.should == %w[dhh me]
+  end
+
+  it "should accept scope returned by find_all into empty() function" do
+    exec(%|{% if !is_empty(users.find_all_by(occupation: "developer")) then: %}it works{%end if%}|, users: User.to_drop).should == "it works"
+    exec(%|{% if is_empty(users.find_all_by(occupation: "idiot")) then: %}it works{% end if%}|, users: User.to_drop).should == "it works"
+  end
+
+  it "should support #pluck" do
+    exec(%!{{ users.pluck('login') | join with: ', ' }}!, users: User.to_drop).should == 'dhh, me, xnutsive'
+  end
+
+  it "should export model name from Drop and Drop::Scope" do
+    exec(%!{{ users.entity }}!, users: User.to_drop).should == 'User'
+    exec(%!{{ users.first.entity }}!, users: User.to_drop).should == 'User'
+  end
+
+  it "should return intact source" do
+    @dhh.to_drop.source.should == @dhh
+  end
+
+  it "should support equality" do
+    (@dhh.to_drop == @dhh.to_drop).should == true
+    (@dhh.to_drop.eql? @dhh.to_drop).should == true
+  end
+
+  it "should support include?" do
+    lib = Module.new do
+      include Liquor::Library
+
+      function "check", {
+                  mandatory_named_args: {
+                    collection: :any,
+                    element:    :any,
+                  }
+                } do |arg, kw|
+        kw[:collection].include? kw[:element]
+      end
+    end
+
+    compiler = Liquor::Compiler.new
+    lib.export compiler
+    code = compiler.compile!(parse(%|
+      {% if check(collection: collection element: element) then: %}
+        yes
+      {% end if %}
+    |, compiler), [:collection, :element])
+
+    code.call(collection: User.to_drop, element: @dhh.to_drop).
+        strip.should == 'yes'
+    code.call(collection: User.to_drop, element: User.new.to_drop).
+        strip.should == ''
+  end
+
+  it "should support uniq'ing" do
+    @dhh.to_drop.hash.should == @dhh.to_drop.hash
+    [@me, @dhh, @dhh].map(&:to_drop).uniq.size.should == 2
+  end
+
+  it "should unwrap arguments to derivative scopes" do
+    Liquor::Drop.unwrap_scope_arguments([ @me.to_drop ]).
+        should == [@me.id]
+    Liquor::Drop.unwrap_scope_arguments([ [@me.to_drop, @dhh.to_drop] ]).
+        should ==  [ [@me.id, @dhh.id] ]
+    Liquor::Drop.unwrap_scope_arguments([ 1, { a: @me.to_drop, b: @dhh.to_drop } ]).
+        should == [ 1, { a: @me.id, b: @dhh.id } ]
+    exec('{{ scope.with_id(obj).first.login }}', scope: User.to_drop, obj: @me.to_drop).
+        should == @me.login
+    Liquor::Drop.unwrap_scope_arguments([ User.order(:id).to_drop ]).
+        should == [ User.pluck(:id).sort ]
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Liquor::Diagnostic do
+  it "is not an error" do
+    diag = Liquor::Diagnostic.new("foobar")
+    diag.error?.should be_false
+  end
+
+  it "decorates source" do
+    source = "line 1\nthis is a diagnostic"
+    diag  = Liquor::Diagnostic.new("foobar", line: 1, start: 10, end: 19)
+    diag.decorate(source).should == [
+      "this is a diagnostic",
+      "          ^^^^^^^^^^"
+    ]
+    diag.as_json.should == {
+      message:  'foobar',
+      is_error: false,
+      location: {
+        line:  1,
+        start: 10,
+        end:   19
+      }
+    }
+  end
+end
+
+describe Liquor::Error do
+  it "is an error" do
+    diag = Liquor::Error.new("foobar")
+    diag.error?.should be_true
+  end
+end
+
+describe Liquor::Deprecation do
+  it "is not an error" do
+    diag = Liquor::Deprecation.new("foobar")
+    diag.error?.should be_false
+  end
+end

data/spec/external_spec.rb

@@ -0,0 +1,207 @@
+require "spec_helper"
+
+describe Liquor::External do
+  it "should export methods" do
+    klass = Class.new do
+      include Liquor::External
+
+      def yes(param)
+        "result #{param}"
+      end
+      export :yes
+
+      def no
+        "not accessible"
+      end
+    end
+
+    klass.should respond_to(:liquor_exports)
+    klass.liquor_exports.should == Set[:yes]
+
+    obj = klass.new
+    obj.liquor_send(:yes, 1).should == "result 1"
+    expect { obj.liquor_send(:no) }.to raise_error
+    expect { obj.liquor_send("yes", 1) }.not_to raise_error
+  end
+
+  it "should correctly support inheritance" do
+    klass = Class.new do
+      include Liquor::External
+
+      def first
+      end
+      export :first
+    end
+
+    klass2 = Class.new(klass) do
+      def second
+      end
+
+      def third
+      end
+
+      export :second, :third
+    end
+
+    klass.liquor_exports.should == Set[:first]
+    klass2.liquor_exports.should == Set[:first, :second, :third]
+  end
+
+  it "should be callable" do
+    klass = Class.new do
+      include Liquor::External
+
+      def static
+        "hello"
+      end
+
+      def dynamic(var)
+        "#{var} world"
+      end
+
+      def other
+        self
+      end
+
+      def with_hash(param, options={})
+        "#{param} #{options.map{ |k,v| "#{k}: #{v}" }.join(" ")}"
+      end
+
+      export :static, :dynamic, :other, :with_hash
+    end
+
+    instance = klass.new
+
+    exec(%Q|{{ ext.static }}|, ext: instance).should == 'hello'
+    exec(%Q|{{ ext.other.static }}|, ext: instance).should == 'hello'
+    expect { exec(%Q|{{ ext.dynamic }}|, ext: instance) }.to raise_error
+    exec(%Q|{{ ext.dynamic() }}|, ext: instance).should == ' world'
+    exec(%Q|{{ ext.dynamic('bye') }}|, ext: instance).should == 'bye world'
+    exec(%Q|{{ ext.with_hash("1" two: "3") }}|, ext: instance).should == "1 two: 3"
+  end
+
+  it "should support indexing" do
+    klass = Class.new do
+      include Liquor::External
+
+      def [](index)
+        "element #{index}"
+      end
+      export :[]
+    end
+
+    instance = klass.new
+
+    exec(%Q|{{ ext[10] }}|, ext: instance).should == 'element 10'
+  end
+
+  it "should wrap host errors" do
+    klass = Class.new do
+      include Liquor::External
+
+      def fail
+        Time.parse("nothing")
+      end
+      export :fail
+    end
+
+    instance = klass.new
+
+    expect {
+      exec(%Q|{{ ext.fail }}|, ext: instance)
+    }.to raise_error(Liquor::HostError)
+  end
+
+  it "should index chained externals" do
+    klass = Class.new do
+      include Liquor::External
+
+      def other
+        self
+      end
+
+      def [](index)
+        index
+      end
+
+      export :other, :[]
+    end
+
+    instance = klass.new
+
+    exec(%Q|{{ ext.other[5] }}|, ext: instance).should == '5'
+  end
+
+  it "should correctly pass arrays" do
+    klass = Class.new do
+      include Liquor::External
+
+      attr_reader :memorized
+
+      def memorize(arg)
+        @memorized = arg
+        "d'oh"
+      end
+
+      export :memorize
+    end
+
+    instance = klass.new
+
+    expect {
+      exec(%Q|{{ ext.memorize(["a", "b"]) }}|, ext: instance)
+    }.not_to raise_error
+
+    instance.memorized.should == ["a", "b"]
+  end
+
+  it "concatenates indexable externals with tuples" do
+    klass = Class.new do
+      include Liquor::External
+
+      def initialize(array)
+        @array = array
+      end
+
+      def [](index); @array[index]; end
+      def size;      @array.size;   end
+      def to_a;      @array;        end
+
+      export :[], :size
+    end
+
+    exec(%Q|{% for i in: ext + ["b", "c"] do: %}{{ i }} {% end for %}|,
+            ext: klass.new(["0", "a"])).strip.should == "0 a b c"
+  end
+
+  it "sets up deprecations" do
+    klass = Class.new do
+      include Liquor::External
+    end
+
+    expect {
+      klass.class_eval { deprecate :foo }
+    }.to raise_error(ArgumentError)
+
+    expect {
+      klass.class_eval { deprecate :foo, date: '2012-03-14' }
+    }.to raise_error(ArgumentError)
+
+    expect {
+      klass.class_eval { deprecate :foo, message: 'not available' }
+    }.to raise_error(ArgumentError)
+
+    expect {
+      klass.class_eval { deprecate :foo, date: '2012-03-14', message: 'not available', foo: 'bar' }
+    }.to raise_error(ArgumentError)
+
+    klass.class_eval {
+      deprecate :foo, :bar, date: '2012-03-14', message: 'not available'
+    }
+
+    klass.liquor_deprecations.should == {
+      foo: { date: Date.parse('2012-03-14'), message: 'not available' },
+      bar: { date: Date.parse('2012-03-14'), message: 'not available' }
+    }
+  end
+end