luca 0.9.76 → 0.9.89

data/lib/luca/luca_application.rb

@@ -0,0 +1,247 @@
+module Luca
+  class LucaApplication
+    attr_accessor :application_name,
+                  :options
+
+
+
+    # Public: creates an instance of a luca application repository.
+    # generally this will be a single folder inside of your asset pipeline
+    #
+    # Example:
+    #   repo = LucaApplication.new("Tools",root:"/path/to/rails/app") 
+    def initialize application_name, options={}
+      @application_name = application_name
+      @options = options
+    end
+
+    def export
+      contents = export_all_component_definitions.to_json
+      File.open(export_file_location, 'w+') do |fh|
+        fh.puts( contents ) 
+      end
+      contents
+    end
+
+    def export_file_location
+      File.join(Luca.base_path,"docs","framework.json")
+    end
+
+    def export_all_component_definitions 
+      list = component_definitions.map do |cdef|
+        cdef.as_json rescue nil
+      end  
+      list.compact
+    end
+
+    def component_definition_filemap 
+      component_definitions.inject({}) do |memo, definition|
+        memo[ definition.class_name ] = definition.source
+        memo
+      end
+    end
+
+    def find_asset_wrapper_for filename
+      if filename.match(/\.js$/) || filename.match(/\.coffee$/)
+        wrapper = component_definitions(false).detect do |component_definition|
+          component_definition.source && 
+          component_definition.source.match(filename)
+        end
+      end
+
+      if filename.match(/\.mustache/) || filename.match(/\.jst/)
+        wrapper = templates.detect do |template|
+          template.source && template.source.match(filename)
+        end  
+      end
+
+      if filename.match(/css|sass|less/)
+        wrapper = stylesheets.detect do |stylesheet|
+          stylesheet.source && stylesheet.source.match(filename)
+        end
+      end
+
+      return wrapper
+    end
+
+    def source_code_for_class class_name
+      find_component_definition_for_class(class_name).contents
+    end
+
+    def find_definition_file_for_class needle
+      definition = find_component_definition_for_class(needle)
+      definition && definition.source
+    end
+
+    def find_component_definition_for_class needle
+      component_definitions.detect {|d| d.class_name == needle }
+    end
+
+    def namespace
+      return options[:application_name] if options[:appliction_name]
+
+      line = initializer_file_contents.lines.to_a.detect do |l|
+        l.match(/Luca.initialize/)
+      end
+
+      match = line.match(/Luca.initialize.+['|"](.+)['|"]/)
+
+      if match && match[1] 
+        match[1]
+      else
+        application_folder.capitalize
+      end
+    end
+
+    def valid?
+      !initializer_file_location.nil? and File.exists?(initializer_file_location)
+    end
+
+    def templates
+      template_file_locations.map {|path| TemplateAsset.new(path) }
+    end
+
+    def stylesheets
+      stylesheet_file_locations.map {|path| Stylesheet.new(path) }
+    end
+
+    def find_stylesheet(params={})
+      if params[:component_class]
+        parts = params[:component_class].split('.')
+        parts.map!(&:downcase)
+        parts.reject! {|p| p == "views" || p == "components" || p == "containers" || p == "pages" }
+        params[:css_class] = parts.join('_').dasherize
+
+      end
+
+      stylesheets.reject do |stylesheet|
+        match = false
+
+        if params[:css_class]
+          match = stylesheet.compiled.include?( params[:css_class] )
+        end
+
+        match
+      end
+    end
+
+    def component_definitions(reject_invalid=true)
+      list = component_file_locations.map do |path|
+        ComponentDefinition.new(path)
+      end
+
+      return list unless reject_invalid
+
+      list.select do |definition|
+        definition.valid?
+      end
+    end  
+
+    protected
+      def template_extensions
+        options[:template_extensions] || ['jst.ejs.haml','mustache'] 
+      end  
+
+      def stylesheet_extensions
+        options[:stylesheet_extensions] || ['css.scss']
+      end
+
+      def component_extensions
+        options[:component_extensions] || ['.coffee']
+      end
+
+      def application_folder
+        options[:application_folder] || application_name.downcase
+      end
+
+      def stylesheet_file_locations
+        stylesheet_folders.flat_map do |folder|
+          Dir.glob("#{ folder }/**/*.css.scss")        
+        end
+      end
+
+      def component_file_locations
+        component_folders.flat_map do |folder|
+          Dir.glob("#{ folder }/**/*.coffee")
+        end
+      end
+
+      def template_file_locations
+        template_folders.flat_map do |folder|
+          template_extensions.flat_map do |extension|
+            Dir.glob("#{ folder }/**/*.#{ extension }")
+          end
+        end
+      end
+
+      def stylesheet_folders
+        list = Dir.entries( stylesheets_root )
+        list = list.slice(2, list.length)
+        
+        list.map! do |path|
+          File.join(stylesheets_root, path)
+        end
+
+        list.select! {|path| File.exists?(path) && File.directory?(path) }
+
+        (list << stylesheets_root << stylesheets_location).uniq
+      end
+
+      def template_folders
+        Dir.glob("#{ javascripts_root }/**/templates*")
+      end
+
+      def component_folders
+        list = %w{views components collections models pages containers} 
+        list += Array(options[:component_folders])
+
+        list.map! do |folder|
+          File.join(coffeescripts_location, folder)
+        end
+
+        # add the root folder
+        list << coffeescripts_location
+
+        list.select {|path| File.exists?(path) || File.directory?(path) }
+      end
+
+      def initializer_file_contents
+        initializer_file_location && IO.read( initializer_file_location )
+      end
+
+      def initializer_file_location
+        filename = root_coffeescript_files.detect do |file|
+          IO.read( File.join(coffeescripts_location, file) ).match('Luca.initialize')
+        end
+
+        File.join( coffeescripts_location, filename )
+      end
+
+      def root_coffeescript_files
+        Dir.entries( coffeescripts_location ).select do |file|
+          !File.directory?(file) && File.extname(file).match(/coffee/)
+        end
+      end 
+
+      def coffeescripts_location
+        options[:coffeescripts_location] || File.join(javascripts_root, application_folder)
+      end
+
+      def stylesheets_location
+        options[:stylesheets_location] || File.join(stylesheets_root, application_folder)
+      end
+
+      def stylesheets_root
+        options[:stylesheets_root] || File.join(project_root, "app", "assets", "stylesheets")
+      end
+
+      def javascripts_root
+        options[:javascripts_root] || File.join(project_root, "app", "assets", "javascripts")
+      end
+
+      def project_root
+        options[:root] || (::Rails.root rescue Dir.pwd())
+      end
+
+  end
+end

data/lib/luca/project.rb

@@ -0,0 +1,73 @@
+module Luca
+  class Project
+    class << self
+      attr_accessor :storage
+    end
+
+
+    attr_accessor :name, 
+                  :path
+
+    def self.store
+      self.storage ||= Luca::Collection.new(namespace:"projects",backend_type:"file")
+    end
+
+    def self.create attributes={}
+      store.create(attributes)
+    end
+
+    def self.index
+      store.index
+    end
+
+    def self.find_by_path path
+      data = index.detect do |project_data|
+        project_data['path'] == path
+      end
+      
+      return nil unless data 
+
+      new(path: data['path'], name: data['name'])    
+    end
+
+    def self.find_or_create_by_name(name, attributes={})
+      if existing = find_by_name(name)
+        return existing
+      else
+        attributes[:name] = name  
+        create(attributes)
+      end
+    end
+
+    def self.find_by_name name
+      data = index.detect do |project_data|
+        project_data['name'] == name
+      end
+
+      return nil unless data
+
+      new(path: data['path'], name: data['name'])
+    end
+
+    def initialize options={}
+      @path = options[:path]
+      @name = options[:name] || File.basename(@path)
+    end
+
+    def as_json
+      {path: path, name: name}
+    end
+
+    def git
+      @git ||= Grit::Repo.new(path) 
+    end
+
+    def app
+      luca_application
+    end
+
+    def luca_application
+      @luca_application ||= LucaApplication.new(name.capitalize, root: path)
+    end
+  end  
+end

data/lib/luca/project_harness.rb

@@ -0,0 +1,96 @@
+module Luca
+  # The Luca::ProjectHarness makes the source code browsing endpoints available
+  class ProjectHarness < Sinatra::Base
+    get "/framework/documentation" do
+      app = Luca::LucaApplication.new("Luca", root: Luca.base_path)
+      
+      payload = if File.exists?( app.export_file_location ) 
+        IO.read( app.export_file_location )
+      else
+        app.export
+      end
+
+      payload
+    end
+
+    get "/framework/documentation/:class_name" do
+      application_repository    = Luca::LucaApplication.new("Luca", root: Luca.base_path)
+      class_name                =  params[:class_name].gsub('__','.')
+      component_definition      = application_repository.find_component_definition_for_class( class_name )      
+
+      component_definition.as_json(:include_contents=>true).to_json      
+    end
+
+    get "/compiled/assets/:type/:id.:extension" do
+      asset = Luca::CompiledAsset.find_by_type_and_id( params[:type], params[:id] )
+      content_type asset.mime_type
+
+      asset.output
+    end
+
+    get "/components/:application_name" do
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      definitions               = application_repository.component_definitions.map(&:as_json)
+
+      definitions.to_json
+    end
+
+    get "/stylesheets/:application_name" do
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      list = application_repository.find_stylesheet(params)
+
+      list.to_json
+    end
+
+    get "/templates/:application_name" do
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      templates                 = application_repository.templates.map(&:as_json)
+
+      templates.to_json
+    end
+
+    get "/templates/:application_name/:template_name" do
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      templates                 = application_repository.templates.map(&:as_json)
+      template                  = templates.detect {|tmpl| tmpl.template_name == params[:template_name] }
+
+      template.to_json
+    end
+
+  
+    post "/components/:application_name" do    
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      application
+    end
+
+    put "/components/:application_name/:class_name" do
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      class_name                =  params[:class_name].gsub('__','.')
+      component_definition      = application_repository.find_component_definition_for_class( class_name )          
+
+      {success: true}.to_json
+    end
+
+    get "/components/:application_name" do
+      application_name          = params[:application_name].capitalize
+      application_repository    = Luca::LucaApplication.new(application_name, root: ::Rails.root) 
+
+      payload = if File.exists?( app.export_file_location ) 
+        IO.read( app.export_file_location )
+      else
+        app.export
+      end
+
+      payload      
+    end
+
+    get "/components/:application_name/:class_name" do
+      application_repository    = Luca::Project.find_by_name( params[:application_name] ).app
+      class_name                =  params[:class_name].gsub('__','.')
+      component_definition      = application_repository.find_component_definition_for_class( class_name )      
+
+      component_definition.as_json(:include_contents=>true).to_json
+    end
+
+  end
+end

data/lib/luca/rails.rb

@@ -2,9 +2,11 @@ module Luca
   module Rails
     require 'luca/template'
     require 'luca/test_harness'
-    require 'luca/code_browser'
-    require 'luca/rails/engine'
-    require 'luca/rails/version'
+    require 'luca/project_harness'
+        
+    if defined?(::Rails)
+      require 'luca/rails/engine'
+    end
   end
 end
 

data/lib/luca/rails/engine.rb

@@ -1,11 +1,23 @@
+require 'hogan_assets'
 module Luca
   module Rails
     class Engine < ::Rails::Engine
+      rake_tasks do
+        load "railties/luca/tasks.rake"
+      end 
+
       initializer "luca.register_template" do |app|
         app.assets.register_engine ".luca", Luca::Template
         Luca::TestHarness.set(:sprockets,app.assets)
         Luca::TestHarness.set :root, File.expand_path('../../../../', __FILE__)
       end
+
+      initializer "sprockets.hogan", :after => "sprockets.environment", :group => :all do |app|
+        HoganAssets::Config.configure do |config|
+          config.template_namespace = 'JST'
+        end        
+      end      
+
     end
   end
 end