moblues 0.1.0 → 0.2.0

data/spec/lib/moblues/generator/base/type_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'moblues/generator/base/type'
+
+describe Moblues::Generator::Base::Type do
+  shared_examples_for 'attribute_type' do |attribute, expected|
+    it "returns #{expected} for #{attribute.type}" do
+      expect(subject.attribute_type(attribute)).to eq(expected)
+    end
+  end
+
+  shared_examples_for 'relationship_type' do |relationship, expected|
+    it "returns #{expected} for #{relationship}" do
+      expect(subject.relationship_type(relationship)).to eq(expected)
+    end
+  end
+
+  context 'SWIFT' do
+    subject { described_class.new(Moblues::Generator::Base::Type::SWIFT) }
+
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :string),  'String'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :number),  'NSNumber'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :decimal), 'NSDecimalNumber'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :date),    'NSDate'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :data),    'NSData'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :id),      'AnyObject'
+
+    it_behaves_like 'relationship_type', FactoryGirl.build(:relationship, :single),          'DestinationEntity'
+    it_behaves_like 'relationship_type', FactoryGirl.build(:relationship, :to_many),         'NSSet'
+    it_behaves_like 'relationship_type', FactoryGirl.build(:relationship, :to_many_ordered), 'NSOrderedSet'
+  end
+
+  context 'OBJC' do
+    subject { described_class.new(Moblues::Generator::Base::Type::OBJC) }
+
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :string),  'NSString *'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :number),  'NSNumber *'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :decimal), 'NSDecimalNumber *'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :date),    'NSDate *'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :data),    'NSData *'
+    it_behaves_like 'attribute_type', FactoryGirl.build(:attribute, :id),      'id '
+
+    it_behaves_like 'relationship_type', FactoryGirl.build(:relationship, :single),          'DestinationEntity *'
+    it_behaves_like 'relationship_type', FactoryGirl.build(:relationship, :to_many),         'NSSet *'
+    it_behaves_like 'relationship_type', FactoryGirl.build(:relationship, :to_many_ordered), 'NSOrderedSet *'
+  end
+end

data/spec/lib/moblues/generator/objc/human_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'moblues/generator/objc/human'
+require 'moblues/data_model'
+
+describe Moblues::Generator::Objc::Human do
+  let(:entity) { Moblues::DataModel::Entity.new(name: 'Author') }
+  let(:output_dir) { Fixtures.generated_dir(:objc) }
+
+  after do
+    Fixtures.delete_tmp_files(%w{Author.h Author.m}, :objc)
+  end
+
+  describe '#generate' do
+    it 'generates a human header' do
+      subject.generate(output_dir, entity)
+
+      expect(Fixtures.generated_file_content('Author.h', :objc)).to eq(Fixtures.expected_content('Author.h', :objc))
+    end
+
+    it 'generates a human implementation' do
+      subject.generate(output_dir, entity)
+
+      expect(Fixtures.generated_file_content('Author.m', :objc)).to eq(Fixtures.expected_content('Author.m', :objc))
+    end
+
+    context 'if the header already exists' do
+      before do
+        File.open(File.join(Fixtures.generated_dir(:objc), 'Author.h'), 'w+') do |f|
+          f.write('do nothing')
+        end
+      end
+
+      it 'does not overwrite the header file' do
+        subject.generate(output_dir, entity)
+
+        expect(Fixtures.generated_file_content('Author.h', :objc)).to eq('do nothing')
+      end
+    end
+
+    context 'if the implementation already exists' do
+      before do
+        File.open(File.join(Fixtures.generated_dir(:objc), 'Author.m'), 'w+') do |f|
+          f.write('do nothing')
+        end
+      end
+
+      it 'does not overwrite the implementation file' do
+        subject.generate(output_dir, entity)
+
+        expect(Fixtures.generated_file_content('Author.m', :objc)).to eq('do nothing')
+      end
+    end
+  end
+end

data/spec/lib/moblues/generator/{machine_spec.rb → objc/machine_spec.rb}

@@ -1,26 +1,27 @@
 require 'spec_helper'
