luca 0.9.8 → 0.9.9

data/lib/luca/cli/sync.rb

@@ -0,0 +1,40 @@
+module Luca
+  module Cli
+    class Sync < Thor
+      namespace :sync  
+
+      method_options :namespace => :string
+      method_option :port, :default => 9292 
+      method_option :timeout, :default => 25 
+      method_option :channel, :default => "faye"
+      method_option :root, :default => Dir.pwd()
+
+      desc "sync", "sync APPLICATION_NAME [options]" 
+      def sync application_name
+        fork do
+          watch(application_name)  
+        end
+
+        fork do
+          server(application_name)
+        end
+
+        Process.waitpid
+      end
+
+      no_tasks do
+        def watch application_name
+          puts "Watching application assets for changes..."
+          watcher = Luca::Watcher.new(application_name, options)
+          watcher.start
+        end        
+
+        def server application_name
+          puts "Running code sync faye process on channel #{ options[:channel] } port #{ options[:port] }"
+          process = Luca::Server.new(:mount=>"/#{ options[:channel] }",:timeout=>options[:timeout])
+          process.listen(options[:port])
+        end      
+      end
+    end
+  end
+end

data/lib/luca/cli/watch.rb

@@ -0,0 +1,16 @@
+module Luca
+  module Cli
+    class Watch < Thor
+      namespace :watch
+
+      desc "watch", "watch APPLICATION_NAME [options]"
+      method_options :name => :string
+      method_option :root, :default => Dir.pwd()
+
+      def watch application_name
+        watcher = Luca::Watcher.new(application_name, options)
+        watcher.start
+      end
+    end
+  end
+end

data/lib/luca/collection.rb

@@ -0,0 +1,64 @@
+# 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/collection/endpoint.rb

@@ -0,0 +1,38 @@
+require 'sinatra/base'
+module Luca
+  class Collection
+    class Endpoint < Sinatra::Base
+      # Index
+      get "/collections/:namespace" do  
+        @collection = Luca::Collection.new(namespace: params[:namespace])
+        @collection.index.to_json
+      end
+
+      # Show
+      get "/collections/:namespace/:id" do
+        @collection = Luca::Collection.new(namespace: params[:namespace])
+        @collection.show( params[:id] ).to_json
+      end
+
+      # Create
+      post "/collections/:namespace" do
+        @collection = Luca::Collection.new(namespace: params[:namespace])
+        payload = JSON.parse( request.body.read.to_s )
+        @collection.create(payload).to_json
+      end
+
+      # Update
+      put "/collections/:namespace/:id" do
+        @collection = Luca::Collection.new(namespace: params[:namespace])
+        payload = JSON.parse( request.body.read.to_s )
+        @collection.update(payload).to_json
+      end
+
+      # Destroy
+      delete "/collections/:namespace/:id" do
+        @collection = Luca::Collection.new(namespace: params[:namespace])
+        @collection.destroy(params).to_json
+      end
+    end
+  end
+end

data/lib/luca/collection/file_backend.rb

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,153 @@
+# 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/compiled_asset.rb

@@ -0,0 +1,61 @@
+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