alephant 0.0.9.9.1-java → 0.1.1-java

data/lib/alephant/models/logger.rb

@@ -1,22 +0,0 @@
-require 'logger'
-
-module Alephant
-  def self.logger
-    ::Alephant::LogSystem.logger
-  end
-
-  def self.logger=(value)
-    ::Alephant::LogSystem.logger = value
-  end
-
-  class LogSystem
-    def self.logger
-      @logger ||= Logger.new(STDOUT)
-    end
-
-    def self.logger=(value)
-      @logger = value
-    end
-  end
-end
-

data/lib/alephant/models/multi_renderer.rb

@@ -1,84 +0,0 @@
-module Alephant
-  class MultiRenderer
-    DEFAULT_LOCATION = 'components'
-
-    def initialize(component_id, view_base_path=nil)
-      self.base_path = "#{view_base_path}/#{component_id}" unless view_base_path.nil?
-      @component_id = component_id
-      @logger = ::Alephant.logger
-    end
-
-    def base_path
-      @base_path || DEFAULT_LOCATION
-    end
-
-    def base_path=(path)
-      @base_path = File.directory?(path) ? path : (raise Errors::InvalidViewPath)
-    end
-
-    def render(data)
-      template_locations.reduce({}) do |obj, file|
-        template_id = template_id_for file
-        @logger.info("MultiRenderer.render: attempting to render #{template_id}")
-
-        obj.tap do |o|
-          o[template_id.to_sym] = render_template(
-            template_id,
-            data
-          )
-        end
-      end
-    end
-
-    def render_template(template_file, data)
-      @logger.info("MultiRenderer.render_template: rendering template #{template_file} (base_path: #{base_path})")
-      renderer(
-        template_file,
-        base_path,
-        data
-      ).render
-    end
-
-    def renderer(template_file, base_path, data)
-      Renderer.new(template_file, base_path, create_instance(template_file, data))
-    end
-
-    def create_instance(template_file, data)
-      begin
-        create_model(template_file, data)
-      rescue Exception => e
-        @logger.error("MultiRenderer.create_instance: exeception #{e.message}")
-        raise Errors::ViewModelNotFound
-      end
-    end
-
-    private
-    def create_model(template_file, data)
-      require model_location_for template_file
-      klass = Views.get_registered_class("#{template_file}")
-
-      @logger.info("MultiRenderer.create_model: creating new klass #{klass}")
-      klass.new(data)
-    end
-
-    def model_location_for(template_file)
-      @logger.info("MultiRenderer.model_location_for(#{template_file})")
-      File.join(base_path, 'models', "#{template_file}.rb")
-    end
-
-   def template_locations
-      @logger.info("MultiRenderer.template_locations: locating templates in #{template_base_path}")
-      Dir[template_base_path]
-    end
-
-    def template_base_path
-      "#{base_path}/templates/*"
-    end
-
-    def template_id_for(template_location)
-      @logger.info("MultiRenderer.template_id_for(#{template_location})")
-      template_location.split('/').last.sub(/\.mustache/, '')
-    end
-
-  end
-end

data/lib/alephant/models/renderer.rb

@@ -1,34 +0,0 @@
-require 'aws-sdk'
-require 'mustache'
-
-module Alephant
-  class Renderer
-    attr_reader :template_file
-
-    def initialize(template_file, base_path, model)
-      @logger        = ::Alephant.logger
-      @template_file = template_file
-      @base_path     = base_path
-      @model         = model
-      @logger.info("Renderer.initialize: end with @base_path set to #{@base_path}")
-    end
-
-    def render
-      @logger.info("Renderer.render: rendered template #{template_file}")
-
-      Mustache.render(template, @model)
-    end
-
-    def template
-      template_location = File.join(@base_path, 'templates', "#{template_file}.mustache")
-
-      begin
-        @logger.info("Renderer.template: #{template_location}")
-        File.open(template_location).read
-      rescue Exception => e
-        @logger.error("Renderer.template: view template #{template_file} not found")
-        raise Errors::ViewTemplateNotFound
-      end
-    end
-  end
-end

data/lib/alephant/models/sequence_table.rb

@@ -1,99 +0,0 @@
-require 'aws-sdk'
-require 'thread'
-require 'timeout'
-
-module Alephant
-  module Sequencer
-    class SequenceTable
-      attr_reader :table_name
-
-      TIMEOUT = 120
-      DEFAULT_CONFIG = {
-        :write_units => 5,
-        :read_units => 10,
-      }
-      SCHEMA = {
-        :hash_key => {
-          :key => :string,
-          :value => :string
-        }
-      }
-
-      def initialize(table_name, config = DEFAULT_CONFIG)
-        @mutex = Mutex.new
-        @dynamo_db = AWS::DynamoDB.new
-        @table_name = table_name
-        @config = config
-      end
-
-      def create
-        @mutex.synchronize do
-          ensure_table_exists
-          ensure_table_active
-        end
-      end
-
-      def table
-        @table ||= @dynamo_db.tables[@table_name]
-      end
-
-      def sequence_for(ident)
-        rows = batch_get_value_for(ident)
-        rows.count >= 1 ? rows.first['value'].to_i : 0
-      end
-
-      def set_sequence_for(ident,value)
-        @mutex.synchronize do
-          AWS::DynamoDB::BatchWrite.new.tap { |batch|
-            batch.put(
-              table_name,
-              [:key => ident,:value => value]
-            )
-          }.process!
-        end
-      end
-
-      def delete_item!(ident)
-        table.items[ident].delete
-      end
-
-      private
-      def batch_get_value_for(ident)
-        table.batch_get(['value'],[ident],batch_get_opts)
-      end
-
-      def batch_get_opts
-        { :consistent_read => true }
-      end
-
-      def ensure_table_exists
-        create_dynamodb_table unless table.exists?
-      end
-
-      def ensure_table_active
-        sleep_until_table_active unless table_active?
-      end
-
-      def create_dynamodb_table
-        @table = @dynamo_db.tables.create(
-          @table_name,
-          @config[:read_units],
-          @config[:write_units],
-          SCHEMA
-        )
-      end
-
-      def table_active?
-        table.status == :active
-      end
-
-      def sleep_until_table_active
-        begin
-          Timeout::timeout(TIMEOUT) do
-            sleep 1 until table_active?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/alephant/models/sequencer.rb

