luca 0.9.9 → 0.9.42

data/lib/luca/collection/file_backend.rb

@@ -1,121 +0,0 @@
-module Luca
-  class Collection
-    class FileBackend
-
-      attr_accessor :namespace,
-                    :required_attributes,
-                    :file_storage,
-                    :record_storage,
-                    :data_dir
-
-      def initialize options={}
-        @options              = options.dup
-        @namespace            = options[:namespace]
-        @required_attributes  = options[:required_attributes]
-        @data_dir             = options[:data_dir] || File.join(::Rails.root, "db", "collections")
-
-        unless File.exists?( file_storage_location )
-          FileUtils.mkdir_p(data_dir)
-   
-          flush_storage_to_disk
-        end
-
-        read_storage_from_disk
-      end
-
-      def flush_storage_to_disk
-        File.open(file_storage_location, 'w+') do |fh|
-          payload = JSON.generate(record_storage)
-          fh.puts(payload)
-        end
-      end
-
-      def read_storage_from_disk
-        data = IO.read( file_storage_location )  
-        @record_storage = JSON.parse(data)
-      end
-
-      def file_storage_location
-        File.join(data_dir, "#{ namespace }.json")
-      end
-
-      def sync method, hash={}, options={}
-        if method == "read" and hash[:id].nil?
-          return index()
-        end
-
-        if method == "read" and !hash[:id].nil?
-          return show( hash[:id] )
-        end
-
-        if method == "create"
-          return create( hash )
-        end
-
-        if method == "update"
-          return update( hash )
-        end
-
-        if method == "delete"
-          return destroy( hash )
-        end
-      end
-
-      alias_method :backbone_sync, :sync  
-
-      def record_storage
-        @record_storage ||= {
-          :namespace => namespace,
-          :id_counter => 0,
-          :records => []
-        }       
-
-        @record_storage.symbolize_keys!
-        @record_storage
-      end
-
-      def records
-        Array(record_storage[:records])
-      end
-
-      def index
-        records
-      end
-
-      def show id
-        record = records.detect {|r| r[:id].to_s == id.to_s }
-        record.symbolize_keys!
-        record
-      end
-
-      def allocate_id
-        record_storage[:id_counter] += 1  
-      end
-
-      def create attributes={}
-        attributes.symbolize_keys!
-        attributes[:id] ||= allocate_id 
-        records << attributes
-        flush_storage_to_disk
-        {success:true,id:attributes[:id],record:attributes} 
-      end
-
-      def update attributes={}
-        attributes.symbolize_keys!
-        record = show(attributes[:id])
-        record.merge! attributes
-        flush_storage_to_disk
-        {success:true,record:record} 
-      end
-
-      def destroy id
-        records.reject! do |record|
-          record[:id] == id
-        end
-        flush_storage_to_disk
-        {success:true}
-      end
-
-    end
-  end
-end

data/lib/luca/collection/redis_backend.rb

@@ -1,153 +0,0 @@
-# This is intended to provide a cheap, throw-away persistence solution
-# for luca collections.  Based on redis.
-#
-# it provides a Backbone.sync adapter and API endpoint for accessing it.  
-#
-# It is used to make luca.collections persistent for
-# multiple users.  Not intended to be used in production or for any apps
-# which require data integrity. 
-
-require 'json'
-
-module Luca
-  class Collection
-    class RedisBackend
-
-      def self.default_redis
-        require 'redis'
-        @default_redis ||= Redis.new host: "localhost", port: 6379, db: 5
-      end
-
-      attr_accessor :namespace, 
-                    :redis, 
-                    :id_storage, 
-                    :required_attributes, 
-                    :redis_database
-
-      def initialize options={}
-        @namespace            = options[:namespace].to_s
-        @redis                = options[:redis] || Luca::Collection::RedisBackend.default_redis
-        @id_storage           = options[:id_storage] ||= "#{ @namespace }:ids"
-        @required_attributes  = options[:required_attributes] || []
-
-        validate_redis_connection
-      end
-
-      def sync method, hash={}, options={}
-        if method == "read" and !hash[:id].nil?
-          return index()
-        end
-
-        if method == "read" and !hash[:id].nil?
-          return show( hash[:id] )
-        end
-
-        if method == "create"
-          return create( hash )
-        end
-
-        if method == "update"
-          return update( hash )
-        end
-
-        if method == "delete"
-          return destroy( hash )
-        end
-      end
-
-      alias_method :backbone_sync, :sync  
-
-      def validate_redis_connection
-        unless @redis
-
-        end
-
-        unless @redis.respond_to?(:get) and @redis.respond_to?(:incr) and @redis.respond_to?(:mget)
-          throw "Must specify a valid redis instance."      
-        end
-      end
-
-      def record_ids
-        Array(redis.smembers( id_storage )).map {|id| "#{ namespace }/#{ id }"}
-      end
-
-      def clear!
-        return unless record_ids.length > 0
-        redis.del( *record_ids )
-        redis.del( id_storage ) 
-      end
-
-      def generate_id id_base=nil
-        id_base ||= id_storage
-        redis.incr("next:#{ id_base }:id")
-      end
-
-      def index search=nil
-        return [] unless record_ids.length > 0
-        
-        redis.mget( *record_ids ).map {|serialized| JSON.parse(serialized) rescue nil }.compact
-      end
-
-      def show id
-        record = redis.get("#{ namespace }/#{ id }")
-        JSON.parse( record ) if record
-      end
-
-      def create hash
-        hash.symbolize_keys!
-
-        if required_attributes.any? {|attribute| hash[attribute].nil?}
-          return {success: false, error:"Missing required attributes."}
-        end 
-
-        next_id = hash[:id] ||= generate_id 
-
-        serialized = JSON.generate(hash)
-        response = redis.set "#{ namespace }/#{ next_id }", serialized 
-
-        if response == "OK"
-          redis.sadd id_storage, hash[:id]
-          return {success: true, id: hash[:id], record: hash}
-        else
-          return {success: false, error:"Error adding record in data store."}
-        end  
-      end
-
-      def destroy hash
-        hash.symbolize_keys!
-
-        stored = redis.get("#{ namespace }/#{ hash[:id] }")  
-
-        if stored
-          redis.del "#{ namespace }/#{ hash[:id] }" 
-          return {success: true}
-        else
-          return {success: false, error:"Could not find record with #{ hash[:id] }"}
-        end
-      end
-
-      def update hash
-        hash.symbolize_keys!
-
-        if required_attributes.any? {|attribute| hash[attribute].nil?}
-          return {success: false, error:"Missing required attributes."}
-        end 
-
-        stored = redis.get("#{ namespace }/#{ hash[:id] }")  
-
-        if stored.nil?
-          return {success: false, error:"Could not find record with #{ hash[:id] }"}
-        end
-
-        serialized = JSON.generate(hash)
-        result = redis.set "#{ namespace }/#{ hash[:id] }", serialized
-
-        if result == "OK"
-          return {success: true}
-        else
-          return {success: false, error:"Error adding record in data store."}
-        end        
-      end
-    end
-  end  
-end

