luca 0.9.76 → 0.9.89

data/lib/luca/collection/endpoint.rb

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

data/lib/luca/component_definition.rb

@@ -0,0 +1,338 @@
+require 'rubygems'
+require 'redcarpet'
+
+module Luca
+  class ComponentDefinition
+    attr_accessor :source, :markdown
+
+    ARGUMENTS_REGEX = /^\w+\:\s*\((.+)\)/
+
+    def initialize source 
+      @source     = source
+      read_source()
+    end
+
+    def read_source
+      raise "Invalid source type" unless source.match(/.coffee|.js/)
+      @contents   = IO.read(source)
+    end
+
+    def update contents
+    #  File.open(source,'w+') do |fh|
+    #    fh.puts(contents)
+    #  end
+    end
+
+    def to_change_notification
+      as_json(compile:true, include_contents:true)
+    end
+
+    def as_json options={} 
+      base = {
+        source: source,
+        defined_in_file: source,
+        type: "javascript"
+      }
+
+      unless class_name.nil?
+        base.merge!({ :class_name           => class_name,
+                      :defined_in_file      => source,
+                      :header_documentation => header_documentation,
+                      :type_alias           => type_alias,
+                      :type                 => "component_definition",
+                      :css_class_identifier => css_class_identifier,
+                      :defines_methods      => method_definition_map,
+                      :defines_properties   => property_definition_map })
+      end
+
+      if options[:include_contents]
+        base.merge!(:source_file_contents => contents)
+      end
+
+      if options[:compile]
+        base.merge!(:compiled => compiled_contents)
+      end
+
+      base
+    end
+
+    def method_definition_map
+      defines_methods.inject({}) do |memo, meth|
+        definition_line = find_definition_of(meth)
+        memo[meth] = {
+          defined_on_line: definition_line.line_number,
+          documentation: documentation_for(meth) || "",
+          arguments: argument_information_for(meth)        
+        } 
+        memo
+      end
+    end
+
+    def property_definition_map
+      defines_properties.inject({}) do |memo,property|
+        definition_line = find_definition_of(property)
+        memo[property] = {
+          defined_on_line: definition_line.line_number,
+          documentation: documentation_for(property),
+          default: ''
+        }
+        memo
+      end
+    end
+
+    def argument_information_for method
+      information = []
+      definition = find_definition_of(method).line.strip
+
+      if arguments  = definition.match(ARGUMENTS_REGEX)
+        arguments = arguments.to_a[1]
+        information = arguments.split(',').map(&:strip).inject(information) do |memo, argument|
+          parts = argument.split('=').map(&:strip)
+          memo << {:argument=>parts[0],:value=>parts[1]}
+        end
+      end
+
+      information
+    end
+
+    def valid?
+      !class_name.nil?
+    end
+
+    def parse
+    end
+
+    def contents
+      @contents.to_s
+    end
+
+    def compiler
+      AssetCompiler.new(input: contents, type: "coffeescript")
+    end
+
+    def compiled
+      compiled_contents
+    end
+
+    def compiled_contents
+      compiler.output
+    end 
+
+    def type_alias
+      classified = class_name && class_name.split('.').last
+      classified && classified.underscore
+    end
+
+    def view_based?
+      extends && !(
+        extends.match('.models.') || 
+        extends.match('.collections.') || 
+        extends.match(/Collection$/) || 
+        extends.match(/Model$/)
+        )
+    end
+
+    def css_class_identifier
+      return '' unless view_based?
+
+      parts = class_name.split('.')
+      parts -= ['views','components'] 
+
+      parts.map!(&:underscore)
+      parts.map!(&:dasherize)
+
+      parts.join('-')
+    end
+
+    def extends
+      extends_line.split(' ').last.gsub(/"|'/,'')
+    end
+
+    def class_name 
+      match = definition_line && definition_line.match(/register.*["|'](.*)["|']/)
+      match && match[1]
+    end
+
+    def component_definition
+      self
+    end
+
+    def lines
+      line_number = 0
+      contents.lines.map do |line|
+        Line.new(line, (line_number += 1) )
+      end
+    end
+
+    def extends_line
+      match = lines.detect do |line|
+        line.component_extension?(definition_proxy_variable_name)
+      end
+
+      match && match.strip
+    end
+
+    def documentation_for method_or_property, compile=true
+      comment_lines = find_comments_above(method_or_property).collect(&:line)
+      comments = comment_lines.map do |comment_line|
+        comment_line.gsub(/\A\s*\#/,'').strip
+      end
+
+      data = comments.reverse.join("\n")
+
+      docs = if compile == true
+        self.class.markdown.render(data) rescue data
+      end
+
+      docs
+    end
+
+    def header_documentation
+      header_comments(true)
+    end
+
+    def header_comment_lines
+      header_lines  = lines[ (0..(definition_line.line_number || 0) ) ]
+      comments      = header_lines.select(&:comment?).map(&:line)
+      
+      comments.map! {|line| line.gsub(/\A\s*\#[\ |\n]/,'') }
+      comments.reject! {|line| line.match(/\=\s*require/) }
+
+      comments
+    end
+
+    def header_comments compile=true
+      combined = header_comment_lines.join("")
+
+      if compile
+        compiled = Redcarpet.new(combined).to_html rescue combined 
+      else
+        combined
+      end
+    end
+
+    def find_comments_above method_or_property
+      comment_lines = []
+      if line = find_definition_of( method_or_property )
+        line_number = line.line_number
+        indentation_level = line.indentation_level        
+
+        next_line = find_line_by_number( line_number -= 1)
+        while !next_line.nil? && next_line.indentation_level == indentation_level && next_line.comment?
+          comment_lines << next_line
+          next_line = find_line_by_number( line_number -= 1)
+        end
+      end
+
+      comment_lines
+    end
+
+    def definition_proxy_variable_name
+      definition_line.split('=').first.strip
+    end
+
+    def find_line_by_number line_number=1
+      lines.detect {|line| line.line_number == line_number }
+    end
+
+    def definition_line
+      lines.detect do |line|
+        !line.comment? && line.component_definition?
+      end
+    end
+
+    def defines
+      lines.select(&:defines_property_or_method?).collect(&:defines)
+    end
+
+    def defines_methods
+      lines.select(&:defines_method?).collect(&:defines)
+    end
+
+    def find_definition_of method_or_property
+      lines.select(&:defines_property_or_method?).detect {|line| line.defines && line.defines.length > 0 && line.defines == method_or_property }
+    end
+
+    def defines_properties
+      lines.select(&:defines_property?).collect(&:defines)
+    end
+
+    class Line
+      attr_accessor :line, :line_number, :found_in
+
+      def initialize(line,line_number)
+        @line = line
+        @line_number = line_number
+      end
+
+      def match pattern
+        line.match(pattern)
+      end
+
+      def split delimiter
+        line.split(delimiter)
+      end
+
+      def strip
+        line.strip 
+      end
+
+      def details
+        {
+          type:                 type,
+          line_number:          line_number,
+          indentation_level:    indentation_level 
+        }
+      end
+
+      def indentation_level
+        space_count = if match = line.match(/\A */)[0] and match.length > 0
+          match.length
+        else
+          0
+        end
+
+        space_count / 2
+      end
+
+      def defines_method?
+        !comment? && indentation_level == 1 && line.match(/\s*\w+\:\s*\(.*\)/)      
+      end
+
+      def comment?
+        line.match(/^(\s*)\#/) or line == "#\n"
+      end
+
+      def defines_property?
+        !comment? && !defines_method? && indentation_level == 1 && line.match(/\s*\w+\:.*\w/)
+      end
+
+      def body?
+        indentation_level == 1 && line.match(/^\s+/)
+      end
+
+      def component
+        found_in
+      end
+
+      def component_definition?
+        line.match(/[A-Z].+\.register/)
+      end
+
+      def component_extension?(proxy)
+        line.include?("#{ proxy }.extends") 
+      end    
+
+      def defines_property_or_method?
+        defines_method? || defines_property?
+      end
+
+      def defines
+        if defines_property_or_method? 
+          line.split(':').first.strip
+        end
+      end
+    end
+
+  end  
+end