xdry 0.1.0

data/lib/xdry/parsing/nodes.rb

@@ -0,0 +1,260 @@
+
+module XDry
+
+  class Node
+    attr_accessor :pos, :indent
+
+    def initialize
+      @tags = Set.new
+    end
+
+    def tags
+      @tags.dup
+    end
+
+    def tags= new_tags
+      @tags = Set.new(new_tags)
+    end
+
+    def tagged_with? tag
+      @tags.include? tag
+    end
+
+    def tags_comment
+      if @tags.empty? then "" else " // " + @tags.to_a.sort.join(", ") end
+    end
+
+    def method_missing id, *args, &block
+      if id.to_s =~ /^with_(.*)$/
+        send("#{$1}=", *args, &block)
+        self
+      else
+        super(id, *args, &block)
+      end
+    end
+
+  end
+
+  class NInterfaceFieldsEnd < Node
+  end
+
+  class NFieldDef < Node
+    attr_reader :name, :type
+
+    def initialize name, type
+      super()
+      @name, @type = name, type
+    end
+
+    def persistent?
+      tagged_with? 'persistent'
+    end
+
+    def wants_property?
+      tagged_with? 'wants-property'
+    end
+
+    def wants_constructor?
+      tagged_with? 'wants-constructor'
+    end
+
+    def to_s
+      "#{@type} #{@name}#{tags_comment}"
+    end
+
+    def to_source
+      "#{@type.to_source_with_space}#{@name};"
+    end
+  end
+
+  class NPropertyDef < Node
+    attr_reader :name, :type
+
+    def initialize name, type
+      super()
+      raise StandardError, "type cannot be nil for prop #{name}" if type.nil?
+      @name, @type = name, type
+    end
+
+    def outlet?
+      tagged_with? 'outlet'
+    end
+
+    def to_s
+      "#{if outlet? then 'IBOutlet ' else '' end}#{@type} #{@name}"
+    end
+
+    def to_source
+      retainment = case @type.default_property_retainment_policy
+        when '' then ''
+        else ', ' + @type.default_property_retainment_policy
+      end
+      iboutlet = if outlet? then "IBOutlet " else '' end
+      "@property(nonatomic#{retainment}) #{iboutlet}#{@type.to_source_with_space}#{@name};"
+    end
+  end
+
+  class NMethodHeader < Node
+    attr_reader :selector_def, :ret_type
+
+    def initialize selector_def, ret_type
+      @selector_def, @ret_type = selector_def, ret_type
+    end
+
+    def selector
+      @selector_def.selector
+    end
+
+    def to_s
+      "- (#{@ret_type})#{selector_def}"
+    end
+
+  end
+
+  class NMethodStart < Node
+    attr_reader :selector_def, :ret_type
+
+    def initialize selector_def, ret_type
+      @selector_def, @ret_type = selector_def, ret_type
+    end
+
+    def selector
+      @selector_def.selector
+    end
+
+    def to_s
+      "- (#{@ret_type})#{selector_def}"
+    end
+
+  end
+
+  class NInterfaceStart < Node
+    attr_reader :class_name
+    def initialize class_name
+      @class_name = class_name
+    end
+  end
+
+  class NImplementationStart < Node
+    attr_reader :class_name
+    def initialize class_name
+      @class_name = class_name
+    end
+  end
+
+  class NEnd < Node
+  end
+
+  class SynthesizeItem
+
+    attr_reader :property_name, :field_name
+
+    def initialize property_name, field_name = nil
+      @property_name, @field_name = property_name, field_name
+    end
+
+    def has_field_name?
+      not @field_name.nil?
+    end
+
+    def to_s
+      if has_field_name?
+        "#{property_name}=#{field_name}"
+      else
+        "#{property_name}"
+      end
+    end
+
+    def self.parse string
+      case string
+        when /^(\w+)$/             then SynthesizeItem.new($1, nil)
+        when /^(\w+)\s*=\s*(\w+)$/ then SynthesizeItem.new($1, $2)
+      end
+    end
+
+  end
+
+  class NSynthesize < Node
+
+    attr_reader :items
+
+    def initialize items
+      @items = items
+    end
+
+    def item_for_property_named property_name
+      @items.find { |item| item.property_name == property_name }
+    end
+
+    def to_s
+      "@synthesize " + @items.join(", ") + ";"
+    end
+
+    def self.parse string
+      if string =~ /^@synthesize\s+(.*);$/
+        NSynthesize.new($1.strip.split(/\s+,\s+/).collect { |s| SynthesizeItem.parse(s) }.compact)
+      end
+    end
+
+  end
+
+  class NOpeningBrace < Node
+  end
+
+  class NClosingBrace < Node
+  end
+
+  class NMethodEnd < Node
+  end
+
+  class NReleaseCall < Node
+    attr_reader :expr
+
+    def initialize expr
+      @expr = expr
+    end
+  end
+
+  class NSuperCall < Node
+  end
+
+  class NReturn < Node
+  end
+
+  class NDefine < Node
+    attr_reader :word
+
+    def initialize word
+      @word = word
+    end
+  end
+
+  class NLine < Node
+
+    attr_reader :line
+
+    def initialize line
+      @line = line
+    end
+
+  end
+
+  class NMarker < Node
+    attr_reader :text
+
+    def initialize text
+      @text = text
+    end
+
+    def to_s
+      "#{self.class.name}('#{text}')"
+    end
+  end
+
+  class NPartLineMarker < NMarker
+  end
+
+  class NFullLineMarker < NMarker
+  end
+
+end

