moblues 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c36abc1af5154b1816b202fe56210ff27c3bab41
-  data.tar.gz: fbb6b0c0cc21e59bc02ed710a4ba072e74fe7678
+  metadata.gz: 1f22698058e9f78222db4f63caa41e57b48356fc
+  data.tar.gz: 2e597a01de3f94ebac46c69c4453804f0b063ad5
 SHA512:
-  metadata.gz: 8a853abe6bed750daa4bd87b4c1fd79b7b51b34dfda63390407325485d5b74abfd03d1ed5c6d566dab5fe41b439d30267bfd386174b1e7f59026de2ef904184a
-  data.tar.gz: 738e69c5b6fc8216013ff86bcee9c7745597830a0ce9c4e8b5dbb14226c512a7904346e17c2623046fb1bbdbb04d4dd20734f80a15c057e23f271cfd50af7254
+  metadata.gz: 519ccda057113e8d835581c6d495698628b2c1f9d0f8f005017a2c969e0dbc1bfdf0f00dc4c79d8fd19d3a5fba66fd352c30384cdec7c31526bf57400a9423a7
+  data.tar.gz: 249f7ffa4ab130fdb8c8b6daf50b7868f9a229b98b1d8cb0045e54e9bd5cff8baeed4d8400f30d132895b769ad3a68f93db1dee4c552340c32916449d867ea24

data/README.md

@@ -24,14 +24,16 @@ Or install it yourself as:
 
 ```
 Usage:
-  moblues generate --human=HUMAN --machine=MACHINE --model=MODEL
+moblues generate --human=HUMAN --machine=MACHINE --model=MODEL
 
 Options:
-  --model=MODEL      # CoreData model path
-  --human=HUMAN      # Path where the human files will be stored
-  --machine=MACHINE  # Path where the machine files will be stored
+--model=MODEL      # Core Data model path
+--human=HUMAN      # Path where the human files will be stored
+--machine=MACHINE  # Path where the machine files will be stored
+[--lang=LANG]      # The language used to generate the files (objc or swift)
+                   # Default: objc
 
-generate the machine and human files
+generate the machine and human files for entities contained in a Core Data model
 ```
 
 ## Contributing

data/lib/moblues/cli.rb

@@ -1,15 +1,14 @@
 require 'thor'
-require 'moblues/reader/model'
-require 'moblues/generator/model'
 
 module Moblues
   class CLI < Thor
-    desc 'generate', 'generate the machine and human files'
+    desc 'generate', 'generate the machine and human files for entities contained in a Core Data model'
     option :model, :required => true, :desc => 'Core Data model path'
     option :human, :required => true, :desc => 'Path where the human files will be stored'
     option :machine, :required => true, :desc => 'Path where the machine files will be stored'
+    option :lang, :default => 'objc', :desc => 'The language used to generate the files (objc or swift)'
     def generate
-      Moblues.generate(options[:model], options[:human], options[:machine])
+      Moblues.generate(options[:model], options[:human], options[:machine], options[:lang].to_sym)
     end
   end
 end

data/lib/moblues/generator/base/model.rb

@@ -0,0 +1,24 @@
+module Moblues
+  module Generator
+    module Base
+      class Model
+        def initialize(params)
+          @human = params.fetch(:human)
+          @machine = params.fetch(:machine)
+          @human_dir = params.fetch(:human_dir)
+          @machine_dir = params.fetch(:machine_dir)
+        end
+
+        def generate(entities)
+          entities.each do |entity|
+            human.generate(human_dir, entity)
+            machine.generate(machine_dir, entity)
+          end
+        end
+
+        private
+        attr_reader :human, :machine, :human_dir, :machine_dir
+      end
+    end
+  end
+end

data/lib/moblues/generator/base/type.rb

