luca 0.9.76 → 0.9.89

data/lib/generators/luca/application/application_generator.rb

@@ -10,16 +10,16 @@ module Luca
       argument :application_name, :type => :string, :default => "luca_app"
 
       def generate_controller
-        template "controller.rb", "app/controllers/#{application_name}_controller.rb"
+        template "controller.rb", "app/controllers/#{application_name.gsub(/-/,'_')}_controller.rb"
       end
 
       def generate_view
-        template "index.html.#{template_extension}", "app/views/#{application_name}/index.html.#{template_extension}"
+        template "index.html.#{template_extension}", "app/views/#{application_name.gsub(/-/,'_')}/index.html.#{template_extension}"
       end
 
       def generate_route
         sentinel = /\.routes\.draw do(?:\s*\|map\|)?\s*$/
-        routing_code = "get '/#{application_name}', :to => '#{application_name}#index'"
+        routing_code = "get '/#{application_name}', :to => '#{application_name.gsub(/-/,'_')}#index'"
 
         in_root do
           inject_into_file 'config/routes.rb', "\n  #{routing_code}\n", { :after => sentinel, :verbose => false }
@@ -27,18 +27,22 @@ module Luca
       end
 
       def generate_javascript
-        file_extension = javascript_extension == :coffee ? "js.coffee" : "js"
-        template "javascripts/application.#{file_extension}", "app/assets/javascripts/#{application_name}/application.#{file_extension}"
+        file_extension = "coffee"
+        template "javascripts/application.#{file_extension}", "app/assets/javascripts/#{application_name}/#{ application_name }_application.#{file_extension}"
         template "javascripts/dependencies.#{file_extension}", "app/assets/javascripts/#{application_name}/dependencies.#{file_extension}"
         template "javascripts/index.#{file_extension}", "app/assets/javascripts/#{application_name}/index.#{file_extension}"
-        template "javascripts/router.#{file_extension}", "app/assets/javascripts/#{application_name}/router.#{file_extension}"
-        template "javascripts/main.#{file_extension}", "app/assets/javascripts/#{application_name}/views/main.#{file_extension}"
+        template "javascripts/router.#{file_extension}", "app/assets/javascripts/#{application_name}/lib/router.#{file_extension}"
+        template "javascripts/collection_manager.#{file_extension}", "app/assets/javascripts/#{application_name}/lib/collection_manager.#{file_extension}"
         template "javascripts/config.#{file_extension}", "app/assets/javascripts/#{application_name}/config.#{file_extension}"
-        template "javascripts/main.jst.ejs", "app/assets/javascripts/#{application_name}/templates/main.jst.ejs"
+        template "javascripts/home.jst.ejs", "app/assets/javascripts/#{application_name}/templates/pages/home.jst.ejs"
         
         empty_directory_with_gitkeep("app/assets/javascripts/#{application_name}/models")
         empty_directory_with_gitkeep("app/assets/javascripts/#{application_name}/collections")
+        empty_directory_with_gitkeep("app/assets/javascripts/#{application_name}/views")
+        empty_directory_with_gitkeep("app/assets/javascripts/#{application_name}/lib")
         empty_directory_with_gitkeep("app/assets/javascripts/#{application_name}/util")
+
+        empty_directory_with_gitkeep("app/assets/stylesheets/#{application_name}")
       end
 
       private

data/lib/generators/luca/application/templates/controller.rb

@@ -1,6 +1,4 @@
 class <%= application_class_name %>Controller < ApplicationController
-
   def index
   end
-  
 end

data/lib/generators/luca/application/templates/index.html.erb

@@ -1,7 +1,19 @@
 <div id='viewport'></div>
 
 <script type="text/javascript">
+  /* 
+    the bootstrap is where you should include serialized
+    models that you want to be available to your collections on
+    page load.  A collection will look for an array of models
+    at the property returned by that collection's cache_key() property.
+  */
   window.<%= javascript_namespace %>Bootstrap = {};
+  
+  /*
+    the base params will be included as query parameters for
+    any RESTful call to the API made by your collections.
+  */
+  window.<%= javascript_namespace %>BaseParams = {};
 </script>
   
 <%%= javascript_include_tag "<%= application_name %>/dependencies", "<%= application_name %>" %>

data/lib/generators/luca/application/templates/index.html.haml