data/lib/xdry/parsing/parsers.rb

@@ -0,0 +1,166 @@
+require 'set'
+
+module XDry
+
+  class Parser
+
+    attr_reader :scope
+
+    def initialize scope
+      @scope = scope
+    end
+
+    def to_s
+      "#{self.class.name}"
+    end
+
+  end
+
+  class PGlobal < Parser
+
+    def parse_line! line, eol_comments, indent
+      case line
+        when /^@interface\s+(\w+)\s*;/
+          name = $1
+        when /^@protocol\s+(\w+)\s*;/
+          name = $1
+
+        when /^@interface\s+(\w+)/  #\s*(?:[:(][\w:(),\s]*)?
+          name, supers, postfix = $1, $2, $'
+          yield NInterfaceStart.new(name)
+          yield NOpeningBrace.new if postfix =~ /\{$/
+
+        when /^@implementation\s+(\w+)/
+          name = $1
+          yield NImplementationStart.new(name)
+
+        when /^@protocol\s+(\w+)\s*;/
+          puts "PREDEF protocol #{$1}"
+
+        when /^#define\s+(\w+)/
+          word = $1
+          yield NDefine.new(word)
+      end
+    end
+
+  end
+
+  class PInterfaceFields < Parser
+
+    def initialize scope
+      super
+      @tags = Set.new
+    end
+
+    def parse_line! line, eol_comments, indent
+      @this_line_tags = Set.new
+      [[/!p\b/, 'wants-property'], [/!c\b/, 'wants-constructor']].each do |regexp, tag|
+        if line =~ regexp
+          marker = $&
+          is_full_line = line.gsub(marker, '').strip.empty?
+          klass = is_full_line ? NFullLineMarker : NPartLineMarker
+          yield klass.new(marker)
+          (is_full_line ? @tags : @this_line_tags) << tag
+          return if is_full_line
+        end
+      end
+      case line
+      when /\}/
+        yield NInterfaceFieldsEnd.new
+      when %r~^//\s*persistent$~
+        @tags << 'persistent'
+      when ''
+        @tags.clear
+      when /^(\w+)\s+(\w+)\s*;/
+        type_name, field_name = $1, $2
+        yield process_type_hint(NFieldDef.new(field_name, SimpleVarType.new(type_name)), eol_comments)
+      when /^(\w+)\s*\*\s*(\w+)\s*;/
+        type_name, field_name = $1, $2
+        yield process_type_hint(NFieldDef.new(field_name, PointerVarType.new(type_name)), eol_comments)
+      when /^id<(\w+)>\s+(\w+)\s*;/
+        type_name, field_name = $1, $2
+        yield process_type_hint(NFieldDef.new(field_name, IdVarType.new()), eol_comments)
+      end
+    end
+
+  private
+
+    def process_type_hint field_def, eol_comments
+      field_def.tags = (@tags + @this_line_tags).to_a
+
+      case field_def.type
+      when PointerVarType
+        case field_def.type.name
+        when 'NSArray'
+          if eol_comments =~ %r`//\s*of\s+(\w+)`
+            field_def.type.type_hint = $1
+          end
+        end
+      end
+
+      field_def
+    end
+  end
+
+  class PInterfaceHeader < Parser
+
+    def parse_line! line, eol_comments, indent
+      case line
+      when /^\{$/
+        yield NOpeningBrace.new
+      when /@end/
+        yield NEnd.new
+      when /^@property(\s*\([\w\s,]*\))?\s+(IBOutlet\s+)?(\w+)\s*\*\s*(\w+)\s*;$/
+        property_flags, iboutlet, type_name, property_name = $1, $2, $3, $4
+        yield NPropertyDef.new(property_name, PointerVarType.new(type_name))
+      when /^@property(\s*\([\w\s,]*\))?\s+(IBOutlet\s+)?(\w+)\s+(\w+)\s*;$/
+        property_flags, iboutlet, type_name, property_name = $1, $2, $3, $4
+        yield NPropertyDef.new(property_name, SimpleVarType.new(type_name))
+      when /^-\s*\(([^)]+)\)\s*(\w+[\w\s():*]*);$/
+        ret_type_decl, selector_decl = $1, $2
+        selector_def = SelectorDef.parse(selector_decl)
+        ret_type = VarType.parse(ret_type_decl)
+        yield NMethodHeader.new(selector_def, ret_type)
+
+      when /^-\s*\(([^)]+)\)\s*(\w+[\w\s():*]*)\{$/
+        ret_type_decl, selector_decl = $1, $2
+        selector_def = SelectorDef.parse(selector_decl)
+        ret_type = VarType.parse(ret_type_decl)
+        yield NMethodStart.new(selector_def, ret_type)
+
+      when /^@synthesize/
+        yield NSynthesize.parse(line)
+      end
+    end
+
+  end
+
+  class PMethodImpl < Parser
+
+    def parse_line! line, eol_comments, indent
+      case line
+      when /^\}$/
+        if indent == scope.start_node.indent
+          yield NMethodEnd.new
+        else
+          yield NClosingBrace.new
+        end
+      when /\[\s*([\w.]+)\s+release\s*\]/
+        expr = $1
+        yield NReleaseCall.new(expr)
+      when /\bself\s*\.\s*(\w+)\s*=\s*nil\s*[,;]/
+        expr = $1
+        yield NReleaseCall.new(expr)
+      when /\b(\w+)\s*=\s*nil\s*[,;]/
+        expr = $1
+        yield NReleaseCall.new(expr)
+      when /\[super\s/
+        yield NSuperCall.new
+      when /^return\b/
+        yield NReturn.new
+      end
+    end
+
+  end
+
+end

data/lib/xdry/parsing/parts/selectors.rb

@@ -0,0 +1,95 @@
+
+module XDry
+
+  class SelectorDef
+
+    def self.parse string
+      string = string.strip
+      if string =~ /^\w+$/
+        SimpleSelectorDef.new(string)
+      else
+        comps = string.split(/\s+(?!\*)/).collect do |component_string|
+          if component_string =~ /^(\w+:)\s*(?:\(([^)]+)\)\s*)?(\w*)$/
+            keyword, type_decl, arg_name = $1, $2, $3
+            type = if type_decl then VarType.parse(type_decl) else nil end
+            SelectorComponent.new(keyword, arg_name, type)
+          else
+            raise StandardError, "Cannot parse selector component '#{component_string}' for selector '#{string}'"
+          end
+        end
+        CompoundSelectorDef.new(comps)
+      end
+    end
+
+  end
+
+  class SimpleSelectorDef < SelectorDef
+
+    attr_reader :selector
+
+    def initialize selector
+      @selector = selector
+    end
+
+    def simple?; true; end
+
+    def var_name_after_keyword keyword
+      nil
+    end
+
+    def to_s
+      @selector
+    end
+
+  end
+
+  class SelectorComponent
+    attr_reader :keyword, :arg_name, :type
+
+    def initialize keyword, arg_name, type
+      raise StandardError, "keyword must end with a colon: '#{keyword}'" unless keyword[-1] == ?:
+      @keyword, @arg_name, @type = keyword, arg_name, type
+    end
+
+    def keyword_without_colon
+      @keyword_without_colon ||= @keyword.sub(/:$/, '')
+    end
+
+    def has_type?
+      not @type.nil?
+    end
+
+    def to_s
+      if has_type?
+        "#{keyword}(#{@type})#{@arg_name}"
+      else
+        "#{keyword}#{@arg_name}"
+      end
+    end
+  end
+
+  class CompoundSelectorDef < SelectorDef
+    attr_reader :components
+
+    def initialize components
+      @components = components.freeze
+    end
+
+    def selector
+      @selector ||= @components.collect { |comp| comp.keyword }.join("")
+    end
+
+    def simple?; false; end
+
+    def to_s
+      @components.collect { |comp| comp.to_s }.join(" ")
+    end
+
+    def var_name_after_keyword keyword
+      comp = @components.find { |comp| comp.keyword == keyword }
+      comp && comp.arg_name
+    end
+
+  end
+
+end