@@ -0,0 +1,63 @@
+module Moblues
+  module Generator
+    module Base
+      class Type
+        SWIFT = {
+          attribute_types:
+            {
+              string:  'String',
+              number:  'NSNumber',
+              decimal: 'NSDecimalNumber',
+              date:    'NSDate',
+              data:    'NSData',
+              id:      'AnyObject'
+            },
+          relationship_types:
+            {
+              to_many:         'NSSet',
+              to_many_ordered: 'NSOrderedSet',
+              suffix:          ''
+            }
+        }
+
+        OBJC = {
+          attribute_types:
+            {
+              string:  'NSString *',
+              number:  'NSNumber *',
+              decimal: 'NSDecimalNumber *',
+              date:    'NSDate *',
+              data:    'NSData *',
+              id:      'id '
+            },
+          relationship_types:
+            {
+              to_many:         'NSSet *',
+              to_many_ordered: 'NSOrderedSet *',
+              suffix:          ' *'
+            }
+        }
+
+        def initialize(params = SWIFT)
+          @attribute_types = params.fetch(:attribute_types)
+          @relationship_types = params.fetch(:relationship_types)
+        end
+
+        def attribute_type(attribute)
+          attribute_types.fetch(attribute.type)
+        end
+
+        def relationship_type(relationship)
+          if relationship.to_many
+            relationship.ordered ? relationship_types[:to_many_ordered] : relationship_types[:to_many]
+          else
+            relationship.destination_entity + relationship_types[:suffix]
+          end
+        end
+
+        protected
+        attr_reader :attribute_types, :relationship_types
+      end
+    end
+  end
+end

data/lib/moblues/generator/objc/base.rb

@@ -0,0 +1,67 @@
+require 'erb'
+require 'moblues/generator/objc/type'
+
+module Moblues
+  module Generator
+    module Objc
+      class Base
+        def initialize
+          @type_generator = Type.new
+        end
+
+        protected
+        attr_reader :type_generator
+
+        def write_header(output_dir, entity)
+          write_file(header_file(output_dir, entity), header(entity))
+        end
+
+        def write_implementation(output_dir, entity)
+          write_file(implementation_file(output_dir, entity), implementation(entity))
+        end
+
+        def write_file(file, text)
+          File.open(file, 'w+') do |f|
+            f.write(text)
+          end
+        end
+
+        def header_file(output_dir, entity)
+          File.join(output_dir, format_name(entity, 'h'))
+        end
+
+        def implementation_file(output_dir, entity)
+          File.join(output_dir, format_name(entity, 'm'))
+        end
+
+        def format_name(entity, extension)
+          raise NotImplemented
+        end
+
+        def header(entity)
+          render(header_template, entity)
+        end
+
+        def implementation(entity)
+          render(implementation_template, entity)
+        end
+
+        def render(template, entity)
+          ERB.new(template, 0, '-').result(entity.send(:binding))
+        end
+
+        def header_template
+          raise NotImplemented
+        end
+
+        def implementation_template
+          raise NotImplemented
+        end
+
+        def file_template(name)
+          File.read(File.expand_path("../#{name}.erb", __FILE__))
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/objc/human.rb

@@ -0,0 +1,27 @@
+require 'moblues/generator/objc/base'
+
+module Moblues
+  module Generator
+    module Objc
+      class Human < Base
+        def generate(output_dir, entity)
+          write_header(output_dir, entity) unless File.exists?(header_file(output_dir, entity))
+          write_implementation(output_dir, entity) unless File.exists?(implementation_file(output_dir, entity))
+        end
+
+        private
+        def format_name(entity, extension)
+          "#{entity.name}.#{extension}"
+        end
+
+        def header_template
+          file_template('human_header.h')
+        end
+
+        def implementation_template
+          file_template('human_implementation.m')
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/objc/machine.rb

