xdry 0.1.0

data/lib/xdry/generators/dictionary_coding.rb

@@ -0,0 +1,129 @@
+
+module XDry
+module Generators
+
+  class DictionaryCoding < Generator
+    id "dict-coding"
+
+    def process_class oclass
+      return unless oclass.attributes.any? { |a| a.persistent? }
+
+      dictionary_var = "dictionary"
+
+      defines_emitter = Emitter.new
+      init_out        = Emitter.new
+      repr_out        = Emitter.new
+
+      dictionary_var = "dictionary"
+
+      oclass.attributes.select { |a| a.persistent? }.each do |oattr|
+        name, type = oattr.name, oattr.type
+        field_name = oattr.field_name
+        raw_name = "#{name}Raw"
+        capitalized_name = name.capitalized_identifier
+        key_const = "#{capitalized_name}Key"
+
+        type_boxer = Boxing.converter_for type
+        if type_boxer.nil?
+          puts "Persistence not (yet) supported for type #{type}"
+          next
+        end
+
+        defines_emitter << %Q`\#define #{key_const} @"#{capitalized_name}"`
+
+        init_out << %Q`id #{raw_name} = [#{dictionary_var} objectForKey:#{key_const}];`
+        init_out.if "#{raw_name} != nil" do
+          unboxed = type_boxer.unbox_retained(init_out, raw_name, name)
+          init_out << "#{field_name} = #{unboxed};"
+        end
+
+        boxed = type_boxer.box(repr_out, field_name, name)
+        repr_out << %Q`[dictionary setObject:#{boxed} forKey:#{key_const}];`
+      end
+
+      init_code = Emitter.capture do |o|
+        o.method "(id)initWithDictionary:(NSDictionary *)#{dictionary_var}" do
+          o.if "self = [super init]" do
+          end
+          o << "return self;"
+        end
+      end
+
+      repr_code = Emitter.capture do |o|
+        o.method "(NSDictionary *)dictionaryRepresentation" do
+          o << "NSMutableDictionary *#{dictionary_var} = [NSMutableDictionary dictionary];"
+          o << "return #{dictionary_var};"
+        end
+      end
+
+      file_scope = oclass.main_implementation.parent_scope
+      define_ip = MultiIP.new(AfterDefineIP.new(file_scope), BeforeImplementationStartIP.new(oclass))
+      define_lines = Emitter.capture do |o|
+        each_persistent_attr(oclass) do |oattr, capitalized_name, key_const, type_boxer|
+          unless file_scope.children.any? { |n| NDefine === n && n.word == key_const }
+            o << %Q`\#define #{key_const} @"#{capitalized_name}"`
+          end
+        end
+      end
+      define_ip.wrap_with_empty_lines_if_last!
+      define_ip.insert @patcher, define_lines
+
+      MethodPatcher.new(patcher, oclass, 'dictionaryRepresentation', ImplementationStartIP.new(oclass), repr_code) do |omethod|
+        impl = omethod.impl
+        ip = BeforeReturnIP.new(impl)
+
+        lines = Emitter.capture do |o|
+          each_persistent_attr(oclass) do |oattr, capitalized_name, key_const, type_boxer|
+            unless impl.children.any? { |n| NLine === n && n.line =~ /\bsetObject:.*(?:\b#{oattr.name}|\b#{oattr.field_name}\b)/ }
+              boxed = type_boxer.box(o, oattr.field_name, oattr.name)
+              o << %Q`[dictionary setObject:#{boxed} forKey:#{key_const}];`
+            end
+          end
+        end
+
+        ip.insert @patcher, lines unless lines.empty?
+      end
+
+      MethodPatcher.new(patcher, oclass, 'initWithDictionary:', ImplementationStartIP.new(oclass), init_code) do |omethod|
+        impl = omethod.impl
+        ip = InsideConstructorIfSuperIP.new(impl)
+        var_name = impl.start_node.selector_def.var_name_after_keyword('initWithDictionary:')
+
+        lines = Emitter.capture do |o|
+          each_persistent_attr(oclass) do |oattr, capitalized_name, key_const, type_boxer|
+            unless impl.children.any? { |n| NLine === n && n.line =~ /^(?:self\s*.\s*#{oattr.name}|#{oattr.field_name})\s*=/ }
+              raw_name = "#{oattr.name}Raw"
+              o << %Q`id #{raw_name} = [#{var_name} objectForKey:#{key_const}];`
+              o.if "#{raw_name} != nil" do
+                unboxed = type_boxer.unbox_retained(o, raw_name, oattr.name)
+                o << "#{oattr.field_name} = #{unboxed};"
+              end
+            end
+          end
+        end
+
+        ip.insert @patcher, lines unless lines.empty?
+      end
+    end
+
+    def each_persistent_attr oclass
+      oclass.attributes.select { |a| a.persistent? }.each do |oattr|
+        name, type = oattr.name, oattr.type
+        field_name = oattr.field_name
+        capitalized_name = name.capitalized_identifier
+        key_const = "#{capitalized_name}Key"
+
+        type_boxer = Boxing.converter_for type
+        if type_boxer.nil?
+          puts "Persistence not (yet) supported for type #{type}"
+          next
+        end
+
+        yield oattr, capitalized_name, key_const, type_boxer
+      end
+    end
+
+  end
+
+end
+end

data/lib/xdry/generators/field_from_property.rb

@@ -0,0 +1,20 @@
+
+module XDry
+module Generators
+
+  class FieldFromProperty < Generator
+    id "field-from-prop"
+
+    def process_attribute oclass, oattr
+      if !oattr.has_field_def? && oattr.type_known? && !oclass.has_method_impl?(oattr.getter_selector)
+        lines = [oattr.new_field_def.to_source]
+        if oclass.main_interface # && oclass.main_interface.fields_scope
+          node = oclass.main_interface.fields_scope.end_node
+          patcher.insert_before node.pos, lines, node.indent + INDENT_STEP
+        end
+      end
+    end
+  end
+
+end
+end

data/lib/xdry/generators/property-from-field.rb

@@ -0,0 +1,22 @@
+
+module XDry
+module Generators
+
+  class PropertyFromField < Generator
+    id "prop-from-field"
+
+    def process_attribute oclass, oattr
+      if !oattr.has_property_def? && oattr.wants_property? && oattr.type_known?
+        pd = oattr.new_property_def
+
+        ip = BeforeInterfaceEndIP.new(oclass)
+        lines = Emitter.capture do |o|
+          o << pd.to_source
+        end
+        ip.insert patcher, [""] + lines + [""]
+      end
+    end
+  end
+
+end
+end

data/lib/xdry/generators/storing_constructor.rb

@@ -0,0 +1,72 @@
+
+module XDry
+module Generators
+
+  class StoringConstructor < Generator
+    id "store-ctor"
+
+    def process_class oclass
+      oclass.methods.each do |omethod|
+        case omethod.selector
+        when /^initWith/
+          process_method oclass, omethod
+        end
+      end
+    end
+
+    def process_method oclass, omethod
+      components = omethod.header_or_impl.selector_def.components
+      mapping = {}
+      components.each do |comp|
+        kw = comp.keyword_without_colon
+        oattr = oclass.find_attribute(kw)
+        if oattr.nil? and comp == components.first
+          stripped_kw = kw.gsub(/^initWith/, '')
+          [stripped_kw.downcase, stripped_kw[0..0].downcase + stripped_kw[1..-1]].each do |alt_kw|
+            oattr = oclass.find_attribute(alt_kw)
+            break unless oattr.nil?
+          end
+        end
+        mapping[kw] = oattr unless oattr.nil?
+      end
+
+      unless mapping.empty?
+        new_selector_def = CompoundSelectorDef.new(components.collect do |comp|
+          if oattr = mapping[kw = comp.keyword_without_colon]
+            arg_name = comp.arg_name
+            arg_name = oattr.name if arg_name.empty?
+            SelectorComponent.new(comp.keyword, arg_name, comp.type || oattr.type)
+          else
+            comp
+          end
+        end)
+        method_header = NMethodHeader.new(new_selector_def, omethod.ret_type)
+
+        init_out = Emitter.new
+
+        new_selector_def.components.each do |comp|
+          if oattr = mapping[kw = comp.keyword_without_colon]
+            field_name = oattr.field_name
+            arg_name = comp.arg_name
+            type = comp.type
+            retain_policy = Boxing.retain_policy_of(type)
+
+            retained = retain_policy.retain(arg_name)
+            init_out << "#{field_name} = #{retained};"
+          end
+        end
+
+        # out << "#{method_header};"
+        # out.block "#{method_header}" do
+        #   out.if "self = [super init]" do
+        #     out << init_out
+        #   end
+        #   out << "return self;"
+        # end
+      end
+    end
+
+  end
+
+end
+end

data/lib/xdry/generators/synthesize.rb

@@ -0,0 +1,25 @@
+
+module XDry
+module Generators
+
+  class Synthesize < Generator
+    id "synth"
+
+    def process_attribute oclass, oattr
+      if oattr.has_property_def? && !oattr.has_synthesize? && !oclass.has_method_impl?(oattr.getter_selector)
+        synthesize = oattr.new_synthesize
+        impl = oclass.main_implementation
+        new_lines = [synthesize.to_s]
+        if impl.synthesizes.empty?
+          pos = impl.start_node.pos
+          new_lines = [""] + new_lines + [""]
+        else
+          pos = impl.synthesizes.sort { |a, b| a.pos.line_no <=> b.pos.line_no }.last.pos
+        end
+        patcher.insert_after pos, new_lines
+      end
+    end
+  end
+
+end
+end

data/lib/xdry/generators_support.rb

@@ -0,0 +1,42 @@
+
+module XDry::Generators
+
+  ALL = []
+
+  Emitter = XDry::Emitter
+  Boxing  = XDry::Boxing
+
+  class Generator
+
+    attr_reader :patcher
+
+    def initialize config, patcher
+      @config = config
+      @patcher = patcher
+    end
+
+    def verbose?
+      @config.verbose
+    end
+
+    def process_class oclass
+      oclass.attributes.each do |oattr|
+        process_attribute oclass, oattr
+      end
+    end
+
+    def process_attribute oclass, oattr
+    end
+
+    def self.id(value=nil)
+      @id = value if value
+      @id
+    end
+
+    def self.inherited subclass
+      ALL << subclass
+    end
+
+  end
+
+end

data/lib/xdry/parsing/driver.rb

@@ -0,0 +1,106 @@
+require 'generator'
+require 'stringio'
+
+module XDry
+
+  class ParsingDriver
+    attr_accessor :verbose
+    attr_reader :markers
+
+    def initialize oglobal
+      @oglobal = oglobal
+      @verbose = false
+      @markers = []
+    end
+
+    def parse_file file_name
+      gen = Generator.new { |g|
+        file_ref = FileRef.new(file_name)
+        File.open(file_name) do |file|
+          new_lines_generator g, file_ref, file
+        end
+      }
+      parse_data_in_file_scope gen
+    end
+
+    def parse_string file_name, source
+      gen = Generator.new { |g|
+        file_ref = TestFileRef.new(file_name, source)
+        new_lines_generator g, file_ref, StringIO.new(source)
+      }
+      parse_data_in_file_scope gen
+    end
+
+    def parse_fragment file_ref, lines, start_lineno, start_scope
+      gen = Generator.new { |g|
+        new_lines_from_array_generator g, file_ref, start_lineno, lines
+      }
+      parse_data_in_scopes gen, start_scope.all_scopes
+    end
+
+  private
+
+    def parse_data_in_file_scope gen
+      parse_data_in_scopes gen, [@oglobal.new_file_scope]
+    end
+
+    def parse_data_in_scopes gen, scopes
+      scope_stack = ScopeStack.new(scopes)
+      scope_stack.verbose = @verbose
+      while gen.next?
+        orig_line, line, pos, eol_comments, indent = gen.next
+        puts "        #{pos} #{orig_line}" if @verbose
+        pos.scope_before = scope_stack.current_scope
+        scope_stack.parse_line line, eol_comments, indent do |scope, child|
+          # child is a Node or a Scope
+          if child.is_a? Node
+            child.pos = pos
+            child.indent = indent
+          end
+          if child.is_a? NMarker
+            @markers << child
+          end
+
+          puts "#{scope} << #{child}" if @verbose
+          scope << child
+        end
+        pos.scope_after = scope_stack.current_scope
+      end
+    end
+
+    def new_lines_generator g, file_ref, io
+      line_no = 0
+      io.each_line do |line|
+        line_no += 1
+        orig_line, line, eol_comments, indent = split_line(line)
+        g.yield [orig_line, line, Pos.new(file_ref, line_no), eol_comments, indent]
+      end
+    end
+
+    def new_lines_from_array_generator g, file_ref, start_lineno, lines
+      line_no = start_lineno - 1
+      lines.each do |line|
+        line_no += 1
+        orig_line, line, eol_comments, indent = split_line(line.dup)
+        g.yield [orig_line, line, Pos.new(file_ref, line_no), eol_comments, indent]
+      end
+    end
+
+    def split_line line
+      orig_line = line.dup
+      line.strip!
+
+      # strip end-of-line comments, but keep comment lines
+      eol_comments = ''
+      line_without_comments = line.sub(%r`//.*$`) { eol_comments = $&; '' }
+      unless line_without_comments.empty?
+        line = line_without_comments
+      end
+
+      indent = if orig_line =~ /^(\s+)/ then $1 else '' end
+      return [orig_line, line, eol_comments, indent]
+    end
+
+  end
+
+end

data/lib/xdry/parsing/model.rb

@@ -0,0 +1,272 @@
+
+module XDry
+
+  class OGlobal
+
+    def initialize
+      @names_to_classes = {}
+    end
+
+    def classes
+      @names_to_classes.values
+    end
+
+    def new_file_scope
+      SFile.new.bind(self)
+    end
+
+    def << child
+      case child
+      when SInterface
+        lookup_class(child.class_name).add_interface child
+      when SImplementation
+        lookup_class(child.class_name).add_implementation child
+      end
+    end
+
+  private
+
+    def lookup_class name
+      @names_to_classes[name] ||= OClass.new(self, name)
+    end
+  end
+
+  class OClass
+    attr_reader :oglobal
+    attr_reader :name, :field_defs, :attributes, :methods
+    attr_reader :interfaces
+    attr_reader :implementations
+
+    def initialize oglobal, name
+      @oglobal, @name = oglobal, name
+
+      @names_to_attributes = {}
+      @attributes = []
+
+      @selectors_to_methods = {}
+      @methods = []
+
+      @field_defs = []
+      @property_defs = []
+      @interfaces = []
+      @implementations = []
+    end
+
+    def add_interface child
+      @interfaces << child.bind(self)
+    end
+
+    def add_implementation child
+      @implementations << child.bind(self)
+    end
+
+    def main_interface
+      # FIXME
+      @interfaces.first
+    end
+
+    def main_implementation
+      # FIXME
+      @implementations.first
+    end
+
+    def << node
+      case node
+      when NFieldDef
+        @field_defs << node
+        attr_name = node.name.gsub /^_/, ''
+        lookup_attribute(attr_name).add_field_def! node
+      when NPropertyDef
+        @property_defs << node
+        attr_name = node.name
+        lookup_attribute(attr_name).add_property_def! node
+      when NMethodHeader
+        selector = node.selector
+        lookup_method(selector).add_method_header! node
+      when NSynthesize
+        node.items.each do |item|
+          lookup_attribute(item.property_name).add_synthesize! node
+        end
+      when SInterfaceFields
+        node.bind(self)
+      when SMethodImpl
+        lookup_method(node.selector).add_method_impl! node
+      end
+    end
+
+    def to_s
+      "class #{name}"
+    end
+
+    def find_attribute name
+      @names_to_attributes[name]
+    end
+
+    def find_method selector
+      @selectors_to_methods[selector]
+    end
+
+    def has_method_impl? selector
+      m = find_method(selector)
+      return m && m.has_impl?
+    end
+
+  private
+
+    def lookup_attribute name
+      @names_to_attributes[name] ||= create_attribute(name)
+    end
+
+    def lookup_method selector
+      @selectors_to_methods[selector] ||= create_method(selector)
+    end
+
+    def create_attribute name
+      a = OAttribute.new(self, name)
+      @attributes << a
+      return a
+    end
+
+    def create_method selector
+      a = OMethod.new(selector)
+      @methods << a
+      return a
+    end
+
+  end
+
+  class OAttribute
+    attr_reader :name
+    attr_reader :field_def
+
+    def initialize oclass, name
+      @oclass, @name = oclass, name
+
+      @field_def    = nil
+      @property_def = nil
+      @synthesizes  = []
+    end
+
+    def field_name
+      if @field_def
+        @field_def.name
+      else
+        FIELD_PREFIX + name
+      end
+    end
+
+    def add_field_def! field_def
+      @field_def = field_def
+    end
+
+    def add_property_def! property_def
+      @property_def = property_def
+    end
+
+    def add_synthesize! synthesize
+      @synthesizes << synthesize
+    end
+
+    def has_field_def?
+      not @field_def.nil?
+    end
+
+    def has_property_def?
+      not @property_def.nil?
+    end
+
+    def has_synthesize?
+      not @synthesizes.empty?
+    end
+
+    def new_property_def
+      NPropertyDef.new(name, type)
+    end
+
+    def new_field_def
+      NFieldDef.new(field_name, type)
+    end
+
+    def new_synthesize
+      NSynthesize.new([SynthesizeItem.new(name, (field_name == name ? nil : field_name) )])
+    end
+
+    def persistent?
+      @field_def && @field_def.persistent?
+    end
+
+    def type_known?
+      not type.nil?
+    end
+
+    def wants_property?
+      has_field_def? && field_def.wants_property?
+    end
+
+    def wants_constructor?
+      has_field_def? && field_def.wants_constructor?
+    end
+
+    def getter_selector
+      # FIXME: need to account for a possible selector override declared in @property
+      @name
+    end
+
+    def type
+      if @property_def
+        @property_def.type
+      elsif @field_def
+        @field_def.type
+      else
+        nil
+      end
+    end
+
+    def to_s
+      traits = []
+      traits << field_name if has_field_def?
+      "#{type} #{name}" + (traits.empty? ? "" : " (" + traits.join(", ") + ")")
+    end
+  end
+
+  class OMethod
+    attr_reader :selector, :header, :impl
+
+    def initialize selector
+      @selector = selector
+    end
+
+    def add_method_header! method_header
+      @header = method_header
+    end
+
+    def add_method_impl! method_impl
+      @impl = method_impl.bind(self)
+    end
+
+    def has_header?
+      not @header.nil?
+    end
+
+    def has_impl?
+      not @impl.nil?
+    end
+
+    def ret_type
+      header_or_impl.ret_type
+    end
+
+    def << child
+    end
+
+    def to_s
+      header_or_impl.to_s
+    end
+
+    def header_or_impl
+      @header || @impl.start_node
+    end
+
+  end
+
+end