@@ -2,5 +2,6 @@
 
 :javascript
   window.<%= javascript_namespace %>Bootstrap = {};
+  window.<%= javascript_namespace %>BaseParams = {};
 
 = javascript_include_tag "<%= application_name %>/dependencies", "<%= application_name %>"

data/lib/generators/luca/application/templates/javascripts/application.coffee

@@ -0,0 +1,18 @@
+application = <%= javascript_namespace %>.register      "<%= javascript_namespace %>.Application"
+
+application.extends                                     "Luca.Application" 
+
+application.defines
+  components:[
+    type: 'controller'
+    name: 'pages'
+    components:[
+      name: "home"
+      template: "pages/home"
+    ]
+  ]
+  el: '#viewport'
+  autoBoot: false
+  name: '<%= javascript_namespace %>App'
+  router:             "<%= javascript_namespace %>.Router"
+  collectionManager:  "<%= javascript_namespace %>CollectionManager"

data/lib/generators/luca/application/templates/javascripts/collection_manager.coffee

@@ -0,0 +1,2 @@
+class <%= javascript_namespace %>.CollectionManager extends Luca.CollectionManager
+  name: "primary"

data/lib/generators/luca/application/templates/javascripts/config.coffee

@@ -0,0 +1,3 @@
+Luca.initialize '<%= javascript_namespace %>',
+  modelBootstrap: window.<%= javascript_namespace %>Bootstrap
+  baseParams: window.<%= javascript_namespace %>BaseParams

data/lib/generators/luca/application/templates/javascripts/dependencies.coffee

@@ -0,0 +1,3 @@
+#= require jquery
+#= require luca/dependencies
+#= require luca

data/lib/generators/luca/application/templates/javascripts/home.jst.ejs

@@ -0,0 +1,2 @@
+Welcome.
+<a href="http://datapimp.com/luca">View the Documentation</a>

data/lib/generators/luca/application/templates/javascripts/index.coffee

@@ -0,0 +1,15 @@
+#= require ./config
+#= require_tree ./util
+#= require_tree ./lib
+#= require_tree ./templates
+#= require_tree ./models
+#= require_tree ./collections
+#= require_tree ./views
+
+#= require ./<%= application_name.gsub(/-/,'_') %>_application
+
+#= require_self
+
+<%= javascript_namespace %>.onReady ->
+  window.<%= javascript_namespace %>CollectionManager = new <%= javascript_namespace %>.CollectionManager();
+  (window.<%= javascript_namespace %>App = new <%= javascript_namespace %>.Application()).boot();

data/lib/generators/luca/application/templates/javascripts/router.coffee

@@ -0,0 +1,4 @@
+_.def('<%= javascript_namespace %>.Router').extends('Luca.Router').with
+
+  routes:
+    "" : <%= javascript_namespace %>.route("home") 

data/lib/guard/luca.rb

@@ -0,0 +1,84 @@
+# Note:
+#
+# This is a WIP and does not provide much in the way of configuration at the moment.  It requires a running instance of 
+# Faye on port 9295, and a connection to redis.  I plan to make the Luca::Collection backend work against a file store
+# in the most simple case
+boot = File.join( Dir.pwd(), 'config', 'boot.rb' ) 
+environment = File.join( Dir.pwd(), 'config', 'environment.rb' ) 
+
+begin
+  ENV['RAILS_ENV'] ||= 'development'
+  require boot
+  require environment
+rescue
+  throw "Doesn't make sense using this outside of rails at the moment"
+end
+
+module Guard
+  class Luca < Guard
+    attr_accessor :faye_notifier, :project
+
+    def initialize(watchers=[],options={})
+      super
+      UI.info "Guard::Luca"
+      @faye_notifier = FayeNotifier.new(faye_url)
+      @project = ::Luca::Project.find_by_path( Dir.pwd() )
+
+      throw "Could not find a luca project in redis.  Create one for this path." unless @project
+    end
+
+    def start
+      UI.info "Guard::Luca has been started"
+    end
+
+    def generate_notification_payload_for(paths=[])
+      paths.compact.inject({}) do |memo,guard_path|
+        base = "stylesheets"
+        base = "javascripts" if guard_path.match(/(coffee|js|ejs.haml|mustache)$/)
+        path = File.join(".","app","assets", base , guard_path)
+        memo[path] = project.app.find_asset_wrapper_for(guard_path).to_change_notification
+        memo
+      end      
+    end
+
+    def faye_url
+      ENV['LUCA_CODE_SYNC_URL'] || "//localhost:9292/faye"
+    end
+
+    def run_on_changes(paths)
+      # temp
+      paths.map(&:downcase!)
+      notification_payload = generate_notification_payload_for(paths)
+      UI.info notification_payload.to_json
+      faye_notifier.publish("/changes", notification_payload )
+    end
+  end
+
+  class FayeNotifier
+    attr_reader :client, :url
+
+    def initialize url 
+      @url = url
+    end
+
+    def client
+      @client ||= ::Faye::Client.new(url)
+    end
+
+    def shutdown
+      EM.stop
+    end
+
+    def publish channel, message
+      EM.run do
+        UI.info "Publishing To #{ url }"
+        client = ::Faye::Client.new(url)
+        pub    = client.publish( channel, message )
+        pub.callback { EM.stop }
+        pub.errback { EM.stop }
+      end
+    end
+
+  end
+
+end