@@ -0,0 +1,31 @@
+require 'moblues/generator/objc/base'
+
+module Moblues
+  module Generator
+    module Objc
+      class Machine < Base
+        def generate(output_dir, entity)
+          write_header(output_dir, entity)
+          write_implementation(output_dir, entity)
+        end
+
+        private
+        def format_name(entity, extension)
+          "_#{entity.name}.#{extension}"
+        end
+
+        def capitalized_name(relationship)
+          relationship.name.sub(/^./) { |first_character| first_character.upcase }
+        end
+
+        def header_template
+          file_template('machine_header.h')
+        end
+
+        def implementation_template
+          file_template('machine_implementation.m')
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/{machine_header.h.erb → objc/machine_header.h.erb}

@@ -11,11 +11,11 @@
 
 @interface _<%= entity.name %> : <%= entity.parent_entity %>
 <% for attribute in entity.attributes -%>
-@property (<%= type_reader.property_attributes(attribute.type).join(', ') %>) <%= type_reader.property_type(attribute.type)%><%= attribute.name %>;
+@property (<%= type_generator.property_attributes(attribute).join(', ') %>) <%= type_generator.attribute_type(attribute)%><%= attribute.name %>;
 <% end -%>
 
 <% for relationship in entity.relationships -%>
-@property (nonatomic, strong) <%= type_reader.relationship_type(relationship) %><%= relationship.name %>;
+@property (nonatomic, strong) <%= type_generator.relationship_type(relationship) %><%= relationship.name %>;
 <% end -%>
 @end
 <% if !entity.relationships.select { |e| e.to_many }.empty? %>

data/lib/moblues/generator/objc/type.rb