@@ -1,61 +0,0 @@
-require 'jsonpath'
-
-module Alephant
-  module Sequencer
-    @@sequence_tables = {}
-
-    def self.create(table_name, ident, jsonpath = nil)
-      @@sequence_tables[table_name] ||= SequenceTable.new(table_name)
-      Sequencer.new(@@sequence_tables[table_name], ident, jsonpath)
-    end
-
-    class Sequencer
-      attr_reader :ident, :jsonpath
-
-      def initialize(sequence_table, id, sequence_path = nil)
-        @mutex = Mutex.new
-        @sequence_table = sequence_table
-        @jsonpath = sequence_path
-        @ident = id
-
-        ::Alephant.logger.info("Sequencer.initialize: with id #{@ident}")
-        @sequence_table.create
-      end
-
-      def sequential?(data)
-        get_last_seen < sequence_id_from(data)
-      end
-
-      def delete!
-        @sequence_table.delete_item!(ident)
-      end
-
-      def set_last_seen(data)
-        last_seen_id = sequence_id_from(data)
-
-        @sequence_table.set_sequence_for(ident, last_seen_id)
-        ::Alephant.logger.info("Sequencer.set_last_seen: #{ident}:#{last_seen_id}")
-      end
-
-      def get_last_seen
-        @sequence_table.sequence_for(ident)
-      end
-
-      private
-      def sequence_id_from(data)
-        jsonpath.nil? ?
-          default_sequence_id_for(data) :
-          sequence_from_jsonpath_for(data)
-      end
-
-      def sequence_from_jsonpath_for(data)
-        JsonPath.on(data.body, jsonpath).first
-      end
-
-      def default_sequence_id_for(data)
-        data.body['sequence_id'].to_i
-      end
-
-    end
-  end
-end

data/lib/alephant/preview/server.rb

@@ -1,75 +0,0 @@
-require 'sinatra/base'
-require 'alephant/models/parser'
-require 'alephant/models/multi_renderer'
-require 'alephant/views/preview'
-require 'faraday'
-require 'json'
-require 'uri'
-
-module Alephant
-  module Preview
-    class Server < Sinatra::Base
-
-      get '/preview/:id/:template/:region/?:fixture?' do
-        render_preview
-      end
-
-      get '/component/:id/:template/?:fixture?' do
-        render_component
-      end
-
-      def render_preview
-        ::Alephant::Views::Preview.new(
-          { region => render_component },
-          preview_template_location
-        ).render
-      end
-
-      def render_component
-        MultiRenderer.new(id, base_path).render_template(template, fixture_data)
-      end
-
-      private
-
-      def template
-        params['template']
-      end
-
-      def region
-        params['region']
-      end
-
-      def id
-        params['id']
-      end
-
-      def fixture
-        params['fixture'] || id
-      end
-
-      def fixture_data
-        parser.parse raw_fixture_data
-      end
-
-      def raw_fixture_data
-        File.open(fixture_location).read
-      end
-
-      def parser
-        @parser ||= Parser.new
-      end
-
-      def base_path
-        "#{Dir.pwd}/components"
-      end
-
-      def fixture_location
-        "#{base_path}/#{id}/fixtures/#{fixture}.json"
-      end
-
-      def preview_template_location
-        "#{::Alephant::Preview.path}/templates/preview.mustache"
-      end
-    end
-  end
-end

data/lib/alephant/preview/template.rb

@@ -1,63 +0,0 @@
-require 'faraday'
-require 'uri'
-
-module Alephant
-  module Preview
-
-    def self.path
-      "#{Dir.pwd}/components/lib"
-    end
-
-    class Template
-
-      def self.update(template_location)
-        self.new.update(template_location)
-      end
-
-      def template
-        response = Faraday.new(:url => host).get(path)
-        raise "Can't get template" if response.status != 200
-
-        apply_static_host_regex_to response.body
-      end
-
-      def update(template_location)
-        File.open(template_location, 'w') { |file|
-          file.write(template)
-        }
-      end
-
-      def host
-        "#{uri.scheme}://#{uri.host}"
-      end
-
-      def path
-        uri.path
-      end
-
-      def uri
-        return @uri if not @uri.nil?
-
-        uri_from_env = ENV['PREVIEW_TEMPLATE_URL']
-        raise Exception.new("PREVIEW_TEMPLATE_URL is unset!") if uri_from_env.nil?
-
-        @uri = URI(uri_from_env)
-      end
-
-      def apply_static_host_regex_to(string)
-        string.gsub(static_host_regex, '{{{static_host}}}')
-      end
-
-      def static_host_regex
-        return @static_host_regex if not @static_host_regex.nil?
-
-        static_host_regex_from_env = ENV['STATIC_HOST_REGEX']
-        raise Exception.new("STATIC_HOST_REGEX is unset!") if static_host_regex_from_env.nil?
-
-        @static_host_regex = Regexp.new(static_host_regex_from_env)
-      end
-    end
-  end
-end
-
-