alephant 0.0.9.9.1-java → 0.1.1-java

data/lib/alephant/tasks.rb

@@ -1,8 +0,0 @@
-require 'rake'
-require 'pathname'
-
-root = Pathname.new(__FILE__).dirname.parent
-task_path = (root + 'tasks').realdirpath
-
-Dir["#{task_path}/**/*.rake"].each { |ext| load ext } if defined?(Rake)
-

data/lib/alephant/util/string.rb

@@ -1,9 +0,0 @@
-class String
-  def underscore
-    self.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
-  end
-end

data/lib/alephant/views.rb

@@ -1,15 +0,0 @@
-require 'alephant/views/base'
-
-module Alephant::Views
-  @@views = {}
-
-  def self.register(klass)
-    id = klass.name.split('::').last
-    @@views[id.underscore] = klass
-  end
-
-  def self.get_registered_class(id)
-    @@views[id]
-  end
-end
-

data/lib/alephant/views/base.rb

@@ -1,16 +0,0 @@
-require 'mustache'
-
-module Alephant::Views
-  class Base < Mustache
-    attr_accessor :data
-
-    def initialize(data)
-      @data = data
-    end
-
-    def self.inherited(subclass)
-      ::Alephant::Views.register(subclass)
-    end
-  end
-end
-

data/lib/alephant/views/preview.rb

@@ -1,44 +0,0 @@
-require 'alephant/views/base'
-
-module Alephant
-  module Views
-    class Preview < Mustache
-      attr_accessor :regions
-
-      def initialize(regions, template_location)
-        @regions=regions
-        self.template_file = template_location
-      end
-
-      def static_host
-        ENV['STATIC_HOST'] || 'localhost:8000'
-      end
-
-      def method_missing(name, *args, &block)
-        return super unless respond_to? name.to_s
-        region @regions[name.to_s]
-      end
-
-      def respond_to?(method)
-        valid_regions.include? method.to_s
-      end
-
-      def region(components)
-        if components.kind_of?(Array)
-          components.join
-        else
-          components
-        end
-      end
-
-      def valid_regions
-        self.template.tokens.find_all { |token|
-          token.is_a?(Array) && token[0] == :mustache
-        }.map{ |token|
-          token[2][2][0].to_s
-        }
-      end
-
-    end
-  end
-end

data/lib/tasks/preview.rake

@@ -1,16 +0,0 @@
-require 'alephant/preview/server'
-require 'alephant/preview/template'
-
-namespace :alephant do
-  namespace :preview do
-    task :go do
-      Alephant::Preview::Server.run!
-    end
-    task :update do
-      Alephant::Preview::Template.update(
-        "#{::Alephant::Preview.path}/templates/preview.mustache"
-      )
-    end
-  end
-end
-

data/spec/cache_spec.rb

@@ -1,63 +0,0 @@
-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/logger_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Alephant::LogSystem do
-  before(:each) do
-    sequencer = double()
-    queue     = double()
-    cache     = double()
-    renderer  = double()
-
-    Alephant::Sequencer.stub(:create).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
-
-  after(:each) do
-    Alephant.logger = nil
-  end
-
-  let (:instance) { Alephant::Alephant }
-  subject { Alephant::LogSystem }
-
-  describe "::Alephant::LogSystem.logger" do
-    context "Logger not provided" do
-      it "return Ruby built-in Logger" do
-        instance.new
-        expect(Alephant.logger.class).to be(Logger)
-      end
-    end
-
-    context "Logger provided" do
-      it "return custom Logger" do
-        class FakeLogger; end
-        instance.new({}, FakeLogger.new)
-        expect(Alephant.logger.class).to be(FakeLogger)
-      end
-    end
-  end
-end
-

data/spec/multi_renderer_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe Alephant::MultiRenderer do
-  let(:component_id) { :foo }
-  let(:data) {{ :foo => :bar }}
-
-  subject { Alephant::MultiRenderer }
-
-  before(:each) do
-    File.stub(:directory?).and_return(true)
-  end
-
-  describe "initialize(view_base_path)" do
-    context "view_base_path = invalid_path" do
-      it "should raise InvalidViewPath" do
-        File.stub(:directory?).and_return(false)
-        expect {
-          subject.new(component_id, './invalid_path')
-        }.to raise_error(
-          Alephant::Errors::InvalidViewPath
-        )
-      end
-    end
-
-    context "view_base_path = '.'" do
-      it "sets base_path" do
-        expect(subject.new(component_id, '.').base_path).to eq("./#{component_id}")
-      end
-    end
-
-    context "view_base_path = nil" do
-      it "sets base_path" do
-        expect(subject.new(component_id).base_path).to eq(Alephant::MultiRenderer::DEFAULT_LOCATION)
-      end
-    end
-  end
-
-  describe "render_template(template_file, data, instance = nil)" do
-    context "instance is not nil" do
-      it "renders the specified template" do
-        Alephant::MultiRenderer.any_instance.stub(:create_instance)
-        Alephant::Renderer.any_instance.stub(:render).and_return('content')
-
-        expect(
-          subject.new(component_id, '.')
-          .render_template('foo', data)
-        ).to eq('content')
-      end
-    end
-  end
-
-  describe "render(data)" do
-    it "calls render_template for each template found" do
-      Alephant::MultiRenderer.any_instance.stub(:render_template)
-      Alephant::MultiRenderer.any_instance.stub(
-        :template_locations
-      ).and_return(['foo', 'bar'])
-
-      expect(
-        subject.new(component_id, '.').render(data).size
-      ).to eq(2)
-    end
-  end
-
-  describe "create_instance(template_file, data)" do
-    it "returns the model" do
-      model = subject.new(
-        component_id,
-        'fixtures/components'
-      ).create_instance('foo', data)
-
-      model.should be_an Alephant::Views::Base
-      expect(model.data).to eq(data)
-    end
-
-    context "invalid model" do
-      it 'should raise ViewModelNotFound' do
-        expect {
-          subject.new(
-            component_id,
-            @base_path
-          ).create_instance(
-            'invalid_model',
-            data
-          )
-        }.to raise_error(
-          Alephant::Errors::ViewModelNotFound
-        )
-      end
-    end
-  end
-end