@@ -0,0 +1,24 @@
+require 'moblues/generator/base/type'
+
+module Moblues
+  module Generator
+    module Objc
+      class Type < Base::Type
+        def initialize
+          super(OBJC)
+        end
+
+        def property_attributes(attribute)
+          case attribute.type
+          when :string
+            %w{nonatomic copy}
+          when :number, :decimal, :date, :data, :id
+            %w{nonatomic strong}
+          else
+            raise ArgumentError.new("unknown type #{type}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/swift/base.rb

@@ -0,0 +1,39 @@
+require 'erb'
+require 'moblues/generator/base/type'
+
+module Moblues
+  module Generator
+    module Swift
+      class Base
+        def initialize
+          @type = Generator::Base::Type.new
+        end
+
+        protected
+        attr_reader :type
+
+        def write_swift(output_dir, entity, file_type)
+          write_file(file_path(output_dir, entity), render(entity, file_type))
+        end
+
+        def write_file(file, text)
+          File.open(file, 'w+') do |f|
+            f.write(text)
+          end
+        end
+
+        def file_path(output_dir, entity)
+          raise NotImplemented
+        end
+
+        def render(entity, file_type)
+          ERB.new(template(file_type), 0, '-').result(entity.send(:binding))
+        end
+
+        def template(file_type)
+          File.read(File.expand_path("../#{file_type}.swift.erb", __FILE__))
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/swift/human.rb

@@ -0,0 +1,18 @@
+require 'moblues/generator/swift/base'
+
+module Moblues
+  module Generator
+    module Swift
+      class Human < Base
+        def generate(output_dir, entity)
+          write_swift(output_dir, entity, :human) unless File.exists?(file_path(output_dir, entity))
+        end
+
+        private
+        def file_path(output_dir, entity)
+          File.join(output_dir, "#{entity.name}.swift")
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/swift/human.swift.erb

@@ -0,0 +1,4 @@
+import Foundation
+
+class <%= entity.name %>: _<%= entity.name %> {
+}

data/lib/moblues/generator/swift/machine.rb

@@ -0,0 +1,18 @@
+require 'moblues/generator/swift/base'
+
+module Moblues
+  module Generator
+    module Swift
+      class Machine < Base
+        def generate(output_dir, entity)
+          write_swift(output_dir, entity, :machine)
+        end
+
+        private
+        def file_path(output_dir, entity)
+          File.join(output_dir, "_#{entity.name}.swift")
+        end
+      end
+    end
+  end
+end

data/lib/moblues/generator/swift/machine.swift.erb

@@ -0,0 +1,12 @@
+import Foundation
+import CoreData
+
+class _<%= entity.name %>: <%= entity.parent_entity %> {
+<% for attribute in entity.attributes -%>
+    @NSManaged var <%= attribute.name %>: <%= type.attribute_type(attribute) %>
+<% end -%>
+
+<% for relationship in entity.relationships -%>
+    @NSManaged var <%= relationship.name %>: <%= type.relationship_type(relationship) %>
+<% end -%>
+}

data/lib/moblues/generator.rb

@@ -1,4 +1,9 @@
-require 'moblues/generator/base'
-require 'moblues/generator/model'
-require 'moblues/generator/machine'
-require 'moblues/generator/human'
+require 'moblues/generator/base/model'
+require 'moblues/generator/base/type'
+require 'moblues/generator/objc/base'
+require 'moblues/generator/objc/human'
+require 'moblues/generator/objc/machine'
+require 'moblues/generator/objc/type'
+require 'moblues/generator/swift/base'
+require 'moblues/generator/swift/human'
+require 'moblues/generator/swift/machine'

data/lib/moblues/reader/type.rb

@@ -5,8 +5,10 @@ module Moblues
         case type_str
         when 'String'
           :string
-        when 'Integer 16', 'Integer 32', 'Integer 64', 'Boolean'
+        when 'Integer 16', 'Integer 32', 'Integer 64', 'Boolean', 'Float', 'Double'
           :number
+        when 'Decimal'
+          :decimal
         when 'Date'
           :date
         when 'Binary'
@@ -17,42 +19,6 @@ module Moblues
           raise ArgumentError.new("unknown type #{type_str}")
         end
       end
-
-      def property_type(type)
-        case type
-        when :string
-          'NSString *'
-        when :number
-          'NSNumber *'
-        when :date
-          'NSDate *'
-        when :data
-          'NSData *'
-        when :id
-          'id '
-        else
-          raise ArgumentError.new("unknown type #{type}")
-        end
-      end
-
-      def property_attributes(type)
-        case type
-        when :string
-          %w{nonatomic copy}
-        when :number, :date, :data, :id
-          %w{nonatomic strong}
-        else
-          raise ArgumentError.new("unknown type #{type}")
-        end
-      end
-
-      def relationship_type(relationship)
-        if relationship.to_many
-          relationship.ordered ? 'NSOrderedSet *' : 'NSSet *'
-        else
-          relationship.destination_entity + ' *'
-        end
-      end
     end
   end
 end

data/lib/moblues/version.rb

@@ -1,3 +1,3 @@
 module Moblues
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/moblues.rb

@@ -6,11 +6,11 @@ require 'moblues/generator'
 module Moblues
   extend self
 
-  def generate(model, human_dir, machine_dir)
+  def generate(model, human_dir, machine_dir, lang = :objc)
     mkdir([human_dir, machine_dir])
-    reader = Moblues::Reader::Model.new
-    generator = Moblues::Generator::Model.new(human_dir: human_dir, machine_dir: machine_dir)
-    entities = reader.model(model)
+    reader    = Moblues::Reader::Model.new
+    generator = generator(human_dir, machine_dir, lang)
+    entities  = reader.model(model)
     generator.generate(entities)
   end
 
@@ -20,4 +20,20 @@ module Moblues
       Dir.mkdir(dir) unless Dir.exists?(dir)
     end
   end
+
+  def generator(human_dir, machine_dir, lang)
+    base_params = { human_dir:   human_dir,
+                    machine_dir: machine_dir }
+    case lang
+    when :swift
+      additional_params = { human:   Moblues::Generator::Swift::Human.new,
+                            machine: Moblues::Generator::Swift::Machine.new }
+    when :objc
+      additional_params = { human:   Moblues::Generator::Objc::Human.new,
+                            machine: Moblues::Generator::Objc::Machine.new }
+    else
+      raise ArgumentError.new("Language #{lang} is not supported")
+    end
+    Moblues::Generator::Base::Model.new(base_params.merge(additional_params))
+  end
 end

data/spec/features/moblues_spec.rb

@@ -7,30 +7,49 @@ describe 'moblues' do
 
   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') } )
+    let(:entities) { %w{User Playable Track Playlist} }
+
+    shared_examples_for 'generate' do |lang|
+      it 'generates human and machine files' do
+        perform
+
+        (machine_files + human_files).each do |file|
+          expect(Fixtures.read_file(Fixtures.generated_dir(lang), file)).to eq(Fixtures.read_file(Fixtures.expected_dir(lang), file))
+        end
+      end
     end
 
-    it 'generates human and machine files' do
-      perform
+    context 'swift' do
+      let(:options) { %w{--model=spec/resources/Model.xcdatamodeld --human=spec/resources/tmp/swift/human --machine=spec/resources/tmp/swift/machine --lang=swift} }
+
+      let(:machine_files) { entities.map{|f| "machine/_#{f}.swift" } }
+      let(:human_files) { entities.map{|f| "human/#{f}.swift" } }
 
-      (machine_files + human_files).each do |file|
-        expect(Fixtures.read_file(Fixtures.generated_dir, file)).to eq(Fixtures.read_file(Fixtures.expected_dir, file))
+      after do
+        Fixtures.delete_tmp_files(machine_files + human_files.select { |f| !f.include?('Playlist') }, :swift)
       end
+
+      it_behaves_like 'generate', :swift
     end
-  end
 
-  def machine_files
-    entities.map{|f| "machine/_#{f}" }.map{ |f| %W(#{f}.h #{f}.m) }.flatten
-  end
+    context 'objc' do
+      let(:options) { %w{--model=spec/resources/Model.xcdatamodeld --human=spec/resources/tmp/objc/human --machine=spec/resources/tmp/objc/machine} }
 
-  def human_files
-    entities.map{|f| "human/#{f}" }.map{ |f| %W(#{f}.h #{f}.m) }.flatten
-  end
+      let(:machine_files) { entities.map{|f| "machine/_#{f}" }.map{ |f| %W(#{f}.h #{f}.m) }.flatten }
+      let(:human_files) { entities.map{|f| "human/#{f}" }.map{ |f| %W(#{f}.h #{f}.m) }.flatten }
+
+      after do
+        Fixtures.delete_tmp_files(machine_files + human_files.select { |f| !f.include?('Playlist') }, :objc)
+      end
 
-  def entities
-    %w{User Playable Track Playlist}
+      it 'generates human and machine files' do
+        perform
+
+        (machine_files + human_files).each do |file|
+          expect(Fixtures.read_file(Fixtures.generated_dir(:objc), file)).to eq(Fixtures.read_file(Fixtures.expected_dir(:objc), file))
+        end
+      end
+    end
   end
 end

data/spec/lib/moblues/cli_spec.rb

@@ -28,11 +28,21 @@ describe Moblues::CLI do
     context 'when options given' do
       let(:options) { %w{--model=model/path --human=human/path --machine=machine/path} }
 
-      it 'created the directories reads the model and generates the files' do
-        expect(Moblues).to receive(:generate).with('model/path', 'human/path', 'machine/path').once
+      it 'uses Moblues and defaults to objc' do
+        expect(Moblues).to receive(:generate).with('model/path', 'human/path', 'machine/path', :objc).once
 
         perform
       end
+
+      context 'when using lang option' do
+        let(:options) { %w{--model=model/path --human=human/path --machine=machine/path --lang=swift} }
+
+        it 'uses Moblues' do
+          expect(Moblues).to receive(:generate).with('model/path', 'human/path', 'machine/path', :swift).once
+
+          perform
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Moblues::Generator::Base::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::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 'generates the human and machine files' do
+      expect(human).to receive(:generate).with(human_dir, entity).once
+      expect(machine).to receive(:generate).with(machine_dir, entity).once
+
+      subject.generate(entities)
+    end
+  end
+end