cocoadex 1.4 → 1.5

data/bin/cdex_completion

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# Function to print all keyword tags by scope
+# (Helper for zsh completion)
+
+require 'cocoadex'
+
+puts Cocoadex::CompletionHelper.new(ARGV[0]).scope_matches.join("\n")

data/bin/cocoadex

@@ -18,15 +18,15 @@ main do |query|
   end
   if options[:configure]
     DocSetHelper.search_and_index
+  elsif options[:'generate-tags']
+    CompletionHelper.generate_tags!
   elsif options[:'load-docset']
     paths = options[:'load-docset'].map do |p|
       File.expand_path(p)
     end.uniq
     DocSetHelper.search_and_index(paths)
   elsif query
-    if Keyword.loaded?
-      logger.debug "Loading index..."
-      Keyword.read
+    if Tokenizer.loaded?
       Cocoadex.search(query, options[:first])
     else
       puts "No DocSets loaded. Run `cocodex --configure` to search for existing DocSets."
@@ -43,6 +43,8 @@ arg :query, :optional
 
 on("--verbose","Be verbose")
 
+on("--generate-tags","Generate a tags file from indexed docsets and exit")
+
 on("--configure","Index all DocSets in default locations")
 
 on("--first","Load first result when multiple matches exist")

data/changelog.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.5
+
+ - Searching for constants, functions, data types, callbacks, and result codes are now supported!
+ - Added smart completion; `Class-method`, `Class+method`, and `Class.property` can now be tab-completed
+
 ## 1.4
 
  - Fixed parsing error on non-ASCII characters. Patch submitted by farcaller.

data/lib/cocoadex/docset_helper.rb

@@ -1,5 +1,7 @@
 
 module Cocoadex