data/lib/luca.rb

@@ -1 +1,18 @@
-require 'luca/rails'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+module Luca
+  def self.base_path
+    File.join(File.dirname(__FILE__), '..')
+  end
+end
+
+require 'luca/rails'
+require 'luca/collection'
+require 'luca/asset_compiler'
+require 'luca/compiled_asset'
+require 'luca/component_definition'
+require 'luca/luca_application'
+require 'luca/project'
+require 'luca/project_harness'
+require 'luca/stylesheet'
+require 'luca/template_asset'
+require 'luca/test_harness'

data/lib/luca/asset_compiler.rb

@@ -0,0 +1,117 @@
+module Luca
+  class AssetCompiler
+    attr_accessor :type, :input, :file, :name
+
+    def initialize(options={})
+      @input    = options[:input]
+      @type     = options[:type] 
+      @name     = options[:name]
+
+      @file     = options[:file]
+
+      if file
+        @name ||= File.basename(file).split('.').first
+        @input ||= IO.read(file)
+      end
+    end
+
+    def output
+      @output ||= compiled
+    end
+
+    def compiled
+      compile_file_using_sprockets rescue compile_file_manually
+    end
+    
+    def filename
+      @filename ||= "#{ rand(36**16).to_s(36).slice(0,8) }__#{ name }#{ extension }"
+    end
+
+    protected
+      def compile_file_manually
+        return compile_file_using_sass if (type == "scss" or type == "sass")
+        return compile_file_using_coffeescript if (type == "coffeescript")
+        return compile_file_using_markdown if (type == "markdown")
+        return compile_template if template?
+      end
+
+      def compile_template
+        compile_file_using_sprockets
+      end
+
+      def compile_file_using_markdown
+        Redcarpet.new(input).to_html()  
+      end
+
+      def compile_file_using_sass
+        Sass.compile(input)
+      end
+
+      def compile_file_using_coffeescript
+        CoffeeScript.compile(input) rescue "//compile error: #{ $! }"
+      end
+
+      def base_type
+      end
+      
+      def extension
+        case type
+        when "coffeescript"
+          ".js.coffee"
+        when "less"
+          ".css.less"
+        when "scss"
+          ".css.scss"
+        when "haml"
+          ".html.haml"
+        when "mustache"
+          then ".mustache"
+        when "template"
+          then ".jst.ejs.haml"
+        end
+      end
+
+      def sprockets
+        return @sprockets if @sprockets
+
+        begin 
+          @sprockets = ::Rails.application.assets
+        rescue
+          @sprockets = Sprockets::Environment.new(".")
+        end
+        
+        @sprockets.prepend_path( temporary_folder )
+
+        @sprockets
+      end
+
+      def template?
+        type == "template" || type == "mustache"
+      end
+
+      def temporary_folder
+        File.join(::Rails.root,"tmp") rescue  "/tmp"
+      end
+
+
+      def compile_target
+        return @compile_target if @compile_target
+
+        @compile_target = File.join( temporary_folder, filename )
+        File.open("#{ compile_target }", 'w+') do |fh|
+          fh.puts(input)
+        end      
+
+        @compile_target
+      end
+
+      def compile_file_using_sprockets
+        begin
+          asset = sprockets.find_asset(File.basename(compile_target))
+          @output = asset.to_s
+        ensure
+          FileUtils.rm( compile_target )
+        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