xdry 0.1.0

data/lib/xdry/patching/insertion_points.rb

@@ -0,0 +1,209 @@
+
+module XDry
+
+  class InsertionPoint
+
+    attr_reader :method, :node, :ip
+
+    def initialize
+      find!
+    end
+
+    def insert patcher, lines
+      raise StandardError, "#{self.class.name} has not been found but trying to insert" unless found?
+      patcher.send(@method, @node.pos, wrap(lines), @indent)
+    end
+
+    def found?
+      not @method.nil?
+    end
+
+  protected
+
+    def wrap lines
+      lines
+    end
+
+    def before node
+      @method = :insert_before
+      @node = node
+      @indent = node.indent
+    end
+
+    def after node
+      @method = :insert_after
+      @node = node
+      @indent = node.indent
+    end
+
+    def indented_before node
+      before node
+      @indent = @indent + INDENT_STEP
+    end
+
+    def indented_after node
+      after node
+      @indent = @indent + INDENT_STEP
+    end
+
+    def try insertion_point
+      if insertion_point.found?
+        @method, @node, @ip = insertion_point.method, insertion_point.node, insertion_point
+        true
+      else
+        false
+      end
+    end
+
+    def find!
+    end
+
+  end
+
+  class ImplementationStartIP < InsertionPoint
+
+    def initialize oclass
+      @oclass = oclass
+      super()
+    end
+
+    def find!
+      after @oclass.main_implementation.start_node
+    end
+
+  end
+
+  class BeforeImplementationStartIP < InsertionPoint
+
+    def initialize oclass
+      @oclass = oclass
+      super()
+    end
+
+    def find!
+      before @oclass.main_implementation.start_node
+    end
+
+  end
+
+  class BeforeInterfaceEndIP < InsertionPoint
+
+    def initialize oclass
+      @oclass = oclass
+      super()
+    end
+
+    def find!
+      before @oclass.main_interface.end_node
+    end
+
+  end
+
+  class BeforeSuperCallIP < InsertionPoint
+
+    def initialize scope
+      @scope = scope
+      super()
+    end
+
+    def find!
+      child_node = @scope.children.find { |child| child.is_a? NSuperCall }
+      if child_node.nil?
+        indented_before @scope.ending_node
+      else
+        before child_node
+      end
+    end
+
+  end
+
+  class BeforeReturnIP < InsertionPoint
+
+    def initialize scope
+      @scope = scope
+      super()
+    end
+
+    def find!
+      child_node = @scope.children.find { |child| child.is_a? NReturn }
+      if child_node.nil?
+        before @scope.ending_node
+      else
+        before child_node
+      end
+    end
+
+  end
+
+  class AfterDefineIP < InsertionPoint
+
+    def initialize scope
+      @scope = scope
+      super()
+    end
+
+    def find!
+      child_nodes = @scope.children.select { |child| child.is_a? NDefine }
+      unless child_nodes.empty?
+        after child_nodes.last
+      end
+    end
+
+  end
+
+  class InsideConstructorIfSuperIP < InsertionPoint
+
+    def initialize scope
+      @scope = scope
+      super()
+    end
+
+    def find!
+      if_start_node = @scope.children.find { |child| child.is_a? NSuperCall }
+      if if_start_node.nil?
+        indented_before @scope.ending_node
+      else
+        if_end_node = @scope.children.find { |child| child.is_a?(NClosingBrace) && child.indent == if_start_node.indent }
+        if if_end_node.nil?
+          indented_after if_start_node
+        else
+          indented_before if_end_node
+        end
+      end
+    end
+
+  end
+
+  class MultiIP < InsertionPoint
+
+    def initialize *insertion_points
+      @insertion_points = insertion_points
+      @last_before = []
+      @last_after  = []
+      super()
+    end
+
+    def wrap_if_last! before, after
+      @last_before = before
+      @last_after  = after
+    end
+
+    def wrap_with_empty_lines_if_last!
+      wrap_if_last! [""], [""]
+    end
+
+    def find!
+      @insertion_points.detect { |ip| try ip }
+    end
+
+    def wrap lines
+      if @ip == @insertion_points.last
+        @last_before + lines + @last_after
+      else
+        lines
+      end
+    end
+
+  end
+
+end

data/lib/xdry/patching/item_patchers.rb