+
+  # Helper for finding and indexing DocSets
   class DocSetHelper
 
     ROOT_PATHS = [
@@ -15,7 +17,9 @@ module Cocoadex
 
     def self.docset_paths
       @paths ||= begin
-        ROOT_PATHS.map { |path| Dir.glob(File.expand_path(path)+'/*/') }.flatten
+        ROOT_PATHS.map do |path|
+          Dir.glob(File.expand_path(path)+'/*/')
+        end.flatten
       end
     end
 
@@ -28,8 +32,8 @@ module Cocoadex
       end
 
       if docsets.size > 0
-        Keyword.write(:overwrite)
-        Keyword.generate_tags!
+        Tokenizer.persist
+        CompletionHelper.generate_tags!
         write(docsets)
       end
       logger.info "Done! #{docsets.size} DocSet#{docsets.size == 1 ? '':'s'} indexed."
@@ -45,7 +49,7 @@ module Cocoadex
 
     def self.write docsets
       @docsets = docsets
-      Serializer.write(data_path, docsets, :overwrite)
+      Serializer.write_array(data_path, docsets, :overwrite)
     end
   end
 end

data/lib/cocoadex/extensions.rb

@@ -0,0 +1,4 @@
+require '../ext/nil'
+require '../ext/string'
+require '../ext/xml_element'
+require '../ext/template_helpers'

data/lib/cocoadex/keyword.rb

@@ -11,41 +11,45 @@ module Cocoadex
     CLASS_PROP_DELIM   = '.'
     SCOPE_CHARS = [CLASS_PROP_DELIM,CLASS_METHOD_DELIM,INST_METHOD_DELIM]
 
-    def self.datastore
-      @store ||= []
+    # Search the cache for matching text
+    def self.find text
+      logger.debug "Searching tokens for #{text}"
+      if scope = Keyword.get_scope(text)
+        class_name, term = text.split(scope)
+        find_with_scope(scope, class_name, term)
+      else
+        keys = Tokenizer.fuzzy_match(text)
+        keys.map {|k| k.to_element }
+      end
     end
 
-    # Cache storage location
-    def self.data_path
-      Cocoadex.config_file("data/store.blob")
+    def self.get_scope text
+      SCOPE_CHARS.detect {|c| text.include? c}
     end
 
-    def self.tags_path
-      Cocoadex.config_file("tags")
+    def initialize term, type, docset, url
+      @term, @type, @docset, @url = term, type, docset, url
     end
 
-    # Search the cache for matching text
-    def self.find text
-      if scope = SCOPE_CHARS.detect {|c| text.include? c }
-        class_name, term = text.split(scope)
-        logger.debug "Searching scope: #{scope}, #{class_name}, #{term}"
-        find_with_scope scope, class_name, term
-      else
-        logger.debug "Searching Keyword datastore (#{datastore.size}): #{text}"
-        keys = datastore.select {|k| k.term.start_with? text }
-        logger.debug "#{keys.size} keys found"
-        if key = keys.detect {|k| k.term == text }
-          keys = [key]
-          logger.debug "Exact match!"
-        end
-        untokenize(keys)
-      end
+    def to_element
+      Tokenizer.untokenize([self]).first
     end
 
+    def inspect
+      "<Keyword:#{type} @term=\"#{term}\">"
+    end
+
+    def to_s
+      "#{type} => #{term}"
+    end
+
+    private
+
     # Find matches for term within a given class
     def self.find_with_scope scope, class_name, term
-      if class_key = datastore.detect {|k| k.term == class_name }
-        klass = untokenize([class_key]).first
+      if class_key = Tokenizer.match(class_name)
+        return [] unless class_key.type == :class
+        klass = class_key.to_element
         list  = case scope
           when CLASS_PROP_DELIM
             klass.methods + klass.properties
@@ -59,82 +63,5 @@ module Cocoadex
         []
       end
     end
-
-    # Are any docsets loaded into the cache?
-    def self.loaded?
-      File.exists? data_path
-    end
-
-    # Read a serialized cache file into an Array
-    def self.read
-      @store = Serializer.read(data_path)
-      logger.debug "Loaded #{datastore.size} tokens"
-    end
-
-    # Write a cache Array as a serialized file
-    def self.write style
-      Serializer.write(data_path, datastore, style)
-    end
-
-    def self.tags
-      @tags ||= begin
-        if File.exists? tags_path
-          IO.read(tags_path).split('\n')
-        else
-          []
-        end
-      end
-    end
-
-    # Build a tags file from existing kewords
-    def self.generate_tags!
-      text = datastore.map {|k| k.term }.join('\n')
-      Serializer.write_text tags_path, text
-    end
-
-    # Create Cocoadex model objects for Keyword references
-    def self.untokenize keys
-      keys.map do |key|
-        case key.type
-        when :class
-          Cocoadex::Class.new(key.url)
-        when :method, :property
-          if class_key = datastore.detect {|k| k.id == key.fk}
-            klass = Cocoadex::Class.new(class_key.url)
-            logger.debug "Searching #{key.type} list of #{klass.name}"
-            list = key.type == :method ? klass.methods : klass.properties
-            list.detect {|m| m.name == key.term}
-          end
-        end
-      end
-    end
-
-    # Find all searchable keywords in a class and add to cache
-    def self.tokenize_class docset, path, id
-      klass = Cocoadex::Class.new(path)
-      class_key = Keyword.new(klass.name, :class, docset, path)
-      class_key.id = id
-      datastore << class_key
-
-      {:method => klass.methods, :property => klass.properties}.each do |type,list|
-        list.each do |item|
-          item_key = Keyword.new(item.name, type, docset, path)
-          item_key.fk = id
-          datastore << item_key
-        end
-      end
-    end
-
-    def initialize term, type, docset, url
-      @term, @type, @docset, @url = term, type, docset, url
-    end
-
-    def inspect
-      "<Keyword#{type} @term=#{term}>"
-    end
-
-    def to_s
-      "#{type} => #{term}"
-    end
   end
-end
+end

data/lib/cocoadex/model.rb

@@ -0,0 +1,56 @@
+require 'cocoadex/models/docset'
+require 'cocoadex/models/element'
+require 'cocoadex/models/seq_node_element'
+require 'cocoadex/models/nested_node_element'
+require 'cocoadex/models/entity'
+require 'cocoadex/models/constant'
+require 'cocoadex/models/parameter'
+require 'cocoadex/models/function'
+require 'cocoadex/models/callback'
+require 'cocoadex/models/result_code'
+require 'cocoadex/models/data_type'
+require 'cocoadex/models/generic_ref'
+require 'cocoadex/models/method'
+require 'cocoadex/models/property'
+require 'cocoadex/models/class'
+
+# Class Structure -------------
+#
+# DocSet
+# Element
+#   Entity
+#     Class
+#     GenericRef
+#   NestedNodeElement
+#     Method
+#     Property
+#   SequentialNodeElement
+#     Callback
+#     ConstantGroup
+#     DataType
+#     Function
+#   Constant
+#   Parameter
+#   ResultCode
+#
+# Relationship Tree -----------
+#   Class
+#     Method
+#       Parameter
+#     Property
+#
+#   GenericRef
+#     Callback
+#       Parameter
+#     ConstantGroup
+#       Constant
+#     DataType
+#       Parameter
+#     Function
+#       Parameter
+#
+#
+module Cocoadex
+  class Model
+  end
+end

data/lib/cocoadex/models/callback.rb

@@ -0,0 +1,12 @@
+
+module Cocoadex
+  class Callback < Function
+    def type
+      "Callback"
+    end
+
+    def discussion
+      @discussion
+    end
+  end
+end

data/lib/cocoadex/models/class.rb

@@ -4,7 +4,7 @@ require 'set'
 module Cocoadex
   # A model of a Cocoa API class or protocol
   class Class < Entity
-    TEMPLATE=Cocoadex::Templates::CLASS_DESCRIPTION
+    TEMPLATE_NAME=:class
 
     attr_reader :description, :overview
 
@@ -48,7 +48,7 @@ module Cocoadex
       @parents = doc.css("div.zSharedSpecBoxHeadList").first.css('a').map {|node| node.text}
 
       parse_properties(doc)
-      parse_tasks(doc)
+      # parse_tasks(doc)
       parse_methods(doc)
     end
 

data/lib/cocoadex/models/constant.rb

@@ -0,0 +1,41 @@
+
+module Cocoadex
+  class ConstantGroup < SequentialNodeElement
+    TEMPLATE_NAME=:constant_group
+
+    attr_reader :abstract, :declaration,
+      :discussion, :declared_in
+
+    def constants
+      @constants ||= []
+    end
+
+    def handle_node node
+      if node.classes.include? "termdef"
+        node.css("dt").each do |field_title_node|
+          source = "#{@origin} > #{@name}"
+          field_name  = field_title_node.css("code").text
+          description = field_title_node.next.css("p").map {|p| p.text}.join("\n")
+          constants << Constant.new(source,field_name, description)
+        end
+      elsif node.name == "p" and node.classes.empty?
+        @abstract = node.text
+      end
+    end
+  end
+
+  class Constant < Element
+    TEMPLATE_NAME=:constant
+
+    attr_reader :description
+
+    def initialize origin, name, description
+      @origin = origin
+      @name, @description = name, description
+    end
+
+    def origin
+      @origin
+    end
+  end
+end

data/lib/cocoadex/models/data_type.rb

@@ -0,0 +1,47 @@
+
+module Cocoadex
+
+  class DataType < SequentialNodeElement
+    TEMPLATE_NAME=:data_type
+
+    class Field < Parameter;end
+
+    attr_reader :abstract, :declaration, :declared_in,
+      :discussion, :availability, :considerations
+    attr_accessor :next_termdef
+
+    def fields
+      @fields ||= []
+    end
+
+    def constants
+      @constants ||= []
+    end
+
+    def origin
+      @origin
+    end
+
+    def handle_node node
+      if ["Fields","Constants"].include? node.text
+        next_termdef = node.text
+      elsif node.classes.include? "termdef" and not next_termdef.nil?
+        if list = termdef_to_properties(next_termdef)
+          node.css("dt").each do |field_title_node|
+            field_name  = field_title_node.css("code").text
+            description = field_title_node.next.text
+            list << Field.new(field_name, description)
+          end
+          next_termdef = ""
+        end
+      end
+    end
+
+    def termdef_to_properties termdef
+      case termdef
+      when "Fields" then fields
+      when "Constants" then constants
+      end
+    end
+  end
+end

data/lib/cocoadex/models/element.rb

@@ -12,7 +12,9 @@ module Cocoadex
     end
 
     def print
-      template = self.class.const_get(:TEMPLATE)
+      template_name = self.class.const_get("TEMPLATE_NAME")
+      path = Cocoadex.view_path(template_name)
+      template = IO.read(path, :mode => 'rb')
       ERB.new(template, nil, '<>').result(binding)
     end
 
@@ -27,5 +29,16 @@ module Cocoadex
     def type
       raise "#{self.class}#type is not defined"
     end
+
+    def parse_parameters node
+      node.css("dt").each do |param|
+        name_nodes = param.css("em")
+        if name_nodes.size > 0
+          name = param.css("em").first.text
+          description = param.next.css("p").first.text
+          parameters << Parameter.new(name, description)
+        end
+      end
+    end
   end
 end

data/lib/cocoadex/models/entity.rb

@@ -2,8 +2,10 @@ module Cocoadex
   # A top level element, roughly equivalent to one
   # page of documentation
   class Entity < Element
+    attr_reader :path
 
     def initialize path
+      @path    = path
       text     = clean(IO.read(path, :mode => 'rb'))
       document = Nokogiri::HTML(text)
       parse(document)
@@ -18,5 +20,9 @@ module Cocoadex
     def strip text
       text.gsub("&#xA0;&#xA0;","")
     end
+
+    def section_by_title doc, title
+      doc.css("section").to_a.detect {|s| s.css("h2.jump").text == title }
+    end
   end
 end

data/lib/cocoadex/models/function.rb

@@ -0,0 +1,28 @@
+
+module Cocoadex
+  class Function < SequentialNodeElement
+    attr_reader :abstract, :declaration, :declared_in,
+      :availability, :return_value
+    TEMPLATE_NAME=:method
+
+    def parameters
+      @parameters ||= []
+    end
+
+    def discussion
+      ""
+    end
+
+    def handle_node node
+      if node.classes.include? "parameters"
+        parse_parameters(node)
+      else
+        logger.debug("Unhandled function property: #{node.classes} => #{node.text}")
+      end
+    end
+
+    def type
+      "Function"
+    end
+  end
+end

data/lib/cocoadex/models/generic_ref.rb

@@ -0,0 +1,88 @@
+
+module Cocoadex
+  # A non-class reference document containing functions,
+  # constants, callbacks, result codes, and data types
+  class GenericRef < Entity
+    attr_reader :specs, :data_types, :overview,
+      :result_codes, :const_groups, :functions,
+      :callbacks
+    TEMPLATE_NAME=:generic_ref
+
+    def parse doc
+      @name  = doc.title.sub("Reference","").strip
+      @specs = {}
+
+      parse_specbox(doc)
+      parse_overview(doc)
+      parse_data_types(doc)
+      parse_result_codes(doc)
+      parse_constants(doc)
+      parse_functions(doc)
+      parse_callbacks(doc)
+    end
+
+    def constants
+      @const_groups.map {|g| g.constants}.flatten
+    end
+
+    def parse_overview doc
+      if section = section_by_title(doc, "Overview")
+        @overview = section.text.sub("Overview","")
+      else
+        @overview = ""
+      end
+    end
+
+    def parse_specbox doc
+      specbox = doc.css(".specbox")
+      return if specbox.to_a.empty?
+      specbox.first.css("tr").each do |row|
+        title = row.css("td").first.css("strong").text
+        value = row.css("td").to_a[1].text.strip
+        @specs[title] = value
+      end
+    end
+
+    def parse_callbacks doc
+      @callbacks = []
+      parse_section(doc, @callbacks, "Callbacks", Callback)
+    end
+
+    def parse_functions doc
+      @functions = []
+      parse_section(doc, @functions, "Functions", Function)
+    end
+
+    def parse_data_types doc
+      @data_types = []
+      parse_section(doc, @data_types, "Data Types", DataType)
+    end
+
+    def parse_constants doc
+      @const_groups = []
+      parse_section(doc, @const_groups, "Constants",ConstantGroup)
+    end
+
+    def parse_section doc, list, title, klass
+      if section = section_by_title(doc, title)
+        section.css("h3").each do |type_title|
+          list << klass.new(@name, type_title)
+        end
+      end
+    end
+
+    def parse_result_codes doc
+      @result_codes = []
+      if section = section_by_title(doc, "Result Codes")
+        table = section.css("table").first
+        table.css("tr").each do |row|
+          if cells = row.css("td") and cells.size > 0
+            value = cells[1].text
+            description = cells[2].css("p").map {|p| p.text}.join("\n\n")
+            @result_codes << ResultCode.new(@name, cells.first.text, value, description)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoadex/models/method.rb

@@ -1,81 +1,32 @@
 
 module Cocoadex
-  class Class < Entity
-    # A model of a method in a Cocoa class
-    class Method < Element
-      TEMPLATE=Cocoadex::Templates::METHOD_DESCRIPTION
+  # A model of a method in a Cocoa class
+  class Method < NestedNodeElement
+    TEMPLATE_NAME=:method
 
-      attr_reader :abstract, :declaration, :discussion,
-        :declared_in, :availability, :parameters,
-        :return_value, :scope, :parent
+    attr_reader :abstract, :declaration, :discussion,
+      :declared_in, :availability, :parameters,
+      :return_value, :scope, :parent
 
-      class Parameter
-        include Comparable
-
-        attr_reader :name, :description
-
-        def initialize name, description
-          @name, @description = name, description
-        end
-
-        def to_s
-          "#{name} - #{description}"
-        end
-
-        def <=> other
-          name <=> other.name if other.respond_to? :name
-        end
-      end
-
-      def parameters
-        @parameters ||= []
-      end
-
-      def initialize parent_class, type, node
-        @parent = parent_class
-        @scope  = type
-        @name   = node.css("h3.#{type}Method").first.text
-        logger.debug("parsing #{@type} method #{@name}")
-
-        @abstract = node.css(".abstract").first.text
-        @declaration = node.css(".declaration").first.text
-
-        decl_nodes = node.css(".declaredIn code.HeaderFile")
-        @declared_in = decl_nodes.first.text if decl_nodes.size > 0
-
-        discussion_node = node.css(".discussion > p")
-        @discussion = discussion_node.first.text if discussion_node.length > 0
-
-        return_nodes = node.css(".return_value p")
-        @return_value = return_nodes.first.text if return_nodes.size > 0
-
-        ava_nodes = node.css(".availability > ul > li")
-        @availability = ava_nodes.first.text if ava_nodes.size > 0
+    def parameters
+      @parameters ||= []
+    end
 
-        parse_parameters(node)
-      end
+    def initialize parent_class, type, node
+      @parent = parent_class
+      @scope  = type
+      @name   = node.css("h3.#{type}Method").first.text
 
-      def parse_parameters node
-        if parameters = node.css(".parameters") and parameters.length > 0
-          @parameters = []
-          parameters.first.css("dt").each do |param|
-            name_nodes = param.css("em")
-            if name_nodes.size > 0
-              name = param.css("em").first.text
-              description = param.next.css("p").first.text
-              @parameters << Parameter.new(name, description)
-            end
-          end
-        end
-      end
+      parse_properties(node)
+      parse_parameters(node.css(".parameters").first)
+    end
 
-      def type
-        "#{scope.to_s.capitalize} Method"
-      end
+    def type
+      "#{scope.to_s.capitalize} Method"
+    end
 
-      def origin
-        parent.to_s
-      end
+    def origin
+      parent.to_s
     end
   end
 end