data/spec/renderer_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe Alephant::Renderer do
-  let(:template_file) { 'foo' }
-  let(:base_path) { :base_path }
-  let(:model) { :model }
-  subject { Alephant::Renderer }
-
-  before(:each) do
-    @base_path = File.join(
-      File.dirname(__FILE__),
-      'fixtures',
-      'components',
-      'foo'
-    )
-  end
-
-  describe "initialize(template_file, base_path, model)" do
-    context "template_file = :template_file" do
-      it "sets the attribute template_file" do
-        expect(subject.new(template_file, base_path, model).template_file).to eq(template_file)
-      end
-    end
-  end
-
-  describe "template()" do
-    it "returns the template" do
-      instance = subject.new(template_file, @base_path, model)
-      template = instance.template
-      expect(template).to eq("{{content}}\n")
-    end
-
-    context 'invalid template' do
-      it 'should raise ViewTemplateNotFound' do
-        instance = subject.new('invalid_example', @base_path, model)
-
-        expect {
-          instance.template
-        }.to raise_error(
-          Alephant::Errors::ViewTemplateNotFound
-        )
-      end
-    end
-  end
-
-  describe "render()" do
-    it 'renders a template returned from template(template_file)' do
-      Mustache
-        .any_instance
-        .stub(:render)
-        .with(:template, :model)
-        .and_return(:content)
-
-      Alephant::Renderer
-        .any_instance
-        .stub(:template)
-        .and_return(:template)
-
-      expect(subject.new(template_file, @base_path, model).render).to eq(:content)
-    end
-  end
-end

data/spec/sequencer_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-
-describe Alephant::Sequencer do
-  let(:ident) { :ident }
-  let(:jsonpath) { :jsonpath }
-
-  describe ".create(table_name, ident, jsonpath)" do
-    it "should return a Sequencer" do
-      Alephant::Sequencer::SequenceTable.any_instance.stub(:create)
-      expect(subject.create(:table_name, ident, jsonpath)).to be_a Alephant::Sequencer::Sequencer
-    end
-  end
-
-  describe Alephant::Sequencer::Sequencer do
-    let(:data)     { double() }
-    let(:last_seen) { 42 }
-    let(:sequence_table) { double().tap { |o| o.stub(:create) } }
-    subject { Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath) }
-
-    describe "#initialize(opts, id)" do
-      it "sets @jsonpath, @ident" do
-        expect(subject.jsonpath).to eq(jsonpath)
-        expect(subject.ident).to eq(ident)
-      end
-
-      it "calls create on sequence_table" do
-        table = double()
-        table.should_receive(:create)
-
-        Alephant::Sequencer::Sequencer.new(table, ident, jsonpath)
-      end
-    end
-
-    describe "#get_last_seen" do
-      it "returns sequence_table.sequence_for(ident)" do
-        table = double()
-        table.stub(:create)
-        table.should_receive(:sequence_for).with(ident).and_return(:expected_value)
-
-        expect(
-          Alephant::Sequencer::Sequencer.new(table, ident).get_last_seen
-        ).to eq(:expected_value)
-      end
-    end
-
-    describe "#set_last_seen(data)" do
-      before(:each) do
-        Alephant::Sequencer::Sequencer.any_instance.stub(:sequence_id_from).and_return(last_seen)
-      end
-
-      it "calls set_sequence_for(ident, last_seen)" do
-        table = double()
-        table.stub(:create)
-        table.should_receive(:set_sequence_for).with(ident, last_seen)
-
-        Alephant::Sequencer::Sequencer.new(table, ident).set_last_seen(data)
-      end
-    end
-
-    describe "#sequential?(data, jsonpath)" do
-
-      before(:each) do
-        Alephant::Sequencer::Sequencer.any_instance.stub(:get_last_seen).and_return(1)
-        data.stub(:body).and_return('sequence_id' => id_value)
-      end
-
-      context "jsonpath = '$.sequence_id'" do
-        let(:jsonpath) { '$.sequence_id' }
-        subject { Alephant::Sequencer::Sequencer.new(sequence_table, :ident, jsonpath) }
-        context "sequential" do
-          let(:id_value) { 2 }
-          it "is true" do
-            expect(subject.sequential?(data)).to be_true
-          end
-        end
-
-        context "nonsequential" do
-          let(:id_value) { 0 }
-          it "is false" do
-            expect(subject.sequential?(data)).to be_false
-          end
-        end
-      end
-
-      context "jsonpath = nil" do
-        let(:jsonpath) { nil }
-        subject { Alephant::Sequencer::Sequencer.new(sequence_table, :ident, jsonpath) }
-
-        context "sequential" do
-          let(:id_value) { 2 }
-          it "is true" do
-            expect(subject.sequential?(data)).to be_true
-          end
-        end
-
-        context "nonsequential" do
-          let(:id_value) { 0 }
-          it "is false" do
-            expect(subject.sequential?(data)).to be_false
-          end
-        end
-      end
-
-    end
-  end
-end