@@ -0,0 +1,74 @@
+
+module XDry
+
+  class ItemPatcher
+
+    attr_reader :item
+    attr_reader :patcher
+
+    def initialize patcher
+      @patcher = patcher
+      find!
+      yield @item if block_given? && found?
+    end
+
+    def found?
+      not item.nil?
+    end
+
+  protected
+
+    def find
+    end
+
+    def insertion_point
+    end
+
+    def new_code
+    end
+
+  private
+
+    def find!
+      @item = find
+      if @item.nil?
+        patch!
+        @item = find
+        raise StandardError, "#{self.class.name} cannot find item even after adding a new one" if @item.nil?
+      end
+    end
+
+    def patch!
+      insertion_point.insert patcher, new_code
+    end
+
+  end
+
+  class MethodPatcher < ItemPatcher
+
+    attr_reader :oclass
+    attr_reader :insertion_point
+    attr_reader :new_code
+
+    def initialize patcher, oclass, selector, insertion_point, new_code
+      @oclass = oclass
+      @selector = selector
+      @insertion_point = insertion_point
+      @new_code = new_code
+      super(patcher)
+    end
+
+  protected
+
+    def find
+      find_method_impl_by_selector(@selector)
+    end
+
+    def find_method_impl_by_selector selector
+      m = oclass.find_method(selector)
+      m && (m.has_impl? ? m : nil)
+    end
+
+  end
+
+end

data/lib/xdry/patching/patcher.rb

@@ -0,0 +1,139 @@
+
+module XDry
+
+  class Patcher
+
+    attr_accessor :dry_run, :verbose
+
+    def initialize
+      @patched = {}
+      @dry_run = true
+    end
+
+    def insert_after pos, new_lines, indent = '', parse = true
+      do_insert_after pos.file_ref, pos.scope_after, pos.line_no - 1, new_lines, indent || '', parse
+    end
+
+    def insert_before pos, new_lines, indent = '', parse = true
+      do_insert_after pos.file_ref, pos.scope_before, pos.line_no - 2, new_lines, indent || '', parse
+    end
+
+    def delete_line pos
+      do_delete_lines pos.file_ref, pos.line_no - 1, 1
+    end
+
+    def replace_line pos
+      old_line = patched_lines_of(pos.file_ref)[pos.line_no-1].rstrip
+      new_line = yield(old_line)
+      delete_line pos
+      insert_before pos, [new_line], '', false
+    end
+
+    def do_delete_lines file_ref, line_index, line_count
+      lines = patched_lines_of(file_ref)
+
+      if @verbose
+        puts "DELETING #{line_count} LINE(S) FROM LINE NO.#{line_index+1}:"
+        lines[line_index .. line_index+line_count-1].each { |line| puts "    #{line}" }
+      end
+
+      file_ref.fixup_positions! line_index+line_count, -line_count
+      lines[line_index .. line_index+line_count-1] = []
+    end
+
+    def do_insert_after file_ref, start_scope, line_index, new_lines, indent, parse
+      new_lines = new_lines.collect { |line| line.blank? ? line : indent + line }
+      new_lines = new_lines.collect { |line| line.gsub("\t", INDENT_STEP) }
+      lines = patched_lines_of(file_ref)
+
+      if @verbose
+        puts "INSERTING LINES AFTER LINE NO.#{line_index+1}:"
+        new_lines.each { |line| puts "    #{line}" }
+        puts "  AFTER LINE:"
+        puts "    #{lines[line_index]}"
+      end
+
+      # collapse leading/trailing empty lines with the empty lines that already exist
+      # in the source code
+
+      # when line_index == -1 (insert at the beginning of the file), there are no leading lines
+      if line_index >= 0
+        desired_leading_empty_lines = new_lines.prefix_while(&:blank?).length
+        actual_leading_empty_lines  = lines[0..line_index].suffix_while(&:blank?).length
+        leading_lines_to_remove     = [actual_leading_empty_lines, desired_leading_empty_lines].min
+        new_lines = new_lines[leading_lines_to_remove .. -1]
+      end
+
+      # if all lines were empty, the number of trailing empty lines might have changed
+      # after removal of some leading lines, so we compute this after the removal
+      desired_trailing_empty_lines = new_lines.suffix_while(&:blank?).length
+      actual_trailing_empty_lines  = lines[line_index+1..-1].prefix_while(&:blank?).length
+      trailing_lines_to_remove     = [actual_trailing_empty_lines, desired_trailing_empty_lines].min
+      new_lines = new_lines[0 .. -(trailing_lines_to_remove+1)]
+
+      file_ref.fixup_positions! line_index+1, new_lines.size
+
+      lines[line_index+1 .. line_index+1] = new_lines.collect { |line| "#{line}\n" } + [lines[line_index+1]]
+
+      if parse
+        driver = ParsingDriver.new(nil)
+        driver.verbose = @verbose
+        driver.parse_fragment file_ref, new_lines, line_index+1+1, start_scope
+      end
+    end
+
+    def save!
+      changed_file_refs = []
+      for file_ref, lines in @patched
+        original_path = file_ref.path
+
+        text = lines.join("")
+        next if text == file_ref.read
+
+        changed_file_refs << file_ref
+
+        new_path = if @dry_run
+          ext = File.extname(original_path)
+          File.join(File.dirname(original_path), File.basename(original_path, ext) + '.xdry' + ext)
+        else
+          original_path
+        end
+
+        open(new_path, 'w') { |f| f.write text }
+      end
+      @patched = {}
+      return changed_file_refs
+    end
+
+    def retrieve!
+      result = {}
+      for file_ref, lines in @patched
+        result[file_ref.path] = lines.join("")
+      end
+      @patched = {}
+      return result
+    end
+
+    def remove_marker! marker
+      if marker.is_a? NFullLineMarker
+        delete_line marker.pos
+      else
+        replace_line marker.pos do |old_line|
+          old_line.gsub(marker.text, '').gsub(/ +$/, '')
+        end
+      end
+    end
+
+  private
+
+    def patched_lines_of file_ref
+      @patched[file_ref] ||= load_lines_of(file_ref)
+    end
+
+    def load_lines_of file_ref
+      file_ref.read.lines.collect
+    end
+
+  end
+
+end

