alephant 0.0.4-java → 0.0.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac3689e07939593c100632167541ecc2efd0994a
-  data.tar.gz: b12b4f8cd17d1a380eabdb1bf44f93ed62628fa0
+  metadata.gz: 2fab1ace0ff9d2ef8b5bb2003bb6fced04808a48
+  data.tar.gz: fd3b8c6a161ea075fef0865fbb1278cb5ac4c47c
 SHA512:
-  metadata.gz: 2094d441612a43e1571817ece377e602f9367f33b7b91cadc003b33a20144cda6938f8f08c207970949efb6dfcd142a684d1bd0cea00ac92b821a65db4077876
-  data.tar.gz: 054fcbe96e00401de0376192925c9278089b386238be2b3bb6c7a44b1085da372620ea1caf4bf081d2be98f142a8446d5d56380e3d7b2fffee46edb55cd8a168
+  metadata.gz: d72470cccb094e58d2735fbce0b19fbf2840949f2ba3aabfd97bd0c400fe8b43baf1da54577677d4c006d972ed49808eef25f9400f4c52641f4df5b05880a345
+  data.tar.gz: 35b38982cfc40c7cf796c2b440d288a6373b0e948f54d85e63e0f4ed8bb806dd9d7c8ea9e3971eb780579dda240b69d3f3fc55378daa42c0fe53df06b4d867a5

data/.gitignore

@@ -4,4 +4,5 @@ Gemfile.lock
 
 /pkg
 /tmp
+/views
 

data/.ruby-version

@@ -1 +1 @@
-jruby-1.7.8
+jruby-1.7.9

data/README.md

@@ -3,16 +3,19 @@ alephant
 
 Static publishing to S3 on push notification from SQS
 