-require 'moblues/generator/machine'
+require 'moblues/generator/objc/machine'
 require 'moblues/data_model'
 
-describe Moblues::Generator::Machine do
-  subject { described_class.new(output_dir: Fixtures.generated_dir) }
+describe Moblues::Generator::Objc::Machine do
+  let(:output_dir) { Fixtures.generated_dir(:objc) }
 
   after do
-    Fixtures.delete_tmp_files(%w{_Author.h _Author.m _Person.h _Person.m _Book.h _Book.m})
+    tmp_files = %w{Author Person Book Team}.map { |klass| %W{_#{klass}.h _#{klass}.m} }.flatten
+    Fixtures.delete_tmp_files(tmp_files, :objc)
   end
 
   describe '#generate' do
     shared_examples_for 'machine_generator' do |name|
       it 'generates a header' do
-        subject.generate(entity)
+        subject.generate(output_dir, entity)
 
-        expect(Fixtures.generated_file_content(header(name))).to eq(Fixtures.expected_content(header(name)))
+        expect(Fixtures.generated_file_content(header(name), :objc)).to eq(Fixtures.expected_content(header(name), :objc))
       end
 
       it 'generates an implementation' do
-        subject.generate(entity)
+        subject.generate(output_dir, entity)
 
-        expect(Fixtures.generated_file_content(implementation(name))).to eq(Fixtures.expected_content(implementation(name)))
+        expect(Fixtures.generated_file_content(implementation(name), :objc)).to eq(Fixtures.expected_content(implementation(name), :objc))
       end
     end
 

data/spec/lib/moblues/generator/objc/type_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'moblues/generator/objc/type'
+
+describe Moblues::Generator::Objc::Type do
+  describe '#property_attributes' do
+    shared_examples_for 'property_attributes' do |attribute, expected|
+      it "returns #{expected} for #{attribute.type}" do
+        expect(subject.property_attributes(attribute)).to eq(expected)
+      end
+    end
+
+    it_behaves_like 'property_attributes', FactoryGirl.build(:attribute, :string),  %w(nonatomic copy)
+    it_behaves_like 'property_attributes', FactoryGirl.build(:attribute, :number),  %w(nonatomic strong)
+    it_behaves_like 'property_attributes', FactoryGirl.build(:attribute, :decimal), %w(nonatomic strong)
+    it_behaves_like 'property_attributes', FactoryGirl.build(:attribute, :date),    %w(nonatomic strong)
+    it_behaves_like 'property_attributes', FactoryGirl.build(:attribute, :data),    %w(nonatomic strong)
+    it_behaves_like 'property_attributes', FactoryGirl.build(:attribute, :id),      %w(nonatomic strong)
+
+    it 'raises ArgumentError when the type is unknown' do
+      expect { subject.property_attributes(FactoryGirl.build(:attribute, :unknown)) }.to raise_exception
+    end
+  end
+end

data/spec/lib/moblues/generator/swift/human_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'moblues/generator/swift/human'
+
+describe Moblues::Generator::Swift::Human do
+  let(:output_dir) { Fixtures.generated_dir(:swift) }
+
+  let(:entity) { Moblues::DataModel::Entity.new(name: 'Author') }
+
+  after do
+    Fixtures.delete_tmp_files(%w{Author.swift}, :swift)
+  end
+
+  describe '#generate' do
+    it 'generates a human file' do
+      subject.generate(output_dir, entity)
+
+      expect(Fixtures.generated_file_content('Author.swift', :swift)).to eq(Fixtures.expected_content('Author.swift', :swift))
+    end
+
+    context 'if the file already exists' do
+      before do
+        File.open(File.join(Fixtures.generated_dir(:swift), 'Author.swift'), 'w+') do |f|
+          f.write('do nothing')
+        end
+      end
+
+      it 'does not overwrite the it' do
+        subject.generate(output_dir, entity)
+
+        expect(Fixtures.generated_file_content('Author.swift', :swift)).to eq('do nothing')
+      end
+    end
+  end
+end

data/spec/lib/moblues/generator/swift/machine_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'moblues/generator/swift/machine'
+
+describe Moblues::Generator::Swift::Machine do
+  let(:output_dir) { Fixtures.generated_dir(:swift) }
+
+  after do
+    tmp_files = %w{Author Book}.map { |klass| "_#{klass}.swift" }
+    Fixtures.delete_tmp_files(tmp_files, :swift)
+  end
+
+  describe '#generate' do
+    shared_examples_for 'machine_generator' do |name|
+      it 'generates a swift file' do
+        subject.generate(output_dir, entity)
+
+        expect(Fixtures.generated_file_content(file(name), :swift)).to eq(Fixtures.expected_content(file(name), :swift))
+      end
+    end
+
+    context 'with a complex entity' do
+      let(:entity) { Moblues::DataModel::Entity.new(name:          'Author',
+                                                    parent_entity: 'Person',
+                                                    attributes:    attributes,
+                                                    relationships: relationships) }
+      let(:attributes) {[
+        Moblues::DataModel::Attribute.new(name: 'dob', type: :date),
+        Moblues::DataModel::Attribute.new(name: 'name', type: :string)
+      ]}
+      let(:relationships) {[
+        Moblues::DataModel::Relationship.new(name: 'books', destination_entity: 'Book', to_many: true, ordered: true),
+        Moblues::DataModel::Relationship.new(name: 'essays', destination_entity: 'Book', to_many: true),
+        Moblues::DataModel::Relationship.new(name: 'publisher', destination_entity: 'Publisher')
+      ]}
+
+      it_behaves_like 'machine_generator', 'Author'
+    end
+
+    context 'with a simple entity' do
+      let(:entity) { Moblues::DataModel::Entity.new(name:          'Book',
+                                                    attributes:    attributes,
+                                                    relationships: relationships) }
+      let(:attributes) {[
+        Moblues::DataModel::Attribute.new(name: 'name', type: :string)
+      ]}
+      let(:relationships) {[
+        Moblues::DataModel::Relationship.new(name: 'editions', destination_entity: 'Edition', to_many: true)
+      ]}
+
+      it_behaves_like 'machine_generator', 'Book'
+    end
+  end
+
+  def file(name)
+    "_#{name}.swift"
+  end
+end

data/spec/lib/moblues/reader/type_spec.rb

@@ -14,6 +14,9 @@ describe Moblues::Reader::Type do
     it_behaves_like 'map_type_str', 'Integer 32',     :number
     it_behaves_like 'map_type_str', 'Integer 64',     :number
     it_behaves_like 'map_type_str', 'Boolean',        :number
+    it_behaves_like 'map_type_str', 'Float',          :number
+    it_behaves_like 'map_type_str', 'Double',         :number
+    it_behaves_like 'map_type_str', 'Decimal',        :decimal
     it_behaves_like 'map_type_str', 'Date',           :date
     it_behaves_like 'map_type_str', 'Binary',         :data
     it_behaves_like 'map_type_str', 'Transformable',  :id
@@ -22,58 +25,4 @@ describe Moblues::Reader::Type do
       expect { subject.map_type_str('Unknown Type') }.to raise_exception(ArgumentError)
     end
   end
-
-  describe '#property_type' do
-    shared_examples 'property_type' do |type, property_type|
-      it "returns #{property_type} for #{type}" do
-        expect(subject.property_type(type)).to eq(property_type)
-      end
-    end
-
-    it_behaves_like 'property_type', :string, 'NSString *'
-    it_behaves_like 'property_type', :number, 'NSNumber *'
-    it_behaves_like 'property_type', :date,   'NSDate *'
-    it_behaves_like 'property_type', :data,   'NSData *'
-    it_behaves_like 'property_type', :id,     'id '
-
-    it 'raises an exception when the type is unknown' do
-      expect { subject.property_type(:unknown) }.to raise_exception(ArgumentError)
-    end
-  end
-
-  describe '#property_attributes' do
-    shared_examples 'property_attributes' do |type, attrs|
-      it "returns #{attrs} for #{type}" do
-        expect(subject.property_attributes(type)).to eq(attrs)
-      end
-    end
-
-    it_behaves_like 'property_attributes', :string, %w(nonatomic copy)
-    it_behaves_like 'property_attributes', :number, %w(nonatomic strong)
-    it_behaves_like 'property_attributes', :date,   %w(nonatomic strong)
-    it_behaves_like 'property_attributes', :data,   %w(nonatomic strong)
-    it_behaves_like 'property_attributes', :id,     %w(nonatomic strong)
-
-    it 'raises an exception when the type is unknown' do
-      expect { subject.property_attributes(:unknown) }.to raise_exception(ArgumentError)
-    end
-  end
-
-  describe '#relationship_type' do
-    shared_examples 'relationship_type' do |rel, type|
-      it "returns #{type} for #{rel}" do
-        expect(subject.relationship_type(rel)).to eq(type)
-      end
-    end
-
-    it_behaves_like 'relationship_type',
-                    Moblues::DataModel::Relationship.new(name: '', destination_entity: 'Dest'),
-                    'Dest *'
-    it_behaves_like 'relationship_type',
-                    Moblues::DataModel::Relationship.new(name: '', destination_entity: 'Dest', to_many: true),
-                    'NSSet *'
-    it_behaves_like 'relationship_type',
-                    Moblues::DataModel::Relationship.new(name: '', destination_entity: 'Dest', to_many: true, ordered: true),
-                    'NSOrderedSet *'
-  end
 end

data/spec/moblues_spec.rb

@@ -5,28 +5,62 @@ describe Moblues do
   subject { described_class }
 
   describe '#generate' do
-    let(:options) { %w{--model=model/path --human=human/path --machine=machine/path} }
-
     let(:model) { 'model/path' }
-    let(:human) { 'human/path' }
-    let(:machine) { 'machine/path' }
+    let(:human_dir) { 'human/path' }
+    let(:machine_dir) { 'machine/path' }
+
+    let(:human) { nil }
+    let(:machine) { nil }
+    let(:params) { { human_dir: human_dir, machine_dir: machine_dir, human: human, machine: machine} }
 
     let(:model_reader) { double(Moblues::Reader::Model) }
-    let(:model_generator) { double(Moblues::Generator::Model) }
+    let(:model_generator) { double(Moblues::Generator::Base::Model) }
     let(:entities) { [build(:entity)] }
 
     before do
       allow(Moblues::Reader::Model).to receive(:new) { model_reader }
-      allow(Moblues::Generator::Model).to receive(:new) { model_generator }
+      allow(Moblues::Generator::Base::Model).to receive(:new).with(params) { model_generator }
+    end
+
+    shared_examples_for 'generate' do |lang|
+      it 'creates the directories reads the model and generates the files' do
+        expect(Dir).to receive(:mkdir).with('human/path').once
+        expect(Dir).to receive(:mkdir).with('machine/path').once
+        expect(model_reader).to receive(:model).with('model/path').once { entities }
+        expect(model_generator).to receive(:generate).with(entities).once
+
+        subject.generate(model, human_dir, machine_dir, lang)
+      end
+    end
+
+    context 'when lang is swift' do
+      let(:human) { double(Moblues::Generator::Swift::Human) }
+      let(:machine) { double(Moblues::Generator::Swift::Machine) }
+
+      before do
+        allow(Moblues::Generator::Swift::Human).to receive(:new) { human }
+        allow(Moblues::Generator::Swift::Machine).to receive(:new) { machine }
+      end
+
+      it_behaves_like 'generate', :swift
     end
 
-    it 'created the directories reads the model and generates the files' do
-      expect(Dir).to receive(:mkdir).with('human/path').once
-      expect(Dir).to receive(:mkdir).with('machine/path').once
-      expect(model_reader).to receive(:model).with('model/path').once { entities }
-      expect(model_generator).to receive(:generate).with(entities).once
+    context 'when lang is objc' do
+      let(:human) { double(Moblues::Generator::Objc::Human) }
+      let(:machine) { double(Moblues::Generator::Objc::Machine) }
+
+      before do
+        allow(Moblues::Generator::Objc::Human).to receive(:new) { human }
+        allow(Moblues::Generator::Objc::Machine).to receive(:new) { machine }
+      end
+
+      it_behaves_like 'generate', :objc
+    end
 
-      subject.generate(model, human, machine)
+    context 'when lang is unknown' do
+      it 'raises an error' do
+        expect { subject.generate(model, human_dir, machine_dir, :unknown) }.to raise_exception
+      end
     end
   end
 end

data/spec/resources/expected/swift/Author.swift

@@ -0,0 +1,4 @@
+import Foundation
+
+class Author: _Author {
+}

data/spec/resources/expected/swift/_Author.swift

@@ -0,0 +1,11 @@
+import Foundation
+import CoreData
+
+class _Author: Person {
+    @NSManaged var dob: NSDate
+    @NSManaged var name: String
+
+    @NSManaged var books: NSOrderedSet
+    @NSManaged var essays: NSSet
+    @NSManaged var publisher: Publisher
+}

data/spec/resources/expected/swift/_Book.swift

@@ -0,0 +1,8 @@
+import Foundation
+import CoreData
+
+class _Book: NSManagedObject {
+    @NSManaged var name: String
+
+    @NSManaged var editions: NSSet
+}

data/spec/resources/expected/swift/human/Playable.swift

@@ -0,0 +1,4 @@
+import Foundation
+
+class Playable: _Playable {
+}

data/spec/resources/expected/swift/human/Playlist.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+class Playlist: _Playlist {
+/* some modifications that should not be erased */
+}

data/spec/resources/expected/swift/human/Track.swift

@@ -0,0 +1,4 @@
+import Foundation
+
+class Track: _Track {
+}

data/spec/resources/expected/swift/human/User.swift

@@ -0,0 +1,4 @@
+import Foundation
+
+class User: _User {
+}

data/spec/resources/expected/swift/machine/_Playable.swift

@@ -0,0 +1,8 @@
+import Foundation
+import CoreData
+
+class _Playable: NSManagedObject {
+    @NSManaged var permalink: String
+    @NSManaged var title: String
+
+}

data/spec/resources/expected/swift/machine/_Playlist.swift

@@ -0,0 +1,8 @@
+import Foundation
+import CoreData
+
+class _Playlist: Playable {
+
+    @NSManaged var tracks: NSOrderedSet
+    @NSManaged var user: User
+}

data/spec/resources/expected/swift/machine/_Track.swift

@@ -0,0 +1,9 @@
+import Foundation
+import CoreData
+
+class _Track: Playable {
+    @NSManaged var duration: NSNumber
+
+    @NSManaged var playlist: Playlist
+    @NSManaged var user: User
+}

data/spec/resources/expected/swift/machine/_User.swift

@@ -0,0 +1,10 @@
+import Foundation
+import CoreData
+
+class _User: NSManagedObject {
+    @NSManaged var dob: NSDate
+    @NSManaged var name: String
+
+    @NSManaged var playlists: NSSet
+    @NSManaged var tracks: NSSet
+}

data/spec/resources/factories/data_model/attribute_factory.rb

@@ -7,6 +7,34 @@ FactoryGirl.define do
     name 'attribute'
     type :string
 
+    trait :string do
+      type :string
+    end
+
+    trait :number do
+      type :number
+    end
+
+    trait :decimal do
+      type :decimal
+    end
+
+    trait :date do
+      type :date
+    end
+
+    trait :data do
+      type :data
+    end
+
+    trait :id do
+      type :id
+    end
+
+    trait :unknown do
+      type :unknown
+    end
+
     initialize_with { new(name: name, type: type) }
   end
 end

data/spec/resources/factories/data_model/relationship_factory.rb

@@ -9,6 +9,21 @@ FactoryGirl.define do
     to_many true
     ordered true
 
+    trait :single do
+      to_many false
+      ordered false
+    end
+
+    trait :to_many do
+      to_many true
+      ordered false
+    end
+
+    trait :to_many_ordered do
+      to_many true
+      ordered true
+    end
+
     initialize_with { new(name: name, destination_entity: destination_entity, to_many: to_many, ordered: ordered) }
   end
 end