moblues 0.0.1

data/moblues.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'moblues/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'moblues'
+  spec.version       = Moblues::VERSION
+  spec.authors       = ['Vincent Garrigues']
+  spec.email         = ['vincent.garrigues@gmail.com']
+  spec.summary       = 'Generates Objective-C files for entities defined in a Core Data model'
+  spec.description   = %q{
+Generates files for entities defined in a Core Data model. Inspired by mogenerator.
+
+For each entity in the Core Data model, moblues will create two files: a machine file and a human file. The machine file will be overwritten each time and should not contain any modifications. Moblues will only create the human file if it doesn't exist.
+}
+  spec.homepage      = 'http://garriguv.io'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'thor', '~> 0.19'
+  spec.add_runtime_dependency 'plist', '~> 3.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'factory_girl', '~> 4.5'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.4.1'
+end

data/spec/features/moblues_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'moblues/cli'
+
+describe 'moblues' do
+  subject { Moblues::CLI }
+  let(:perform) { subject.start([command] + options) }
+
+  describe 'generate' do
+    let(:command) { 'generate' }
+    let(:options) { %w{--model=spec/resources/Model.xcdatamodeld --human=spec/resources/tmp/human --machine=spec/resources/tmp/machine} }
+
+    after do
+      Fixtures.delete_tmp_files(machine_files + human_files.select { |f| !f.include?('Playlist') } )
+    end
+
+    it 'generates human and machine files' do
+      perform
+
+      (machine_files + human_files).each do |file|
+        expect(Fixtures.read_file(Fixtures.generated_dir, file)).to eq(Fixtures.read_file(Fixtures.expected_dir, file))
+      end
+    end
+  end
+
+  def machine_files
+    entities.map{|f| "machine/_#{f}" }.map{ |f| %W(#{f}.h #{f}.m) }.flatten
+  end
+
+  def human_files
+    entities.map{|f| "human/#{f}" }.map{ |f| %W(#{f}.h #{f}.m) }.flatten
+  end
+
+  def entities
+    %w{User Playable Track Playlist}
+  end
+end

data/spec/moblues/cli_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'moblues/cli'
+
+describe Moblues::CLI do
+  subject { described_class }
+  let(:perform) { subject.start([command] + options, debug: true) }
+
+  context 'when command is invalid' do
+    let(:command) { 'invalid' }
+    let(:options) { [] }
+
+    it 'fails' do
+      expect { perform }.to raise_error
+    end
+  end
+
+  context 'generate' do
+    let(:command) { 'generate' }
+
+    context 'when options missing' do
+      let(:options) { [] }
+
+      it 'fails' do
+        expect { perform }.to raise_error
+      end
+    end
+
+    context 'when options given' do
+      let(:options) { %w{--model=model/path --human=human/path --machine=machine/path} }
+
+      let(:model_reader) { double(Moblues::Reader::Model) }
+      let(:model_generator) { double(Moblues::Generator::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 }
+      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
+
+        perform
+      end
+    end
+  end
+end

data/spec/moblues/data_model/attribute_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'moblues/data_model/attribute'
+
+module Moblues
+  module DataModel
+    describe Attribute do
+      describe '#initialize' do
+        context 'when name and type provided' do
+          subject { described_class.new(name: 'attribute', type: 'type') }
+
+          it 'returns an Attribute object' do
+            expect(subject).to eq(Attribute.new(name: 'attribute', type: 'type'))
+          end
+        end
+
+        context 'when name missing' do
+          it 'raises an assertion' do
+            expect { Attribute.new(type: 'type') }.to raise_exception(KeyError)
+          end
+        end
+
+        context 'when type missing' do
+          it 'raises an assertion' do
+            expect { Attribute.new(name: 'attribute') }.to raise_exception(KeyError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/moblues/data_model/entity_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'moblues/data_model/entity'
+
+module Moblues
+  module DataModel
+    describe Entity do
+      describe '#initialize' do
+        context 'when name, parent_entity, attributes and relationship provided' do
+          subject { described_class.new(name: 'AudioBook', parent_entity: 'Book', attributes: ['title'], relationships: ['author']) }
+
+          it 'returns an Entity object' do
+            expect(subject).to eq(Entity.new(name: 'AudioBook', parent_entity: 'Book', attributes: ['title'], relationships: ['author']))
+          end
+        end
+
+        context 'when name missing' do
+          it 'raises an exception' do
+            expect { Entity.new(parent_entity: 'Book', attributes: ['title'], relationships: ['author']) }.to raise_exception(KeyError)
+          end
+        end
+
+        context 'when parent_entity missing' do
+          subject { described_class.new(name: 'AudioBook', attributes: ['title'], relationships: ['author']) }
+
+          it 'returns an Entity with NSManagedObject parent_entity' do
+            expect(subject).to eq(Entity.new(name: 'AudioBook', parent_entity: 'NSManagedObject', attributes: ['title'], relationships: ['author']))
+          end
+        end
+
+        context 'when attributes missing' do
+          subject { described_class.new(name: 'AudioBook', parent_entity: 'Book', relationships: ['author']) }
+
+          it 'returns an Entity with empty attributes' do
+            expect(subject).to eq(Entity.new(name: 'AudioBook', parent_entity: 'Book', attributes: [], relationships: ['author']))
+          end
+        end
+
+        context 'when relationships missing' do
+          subject { described_class.new(name: 'AudioBook', parent_entity: 'Book', attributes: ['title']) }
+
+          it 'returns an Entity with empty relationships' do
+            expect(subject).to eq(Entity.new(name: 'AudioBook', parent_entity: 'Book', attributes: ['title'], relationships: []))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/moblues/data_model/relationship_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'moblues/data_model/relationship'
+
+module Moblues
+  module DataModel
+    describe Relationship do
+      describe '#initialize' do
+        context 'when name, destination_entity, to_many and ordered provided' do
+          subject { described_class.new(name: 'relationship', destination_entity: 'entity', to_many: true, ordered: true) }
+
+          it 'returns a Relationship object' do
+            expect(subject).to eq(Relationship.new(name: 'relationship', destination_entity: 'entity', to_many: true, ordered: true))
+          end
+        end
+
+        context 'when name missing' do
+          it 'raises an assertion' do
+            expect { Relationship.new(destination_entity: 'entity', to_many: true, ordered: true) }.to raise_exception(KeyError)
+          end
+        end
+
+        context 'when destination_entity missing' do
+          it 'raises an assertion' do
+            expect { Relationship.new(name: 'relationship', to_many: true, ordered: true) }.to raise_exception(KeyError)
+          end
+        end
+
+        context 'when to_many missing' do
+          subject { described_class.new(name: 'relationship', destination_entity: 'entity', ordered: true) }
+
+          it 'returns a Relationship with to_many false' do
+            expect(subject).to eq(Relationship.new(name: 'relationship', destination_entity: 'entity', to_many: false, ordered: true))
+          end
+        end
+
+        context 'when ordered missing' do
+          subject { described_class.new(name: 'relationship', destination_entity: 'entity', to_many: true) }
+
+          it 'returns a Relationship with ordered false' do
+            expect(subject).to eq(Relationship.new(name: 'relationship', destination_entity: 'entity', to_many: true, ordered: false))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/moblues/generator/human_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'moblues/generator/human'
+require 'moblues/data_model'
+
+describe Moblues::Generator::Human do
+  subject { described_class.new(output_dir: Fixtures.generated_dir) }
+
+  after do
+    Fixtures.delete_tmp_files(%w{Author.h Author.m})
+  end
+
+  describe '#generate' do
+    it 'generates a human header' do
+      subject.generate(entity)
+
+      expect(Fixtures.generated_file_content('Author.h')).to eq(Fixtures.expected_content('Author.h'))
+    end
+
+    it 'generates a human implementation' do
+      subject.generate(entity)
+
+      expect(Fixtures.generated_file_content('Author.m')).to eq(Fixtures.expected_content('Author.m'))
+    end
+
+    context 'if the header already exists' do
+      before do
+        File.open(File.join(Fixtures.generated_dir, 'Author.h'), 'w+') do |f|
+          f.write('do nothing')
+        end
+      end
+
+      it 'does not overwrite the header file' do
+        subject.generate(entity)
+
+        expect(Fixtures.generated_file_content('Author.h')).to eq('do nothing')
+      end
+    end
+
+    context 'if the implementation already exists' do
+      before do
+        File.open(File.join(Fixtures.generated_dir, 'Author.m'), 'w+') do |f|
+          f.write('do nothing')
+        end
+      end
+
+      it 'does not overwrite the implementation file' do
+        subject.generate(entity)
+
+        expect(Fixtures.generated_file_content('Author.m')).to eq('do nothing')
+      end
+    end
+  end
+
+  def entity
+    Moblues::DataModel::Entity.new(name:          'Author',
+                                   attributes:    attributes,
+                                   relationships: relationships)
+  end
+
+  def attributes
+    [
+      Moblues::DataModel::Attribute.new(name: 'dob', type: :date),
+      Moblues::DataModel::Attribute.new(name: 'name', type: :string)
+    ]
+  end
+
+  def 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')
+    ]
+  end
+end

data/spec/moblues/generator/machine_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'moblues/generator/machine'
+require 'moblues/data_model'
+
+describe Moblues::Generator::Machine do
+  subject { described_class.new(output_dir: Fixtures.generated_dir) }
+
+  after do
+    Fixtures.delete_tmp_files(%w{_Author.h _Author.m _Person.h _Person.m _Book.h _Book.m})
+  end
+
+  describe '#generate' do
+    shared_examples_for 'machine_generator' do |name|
+      it 'generates a header' do
+        subject.generate(entity)
+
+        expect(Fixtures.generated_file_content(header(name))).to eq(Fixtures.expected_content(header(name)))
+      end
+
+      it 'generates an implementation' do
+        subject.generate(entity)
+
+        expect(Fixtures.generated_file_content(implementation(name))).to eq(Fixtures.expected_content(implementation(name)))
+      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 an entity without relationships' do
+      let(:entity) { Moblues::DataModel::Entity.new(name:       'Person',
+                                                    attributes: [Moblues::DataModel::Attribute.new(name: 'name', type: :string),
+                                                                 Moblues::DataModel::Attribute.new(name: 'dob', type: :date)]) }
+
+      it_behaves_like 'machine_generator', 'Person'
+    end
+
+    context 'with an entity with attributes, relationships but NO forward declaration' 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
+
+    context 'with an entity that has a to-many relationship an a variable name that contains capitals' do
+      let(:entity) { Moblues::DataModel::Entity.new(name:          'Team',
+                                                    attributes:    [],
+                                                    relationships: relationships) }
+      let(:relationships) {[
+        Moblues::DataModel::Relationship.new(name: 'teamMembers', destination_entity: 'Person', to_many: true)
+      ]}
+
+      it_behaves_like 'machine_generator', 'Team'
+    end
+  end
+
+  def header(name)
+    "_#{name}.h"
+  end
+
+  def implementation(name)
+    "_#{name}.h"
+  end
+end

data/spec/moblues/generator/model_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Moblues::Generator::Model do
+  describe '#generate' do
+    subject { described_class.new(human: human, machine: machine, human_dir: human_dir, machine_dir: machine_dir) }
+
+    let(:entities) { [build(:entity)] }
+    let(:entity) { entities.first }
+    let(:human_dir) { 'human/dir'}
+    let(:machine_dir) { 'machine/dir'}
+
+    let(:human) { double(Moblues::Generator::Human) }
+    let(:machine) { double(Moblues::Generator::Machine) }
+
+    before do
+      allow(Moblues::Generator::Human).to receive(:new).with(output_dir: human_dir) { human }
+      allow(Moblues::Generator::Machine).to receive(:new).with(output_dir: machine_dir) { machine }
+    end
+
+    it 'generates the human and machine files' do
+      expect(human).to receive(:generate).with(entity).once
+      expect(machine).to receive(:generate).with(entity).once
+
+      subject.generate(entities)
+    end
+  end
+end

data/spec/moblues/reader/attribute_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'moblues/reader/attribute'
+
+describe Moblues::Reader::Attribute do
+  describe '#attribute' do
+    context 'when XML is valid' do
+      let(:xml) { REXML::Document.new('<attribute name="testName" attributeType="String"/>').elements.first }
+
+      it 'returns an Attribute object' do
+        expect(subject.attribute(xml)).to eq(Moblues::DataModel::Attribute.new(name: 'testName', type: :string))
+      end
+    end
+
+    context 'when XML is invalid' do
+      let(:xml) { REXML::Document.new('<notAnAttribute/>').elements.first }
+
+      it 'raises an assertion' do
+        expect { subject.attribute(xml) }.to raise_exception
+      end
+    end
+  end
+end

data/spec/moblues/reader/entity_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'moblues/reader/entity'
+
+describe Moblues::Reader::Entity do
+  describe '#entity' do
+    context 'when XML is valid' do
+      subject { described_class.new(attribute_reader: attribute_reader, relationship_reader: relationship_reader) }
+
+      let(:attribute_reader) { double(Moblues::Reader::Attribute) }
+      let(:relationship_reader) { double(Moblues::Reader::Relationship) }
+      let(:xml) {
+        xml_str = <<EOF
+<entity name="Author" parentEntity="Person" syncable="YES">
+  <attribute name="dob" attributeType="Date" syncable="YES"/>
+  <attribute name="name" attributeType="String" syncable="YES"/>
+  <relationship name="books" optional="YES" toMany="YES" deletionRule="Nullify" destinationEntity="Book" inverseName="author" inverseEntity="Book" syncable="YES"/>
+</entity>
+EOF
+        REXML::Document.new(xml_str).elements.first
+      }
+
+      before(:each) do
+        allow(attribute_reader).to receive(:attribute) { build(:attribute) }
+        allow(relationship_reader).to receive(:relationship) { build(:relationship) }
+      end
+
+      it 'maps attributes' do
+        expect(attribute_reader).to receive(:attribute).twice
+
+        subject.entity(xml)
+      end
+
+      it 'maps relationships' do
+        expect(relationship_reader).to receive(:relationship).once
+
+        subject.entity(xml)
+      end
+
+      it 'returns an Entity' do
+        entity = Moblues::DataModel::Entity.new(name:          'Author',
+                                                parent_entity: 'Person',
+                                                attributes:    [build(:attribute), build(:attribute)],
+                                                relationships: [build(:relationship)])
+
+        expect(subject.entity(xml)).to eq(entity)
+      end
+    end
+
+    context 'when XML is invalid' do
+      let(:xml) { REXML::Document.new('<notAnEntity/>').elements.first }
+
+      it 'raises an exception' do
+        expect { subject.entity(xml) }.to raise_exception
+      end
+    end
+  end
+end

data/spec/moblues/reader/model_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'moblues/reader/model'
+
+describe Moblues::Reader::Model do
+  let(:model) { build(:model) }
+  let(:model_resolver) { double(Moblues::Utils::ModelResolver) }
+  let(:entity_reader) { double(Moblues::Reader::Entity) }
+  let(:file_str) {
+    <<EOF
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<model userDefinedModelVersionIdentifier="2.0" type="com.apple.IDECoreDataModeler.DataModel" documentVersion="1.0" lastSavedToolsVersion="6252" systemVersion="14A389" minimumToolsVersion="Xcode 4.3" macOSVersion="Automatic" iOSVersion="Automatic">
+    <entity name="Author" syncable="YES">
+        <attribute name="dob" attributeType="Date" syncable="YES"/>
+        <attribute name="name" attributeType="String" syncable="YES"/>
+        <relationship name="books" optional="YES" toMany="YES" deletionRule="Nullify" destinationEntity="Book" inverseName="author" inverseEntity="Book" syncable="YES"/>
+    </entity>
+    <entity name="Book" syncable="YES">
+        <attribute name="numberOfPages" attributeType="Integer 32" defaultValueString="0" syncable="YES"/>
+        <attribute name="title" attributeType="String" syncable="YES"/>
+        <relationship name="author" maxCount="1" deletionRule="Nullify" destinationEntity="Author" inverseName="books" inverseEntity="Author" syncable="YES"/>
+        <relationship name="publisher" maxCount="1" deletionRule="Nullify" destinationEntity="Publisher" inverseName="books" inverseEntity="Publisher" syncable="YES"/>
+    </entity>
+    <entity name="Publisher" syncable="YES">
+        <attribute name="name" attributeType="String" syncable="YES"/>
+        <attribute name="website" optional="YES" attributeType="String" syncable="YES"/>
+        <relationship name="books" maxCount="1" deletionRule="Nullify" destinationEntity="Book" inverseName="publisher" inverseEntity="Book" syncable="YES"/>
+    </entity>
+    <elements>
+        <element name="Author" positionX="-281" positionY="-39" width="128" height="88"/>
+        <element name="Book" positionX="-54" positionY="-9" width="128" height="103"/>
+        <element name="Publisher" positionX="153" positionY="6" width="128" height="88"/>
+    </elements>
+</model>
+EOF
+  }
+
+  subject { described_class.new(resolver: model_resolver, reader: entity_reader) }
+
+  before do
+    allow(model_resolver).to receive(:resolve_model)
+    allow(entity_reader).to receive(:entity) { build(:entity) }
+    allow(File).to receive(:read) { file_str }
+  end
+
+  describe '#parse_model' do
+    it 'resolves the model contents' do
+      expect(model_resolver).to receive(:resolve_model).with('path')
+
+      subject.model('path')
+    end
+
+    it 'maps the model' do
+      expect(entity_reader).to receive(:entity).exactly(3).times
+
+      subject.model('path')
+    end
+
+    it 'returns an array of entities' do
+      expect(subject.model('path')).to eq([build(:entity), build(:entity), build(:entity)])
+    end
+
+    it 'raises an assertion if path is nil' do
+      expect { subject.model(nil) }.to raise_exception
+    end
+  end
+end

data/spec/moblues/reader/relationship_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'moblues/reader/relationship'
+
+describe Moblues::Reader::Relationship do
+  describe '#relationship' do
+    context 'when XML is valid' do
+      let(:xml) { REXML::Document.new('<relationship name="testName" toMany="YES" destinationEntity="TestEntity" ordered="YES"/>').elements.first }
+
+      it 'returns a Relationship' do
+        expect(subject.relationship(xml)).to eq(Moblues::DataModel::Relationship.new(name: 'testName', destination_entity: 'TestEntity', to_many: true, ordered: true))
+      end
+    end
+
+    context 'when XML is invalid' do
+      let(:xml) { REXML::Document.new('<notARelationship/>').elements.first }
+
+      it 'raises an exception' do
+        expect { subject.relationship(xml) }.to raise_exception
+      end
+    end
+  end
+end