data/lib/luca/collection.rb

@@ -1,64 +0,0 @@
-# The Luca::Collection can be exposed via a Rack based Luca::Collection::Endpoint.
-# It allows for a cheap persistence mechanism to support front end Luca.Collection objects.
-module Luca
-  class Collection
-    require 'luca/collection/redis_backend'
-    require 'luca/collection/file_backend'
-    require 'luca/collection/endpoint'
-
-    attr_accessor :backend,
-                  :options,
-                  :namespace
-
-    def initialize options={}
-      @options    = options.dup
-      @backend    = options[:backend]
-      @namespace  = options[:namespace]
-
-      setup_backend
-    end    
-
-    def sync method, hash={}, options={}
-      backend.sync(method, hash, options)
-    end
-
-    def index
-      backend.index
-    end
-
-    def create hash={}
-      backend.create(hash)
-    end
-
-    def update hash={}
-      backend.update(hash)
-    end
-
-    def show id
-      backend.show(id)
-    end
-
-    def destroy id
-      backend.destroy(id)
-    end
-
-    protected
-      def setup_backend
-        if backend.nil?
-          if options[:backend] == "file"
-            self.backend = Luca::Collection::FileBackend.new(namespace: namespace)
-          end
-
-          if options[:backend] == "redis"
-            self.backend = Luca::Collection::RedisBackend.new(namespace: namespace)
-          end  
-
-          if backend.nil? and defined?(Redis)
-            self.backend = Luca::Collection::RedisBackend.new(namespace: namespace)
-          else
-            self.backend = Luca::Collection::FileBackend.new(namespace: namespace)
-          end
-        end        
-      end
-  end
-end

data/lib/luca/compiled_asset.rb

@@ -1,61 +0,0 @@
-module Luca
-  class CompiledAsset
-    class << self
-      attr_accessor :coffeescript_assets,
-                    :sass_assets,
-                    :scss_assets,
-                    :less_assets,
-                    :markdown_assets,
-                    :asset_stores_setup
-    end
-
-    self.asset_stores_setup = false
-
-    def self.setup_asset_stores
-      return if self.asset_stores_setup == true
-      
-      self.coffeescript_assets  = Luca::Collection.new(namespace:"coffeescripts",backend:"file")
-      self.sass_assets          = Luca::Collection.new(namespace:"sass_stylesheets",backend:"file")
-      self.scss_assets          = Luca::Collection.new(namespace:"scss_stylesheets",backend:"file")
-      self.less_assets          = Luca::Collection.new(namespace:"less_stylesheets",backend:"file")
-      self.markdown_assets      = Luca::Collection.new(namespace:"markdown_assets",backend:"file")
-      self.asset_stores_setup = true
-    end
-
-    attr_accessor :type, :asset 
-
-    def initialize type, asset 
-      CompiledAsset.setup_asset_stores
-      @type = type
-      @asset = asset
-    end
-
-    def compiler
-      @compiler ||= AssetCompiler.new(input: asset['input'], type: type)
-    end
-
-    def output
-      compiler.output
-    end
-
-    def mime_type
-      if type == "coffeescript" || type == "haml" || type == "mustache"
-        "text/javascript"
-      elsif type == "markdown"
-        "text/html"
-      else
-        "text/css"
-      end
-    end
-
-    def self.find_by_type_and_id type, id
-      if ["markdown", "haml","coffeescript","sass","scss","less"].include?(type)
-        asset = self.send("#{ type }_assets".to_sym)
-        asset = asset && asset.show(:id)
-        if !asset.nil?
-          new(type, asset)
-        end
-      end
-    end
-  end
-end