data/lib/xdry/run.rb

@@ -0,0 +1,227 @@
+require 'optparse'
+
+module XDry
+
+  def self.produce_everything oglobal, patcher, config
+    puts "Generating code... " if config.verbose
+
+    generators = Generators::ALL.select { |klass| config.enabled?(klass.id) }.
+        collect { |klass| klass.new(config, patcher) }
+
+    if config.verbose
+      puts "Running generators: " + generators.collect { |gen| gen.class.id }.join(", ")
+    end
+
+    oglobal.classes.each do |oclass|
+      puts "  - #{oclass.name}" if config.verbose
+
+      if config.verbose
+        oclass.attributes.each do |oattr|
+          puts "      #{oattr}"
+        end
+
+        oclass.methods.each do |omethod|
+          puts "      #{omethod}"
+        end
+
+        oclass.implementations.each do |nimpl|
+          puts "      #{nimpl}"
+          nimpl.synthesizes.each do |nsynth|
+            puts "        #{nsynth}"
+          end
+        end
+      end
+
+      generators.each { |gen| gen.process_class(oclass) }
+    end
+  end
+
+  class Config < Struct.new(:only, :dry_run, :watch, :verbose, :disable, :enable_only)
+
+    def initialize
+      self.only = nil
+      self.dry_run = false
+      self.watch = false
+      self.verbose = false
+      self.disable = []
+      self.enable_only = nil
+    end
+
+    def enabled? gen_id
+      (enable_only.nil? || enable_only.include?(gen_id)) && !disable.include?(gen_id)
+    end
+
+  end
+
+  def self.parse_command_line_config(args)
+      config = Config.new
+
+      opts = OptionParser.new do |opts|
+          opts.banner = "Usage: xdry [options]"
+
+          opts.separator ""
+          opts.separator "General options:"
+
+          opts.on("-w", "--watch", "Watch for file system changes and rerun each time .h/.m is modified") do
+            config.watch = true
+          end
+
+          opts.separator ""
+          opts.separator "Filtering options:"
+
+          opts.on("-o", "--only=MASK", "Only process files matching this mask") do |v|
+              config.only = v
+          end
+
+          opts.separator ""
+          opts.separator "Choosing which generators to run:"
+
+          opts.on("-e", "--enable-only=LIST", "Only run the given generators (e.g.: -e dealloc,synth)") do |v|
+            config.enable_only = v.split(",").collect { |n| n.strip }
+
+            all = XDry::Generators::ALL.collect { |kl| kl.id }
+            unless (unsup = config.enable_only - all).empty?
+              puts "Unknown generator names in -e: #{unsup.join(', ')}."
+              puts "Supported names are: #{all.join(', ')}."
+              exit 1
+            end
+          end
+
+          opts.on("-d", "--disable=LIST", "Disable the given generators (e.g.: -d dealloc,synth)") do |v|
+            config.disable = v.split(",").collect { |n| n.strip }
+
+            all = XDry::Generators::ALL.collect { |kl| kl.id }
+            unless (unsup = config.disable - all).empty?
+              puts "Unknown generator names in -d: #{unsup.join(', ')}."
+              puts "Supported names are: #{all.join(', ')}."
+              exit 1
+            end
+          end
+
+          opts.on("--list", "List all supported generators and exit") do |v|
+            XDry::Generators::ALL.each { |kl| puts "#{kl.id}" }
+            exit
+          end
+
+          opts.separator ""
+          opts.separator "Patching options:"
+
+          opts.on("-n", "--dry-run", "Save changed files as .xdry.{h/m}") do |v|
+            config.dry_run = true
+          end
+
+          opts.separator ""
+          opts.separator "Common options:"
+
+          opts.on("-v", "--verbose", "Print TONS of progress information") do
+            config.verbose = true
+          end
+
+          opts.on_tail("-h", "--help", "Show this message") do
+              puts opts
+              exit
+          end
+      end
+
+      opts.parse!(args)
+      return config
+  end
+
+  def self.run_once config
+    oglobal = OGlobal.new
+
+    parser = ParsingDriver.new(oglobal)
+    parser.verbose = config.verbose
+
+    Dir["**/*.m"].each do |m_file|
+      next if config.only and not File.fnmatch(config.only, m_file)
+      next if m_file =~ /\.xdry\./
+      h_file = m_file.sub /\.m$/, '.h'
+      if File.file? h_file
+        puts h_file if config.verbose
+
+        parser.parse_file(h_file)
+        parser.parse_file(m_file)
+      end
+    end
+
+    patcher = Patcher.new
+    patcher.dry_run = config.dry_run
+    patcher.verbose = config.verbose
+
+    parser.markers.each { |marker| patcher.remove_marker! marker }
+
+    self.produce_everything(oglobal, patcher, config)
+
+    return patcher.save!
+  end
+
+  def self.test_run sources, config
+    oglobal = OGlobal.new
+
+    parser = ParsingDriver.new(oglobal)
+    parser.verbose = config.verbose
+    sources.each do |file_path, content|
+      parser.parse_string file_path, content
+    end
+
+    patcher = Patcher.new
+    patcher.verbose = config.verbose
+
+    parser.markers.each { |marker| patcher.remove_marker! marker }
+
+    self.produce_everything(oglobal, patcher, config)
+
+    return patcher.retrieve!
+  end
+
+  def self.run args
+    config = parse_command_line_config(args)
+
+    while Dir.pwd != '/' && Dir['*.xcodeproj'] == []
+      Dir.chdir('..')
+    end
+    if Dir['*.xcodeproj'] == []
+      puts "Cannot find *.xcodeproj in any of the parent directories. Stop."
+      exit 1
+    end
+
+    changed_file_refs = run_once config
+
+    if config.watch
+      require 'rubygems'
+      require 'fssm'
+      rebuild = lambda do |base, relative|
+        unless File.basename(relative) == 'xdry.m'
+          changed_file_refs = run_once(config)
+          unless changed_file_refs.empty?
+            system "growlnotify", "-a", "Xcode", "-t", "XD.R.Y.", "-m", "Updating..."
+            system "osascript", "-e", '
+              tell application "Finder" to activate
+              delay 0.3
+              tell application "Xcode" to activate
+              delay 0.5
+              tell application "System Events" to keystroke "u" using {command down}
+            '
+            system "growlnotify", "-a", "Xcode", "-t", "XD.R.Y.", "-m", "Updated!"
+          end
+        end
+      end
+      puts
+      puts "Monitoring for file system changes..."
+      FSSM.monitor '.', ['**/*.{h,m}'] do |monitor|
+        monitor.create &rebuild
+        monitor.update &rebuild
+        monitor.delete &rebuild
+      end
+    else
+      if changed_file_refs.empty?
+        puts "No changes."
+      else
+        puts "Modified:"
+        changed_file_refs.each { |ref| puts "-> #{ref.path}" }
+      end
+    end
+  end
+
+end