luca 0.9.8 → 0.9.9

data/lib/luca/component_definition.rb

@@ -0,0 +1,356 @@
+require 'rubygems'
+require 'redcarpet'
+require 'active_support/core_ext'
+
+module Luca
+  class ComponentDefinition
+    attr_accessor :source, :markdown
+
+    ARGUMENTS_REGEX = /^\w+\:\s*\((.+)\)/
+
+    class << self
+      attr_accessor :markdown
+    end
+
+    begin
+      self.markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :autolink => true, :space_after_headers => true)
+    rescue Exception => e
+       
+    end 
+
+    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",
+        starts_on_line: definition_line && definition_line.line_number
+      }
+
+      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: default_value_for(property) 
+        }
+        memo
+      end
+    end
+
+    def default_value_for property
+      definition = find_definition_of(property).line.strip
+      property, value = definition.split(':')
+      value && value.strip
+    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 && self.class.markdown && self.class.markdown.respond_to?(:render)
+        self.class.markdown.render(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

data/lib/luca/luca_application.rb

@@ -0,0 +1,258 @@
+require 'rubygems'
+require 'redcarpet'
+require 'active_support/core_ext'
+
+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|
+        contents = "window.#{ namespace } = window.#{ namespace } || {}; window.#{ namespace }.documentation = #{ contents };"
+        fh.puts( contents ) 
+      end
+      contents
+    end
+
+    def export_file_location
+      loc = options[:export_location] || File.join(Luca.base_path,"site","source", "javascripts")
+
+      File.join(loc, "#{ application_name.downcase }-docs.js")
+    end
+
+    def export_all_component_definitions 
+      list = component_definitions.map do |cdef|
+        cdef.as_json(include_contents:true) 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].capitalize if options[:application_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  
+
+    def assets_root
+      options[:assets_root] || File.join(project_root,"app","assets")
+    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(assets_root,"stylesheets")
+      end
+
+      def javascripts_root
+        options[:javascripts_root] || File.join(assets_root,"javascripts")
+      end
+
+
+
+      def project_root
+        options[:root] || (::Rails.root rescue Dir.pwd())
+      end
+
+  end
+end