xdry 0.1.0

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

@@ -0,0 +1,66 @@
+
+module XDry
+
+  class VarType
+    def self.parse type_decl
+      type_decl = type_decl.strip
+      case type_decl
+      when /^id$/
+        IdVarType.new
+      when /^(?:unsigned\s+|signed\s+|long\s+)?\w+$/
+        SimpleVarType.new(type_decl.gsub(/\s+/, ' '))
+      when /^(\w+)\s*\*$/
+        class_name = $1
+        PointerVarType.new(class_name)
+      else
+        raise StandardError, "Cannot parse Obj-C type: '#{type_decl}'"
+      end
+    end
+
+    def to_source_with_space
+      needs_space? ? "#{to_s} " : "#{to_s}"
+    end
+
+    def needs_space?; true; end
+  end
+
+  class IdVarType < VarType
+    def to_s
+      "id"
+    end
+
+    def default_property_retainment_policy; 'assign'; end
+  end
+
+  class SimpleVarType < VarType
+    attr_reader :name
+
+    def initialize name
+      @name = name
+    end
+
+    def to_s
+      "#{@name}"
+    end
+
+    def default_property_retainment_policy; ''; end
+  end
+
+  class PointerVarType < VarType
+    attr_reader :name
+    attr_accessor :type_hint
+
+    def initialize name
+      @name = name
+    end
+
+    def to_s
+      "#{@name} *"
+    end
+
+    def needs_space?; false; end
+
+    def default_property_retainment_policy; 'retain'; end
+  end
+
+end

data/lib/xdry/parsing/pos.rb

@@ -0,0 +1,75 @@
+
+module XDry
+
+  class BaseFileRef
+
+    attr_reader :positions
+
+    def initialize
+      @positions = []
+    end
+
+    def add_pos! pos
+      @positions << pos
+    end
+
+    def fixup_positions! after_line_no, offset
+      @positions.each { |pos| pos.fixup! after_line_no, offset }
+    end
+
+  end
+
+  class FileRef < BaseFileRef
+
+    attr_reader :path
+
+    def initialize path
+      super()
+      @path = path
+    end
+
+    def read
+      open(@path) { |f| f.read }
+    end
+
+  end
+
+  class TestFileRef < BaseFileRef
+    attr_reader :path
+
+    def initialize path, source
+      super()
+      @path, @source = path, source
+    end
+
+    def read
+      @source
+    end
+  end
+
+  class Pos
+    attr_reader :file_ref, :line_no
+    attr_accessor :scope_before, :scope_after
+
+    def initialize file_ref, line_no
+      @file_ref = file_ref
+      @line_no  = line_no
+      @file_ref.add_pos! self
+    end
+
+    def file_path
+      @file_ref.path
+    end
+
+    def fixup! after_line_no, offset
+      if @line_no > after_line_no
+        @line_no += offset
+      end
+    end
+
+    def to_s
+      "#{File.basename(@file_ref.path)}:#{@line_no}"
+    end
+  end
+
+end

data/lib/xdry/parsing/scope_stack.rb

@@ -0,0 +1,68 @@
+
+module XDry
+
+  class ScopeStack
+
+    attr_accessor :verbose
+
+    def initialize root_scopes
+      @stack = []
+      root_scopes.each { |scope| push(scope) }
+    end
+
+    def parse_line line, eol_comments, indent
+      parse_line_using_parser! line, eol_comments, indent do |node|
+        unless node.nil?  # to simply code we allow the parser to yield nil when it cannot parse something
+          # update the scope based on this new node
+          while @current_scope.ends_after? node
+            yield @current_scope, node
+            pop
+          end
+          if subscope = @current_scope.subscope_for(node)
+            # a subscope is added as a child of its parent scope
+            yield @current_scope, subscope
+            subscope.assert_bound!
+            push subscope
+          end
+          # add the new node to the scope we have finally decided on
+          yield @current_scope, node
+        end
+      end
+    end
+
+    def current_scope
+      @current_scope
+    end
+
+  private
+
+    def parse_line_using_parser! line, eol_comments, indent
+      parsed = false
+      @current_scope.parser.parse_line! line, eol_comments, indent do |node|
+        parsed = true
+        yield node
+      end
+      unless parsed
+        yield NLine.new(line)
+      end
+    end
+
+    def push subscope
+      raise StandardError, "Attempted to push a nil subscope" if subscope.nil?
+      @stack.push subscope
+      update_current_scope
+    end
+
+    def pop
+      @stack.pop
+      update_current_scope
+    end
+
+    def update_current_scope
+      old_scope, @current_scope = @current_scope, @stack[-1]
+      puts "#{old_scope} --> #{@current_scope}" if @verbose
+    end
+
+  end
+
+end

data/lib/xdry/parsing/scopes.rb