-[![Code Climate](https://codeclimate.com/repos/52cd866de30ba018f10000a2/badges/5d9c02131201565a630e/gpa.png)](https://codeclimate.com/repos/52cd866de30ba018f10000a2/feed)
+[![Code Climate](https://codeclimate.com/repos/52d6bec56956802e26011a0f/badges/fce457795179641460e0/gpa.png)](https://codeclimate.com/repos/52d6bec56956802e26011a0f/feed)
 
-[![Build Status](https://travis-ci.org/kenoir/alephant.png?branch=master)](https://travis-ci.org/kenoir/alephant)
+[![Build Status](https://travis-ci.org/BBC-News/alephant.png?branch=master)](https://travis-ci.org/BBC-News/alephant)
 
 [![Gem Version](https://badge.fury.io/rb/alephant.png)](http://badge.fury.io/rb/alephant)
 
 ##Dependencies
 
 - JRuby 1.7.8
-- An AWS account
+- An AWS account (you'll need to create):
+  - An S3 bucket
+  - An SQS Queue
+  - A Dynamo DB table (optional, will attempt to create if can't be found)
 
 ##Setup
 
@@ -30,7 +33,64 @@ gem install alephant
 In your application:
 ```rb
 require 'alephant'
+opts = {
+  :s3_bucket_id => 'bucket-id',
+  :s3_object_path => 'path/to/object',
+  :s3_object_id => 'object_id',
+  :table_name => 'your_dynamo_db_table',
+  :sqs_queue_id => 'https://your_amazon_sqs_queue_url',
+  :view_id => 'my_view_id',
+  :sequential_proc => Proc.new { |last_seen_id, data|
+    last_seen_id < data["sequence_id"].to_i
+  },
+  :set_last_seen_proc => Proc.new { |data|
+    data["sequence_id"].to_i
+  }
+}
 
-Alephant.run('your_cache_id')
+thread = Alephant::Alephant.new(opts).run!
+thread.join
+```
+
+Provide a view in a folder:
+
+```
+└── views
+    ├── models
+    │   └── foo.rb
+    └── templates
+        └── foo.mustache
+```
+
+**SQS Message Format**
+
+```json
+{
+  "content": "hello world",
+  "sequential_id": 1
+}
+```
+
+**foo.rb**
+```rb
+module MyApp
+  module Views
+    class Foo < Alephant::Views::Base
+      def content
+        @data['content']
+      end
+    end
+  end
+end
+```
+
+**foo.mustache**
+```mustache
+{{content}}
+```
+
+**S3 Output**
+```
+hello world
 ```
 

data/lib/alephant.rb

@@ -1,7 +1,11 @@
+$: << File.dirname(__FILE__)
+
 require 'aws-sdk'
-require 'env'
 require 'json'
 
+require_relative 'env'
+
+require 'alephant/models/queue'
 require 'alephant/models/cache'
 require 'alephant/models/renderer'
 require 'alephant/models/sequencer'
@@ -9,31 +13,72 @@ require 'alephant/models/sequencer'
 require 'alephant/errors'
 require 'alephant/views'
 
-
 module Alephant
+  class Alephant
+    attr_reader :sequencer, :queue, :cache, :renderer
 
-  def self.run(cache_id)
-    queue = AWS::SQS.new.queues.create(cache_id)
-    cache = Cache.new(cache_id)
-    sequencer = Sequencer.new(cache_id)
-    renderer = Renderer.new(cache_id)
+    VALID_OPTS = [
+      :s3_bucket_id,
+      :s3_object_path,
+      :s3_object_id,
+      :table_name,
+      :sqs_queue_id,
+      :view_id,
+      :sequential_proc,
+      :set_last_seen_proc
+    ]
 
-    thread = Thread.new do
-      puts "Polling queue..."
-      queue.poll do |msg|
-        data = JSON.parse(msg.body)
+    def initialize(opts = {})
+      set_opts(opts)
 
-        if data["seq"] > sequencer.last_seen
-          puts "Rendering from message #{data["seq"]}"
+      @sequencer = Sequencer.new(
+        {
+          :table_name => @table_name
+        },
+        @sqs_queue_id
+      )
+
+      @queue = Queue.new(@sqs_queue_id)
+      @cache = Cache.new(@s3_bucket_id, @s3_object_path)
+      @renderer = Renderer.new(@view_id)
+    end
+
+    def parse(msg)
+      JSON.parse(msg)
+    end
+
+    def write(data)
+      @cache.put(
+        @s3_object_id,
+        @renderer.render(data)
+      )
+    end
 
-          content = renderer.render(data)
-          cache.put(cache_id, content)
-          sequencer.last_seen = data["seq"]
+    def receive(msg)
+      data = parse(msg.body)
+
+      if @sequencer.sequential?(data, &@sequential_proc)
+        write data
+        @sequencer.set_last_seen(data, &@set_last_seen_proc)
+      end
+    end
+
+    def run!
+      Thread.new do
+        @queue.poll { |msg| receive(msg) }
+      end
+    end
+
+    private
+    def set_opts(opts)
+      VALID_OPTS.each do | k |
+        v = opts.has_key?(k) ? opts[k] : nil
+        singleton_class.class_eval do
+          attr_accessor k
         end
+        send("#{k}=", v)
       end
     end
 
-    thread
   end
 end
-

data/lib/alephant/models/cache.rb

@@ -2,19 +2,23 @@ require 'aws-sdk'
 
 module Alephant
   class Cache
+    attr_reader :id, :bucket, :path
 
-    def initialize(id)
-      @s3_bucket = AWS::S3.new.buckets.create(id)
-    end
+    def initialize(id, path)
+      @id = id
+      @path = path
 
-    def get(object_id)
-      @s3_bucket.objects[object_id].read
+      s3 = AWS::S3.new
+      @bucket = s3.buckets[id]
     end
 
-    def put(object_id, data)
-      @s3_bucket.objects[object_id].write(data)
+    def put(id, data)
+      @bucket.objects["#{@path}/#{id}"].write(data)
     end
 
+    def get(id)
+      @bucket.objects["#{@path}/#{id}"].read
+    end
   end
 end
 

data/lib/alephant/models/queue.rb

@@ -0,0 +1,25 @@
+require 'aws-sdk'
+
+module Alephant
+  class Queue
+    attr_accessor :q
+
+    def initialize(id)
+      @sqs = AWS::SQS.new
+      @q = @sqs.queues[id]
+
+      unless @q.exists?
+        @q = @sqs.queues.create(id)
+        sleep_until_queue_exists
+      end
+    end
+
+    def sleep_until_queue_exists
+      sleep 1 until @q.exists?
+    end
+
+    def poll(*args, &block)
+      @q.poll(*args, &block)
+    end
+  end
+end

data/lib/alephant/models/sequencer.rb

@@ -2,40 +2,64 @@ require 'aws-sdk'
 
 module Alephant
   class Sequencer
-    attr_reader :id, :table
+    attr_reader :id, :table_name, :table_conf
 
-    def initialize(id)
-      @id = id
-
-      dynamo_db = AWS::DynamoDB.new
-      schema = {
-        :hash_key => {
-          :key => :string,
-          :value => :string
+    def table_conf_defaults
+      {
+        :write_units => 5,
+        :read_units => 10,
+        :schema => {
+          :hash_key => {
+            :key => :string,
+            :value => :string
+          }
         }
       }
+    end
+
+    def initialize(opts, id)
+      dynamo_db = AWS::DynamoDB.new
+
+      @id = id
+      @table_name = opts[:table_name]
+      @table_conf = opts[:table_conf] || table_conf_defaults
+      @table = dynamo_db.tables[@table_name]
 
-      @table = dynamo_db.tables[id]
       begin
         sleep_until_table_active
       rescue AWS::DynamoDB::Errors::ResourceNotFoundException
-        puts "CREATING TABLE: #{id}"
-        @table = dynamo_db.tables.create(id, 10, 5, schema)
+        @table = dynamo_db.tables.create(
+          @table_name,
+          @table_conf[:read_units],
+          @table_conf[:write_units],
+          @table_conf[:schema]
+        )
 
         sleep_until_table_active
       end
+    end
 
+    def sequential?(data)
+      if block_given?
+        yield(get_last_seen, data)
+      else
+        get_last_seen < data["sequence_id"].to_i
+      end
     end
 
-    def sequential?(n)
-      last_seen < n
+    def set_last_seen(data)
+      last_seen_id = block_given? ? yield(data) : data["sequence_id"]
+
+      batch = AWS::DynamoDB::BatchWrite.new
+      batch.put(@table_name, [:key => @id,:value => last_seen_id])
+      batch.process!
     end
 
-    def last_seen
+    def get_last_seen
       begin
         @table.batch_get(
           ['value'],
-          ['last_seen'],
+          [@id],
           {
             :consistent_read => true
           }
@@ -45,13 +69,6 @@ module Alephant
       end
     end
 
-    def last_seen=(last_seen)
-      batch = AWS::DynamoDB::BatchWrite.new
-      batch.put(@id, [:key => "last_seen",:value => last_seen])
-      batch.process!
-    end
-
-    private
     def sleep_until_table_active
       sleep 1 until @table.status == :active
     end

data/lib/alephant/version.rb

@@ -1,3 +1,3 @@
 module Alephant
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/alephant_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Alephant::Alephant do
+  subject { Alephant::Alephant }
+
+  describe "initialize(opts = {})" do
+    before(:each) do
+      sequencer = double()
+      queue     = double()
+      cache     = double()
+      renderer  = double()
+
+      Alephant::Sequencer.any_instance.stub(:initialize).and_return(sequencer)
+      Alephant::Queue.any_instance.stub(:initialize).and_return(queue)
+      Alephant::Cache.any_instance.stub(:initialize).and_return(cache)
+      Alephant::Renderer.any_instance.stub(:initialize).and_return(renderer)
+    end
+
+    it "sets specified options" do
+      instance = subject.new({
+        :s3_bucket_id       => :s3_bucket_id,
+        :s3_object_path     => :s3_object_path,
+        :s3_object_id       => :s3_object_id,
+        :table_name         => :table_name,
+        :sqs_queue_id       => :sqs_queue_id,
+        :view_id            => :view_id,
+        :sequential_proc    => :sequential_proc,
+        :set_last_seen_proc => :set_last_seen_proc
+      })
+
+      expect(instance.s3_bucket_id).to eq(:s3_bucket_id);
+      expect(instance.s3_object_path).to eq(:s3_object_path);
+      expect(instance.s3_object_id).to eq(:s3_object_id);
+      expect(instance.table_name).to eq(:table_name);
+      expect(instance.sqs_queue_id).to eq(:sqs_queue_id);
+      expect(instance.view_id).to eq(:view_id);
+      expect(instance.sequential_proc).to eq(:sequential_proc);
+      expect(instance.set_last_seen_proc).to eq(:set_last_seen_proc);
+    end
+
+    it "sets unspecified options to nil" do
+      instance = subject.new
+
+      expect(instance.s3_bucket_id).to eq(nil);
+      expect(instance.s3_object_path).to eq(nil);
+      expect(instance.s3_object_id).to eq(nil);
+      expect(instance.table_name).to eq(nil);
+      expect(instance.sqs_queue_id).to eq(nil);
+      expect(instance.view_id).to eq(nil);
+      expect(instance.sequential_proc).to eq(nil);
+      expect(instance.set_last_seen_proc).to eq(nil);
+    end
+
+    context "initializes @sequencer" do
+      it "with Sequencer.new({ :table_name => :table_name }, @sqs_queue_id)" do
+        Alephant::Sequencer.should_receive(:new)
+          .with({ :table_name => :table_name }, :sqs_queue_id)
+
+        instance = subject.new({
+          :table_name   => :table_name,
+          :sqs_queue_id => :sqs_queue_id
+        })
+      end
+    end
+
+    context "initializes @queue" do
+      it "with Queue.new(@sqs_queue_id)" do
+        Alephant::Queue.should_receive(:new).with(:sqs_queue_id)
+
+        instance = subject.new({
+          :sqs_queue_id => :sqs_queue_id
+        })
+      end
+    end
+
+    context "initializes @cache" do
+      it "with Cache.new(@s3_bucket_id, @s3_object_path)" do
+        Alephant::Cache.should_receive(:new).with(:s3_bucket_id, :s3_object_path)
+
+        instance = subject.new({
+          :s3_bucket_id   => :s3_bucket_id,
+          :s3_object_path => :s3_object_path
+        })
+      end
+    end
+
+    context "initializes @renderer" do
+      it "with Renderer.new(@view_id)" do
+        Alephant::Renderer.should_receive(:new).with(:view_id)
+
+        instance = subject.new({
+          :view_id => :view_id
+        })
+      end
+    end
+  end
+
+  describe "run!" do
+    before(:each) do
+      sequencer = double()
+      queue     = double()
+      cache     = double()
+      renderer  = double()
+
+      Alephant::Sequencer.any_instance.stub(:initialize).and_return(sequencer)
+      Alephant::Queue.any_instance.stub(:initialize).and_return(queue)
+      Alephant::Cache.any_instance.stub(:initialize).and_return(cache)
+      Alephant::Renderer.any_instance.stub(:initialize).and_return(renderer)
+    end
+
+    it "returns a Thread" do
+      instance = subject.new({
+        :sqs_queue_id => :sqs_queue_id
+      })
+
+      expect(instance.run!).to be_a(Thread)
+    end
+
+    it "calls @queue.poll" do
+      instance = subject.new({
+        :sqs_queue_id => :sqs_queue_id
+      })
+
+      instance.should_receive(:receive).with(:msg)
+
+      expect_any_instance_of(Alephant::Queue).to receive(:poll).and_yield(:msg)
+
+      t = instance.run!
+      t.join
+    end
+  end
+
+  describe "receive(msg)" do
+    before(:each) do
+      sequencer = double()
+      queue     = double()
+      cache     = double()
+      renderer  = double()
+
+      Alephant::Sequencer.any_instance.stub(:initialize).and_return(sequencer)
+      Alephant::Queue.any_instance.stub(:initialize).and_return(queue)
+      Alephant::Cache.any_instance.stub(:initialize).and_return(cache)
+      Alephant::Renderer.any_instance.stub(:initialize).and_return(renderer)
+    end
+
+    it "takes json as an argument" do
+      instance = subject.new
+      msg = double()
+      msg.stub(:body).and_return('notjson')
+
+      expect { instance.receive(msg) }.to raise_error(JSON::ParserError);
+    end
+
+    it "writes data to cache if sequential order is true" do
+      data = "{ \"foo\":\"bar\" }"
+      msg = double()
+      msg.stub(:body).and_return(data)
+
+      instance = subject.new
+
+      Alephant::Sequencer.any_instance.stub(:sequential?).and_return(true)
+      Alephant::Sequencer.any_instance.stub(:set_last_seen)
+
+      instance.should_receive(:write).with(JSON.parse(data))
+      instance.receive(msg)
+    end
+  end
+
+  describe "write(data)" do
+    before(:each) do
+      sequencer = double()
+      queue     = double()
+      cache     = double()
+      renderer  = double()
+
+      Alephant::Sequencer.any_instance.stub(:initialize).and_return(sequencer)
+      Alephant::Queue.any_instance.stub(:initialize).and_return(queue)
+      Alephant::Cache.any_instance.stub(:initialize).and_return(cache)
+      Alephant::Renderer.any_instance.stub(:initialize).and_return(renderer)
+    end
+
+    it "puts rendered data into the S3 Cache" do
+      Alephant::Cache.any_instance.should_receive(:put).with(:s3_object_id, :content)
+      Alephant::Renderer.any_instance.stub(:render).and_return(:content)
+
+      instance = subject.new({
+        :s3_object_id => :s3_object_id
+      })
+
+      instance.write(:content)
+    end
+  end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'pry'
+
+describe Alephant::Cache do
+  let(:id)   { :id }
+  let(:path) { :path }
+  let(:data) { :data }
+  subject { Alephant::Cache }
+
+  describe "initialize(id, path)" do
+    it "sets and exposes id, path instance variables " do
+      instance = subject.new(id, path)
+      expect(instance.id).to eq(id)
+      expect(instance.path).to eq(path)
+    end
+
+    it "sets bucket instance variable as S3 bucket with id" do
+      instance = subject.new(id, path)
+
+      expect(instance.bucket).to be_an AWS::S3::Bucket
+      expect(instance.bucket.name).to eq('id')
+    end
+  end
+
+  describe "put(id, data)" do
+    it "sets bucket path/id content data" do
+      s3_object_collection = double()
+      s3_object_collection.should_receive(:write).with(:data)
+
+      s3_bucket = double()
+      s3_bucket.should_receive(:objects).and_return(
+        {
+          "path/id" => s3_object_collection
+        }
+      )
+
+      AWS::S3.any_instance.stub(:buckets).and_return({ id => s3_bucket })
+      instance = subject.new(id, path)
+
+      instance.put(id, data);
+    end
+  end
+
+  describe "get(id)" do
+    it "gets bucket path/id content data" do
+      s3_object_collection = double()
+      s3_object_collection.should_receive(:read)
+
+      s3_bucket = double()
+      s3_bucket.should_receive(:objects).and_return(
+        {
+          "path/id" => s3_object_collection
+        }
+      )
+
+      AWS::S3.any_instance.stub(:buckets).and_return({ id => s3_bucket })
+
+      instance = subject.new(id, path)
+      instance.get(id);
+    end
+  end
+end
+

data/spec/queue_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Alephant::Queue do
+  subject { Alephant::Queue }
+
+  describe "initialize(id)" do
+    it "sets @q to an instance of AWS:SQS::Queue" do
+      AWS::SQS::Queue.any_instance.stub(:exists?)
+        .and_return(true)
+
+      instance = subject.new(:id)
+      expect(instance.q).to be_a(AWS::SQS::Queue)
+    end
+
+    context "@q.exists? == false" do
+      it "@q = AWS::SQS.new.queues.create(id), then sleep_until_queue_exists" do
+        queue = double()
+        queue.stub(:exists?).and_return(false)
+
+        queue_collection = double()
+        queue_collection.should_receive(:create).with(:id)
+          .and_return(queue)
+
+        sqs = double()
+        sqs.should_receive(:queues)
+          .and_return({ :id => queue }, queue_collection)
+
+        AWS::SQS.should_receive(:new).and_return(sqs)
+
+        subject.any_instance.should_receive(:sleep_until_queue_exists)
+
+        instance = subject.new(:id)
+      end
+    end
+  end
+
+  describe "poll(*args, &block)" do
+    it "calls @q.poll(*args, &block)" do
+      block = double()
+      block.should_receive(:called)
+
+      AWS::SQS::Queue.any_instance.stub(:exists?)
+        .and_return(true)
+
+      AWS::SQS::Queue.any_instance.should_receive(:poll).with(:arg).and_yield
+
+      subject.new(:id).poll(:arg) do
+        block.called
+      end
+    end
+  end
+
+  describe "sleep_until_queue_exists" do
+    context "@q.exists? == true" do
+      it "should not call sleep" do
+        AWS::SQS::Queue.any_instance.stub(:exists?)
+          .and_return(true)
+
+        Alephant::Queue.any_instance.stub(:sleep)
+        Alephant::Queue.any_instance.should_not_receive(:sleep)
+
+        subject.new(:id).sleep_until_queue_exists
+      end
+    end
+    context "@q.exists? == false" do
+      it "should call sleep(1)" do
+        AWS::SQS::Queue.any_instance.stub(:exists?)
+          .and_return(true, false, true)
+
+        Alephant::Queue.any_instance.stub(:sleep)
+        Alephant::Queue.any_instance.should_receive(:sleep).with(1)
+
+        subject.new(:id).sleep_until_queue_exists
+      end
+    end
+  end
+
+end

data/spec/sequencer_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Alephant::Sequencer do
+  subject { Alephant::Sequencer }
+
+  describe "initialize(opts, id)" do
+
+    it "sets @id, @table_name and @table_conf" do
+      AWS::DynamoDB.any_instance.stub(:initialize).and_return({
+        :tables => {
+          :status => :active
+        }
+      })
+
+      Alephant::Sequencer.any_instance.stub(:sleep_until_table_active)
+
+      instance = subject.new({
+        :table_name => :table_name,
+        :table_conf => :table_conf
+      }, :sqs_queue_id)
+
+      expect(instance.id).to eq(:sqs_queue_id)
+      expect(instance.table_name).to eq(:table_name)
+      expect(instance.table_conf).to eq(:table_conf)
+    end
+
+    context "sleep_until_table_active raises" do
+      context "AWS::DynamoDB::Errors::ResourceNotFoundException" do
+        it "dynamo_db.tables.create(@table_name, opts) then sleep_until_table_active" do
+          opts = {
+              :table_name => :table_name,
+              :table_conf => {
+                :read_units => :read_units,
+                :write_units => :write_units,
+                :schema => :schema
+              }
+          }
+
+          table_collection = double()
+          table_collection.should_receive(:create).with(
+            opts[:table_name],
+            opts[:table_conf][:read_units],
+            opts[:table_conf][:write_units],
+            opts[:table_conf][:schema]
+          )
+
+          AWS::DynamoDB.any_instance.stub(:tables).and_return({},table_collection)
+
+          Alephant::Sequencer
+            .any_instance
+            .stub(:sleep_until_table_active).and_yield do
+              @times_called ||= 0
+              raise AWS::DynamoDB::Errors::ResourceNotFoundException if @times_called == 0
+              @times_called += 1
+            end
+
+          subject.new(opts, :id)
+        end
+      end
+    end
+  end
+
+  describe "sequential?(data)" do
+    before(:each) do
+      Alephant::Sequencer
+        .any_instance.stub(:initialize)
+        .and_return(double())
+    end
+
+    context "block_given? == true" do
+      it "yields to block" do
+        Alephant::Sequencer
+          .any_instance
+          .stub(:get_last_seen)
+          .and_return(1)
+
+        instance = subject.new
+
+        in_sequence = instance.sequential?(:data) do |last_seen, data|
+          :foo
+        end
+
+        expect(in_sequence).to eq(:foo)
+      end
+    end
+
+    context "block_given? == false" do
+      context "get_last_seen < data['sequence_id']" do
+        it "returns true" do
+          Alephant::Sequencer
+            .any_instance
+            .stub(:get_last_seen)
+            .and_return(0)
+
+          instance = subject.new
+
+          data = { "sequence_id" => "1" }
+
+          expect(instance.sequential? data).to be(true)
+        end
+      end
+
+      context "get_last_seen >= data['sequence_id']" do
+        it "returns false" do
+          Alephant::Sequencer
+            .any_instance
+            .stub(:get_last_seen)
+            .and_return(1)
+
+          instance = subject.new
+
+          data = { "sequence_id" => "0" }
+
+          expect(instance.sequential? data).to be(false)
+        end
+      end
+    end
+
+  end
+end
+

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $: << File.join(File.dirname(__FILE__),"..", "lib")
 
+require 'pry'
 require 'alephant'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alephant
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: java
 authors:
 - Robert Kenny
@@ -143,6 +143,7 @@ files:
 - lib/alephant/errors/view_model_not_found.rb
 - lib/alephant/errors/view_template_not_found.rb
 - lib/alephant/models/cache.rb
+- lib/alephant/models/queue.rb
 - lib/alephant/models/renderer.rb
 - lib/alephant/models/sequencer.rb
 - lib/alephant/util/string.rb
@@ -150,9 +151,13 @@ files:
 - lib/alephant/views.rb
 - lib/alephant/views/base.rb
 - lib/env.rb
+- spec/alephant_spec.rb
+- spec/cache_spec.rb
 - spec/fixtures/views/models/example.rb
 - spec/fixtures/views/templates/example.mustache
+- spec/queue_spec.rb
 - spec/renderer_spec.rb
+- spec/sequencer_spec.rb
 - spec/spec_helper.rb
 homepage: http://rubygems.org/gems/alephant
 licenses:
@@ -179,7 +184,11 @@ signing_key:
 specification_version: 4
 summary: Static Publishing in the Cloud
 test_files:
+- spec/alephant_spec.rb
+- spec/cache_spec.rb
 - spec/fixtures/views/models/example.rb
 - spec/fixtures/views/templates/example.mustache
+- spec/queue_spec.rb
 - spec/renderer_spec.rb
+- spec/sequencer_spec.rb
 - spec/spec_helper.rb