@@ -0,0 +1,61 @@
+
+module XDry
+
+  class SMethodImpl < ChildScope
+
+    parse_using PMethodImpl
+
+    on NMethodEnd, :pop, :store_into => :end_node
+
+    def selector
+      @start_node.selector
+    end
+
+  end
+
+  class SInterfaceFields < ChildScope
+
+    parse_using PInterfaceFields
+
+    on NInterfaceFieldsEnd, :pop, :store_into => :end_node
+
+  end
+
+  class SInterface < ChildScope
+
+    parse_using PInterfaceHeader
+
+    on NEnd, :pop, :store_into => :end_node
+    on NOpeningBrace, :start => SInterfaceFields
+    on SInterfaceFields, :store_into => :fields_scope
+
+    def class_name
+      @start_node.class_name
+    end
+
+  end
+
+  class SImplementation < ChildScope
+
+    parse_using PInterfaceHeader
+
+    on NEnd, :pop
+    on NSynthesize, :add_to => :synthesizes
+    on NMethodStart, :start => SMethodImpl
+
+    def class_name
+      @start_node.class_name
+    end
+
+  end
+
+  class SFile < Scope
+
+    parse_using PGlobal
+
+    on NInterfaceStart, :start => SInterface
+    on NImplementationStart, :start => SImplementation
+
+  end
+
+end

data/lib/xdry/parsing/scopes_support.rb

@@ -0,0 +1,143 @@
+
+module XDry
+
+  class Scope
+
+    attr_reader :model
+    attr_reader :children
+
+    def initialize
+      @children = []
+      self.class.child_collections.each do |var_name|
+        instance_variable_set("@#{var_name}", [])
+      end
+    end
+
+    def bind model
+      raise StandardError, "#{self} already bound to #{@model} when trying to bind to #{model}" unless @model.nil?
+      @model = model
+      self
+    end
+
+    def assert_bound!
+      raise StandardError, "#{self.class.name} hasn't been bound to a model" if @model.nil?
+    end
+
+    def parser
+      @parser ||= create_parser
+    end
+
+    def subscope_for node
+      if subscope_class = self.class.child_subscope_table[node.class]
+        subscope_class.new(self, node)
+      else
+        nil
+      end
+    end
+
+    def ends_after? node
+      self.class.stop_children.include? node.class
+    end
+
+    def << child
+      raise StandardError, "#{self.class.name} hasn't been bound to a model, but is trying to accept a child #{child}" if @model.nil?
+      @children << child
+      @model << child
+      child_added child
+    end
+
+    def child_added child
+      (self.class.child_action_table[child.class] || []).each { |action| action.call(self, child) }
+    end
+
+    def to_s
+      "#{self.class.name}:#{@model}"
+    end
+
+    def parent_scopes
+      []
+    end
+
+    def all_scopes
+      parent_scopes + [self]
+    end
+
+  protected
+
+    def create_parser
+      return self.class.parser_class.new(self) if self.class.parser_class
+      raise StandardError, "#{self.class.name} does not override create_parser"
+    end
+
+    class << self
+
+      attr_reader :parser_class
+
+      def parse_using parser_class
+        @parser_class = parser_class
+      end
+
+      # on NSome, :pop, :store_into => :my_var
+      # on NOther, :start => SOther
+      # on NAwesome, :add_to => :awesomes
+      def on child_class, *args
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        if args.include? :pop
+          stop_children << child_class
+        end
+        if options[:start]
+          child_subscope_table[child_class] = options[:start]
+        end
+        if var_name = options[:store_into]
+          (child_action_table[child_class] ||= []) << lambda do |instance, child|
+            instance.send(:instance_variable_set, "@#{var_name}", child)
+          end
+          attr_reader :"#{var_name}"
+        end
+        if coll_name = options[:add_to]
+          (child_action_table[child_class] ||= []) << lambda do |instance, child|
+            instance.send(:instance_variable_get, "@#{coll_name}") << child
+          end
+          child_collections << coll_name
+          attr_reader :"#{coll_name}"
+        end
+      end
+
+      def stop_children
+        @stop_children ||= []
+      end
+
+      def child_subscope_table
+        @child_subscope_table ||= {}
+      end
+
+      def child_action_table
+        @child_action_table ||= {}
+      end
+
+      def child_collections
+        @child_collections ||= []
+      end
+
+    end
+
+  end
+
+  class ChildScope < Scope
+
+    attr_reader :start_node
+    attr_reader :parent_scope
+
+    def initialize parent_scope, start_node
+      super()
+      @parent_scope = parent_scope
+      @start_node = start_node
+    end
+
+    def parent_scopes
+      parent_scope.all_scopes
+    end
+
+  end
+
+end

data/lib/xdry/patching/emitter.rb

@@ -0,0 +1,60 @@
+module XDry
+
+  class Emitter
+    attr_reader :lines
+
+    def initialize
+      @lines = []
+      @indent = "\t"
+      @current_indent = ""
+    end
+
+    def self.capture
+      emitter = Emitter.new
+      yield emitter
+      return emitter.lines
+    end
+
+    def << line
+      case line
+      when Emitter
+        @lines.push *line.lines.collect { |l| @current_indent + l }
+      when Array
+        @lines.push *line.collect { |l| @current_indent + l }
+      else
+        @lines << @current_indent + line
+      end
+    end
+
+    def indent
+      prev_indent = @current_indent
+      @current_indent = @current_indent + @indent
+      yield
+      @current_indent = prev_indent
+    end
+
+    def empty?
+      @lines.empty?
+    end
+
+    def to_s
+      @lines.collect { |line| line + "\n" }.join("")
+    end
+
+    def block prefix = ''
+      self << "#{prefix} {"
+      self.indent { yield }
+      self << "}"
+    end
+
+    def method decl, &block
+      self << ""
+      self.block "- #{decl}", &block
+    end
+
+    def if condition, &block
+      self.block "if (#{condition})", &block
+    end
+  end
+
+end